Merge branch 'main' into feature/148-Character-Setup

module/applications/_module.mjs

@@ -13,5 +13,3 @@ export { default as DhpArmor } from './sheets/items/armor.mjs';
 export { default as DhpChatMessage } from './chatMessage.mjs';
 export { default as DhpEnvironment } from './sheets/environment.mjs';
 export { default as DhActiveEffectConfig } from './sheets/activeEffectConfig.mjs';
-
-export * as pseudoDocumentSheet from './sheets/pseudo-documents/_module.mjs';

module/applications/sheets/pseudo-documents/_module.mjs

@@ -1 +0,0 @@
-export {default as PseudoDocumentSheet }from "./pseudo-documents-sheet.mjs";

module/applications/sheets/pseudo-documents/pseudo-documents-sheet.mjs

@@ -1,66 +0,0 @@
-const { ApplicationV2, HandlebarsApplicationMixin } = foundry.applications.api;
-
-export default class PseudoDocumentSheet extends HandlebarsApplicationMixin(ApplicationV2) {
-  constructor(options) {
-    super(options);
-    this.#pseudoDocument = options.document;
-  }
-
-  /**
-  * The UUID of the associated pseudo-document
-  * @type {string}
-  */
-  get pseudoUuid() {
-    return this.pseudoDocument.uuid;
-  }
-
-  #pseudoDocument;
-
-  /**
-   * The pseudo-document instance this sheet represents
-   * @type {object}
-   */
-  get pseudoDocument() {
-    return this.#pseudoDocument;
-  }
-
-  static DEFAULT_OPTIONS = {
-    tag: 'form',
-    classes: ['daggerheart', 'sheet'],
-    position: { width: 600 },
-    form: {
-      handler: PseudoDocumentSheet.#onSubmitForm,
-      submitOnChange: true,
-      closeOnSubmit: false
-    },
-    dragDrop: [{ dragSelector: null, dropSelector: null }],
-  };
-
-  static PARTS = {
-    header: { template: 'systems/daggerheart/templates/sheets/pseudo-documents/header.hbs' },
-  };
-
-  /** @inheritDoc */
-  async _prepareContext(options) {
-    const context = await super._prepareContext(options);
-    const document = this.pseudoDocument;
-    return Object.assign(context, {
-      document,
-      source: document._source,
-      editable: this.isEditable,
-      user: game.user,
-      rootId: this.id,
-    });
-  }
-
-  /**
-   * Form submission handler
-   * @param {SubmitEvent | Event} event - The originating form submission or input change event
-   * @param {HTMLFormElement} form - The form element that was submitted
-   * @param {foundry.applications.ux.FormDataExtended} formData - Processed data for the submitted form
-   */
-  static async #onSubmitForm(event, form, formData) {
-    const submitData = foundry.utils.expandObject(formData.object);
-    await this.pseudoDocument.update(submitData);
-  }
-}

module/config/pseudoConfig.mjs

@@ -1,17 +0,0 @@
-import { pseudoDocuments } from "../data/_module.mjs";
-import { pseudoDocumentSheet } from "../applications/_module.mjs";
-
-//CONFIG.daggerheart.pseudoDocuments
-export default {
-  sheetClass: pseudoDocumentSheet.PseudoDocumentSheet,
-  feature: {
-    label: "DAGGERHEART.Feature.Label",
-    documentClass: pseudoDocuments.feature.BaseFeatureData,
-    types: {
-      weapon: {
-        label: "DAGGERHEART.Feature.Weapon.Label",
-        documentClass: pseudoDocuments.feature.WeaponFeature,
-      }
-    }
-  }
-};

module/config/system.mjs

@@ -5,7 +5,6 @@ import * as ITEM from './itemConfig.mjs';
 import * as SETTINGS from './settingsConfig.mjs';
 import * as EFFECTS from './effectConfig.mjs';
 import * as ACTIONS from './actionConfig.mjs';
