Fix conflict

module/data/item/base.mjs

@@ -5,52 +5,49 @@
  * @property {string} type - The system type that this data model represents.
  * @property {boolean} hasDescription - Indicates whether items of this type have description field
  * @property {boolean} isQuantifiable - Indicates whether items of this type have quantity field
- * @property {Record<string,string>} embedded - Record of document names of pseudo-documents and the path to the collection
  */
 
 const fields = foundry.data.fields;
 
 export default class BaseDataItem extends foundry.abstract.TypeDataModel {
-  /** @returns {ItemDataModelMetadata}*/
-  static get metadata() {
-    return {
-      label: "Base Item",
-      type: "base",
-      hasDescription: false,
-      isQuantifiable: false,
-      embedded: {},
-    };
-  }
+    /** @returns {ItemDataModelMetadata}*/
+    static get metadata() {
+        return {
+            label: 'Base Item',
+            type: 'base',
+            hasDescription: false,
+            isQuantifiable: false
+        };
+    }
 
-  /** @inheritDoc */
-  static defineSchema() {
-    const schema = {};
+    /** @inheritDoc */
+    static defineSchema() {
+        const schema = {};
 
-    if (this.metadata.hasDescription)
-      schema.description = new fields.HTMLField({ required: true, nullable: true });
+        if (this.metadata.hasDescription) schema.description = new fields.HTMLField({ required: true, nullable: true });
 
-    if (this.metadata.isQuantifiable)
-      schema.quantity = new fields.NumberField({ integer: true, initial: 1, min: 0, required: true });
+        if (this.metadata.isQuantifiable)
+            schema.quantity = new fields.NumberField({ integer: true, initial: 1, min: 0, required: true });
 
-    return schema;
-  }
+        return schema;
+    }
 
-  /**
-   * Convenient access to the item's actor, if it exists.
-   * @returns {foundry.documents.Actor | null}
-   */
-  get actor() {
-    return this.parent.actor;
-  }
+    /**
+     * Convenient access to the item's actor, if it exists.
+     * @returns {foundry.documents.Actor | null}
+     */
+    get actor() {
+        return this.parent.actor;
+    }
 
-  /**
-   * Obtain a data object used to evaluate any dice rolls associated with this Item Type
-   * @param {object} [options] - Options which modify the getRollData method. 
-   * @returns {object}
-   */
-  getRollData(options = {}) {
-    const actorRollData = this.actor?.getRollData() ?? {};
-    const data = { ...actorRollData, item: { ...this } };
-    return data;
-  }
-}
+    /**
+     * Obtain a data object used to evaluate any dice rolls associated with this Item Type
+     * @param {object} [options] - Options which modify the getRollData method.
+     * @returns {object}
+     */
+    getRollData(options = {}) {
+        const actorRollData = this.actor?.getRollData() ?? {};
+        const data = { ...actorRollData, item: { ...this } };
+        return data;
+    }
+}

module/data/item/class.mjs

@@ -1,5 +1,6 @@
 import BaseDataItem from './base.mjs';
 import ForeignDocumentUUIDField from '../fields/foreignDocumentUUIDField.mjs';