-import pseudoDocuments from "./pseudoConfig.mjs";
 
 export const SYSTEM_ID = 'daggerheart';
 
@@ -18,5 +17,4 @@ export const SYSTEM = {
     SETTINGS,
     EFFECTS,
     ACTIONS,
-    pseudoDocuments
 };

module/data/_module.mjs

@@ -1,5 +1,3 @@
-export { default as DhClass } from './item/class.mjs';
-export { default as DhSubclass } from './item/subclass.mjs';
 export { default as DhCombat } from './combat.mjs';
 export { default as DhCombatant } from './combatant.mjs';
 
@@ -8,4 +6,3 @@ export * as items from './item/_module.mjs';
 export { actionsTypes } from './action/_module.mjs';
 export * as messages from './chat-message/_modules.mjs';
 export * as fields from './fields/_module.mjs';
-export * as pseudoDocuments from './pseudo-documents/_module.mjs';

module/data/fields/_module.mjs

@@ -1,3 +1,3 @@
 export { default as FormulaField } from './formulaField.mjs';
 export { default as ForeignDocumentUUIDField } from './foreignDocumentUUIDField.mjs';
-export { default as PseudoDocumentsField } from './pseudoDocumentsField.mjs';
+export { default as ForeignDocumentUUIDArrayField } from './foreignDocumentUUIDArrayField.mjs';

module/data/fields/foreignDocumentUUIDArrayField.mjs

@@ -0,0 +1,20 @@
+import ForeignDocumentUUIDField from './foreignDocumentUUIDField.mjs';
+/**
+ * A subclass of {@link foundry.data.fields.ArrayField} that defines an array of foreign document UUID references.
+ */
+export default class ForeignDocumentUUIDArrayField extends foundry.data.fields.ArrayField {
+    /**
+     * @param {foundry.data.types.DocumentUUIDFieldOptions} [fieldOption] - Options to configure each individual ForeignDocumentUUIDField.
+     * @param {foundry.data.types.ArrayFieldOptions} [options] - Options to configure the array behavior
+     * @param {foundry.data.types.DataFieldContext} [context] -  Optional context for schema processing
+     */
+    constructor(fieldOption = {}, options = {}, context = {}) {
+        super(new ForeignDocumentUUIDField(fieldOption), options, context);
+    }
+
+    /** @inheritdoc */
+    initialize(value, model, options = {}) {
+        const v = super.initialize(value, model, options);
+        return () => v.map(entry => (typeof entry === 'function' ? entry() : entry));
+    }
+}

module/data/fields/foreignDocumentUUIDField.mjs

@@ -23,7 +23,7 @@ export default class ForeignDocumentUUIDField extends foundry.data.fields.Docume
     /**@override */
     initialize(value, _model, _options = {}) {
         if (this.idOnly) return value;
-        return (() => {
+        return () => {
             try {
                 const doc = fromUuidSync(value);
                 return doc;
@@ -31,7 +31,7 @@ export default class ForeignDocumentUUIDField extends foundry.data.fields.Docume
                 console.error(error);
                 return value ?? null;
             }
-        })();
+        };
     }
 
     /**@override */

module/data/fields/pseudoDocumentsField.mjs