+import ForeignDocumentUUIDArrayField from '../fields/foreignDocumentUUIDArrayField.mjs';
 import ActionField from '../fields/actionField.mjs';
 
 export default class DHClass extends BaseDataItem {
@@ -18,23 +19,16 @@ export default class DHClass extends BaseDataItem {
         return {
             ...super.defineSchema(),
             domains: new fields.ArrayField(new fields.StringField(), { max: 2 }),
-            classItems: new fields.ArrayField(new ForeignDocumentUUIDField({ type: 'Item' })),
+            classItems: new ForeignDocumentUUIDArrayField({ type: 'Item', required: false }),
+
             evasion: new fields.NumberField({ initial: 0, integer: true }),
             hopeFeatures: new foundry.data.fields.ArrayField(new ActionField()),
             classFeatures: new foundry.data.fields.ArrayField(new ActionField()),
-            subclasses: new fields.ArrayField(
-                new ForeignDocumentUUIDField({ type: 'Item', required: false, nullable: true, initial: undefined })
-            ),
+            subclasses: new ForeignDocumentUUIDArrayField({ type: 'Item', required: false }),
             inventory: new fields.SchemaField({
-                take: new fields.ArrayField(
-                    new ForeignDocumentUUIDField({ type: 'Item', required: false, nullable: true, initial: undefined })
-                ),
-                choiceA: new fields.ArrayField(
-                    new ForeignDocumentUUIDField({ type: 'Item', required: false, nullable: true, initial: undefined })
-                ),
-                choiceB: new fields.ArrayField(
-                    new ForeignDocumentUUIDField({ type: 'Item', required: false, nullable: true, initial: undefined })
-                )
+                take: new ForeignDocumentUUIDArrayField({ type: 'Item', required: false }),
+                choiceA: new ForeignDocumentUUIDArrayField({ type: 'Item', required: false }),
+                choiceB: new ForeignDocumentUUIDArrayField({ type: 'Item', required: false })
             }),
             characterGuide: new fields.SchemaField({
                 suggestedTraits: new fields.SchemaField({

module/data/item/consumable.mjs

@@ -1,14 +1,14 @@
-import BaseDataItem from "./base.mjs";
+import BaseDataItem from './base.mjs';
 import ActionField from '../fields/actionField.mjs';
 
 export default class DHConsumable extends BaseDataItem {
-     /** @inheritDoc */
+    /** @inheritDoc */
     static get metadata() {
         return foundry.utils.mergeObject(super.metadata, {
-            label: "TYPES.Item.consumable",
-            type: "consumable",
+            label: 'TYPES.Item.consumable',
+            type: 'consumable',
             hasDescription: true,
-            isQuantifiable: true,
+            isQuantifiable: true
         });
     }
 

module/data/item/miscellaneous.mjs

@@ -5,10 +5,10 @@ export default class DHMiscellaneous extends BaseDataItem {
     /** @inheritDoc */
     static get metadata() {
         return foundry.utils.mergeObject(super.metadata, {
-            label: "TYPES.Item.miscellaneous",
-            type: "miscellaneous",
+            label: 'TYPES.Item.miscellaneous',
+            type: 'miscellaneous',
             hasDescription: true,
-            isQuantifiable: true,
+            isQuantifiable: true
         });
     }
 

module/data/item/subclass.mjs

@@ -1,11 +1,11 @@
 import ActionField from '../fields/actionField.mjs';
-import ForeignDocumentUUIDField from '../fields/foreignDocumentUUIDField.mjs';
+import ForeignDocumentUUIDArrayField from '../fields/foreignDocumentUUIDArrayField.mjs';
 import BaseDataItem from './base.mjs';
 
 const featureSchema = () => {
     return new foundry.data.fields.SchemaField({
         name: new foundry.data.fields.StringField({ required: true }),
-        effects: new foundry.data.fields.ArrayField(new ForeignDocumentUUIDField({ type: 'ActiveEffect' })),
+        effects: new ForeignDocumentUUIDArrayField({ type: 'ActiveEffect', required: false }),
         actions: new foundry.data.fields.ArrayField(new ActionField())
     });
 };
@@ -64,7 +64,7 @@ export default class DHSubclass extends BaseDataItem {
             } else if (subclassData) {
                 ui.notifications.error(game.i18n.localize('DAGGERHEART.Item.Errors.SubclassAlreadySelected'));
                 return false;
-            } else if (classData.system.subclasses.every(x => x.uuid !== `Item.${data._id}`)) {
+            } else if (classData.system.subclasses.every(x => x.uuid !== (data.uuid ?? `Item.${data._id}`))) {
                 ui.notifications.error(game.i18n.localize('DAGGERHEART.Item.Errors.SubclassNotInClass'));
                 return false;
             }