@@ -1,56 +0,0 @@
-import PseudoDocument from '../pseudo-documents/base/pseudoDocument.mjs';
-
-const { TypedObjectField, TypedSchemaField } = foundry.data.fields;
-
-/**
- * @typedef _PseudoDocumentsFieldOptions
- * @property {Number} [max] - The maximum amount of elements (default: `Infinity`)
- * @property {String[]} [validTypes] - Allowed pseudo-documents types (default: `[]`)
- * @property {Function} [validateKey] - callback for validate keys of the object;
-
- * @typedef {foundry.data.types.DataFieldOptions & _PseudoDocumentsFieldOptions} PseudoDocumentsFieldOptions
- */
-export default class PseudoDocumentsField extends TypedObjectField {
-    /**
-     * @param {PseudoDocument} model - The PseudoDocument of each entry in this collection.
-     * @param {PseudoDocumentsFieldOptions} [options] - Options which configure the behavior of the field
-     * @param {foundry.data.types.DataFieldContext} [context] - Additional context which describes the field
-     */
-    constructor(model, options = {}, context = {}) {
-        options.validateKey ||= key => foundry.data.validators.isValidId(key);
-        if (!foundry.utils.isSubclass(model, PseudoDocument)) throw new Error('The model must be a PseudoDocument');
-
-        const allTypes = model.TYPES;
-
-        const filteredTypes = options.validTypes
-            ? Object.fromEntries(
-                Object.entries(allTypes).filter(([key]) => options.validTypes.includes(key))
-            )
-            : allTypes;
-
-        const field = new TypedSchemaField(filteredTypes);
-        super(field, options, context);
-    }
-
-    /** @inheritdoc */
-    static get _defaults() {
-        return Object.assign(super._defaults, {
-            max: Infinity,
-            validTypes: []
-        });
-    }
-
-    /** @override */
-    _validateType(value, options = {}) {
-        if (Object.keys(value).length > this.max) throw new Error(`cannot have more than ${this.max} elements`);
-        return super._validateType(value, options);
-    }
-
-    /** @override */
-    initialize(value, model, options = {}) {
-        if (!value) return;
-        value = super.initialize(value, model, options);
-        const collection = new foundry.utils.Collection(Object.values(value).map(d => [d._id, d]));
-        return collection;
-    }
-}

module/data/item/base.mjs

@@ -5,7 +5,6 @@
  * @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;
@@ -18,7 +17,6 @@ export default class BaseDataItem extends foundry.abstract.TypeDataModel {
       type: "base",
       hasDescription: false,
       isQuantifiable: false,
-      embedded: {},
     };
   }
 

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(
+            subclasses: new ForeignDocumentUUIDArrayField({type: 'Item', required: false}),
-                new ForeignDocumentUUIDField({ type: 'Item', required: false, nullable: true, initial: undefined })
-            ),
             inventory: new fields.SchemaField({
-                take: new fields.ArrayField(
+                take: new ForeignDocumentUUIDArrayField({type: 'Item', required: false}),
-                    new ForeignDocumentUUIDField({ type: 'Item', required: false, nullable: true, initial: undefined })
+                choiceA: new ForeignDocumentUUIDArrayField({type: 'Item', required: false}),
-                ),
+                choiceB: new ForeignDocumentUUIDArrayField({type: 'Item', required: false}),
-                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 })
-                )
             }),
             characterGuide: new fields.SchemaField({
                 suggestedTraits: new fields.SchemaField({

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: 'Item', required: false}),
         actions: new foundry.data.fields.ArrayField(new ActionField())
     });
 };

module/data/pseudo-documents/_module.mjs

@@ -1,2 +0,0 @@
-export { default as base } from './base/pseudoDocument.mjs';
-export * as feature from './feature/_module.mjs';

module/data/pseudo-documents/base/base.mjs

@@ -1,213 +0,0 @@
-/**
- * @typedef {object} PseudoDocumentMetadata
- * @property {string} name - The document name of this pseudo-document
- * @property {Record<string, string>} embedded - Record of document names and their collection paths
- * @property {typeof foundry.applications.api.ApplicationV2} [sheetClass] - The class used to render this pseudo-document
- * @property {string} defaultArtwork - The default image used for newly created documents
- */
-
-/**
- * @class Base class for pseudo-documents
- * @extends {foundry.abstract.DataModel}
- */
-export default class BasePseudoDocument extends foundry.abstract.DataModel {
-    /**
-     * Pseudo-document metadata.
-     * @returns {PseudoDocumentMetadata}
-     */
-    static get metadata() {
-        return {
-            name: '',
-            embedded: {},
-            defaultArtwork: foundry.documents.Item.DEFAULT_ICON,
-            sheetClass: CONFIG.daggerheart.pseudoDocuments.sheetClass,
-        };
-    }
-
-    /** @override */
-    static LOCALIZATION_PREFIXES = ['DOCUMENT'];
-
-    /** @inheritdoc */
-    static defineSchema() {
-        const { fields } = foundry.data;
-
-        return {
-            _id: new fields.DocumentIdField({ initial: () => foundry.utils.randomID() }),
-            name: new fields.StringField({ required: true, blank: false, textSearch: true }),
-            img: new fields.FilePathField({ categories: ['IMAGE'], initial: this.metadata.defaultArtwork }),
-            description: new fields.HTMLField({ textSearch: true })
-        };
-    }
-
-    /* -------------------------------------------- */
-    /*  Instance Properties                         */
-    /* -------------------------------------------- */
-
-    /**
-     * The id of this pseudo-document.
-     * @type {string}
-     */
-    get id() {
-        return this._id;
-    }
-
-    /* -------------------------------------------- */
-
-    /**
-     * The uuid of this document.
-     * @type {string}
-     */
-    get uuid() {
-        let parent = this.parent;
-        while (!(parent instanceof BasePseudoDocument) && !(parent instanceof foundry.abstract.Document))
-            parent = parent.parent;
-        return [parent.uuid, this.constructor.metadata.name, this.id].join('.');
-    }
-
-    /* -------------------------------------------- */
-
-    /**
-     * The parent document of this pseudo-document.
-     * @type {foundry.abstract.Document}
-     */
-    get document() {
-        let parent = this;
-        while (!(parent instanceof foundry.abstract.Document)) parent = parent.parent;
-        return parent;
-    }
-
-    /* -------------------------------------------- */
-
-    /**
-     * Item to which this PseudoDocument belongs, if applicable.
-     * @type {foundry.documents.Item|null}
-     */
-    get item() {
-        return this.parent?.parent instanceof Item ? this.parent.parent : null;
-    }
-
-    /* -------------------------------------------- */
-
-    /**
-     * Actor to which this PseudoDocument's item belongs, if the item is embedded.
-     * @type {foundry.documents.Actor|null}
-     */
-    get actor() {
-        return this.item?.parent ?? null;
-    }
-
-    /* -------------------------------------------- */
-
-    /**
-     * The property path to this pseudo document relative to its parent document.
-     * @type {string}
-     */
-    get fieldPath() {
-        const fp = this.schema.fieldPath;
-        let path = fp.slice(0, fp.lastIndexOf('element') - 1);
-
-        if (this.parent instanceof BasePseudoDocument) {
-            path = [this.parent.fieldPath, this.parent.id, path].join('.');
-        }
-
-        return path;
-    }
-
-    /* -------------------------------------------- */
-    /*  Embedded Document Methods                   */
-    /* -------------------------------------------- */
-
-    /**
-     * Retrieve an embedded pseudo-document.
-     * @param {string} embeddedName         The document name of the embedded pseudo-document.
-     * @param {string} id                   The id of the embedded pseudo-document.
-     * @param {object} [options]            Retrieval options.
-     * @param {boolean} [options.strinct]   Throw an error if the embedded pseudo-document does not exist?
-     * @returns {PseudoDocument|null}
-     */
-    getEmbeddedDocument(embeddedName, id, { strict = false } = {}) {
-        const embeds = this.constructor.metadata.embedded ?? {};
-        if (embeddedName in embeds) {
-            return foundry.utils.getProperty(this, embeds[embeddedName]).get(id, { strict }) ?? null;
-        }
-        return null;
-    }
-
-    /* -------------------------------------------- */
-    /*  CRUD Operations                             */
-    /* -------------------------------------------- */
-
-    /**
-     * Does this pseudo-document exist in the document's source?
-     * @type {boolean}
-     */
-    get isSource() {
-        const source = foundry.utils.getProperty(this.document._source, this.fieldPath);
-        if (foundry.utils.getType(source) !== 'Object') {
-            throw new Error('Source is not an object!');
-        }
-        return this.id in source;
-    }
-
-    /**
-     * Create a new instance of this pseudo-document.
-     * @param {object} [data]                                 The data used for the creation.
-     * @param {object} operation                              The context of the update operation.
-     * @param {foundry.abstract.Document} operation.parent    The parent of this document.
-     * @returns {Promise<foundry.abstract.Document>}          A promise that resolves to the updated document.
-     */
-    static async create(data = {}, { parent, ...operation } = {}) {
-        if (!parent) {
-            throw new Error('A parent document must be specified for the creation of a pseudo-document!');
-        }
-        const id =
-            operation.keepId && foundry.data.validators.isValidId(data._id) ? data._id : foundry.utils.randomID();
-
-        const fieldPath = parent.system.constructor.metadata.embedded?.[this.metadata.name];
-        if (!fieldPath) {
-            throw new Error(
-                `A ${parent.documentName} of type '${parent.type}' does not support ${this.metadata.name}!`
-            );
-        }
-
-        const update = { [`system.${fieldPath}.${id}`]: { ...data, _id: id } };
-        const updatedParent = await parent.update(update, operation);
-        return foundry.utils.getProperty(updatedParent, `system.${fieldPath}.${id}`);
-    }
-
-    /**
-     * Delete this pseudo-document.
-     * @param {object} [operation]                      The context of the operation.
-     * @returns {Promise<foundry.abstract.Document>}    A promise that resolves to the updated document.
-     */
-    async delete(operation = {}) {
-        if (!this.isSource) throw new Error('You cannot delete a non-source pseudo-document!');
-        const update = { [`${this.fieldPath}.-=${this.id}`]: null };
-        return this.document.update(update, operation);
-    }
-
-    /**
-     * Duplicate this pseudo-document.
-     * @returns {Promise<foundry.abstract.Document>}    A promise that resolves to the updated document.
-     */
-    async duplicate() {
-        if (!this.isSource) throw new Error('You cannot duplicate a non-source pseudo-document!');
-        const docData = foundry.utils.mergeObject(this.toObject(), {
-            name: game.i18n.format('DOCUMENT.CopyOf', { name: this.name })
-        });
-        return this.constructor.create(docData, { parent: this.document });
-    }
-
-    /**
-     * Update this pseudo-document.
-     * @param {object} [change]                         The change to perform.
-     * @param {object} [operation]                      The context of the operation.
-     * @returns {Promise<foundry.abstract.Document>}    A promise that resolves to the updated document.
-     */
-    async update(change = {}, operation = {}) {
-        if (!this.isSource) throw new Error('You cannot update a non-source pseudo-document!');
-        const path = [this.fieldPath, this.id].join('.');
-        const update = { [path]: change };
-        return this.document.update(update, operation);
-    }
-}

module/data/pseudo-documents/base/pseudoDocument.mjs

@@ -1,59 +0,0 @@
-import BasePseudoDocument from './base.mjs';
-import SheetManagementMixin from './sheetManagementMixin.mjs';
-
-/** @extends BasePseudoDocument */
-export default class PseudoDocument extends SheetManagementMixin(BasePseudoDocument) {
-    static get TYPES() {
-        const { types } = CONFIG.daggerheart.pseudoDocuments[this.metadata.name];
-        const typeEntries = Object.entries(types).map(([key, { documentClass }]) => [key, documentClass]);
-        return (this._TYPES ??= Object.freeze(Object.fromEntries(typeEntries)));
-    }
-
-    static _TYPES;
-
-    /**
-     * The type of this shape.
-     * @type {string}
-     */
-    static TYPE = '';
-
-    /* -------------------------------------------- */
-
-    static getTypesChoices(validTypes) {
-        const { types } = CONFIG.daggerheart.pseudoDocuments[model.metadata.name];
-        const typeEntries = Object.entries(types)
-            .map(([key, { label }]) => [key, label])
-            .filter(([key]) => !validTypes || validTypes.includes(key));
-
-        return Object.entries(typeEntries);
-    }
-
-    /* -------------------------------------------- */
-
-    /** @override */
-    static defineSchema() {
-        const { fields } = foundry.data;
-
-        return Object.assign(super.defineSchema(), {
-            type: new fields.StringField({
-                required: true,
-                blank: false,
-                initial: this.TYPE,
-                validate: value => value === this.TYPE,
-                validationError: `must be equal to "${this.TYPE}"`
-            })
-        });
-    }
-
-    /** @inheritdoc */
-    static async create(data = {}, { parent, ...operation } = {}) {
-        data = foundry.utils.deepClone(data);
-        if (!data.type) data.type = Object.keys(this.TYPES)[0];
-        if (!(data.type in this.TYPES)) {
-            throw new Error(
-                `The '${data.type}' type is not a valid type for a '${this.metadata.documentName}' pseudo-document!`
-            );
-        }
-        return super.create(data, { parent, ...operation });
-    }
-}

module/data/pseudo-documents/base/sheetManagementMixin.mjs

@@ -1,158 +0,0 @@
-import BasePseudoDocument from './base.mjs';
-const { ApplicationV2 } = foundry.applications.api;
-
-/**
- * A mixin that adds sheet management capabilities to pseudo-documents
- * @template {typeof BasePseudoDocument} T
- * @param {T} Base
- * @returns {T & typeof PseudoDocumentWithSheets}
- */
-export default function SheetManagementMixin(Base) {
-    class PseudoDocumentWithSheets extends Base {
-        /**
-         * Reference to the sheet of this pseudo-document.
-         * @type {ApplicationV2|null}
-         */
-        get sheet() {
-            if (this._sheet) return this._sheet;
-            const cls = this.constructor.metadata.sheetClass ?? ApplicationV2;
-            
-            if (!foundry.utils.isSubclass(cls, ApplicationV2)) {
-                return void ui.notifications.error(
-                    'Daggerheart | Error on PseudoDocument | sheetClass must be ApplicationV2'
-                );
-            }
-
-            const sheet = new cls({ document: this });
-            this._sheet = sheet;
-            return sheet;
-        }
-
-        /* -------------------------------------------- */
-        /*  Static Properties                           */
-        /* -------------------------------------------- */
-
-        /**
-         * Set of apps what should be re-render.
-         * @type {Set<ApplicationV2>}
-         * @internal
-         */
-        _apps = new Set();
-
-        /* -------------------------------------------- */
-
-        /**
-         * Existing sheets of a specific type for a specific document.
-         * @type {ApplicationV2 | null}
-         */
-        _sheet = null;
-
-        /* -------------------------------------------- */
-        /*  Display Methods                             */
-        /* -------------------------------------------- */
-
-        /**
-         * Render all the Application instances which are connected to this PseudoDocument.
-         * @param {ApplicationRenderOptions} [options]  Rendering options.
-         */
-        render(options) {
-            for (const app of this._apps ?? []) {
-                app.render({ window: { title: app.title }, ...options });
-            }
-        }
-
-        /* -------------------------------------------- */
-
-        /**
-         * Register an application to respond to updates to a certain document.
-         * @param {ApplicationV2} app     Application to update.
-         * @internal
-         */
-        _registerApp(app) {
-            this._apps.add(app);
-        }
-
-        /* -------------------------------------------- */
-
-        /**
-         * Remove an application from the render registry.
-         * @param {ApplicationV2} app     Application to stop watching.
-         */
-        _unregisterApp(app) {
-            this._apps.delete(app);
-        }
-
-        /* -------------------------------------------- */
-        /*  Drag and Drop                               */
-        /* -------------------------------------------- */
-
-        /**
-         * Serialize salient information for this PseudoDocument when dragging it.
-         * @returns {object}  An object of drag data.
-         */
-        toDragData() {
-            const dragData = { type: this.documentName, data: this.toObject() };
-            if (this.id) dragData.uuid = this.uuid;
-            return dragData;
-        }
-
-        /* -------------------------------------------- */
-        /*  Dialog Methods                              */
-        /* -------------------------------------------- */
-
-        /**
-         * Spawn a dialog for creating a new PseudoDocument.
-         * @param {object} [data]  Data to pre-populate the document with.
-         * @param {object} context
-         * @param {foundry.documents.Item} context.parent        A parent for the document.
-         * @param {string[]|null} [context.types]  A list of types to restrict the choices to, or null for no restriction.
-         * @returns {Promise<BasePseudoDocument|null>}
-         */
-        static async createDialog(data = {}, { parent, types = null, ...options } = {}) {
-            // TODO
-        }
-
-        /**
-         * Present a Dialog form to confirm deletion of this PseudoDocument.
-         * @param {object} [options] - Additional options passed to `DialogV2.confirm`;
-         * @returns {Promise<foundry.abstract.Document>}  A Promise which resolves to the deleted PseudoDocument.
-         */
-        async deleteDialog(options = {}) {
-            const type = game.i18n.localize(this.constructor.metadata.label);
-            const content = options.content ?? `<p>
-            <strong>${game.i18n.localize("AreYouSure")}</strong>
-            ${game.i18n.format("SIDEBAR.DeleteWarning", { type })}
-            </p>`;
-
-            return foundry.applications.api.DialogV2.confirm({
-                content,
-                yes: { callback: () => this.delete(operation) },
-                window: {
-                    icon: "fa-solid fa-trash",
-                    title: `${game.i18n.format("DOCUMENT.Delete", { type })}: ${this.name}`
-                },
-                ...options
-            });
-        }
-
-        /**
-         * Gets the default new name for a Document
-         * @param {object} collection - Collection of Documents
-         * @returns {string}
-         */
-        static defaultName(collection) {
-            const documentName = this.metadata.name;
-            const takenNames = new Set();
-            for (const document of collection) takenNames.add(document.name);
-
-            const config = CONFIG.daggerheart.pseudoDocuments[documentName];
-            const baseName = game.i18n.localize(config.label);
-            let name = baseName;
-            let index = 1;
-            while (takenNames.has(name)) name = `${baseName} (${++index})`;
-            return name;
-        }
-    }
-
-    return PseudoDocumentWithSheets;
-}

module/data/pseudo-documents/feature/_module.mjs

@@ -1,2 +0,0 @@
-export { default as BaseFeatureData } from './baseFeatureData.mjs';
-export { default as WeaponFeature } from './weaponFeature.mjs';

module/data/pseudo-documents/feature/baseFeatureData.mjs

@@ -1,24 +0,0 @@
-import PseudoDocument from '../base/pseudoDocument.mjs';
-
-export default class BaseFeatureData extends PseudoDocument {
-    /**@inheritdoc */
-    static get metadata() {
-        return foundry.utils.mergeObject(
-            super.metadata,
-            {
-                name: 'feature',
-                embedded: {},
-                //sheetClass: null //TODO: define feature-sheet
-            },
-            { inplace: false }
-        );
-    }
-
-    static defineSchema() {
-        const { fields } = foundry.data;
-        const schema = super.defineSchema();
-        return Object.assign(schema, {
-            subtype: new fields.StringField({ initial: 'test' })
-        });
-    }
-}

module/data/pseudo-documents/feature/weaponFeature.mjs

@@ -1,6 +0,0 @@
-import BaseFeatureData from './baseFeatureData.mjs';
-
-export default class WeaponFeature extends BaseFeatureData {
-    /**@override */
-    static TYPE = 'weapon';
-}