Merge branch 'refactor/84-data-models-structure' into feature/109-LevelUp-Followup

module/data/_module.mjs

@@ -5,4 +5,7 @@ export { default as DhCombatant } from './combatant.mjs';
 
 export * as actors from './actor/_module.mjs';
 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/action.mjs

@@ -1,34 +0,0 @@
-export default class DaggerheartAction extends foundry.abstract.DataModel {
-    static defineSchema() {
-        const fields = foundry.data.fields;
-        return {
-            id: new fields.DocumentIdField(),
-            name: new fields.StringField({ initial: 'New Action' }),
-            damage: new fields.SchemaField({
-                type: new fields.StringField({ choices: SYSTEM.GENERAL.damageTypes, nullable: true, initial: null }),
-                value: new fields.StringField({})
-            }),
-            healing: new fields.SchemaField({
-                type: new fields.StringField({ choices: SYSTEM.GENERAL.healingTypes, nullable: true, initial: null }),
-                value: new fields.StringField()
-            }),
-            conditions: new fields.ArrayField(
-                new fields.SchemaField({
-                    name: new fields.StringField(),
-                    icon: new fields.StringField(),
-                    description: new fields.StringField()
-                })
-            ),
-            cost: new fields.SchemaField({
-                type: new fields.StringField({ choices: SYSTEM.GENERAL.abilityCosts, nullable: true, initial: null }),
-                value: new fields.NumberField({ nullable: true, initial: null })
-            }),
-            target: new fields.SchemaField({
-                type: new fields.StringField({
-                    choices: SYSTEM.ACTIONS.targetTypes,
-                    initial: SYSTEM.ACTIONS.targetTypes.other.id
-                })
-            })
-        };
-    }
-}

module/data/action/_module.mjs

@@ -0,0 +1,23 @@
+import {
+    DHAttackAction,
+    DHBaseAction,
+    DHDamageAction,
+    DHEffectAction,
+    DHHealingAction,
+    DHMacroAction,
+    DHResourceAction,
+    DHSpellCastAction,
+    DHSummonAction
+} from './action.mjs';
+
+export const actionsTypes = {
+    base: DHBaseAction,
+    attack: DHAttackAction,
+    spellcast: DHSpellCastAction,
+    resource: DHResourceAction,
+    damage: DHDamageAction,
+    healing: DHHealingAction,
+    summon: DHSummonAction,
+    effect: DHEffectAction,
+    macro: DHMacroAction
+};

module/data/action/action.mjs

@@ -0,0 +1,386 @@
+import { abilities } from '../../config/actorConfig.mjs';
+import { DHActionDiceData, DHDamageData, DHDamageField } from './actionDice.mjs';
+
+export default class DHAction extends foundry.abstract.DataModel {
+    static defineSchema() {
+        const fields = foundry.data.fields;
+        return {
+            id: new fields.DocumentIdField(),
+            name: new fields.StringField({ initial: 'New Action' }),
+            damage: new fields.SchemaField({
+                type: new fields.StringField({ choices: SYSTEM.GENERAL.damageTypes, nullable: true, initial: null }),
+                value: new fields.StringField({})
+            }),
+            healing: new fields.SchemaField({
+                type: new fields.StringField({ choices: SYSTEM.GENERAL.healingTypes, nullable: true, initial: null }),
+                value: new fields.StringField()
+            }),
+            conditions: new fields.ArrayField(
+                new fields.SchemaField({
+                    name: new fields.StringField(),
+                    icon: new fields.StringField(),
+                    description: new fields.StringField()
+                })
+            ),
+            cost: new fields.SchemaField({
+                type: new fields.StringField({ choices: SYSTEM.GENERAL.abilityCosts, nullable: true, initial: null }),
+                value: new fields.NumberField({ nullable: true, initial: null })
+            }),
+            target: new fields.SchemaField({
+                type: new fields.StringField({
+                    choices: SYSTEM.ACTIONS.targetTypes,
+                    initial: SYSTEM.ACTIONS.targetTypes.other.id
+                })
+            })
+        };
+    }
+}
+
+const fields = foundry.data.fields;
+
+/*
+    ToDo
+    - Apply ActiveEffect => Add to Chat message like Damage Button ?
+    - Add Drag & Drop for documentUUID field (Macro & Summon)
+    - Add optionnal Role for Healing ?
+    - Handle Roll result as part of formula if needed
+    - Target Check
+    - Cost Check
+    - Range Check
+    - Area of effect and measurement placement
+    - Auto use costs and action
+*/
+
+export class DHBaseAction extends foundry.abstract.DataModel {
+    static defineSchema() {
+        return {
+            _id: new fields.DocumentIdField(),
+            type: new fields.StringField({ initial: undefined, readonly: true, required: true }),
+            name: new fields.StringField({ initial: undefined }),
+            img: new fields.FilePathField({ initial: undefined, categories: ['IMAGE'], base64: false }),
+            actionType: new fields.StringField({ choices: SYSTEM.ITEM.actionTypes, initial: 'action', nullable: true }),
+            cost: new fields.ArrayField(
+                new fields.SchemaField({
+                    type: new fields.StringField({
+                        choices: SYSTEM.GENERAL.abilityCosts,
+                        nullable: false,
+                        required: true,
+                        initial: 'hope'
+                    }),
+                    value: new fields.NumberField({ nullable: true, initial: 1 }),
+                    scalable: new fields.BooleanField({ initial: false }),
+                    step: new fields.NumberField({ nullable: true, initial: null })
+                })
+            ),
+            uses: new fields.SchemaField({
+                value: new fields.NumberField({ nullable: true, initial: null }),
+                max: new fields.NumberField({ nullable: true, initial: null }),
+                recovery: new fields.StringField({
+                    choices: SYSTEM.GENERAL.refreshTypes,
+                    initial: null,
+                    nullable: true
+                })
+            }),
+            range: new fields.StringField({
+                choices: SYSTEM.GENERAL.range,
+                required: true,
+                blank: false,
+                initial: 'self'
+            })
+        };
+    }
+
+    prepareData() {}
+
+    get index() {
+        return this.parent.actions.indexOf(this);
+    }
+
+    get item() {
+        return this.parent.parent;
+    }
+
+    get actor() {
+        return this.item?.actor;
+    }
+
+    get chatTemplate() {
+        return 'systems/daggerheart/templates/chat/attack-roll.hbs';
+    }
+
+    static getRollType() {
+        return 'ability';
+    }
+
+    static getSourceConfig(parent) {
+        const updateSource = {};
+        updateSource.img ??= parent?.img ?? parent?.system?.img;
+        if (parent?.system?.trait) {
+            updateSource['roll'] = {
+                type: this.getRollType(),
+                trait: parent.system.trait
+            };
+        }
+        if (parent?.system?.range) {
+            updateSource['range'] = parent?.system?.range;
+        }
+        return updateSource;
+    }
+
+    async use(event) {
+        if (this.roll.type && this.roll.trait) {
+            const modifierValue = this.actor.system.traits[this.roll.trait].value;
+            const config = {
+                event: event,
+                title: this.item.name,
+                roll: {
+                    modifier: modifierValue,
+                    label: game.i18n.localize(abilities[this.roll.trait].label),
+                    type: this.actionType,
+                    difficulty: this.roll?.difficulty
+                },
+                chatMessage: {
+                    template: this.chatTemplate
+                }
+            };
+            if (this.target?.type) config.checkTarget = true;
+            if (this.damage.parts.length) {
+                config.damage = {
+                    value: this.damage.parts.map(p => p.getFormula(this.actor)).join(' + '),
+                    type: this.damage.parts[0].type
+                };
+            }
+            if (this.effects.length) {
+                // Apply Active Effects. In Chat Message ?
+            }
+            return this.actor.diceRoll(config);
+        }
+    }
+}
+
+const extraDefineSchema = (field, option) => {
+    return {
+        [field]: {
+            // damage: new fields.SchemaField({
+            //     parts: new fields.ArrayField(new fields.EmbeddedDataField(DHDamageData))
+            // }),
+            damage: new DHDamageField(option),
+            roll: new fields.SchemaField({
+                type: new fields.StringField({ nullable: true, initial: null, choices: SYSTEM.GENERAL.rollTypes }),
+                trait: new fields.StringField({ nullable: true, initial: null, choices: SYSTEM.ACTOR.abilities }),
+                difficulty: new fields.NumberField({ nullable: true, initial: null, integer: true, min: 0 })
+            }),
+            target: new fields.SchemaField({
+                type: new fields.StringField({
+                    choices: SYSTEM.ACTIONS.targetTypes,
+                    initial: SYSTEM.ACTIONS.targetTypes.other.id
+                })
+            }),
+            effects: new fields.ArrayField( // ActiveEffect
+                new fields.SchemaField({
+                    _id: new fields.DocumentIdField()
+                })
+            )
+        }[field]
+    };
+};
+
+export class DHAttackAction extends DHBaseAction {
+    static defineSchema() {
+        return {
+            ...super.defineSchema(),
+            ...extraDefineSchema('damage', true),
+            ...extraDefineSchema('roll'),
+            ...extraDefineSchema('target'),
+            ...extraDefineSchema('effects')
+        };
+    }
+
+    static getRollType() {
+        return 'weapon';
+    }
+
+    prepareData() {
+        super.prepareData();
+        if (this.damage.includeBase && !!this.item?.system?.damage) {
+            const baseDamage = this.getParentDamage();
+            this.damage.parts.unshift(new DHDamageData(baseDamage));
+        }
+    }
+
+    getParentDamage() {
+        return {
+            multiplier: 'proficiency',
+            dice: this.item?.system?.damage.value,
+            bonus: this.item?.system?.damage.bonus ?? 0,
+            type: this.item?.system?.damage.type,
+            base: true
+        };
+    }
+
+    // Temporary until full formula parser
+    // getDamageFormula() {
+    //     return this.damage.parts.map(p => p.formula).join(' + ');
+    // }
+}
+
+export class DHSpellCastAction extends DHBaseAction {
+    static defineSchema() {
+        return {
+            ...super.defineSchema(),
+            ...extraDefineSchema('damage'),
+            ...extraDefineSchema('roll'),
+            ...extraDefineSchema('target'),
+            ...extraDefineSchema('effects')
+        };
+    }
+
+    static getRollType() {
+        return 'spellcast';
+    }
+}
+
+export class DHDamageAction extends DHBaseAction {
+    static defineSchema() {
+        return {
+            ...super.defineSchema(),
+            ...extraDefineSchema('damage', false),
+            ...extraDefineSchema('target'),
+            ...extraDefineSchema('effects')
+        };
+    }
+
+    async use(event) {
+        const formula = this.damage.parts.map(p => p.getFormula(this.actor)).join(' + ');
+        if (!formula || formula == '') return;
+
+        let roll = { formula: formula, total: formula };
+        if (isNaN(formula)) {
+            roll = await new Roll(formula).evaluate();
+        }
+
+        const cls = getDocumentClass('ChatMessage');
+        const msg = new cls({
+            user: game.user.id,
+            content: await foundry.applications.handlebars.renderTemplate(
+                'systems/daggerheart/templates/chat/damage-roll.hbs',
+                {
+                    roll: roll.formula,
+                    total: roll.total,
+                    type: this.damage.parts.map(p => p.type)
+                }
+            )
+        });
+
+        cls.create(msg.toObject());
+    }
+}
+
+export class DHHealingAction extends DHBaseAction {
+    static defineSchema() {
+        return {
+            ...super.defineSchema(),
+            healing: new fields.SchemaField({
+                type: new fields.StringField({
+                    choices: SYSTEM.GENERAL.healingTypes,
+                    required: true,
+                    blank: false,
+                    initial: SYSTEM.GENERAL.healingTypes.health.id,
+                    label: 'Healing'
+                }),
+                value: new fields.EmbeddedDataField(DHActionDiceData)
+            }),
+            ...extraDefineSchema('target'),
+            ...extraDefineSchema('effects')
+        };
+    }
+
+    async use(event) {
+        const formula = this.healing.value.getFormula(this.actor);
+        if (!formula || formula == '') return;
+
+        // const roll = await super.use(event);
+        let roll = { formula: formula, total: formula };
+        if (isNaN(formula)) {
+            roll = await new Roll(formula).evaluate();
+        }
+
+        const cls = getDocumentClass('ChatMessage');
+        const msg = new cls({
+            user: game.user.id,
+            content: await foundry.applications.handlebars.renderTemplate(
+                'systems/daggerheart/templates/chat/healing-roll.hbs',
+                {
+                    roll: roll.formula,
+                    total: roll.total,
+                    type: this.healing.type
+                }
+            )
+        });
+
+        cls.create(msg.toObject());
+    }
+
+    get chatTemplate() {
+        return 'systems/daggerheart/templates/chat/healing-roll.hbs';
+    }
+}
+
+export class DHResourceAction extends DHBaseAction {
+    static defineSchema() {
+        return {
+            ...super.defineSchema(),
+            // ...extraDefineSchema('roll'),
+            ...extraDefineSchema('target'),
+            ...extraDefineSchema('effects'),
+            resource: new fields.SchemaField({
+                type: new fields.StringField({
+                    choices: [],
+                    blank: true,
+                    required: false,
+                    initial: '',
+                    label: 'Resource'
+                }),
+                value: new fields.NumberField({ initial: 0, label: 'Value' })
+            })
+        };
+    }
+}
+
+export class DHSummonAction extends DHBaseAction {
+    static defineSchema() {
+        return {
+            ...super.defineSchema(),
+            documentUUID: new fields.StringField({ blank: true, initial: '', placeholder: 'Enter a Creature UUID' })
+        };
+    }
+}
+
+export class DHEffectAction extends DHBaseAction {
+    static defineSchema() {
+        return {
+            ...super.defineSchema(),
+            ...extraDefineSchema('effects')
+        };
+    }
+}
+
+export class DHMacroAction extends DHBaseAction {
+    static defineSchema() {
+        return {
+            ...super.defineSchema(),
+            documentUUID: new fields.StringField({ blank: true, initial: '', placeholder: 'Enter a macro UUID' })
+        };
+    }
+
+    async use(event) {
+        const fixUUID = !this.documentUUID.includes('Macro.') ? `Macro.${this.documentUUID}` : this.documentUUID,
+            macro = await fromUuid(fixUUID);
+        try {
+            if (!macro) throw new Error(`No macro found for the UUID: ${this.documentUUID}.`);
+            macro.execute();
+        } catch (error) {
+            ui.notifications.error(error);
+        }
+    }
+}

module/data/action/actionDice.mjs

@@ -0,0 +1,55 @@
+import FormulaField from '../fields/formulaField.mjs';
+
+const fields = foundry.data.fields;
+
+export class DHActionDiceData extends foundry.abstract.DataModel {
+    /** @override */
+    static defineSchema() {
+        return {
+            multiplier: new fields.StringField({
+                choices: SYSTEM.GENERAL.multiplierTypes,
+                initial: 'proficiency',
+                label: 'Multiplier'
+            }),
+            dice: new fields.StringField({ choices: SYSTEM.GENERAL.diceTypes, initial: 'd6', label: 'Formula' }),
+            bonus: new fields.NumberField({ nullable: true, initial: null, label: 'Bonus' }),
+            custom: new fields.SchemaField({
+                enabled: new fields.BooleanField({ label: 'Custom Formula' }),
+                formula: new FormulaField({ label: 'Formula' })
+            })
+        };
+    }
+
+    getFormula(actor) {
+        return this.custom.enabled
+            ? this.custom.formula
+            : `${actor.system[this.multiplier] ?? 1}${this.dice}${this.bonus ? (this.bonus < 0 ? ` - ${Math.abs(this.bonus)}` : ` + ${this.bonus}`) : ''}`;
+    }
+}
+
+export class DHDamageField extends fields.SchemaField {
+    constructor(hasBase, options, context = {}) {
+        const damageFields = {
+            parts: new fields.ArrayField(new fields.EmbeddedDataField(DHDamageData))
+        };
+        if (hasBase) damageFields.includeBase = new fields.BooleanField({ initial: true });
+        super(damageFields, options, context);
+    }
+}
+
+export class DHDamageData extends DHActionDiceData {
+    /** @override */
+    static defineSchema() {
+        return {
+            ...super.defineSchema(),
+            base: new fields.BooleanField({ initial: false, readonly: true, label: 'Base' }),
+            type: new fields.StringField({
+                choices: SYSTEM.GENERAL.damageTypes,
+                initial: 'physical',
+                label: 'Type',
+                nullable: false,
+                required: true
+            })
+        };
+    }
+}

module/data/chat-message/adversaryRoll.mjs

@@ -5,17 +5,19 @@ export default class DHAdversaryRoll extends foundry.abstract.TypeDataModel {
         return {
             title: new fields.StringField(),
             origin: new fields.StringField({ required: true }),
-            roll: new fields.StringField({}),
-            total: new fields.NumberField({ integer: true }),
+            dice: new fields.DataField(),
+            roll: new fields.DataField(),
             modifiers: new fields.ArrayField(
                 new fields.SchemaField({
                     value: new fields.NumberField({ integer: true }),
-                    label: new fields.StringField({}),
-                    title: new fields.StringField({})
+                    label: new fields.StringField({})
                 })
             ),
-            advantageState: new fields.NumberField({ required: true, choices: [0, 1, 2], initial: 0 }),
-            dice: new fields.EmbeddedDataField(DhpAdversaryRollDice),
+            advantageState: new fields.BooleanField({ nullable: true, initial: null }),
+            advantage: new fields.SchemaField({
+                dice: new fields.StringField({}),
+                value: new fields.NumberField({ integer: true })
+            }),
             targets: new fields.ArrayField(
                 new fields.SchemaField({
                     id: new fields.StringField({}),
@@ -37,42 +39,8 @@ export default class DHAdversaryRoll extends foundry.abstract.TypeDataModel {
     }
 
     prepareDerivedData() {
-        const diceKeys = Object.keys(this.dice.rolls);
-        const highestDiceIndex =
-            diceKeys.length < 2
-                ? null
-                : this.dice.rolls[diceKeys[0]].value > this.dice.rolls[diceKeys[1]].value
-                  ? 0
-                  : 1;
-        if (highestDiceIndex !== null) {
-            this.dice.rolls = this.dice.rolls.map((roll, index) => ({
-                ...roll,
-                discarded: this.advantageState === 1 ? index !== highestDiceIndex : index === highestDiceIndex
-            }));
-        }
-
         this.targets.forEach(target => {
             target.hit = target.difficulty ? this.total >= target.difficulty : this.total >= target.evasion;
         });
     }
 }
-
-class DhpAdversaryRollDice extends foundry.abstract.DataModel {
-    static defineSchema() {
-        const fields = foundry.data.fields;
-
-        return {
-            type: new fields.StringField({ required: true }),
-            rolls: new fields.ArrayField(
-                new fields.SchemaField({
-                    value: new fields.NumberField({ required: true, integer: true }),
-                    discarded: new fields.BooleanField({ initial: false })
-                })
-            )
-        };
-    }
-
-    get rollTotal() {
-        return this.rolls.reduce((acc, roll) => acc + (!roll.discarded ? roll.value : 0), 0);
-    }
-}

module/data/chat-message/damageRoll.mjs

@@ -9,7 +9,13 @@ export default class DHDamageRoll extends foundry.abstract.TypeDataModel {
                 total: new fields.NumberField({ required: true, integer: true }),
                 type: new fields.StringField({ choices: Object.keys(SYSTEM.GENERAL.damageTypes), integer: false })
             }),
-            dice: new fields.ArrayField(new fields.EmbeddedDataField(DhpDamageDice)),
+            dice: new fields.ArrayField(
+                new fields.SchemaField({
+                    type: new fields.StringField({ required: true }),
+                    rolls: new fields.ArrayField(new fields.NumberField({ required: true, integer: true })),
+                    total: new fields.NumberField({ integer: true })
+                })
+            ),
             modifiers: new fields.ArrayField(
                 new fields.SchemaField({
                     value: new fields.NumberField({ required: true, integer: true }),
@@ -26,18 +32,3 @@ export default class DHDamageRoll extends foundry.abstract.TypeDataModel {
         };
     }
 }
-
-class DhpDamageDice extends foundry.abstract.DataModel {
-    static defineSchema() {
-        const fields = foundry.data.fields;
-
-        return {
-            type: new fields.StringField({ required: true }),
-            rolls: new fields.ArrayField(new fields.NumberField({ required: true, integer: true }))
-        };
-    }
-
-    get rollTotal() {
-        return this.rolls.reduce((acc, roll) => acc + roll, 0);
-    }
-}

module/data/chat-message/dualityRoll.mjs

@@ -1,4 +1,4 @@
-import { DualityRollColor } from "../settings/Appearance.mjs";
+import { DualityRollColor } from '../settings/Appearance.mjs';
 
 const fields = foundry.data.fields;
 const diceField = () =>
@@ -18,18 +18,17 @@ export default class DHDualityRoll extends foundry.abstract.TypeDataModel {
         return {
             title: new fields.StringField(),
             origin: new fields.StringField({ required: true }),
-            roll: new fields.StringField({}),
+            roll: new fields.DataField({}),
             modifiers: new fields.ArrayField(
                 new fields.SchemaField({
                     value: new fields.NumberField({ integer: true }),
-                    label: new fields.StringField({}),
-                    title: new fields.StringField({})
+                    label: new fields.StringField({})
                 })
             ),
             hope: diceField(),
             fear: diceField(),
+            advantageState: new fields.BooleanField({ nullable: true, initial: null }),
             advantage: diceField(),
-            disadvantage: diceField(),
             targets: new fields.ArrayField(
                 new fields.SchemaField({
                     id: new fields.StringField({}),
@@ -64,15 +63,6 @@ export default class DHDualityRoll extends foundry.abstract.TypeDataModel {
         };
     }
 
-    get total() {
-        const advantage = this.advantage.value
-            ? this.advantage.value
-            : this.disadvantage.value
-              ? -this.disadvantage.value
-              : 0;
-        return this.diceTotal + advantage + this.modifierTotal.value;
-    }
-
     get diceTotal() {
         return this.hope.value + this.fear.value;
     }
@@ -112,13 +102,7 @@ export default class DHDualityRoll extends foundry.abstract.TypeDataModel {
     }
 
     prepareDerivedData() {
-        const total = this.total;
-
         this.hope.discarded = this.hope.value < this.fear.value;
         this.fear.discarded = this.fear.value < this.hope.value;
-
-        this.targets.forEach(target => {
-            target.hit = target.difficulty ? total >= target.difficulty : total >= target.evasion;
-        });
     }
 }

module/data/fields/_module.mjs

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

module/data/fields/actionField.mjs

@@ -0,0 +1,40 @@
+import { actionsTypes } from '../action/_module.mjs';
+
+// Temporary Solution
+export default class ActionField extends foundry.data.fields.ObjectField {
+    getModel(value) {
+        return actionsTypes[value.type] ?? actionsTypes.attack;
+    }
+
+    /* -------------------------------------------- */
+
+    /** @override */
+    _cleanType(value, options) {
+        if (!(typeof value === 'object')) value = {};
+
+        const cls = this.getModel(value);
+        if (cls) return cls.cleanData(value, options);
+        return value;
+    }
+
+    /* -------------------------------------------- */
+
+    /** @override */
+    initialize(value, model, options = {}) {
+        const cls = this.getModel(value);
+        if (cls) return new cls(value, { parent: model, ...options });
+        return foundry.utils.deepClone(value);
+    }
+
+    /* -------------------------------------------- */
+
+    /**
+     * Migrate this field's candidate source data.
+     * @param {object} sourceData  Candidate source data of the root model.
+     * @param {any} fieldData      The value of this field within the source data.
+     */
+    migrateSource(sourceData, fieldData) {
+        const cls = this.getModel(fieldData);
+        if (cls) cls.migrateDataSafe(fieldData);
+    }
+}

module/data/fields/formulaField.mjs

@@ -16,78 +16,78 @@
  * Special case StringField which represents a formula.
  */
 export default class FormulaField extends foundry.data.fields.StringField {
+    /**
+     * @param {FormulaFieldOptions} [options] - Options which configure the behavior of the field
+     * @param {foundry.data.types.DataFieldContext} [context] - Additional context which describes the field
+     */
+    constructor(options, context) {
+        super(options, context);
+    }
 
-  /**
- * @param {FormulaFieldOptions} [options] - Options which configure the behavior of the field
- * @param {foundry.data.types.DataFieldContext} [context] - Additional context which describes the field
- */
-  constructor(options, context) {
-    super(options, context);
-  }
+    /** @inheritDoc */
+    static get _defaults() {
+        return foundry.utils.mergeObject(super._defaults, {
+            deterministic: false
+        });
+    }
 
-  /** @inheritDoc */
-  static get _defaults() {
-    return foundry.utils.mergeObject(super._defaults, {
-      deterministic: false
-    });
-  }
+    /* -------------------------------------------- */
 
-  /* -------------------------------------------- */
+    /** @inheritDoc */
+    _validateType(value) {
+        const roll = new Roll(value.replace(/@([a-z.0-9_-]+)/gi, '1'));
+        roll.evaluateSync({ strict: false });
+        if (this.options.deterministic && !roll.isDeterministic)
+            throw new Error(`must not contain dice terms: ${value}`);
+        super._validateType(value);
+    }
 
-  /** @inheritDoc */
-  _validateType(value) {
-    const roll = new Roll(value.replace(/@([a-z.0-9_-]+)/gi, "1"));
-    roll.evaluateSync({ strict: false });
-    if (this.options.deterministic && !roll.isDeterministic) throw new Error(`must not contain dice terms: ${value}`);
-    super._validateType(value);
-  }
+    /* -------------------------------------------- */
+    /*  Active Effect Integration                   */
+    /* -------------------------------------------- */
 
-  /* -------------------------------------------- */
-  /*  Active Effect Integration                   */
-  /* -------------------------------------------- */
+    /** @override */
+    _castChangeDelta(delta) {
+        return this._cast(delta).trim();
+    }
 
-  /** @override */
-  _castChangeDelta(delta) {
-    return this._cast(delta).trim();
-  }
+    /* -------------------------------------------- */
 
-  /* -------------------------------------------- */
+    /** @override */
+    _applyChangeAdd(value, delta, model, change) {
+        if (!value) return delta;
+        const operator = delta.startsWith('-') ? '-' : '+';
+        delta = delta.replace(/^[+-]/, '').trim();
+        return `${value} ${operator} ${delta}`;
+    }
 
-  /** @override */
-  _applyChangeAdd(value, delta, model, change) {
-    if (!value) return delta;
-    const operator = delta.startsWith("-") ? "-" : "+";
-    delta = delta.replace(/^[+-]/, "").trim();
-    return `${value} ${operator} ${delta}`;
-  }
+    /* -------------------------------------------- */
 
-  /* -------------------------------------------- */
+    /** @override */
+    _applyChangeMultiply(value, delta, model, change) {
+        if (!value) return delta;
+        const terms = new Roll(value).terms;
+        if (terms.length > 1) return `(${value}) * ${delta}`;
+        return `${value} * ${delta}`;
+    }
 
-  /** @override */
-  _applyChangeMultiply(value, delta, model, change) {
-    if (!value) return delta;
-    const terms = new Roll(value).terms;
-    if (terms.length > 1) return `(${value}) * ${delta}`;
-    return `${value} * ${delta}`;
-  }
+    /* -------------------------------------------- */
 
-  /* -------------------------------------------- */
+    /** @override */
+    _applyChangeUpgrade(value, delta, model, change) {
+        if (!value) return delta;
+        const terms = new Roll(value).terms;
+        if (terms.length === 1 && terms[0].fn === 'max') return value.replace(/\)$/, `, ${delta})`);
+        return `max(${value}, ${delta})`;
+    }
 
-  /** @override */
-  _applyChangeUpgrade(value, delta, model, change) {
-    if (!value) return delta;
-    const terms = new Roll(value).terms;
-    if ((terms.length === 1) && (terms[0].fn === "max")) return value.replace(/\)$/, `, ${delta})`);
-    return `max(${value}, ${delta})`;
-  }
+    /* -------------------------------------------- */
 
-  /* -------------------------------------------- */
-
-  /** @override */
-  _applyChangeDowngrade(value, delta, model, change) {
-    if (!value) return delta;
-    const terms = new Roll(value).terms;
-    if ((terms.length === 1) && (terms[0].fn === "min")) return value.replace(/\)$/, `, ${delta})`);
-    return `min(${value}, ${delta})`;
-  }
-}
+    /** @override */
+    _applyChangeDowngrade(value, delta, model, change) {
+        if (!value) return delta;
+        const terms = new Roll(value).terms;
+        if (terms.length === 1 && terms[0].fn === 'min') return value.replace(/\)$/, `, ${delta})`);
+        return `min(${value}, ${delta})`;
+    }
+}

module/data/fields/pseudoDocumentsField.mjs

@@ -0,0 +1,56 @@
+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/_module.mjs

@@ -10,27 +10,27 @@ import DHSubclass from './subclass.mjs';
 import DHWeapon from './weapon.mjs';
 
 export {
-  DHAncestry,
-  DHArmor,
-  DHClass,
-  DHCommunity,
-  DHConsumable,
-  DHDomainCard,
-  DHFeature,
-  DHMiscellaneous,
-  DHSubclass,
-  DHWeapon,
-}
+    DHAncestry,
+    DHArmor,
+    DHClass,
+    DHCommunity,
+    DHConsumable,
+    DHDomainCard,
+    DHFeature,
+    DHMiscellaneous,
+    DHSubclass,
+    DHWeapon
+};
 
 export const config = {
-  ancestry: DHAncestry,
-  armor: DHArmor,
-  class: DHClass,
-  community: DHCommunity,
-  consumable: DHConsumable,
-  domainCard: DHDomainCard,
-  feature: DHFeature,
-  miscellaneous: DHMiscellaneous,
-  subclass: DHSubclass,
-  weapon: DHWeapon,
-};
+    ancestry: DHAncestry,
+    armor: DHArmor,
+    class: DHClass,
+    community: DHCommunity,
+    consumable: DHConsumable,
+    domainCard: DHDomainCard,
+    feature: DHFeature,
+    miscellaneous: DHMiscellaneous,
+    subclass: DHSubclass,
+    weapon: DHWeapon
+};

module/data/item/base.mjs

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

module/data/item/domainCard.mjs

@@ -1,4 +1,4 @@
-import DaggerheartAction from '../action.mjs';
+import DHAction from '../action/action.mjs';
 import BaseDataItem from './base.mjs';
 
 export default class DHDomainCard extends BaseDataItem {
@@ -22,7 +22,7 @@ export default class DHDomainCard extends BaseDataItem {
             type: new fields.StringField({ choices: SYSTEM.DOMAIN.cardTypes, required: true, blank: true }),
             foundation: new fields.BooleanField({ initial: false }),
             inVault: new fields.BooleanField({ initial: false }),
-            actions: new fields.ArrayField(new fields.EmbeddedDataField(DaggerheartAction))
+            actions: new fields.ArrayField(new fields.EmbeddedDataField(DHAction))
         };
     }
 

module/data/item/feature.mjs

@@ -1,14 +1,14 @@
 import { getTier } from '../../helpers/utils.mjs';
-import DaggerheartAction from '../action.mjs';
+import DHAction from '../action/action.mjs';
 import BaseDataItem from './base.mjs';
 
 export default class DHFeature extends BaseDataItem {
     /** @inheritDoc */
     static get metadata() {
         return foundry.utils.mergeObject(super.metadata, {
-            label: "TYPES.Item.feature",
-            type: "feature",
-            hasDescription: true,
+            label: 'TYPES.Item.feature',
+            type: 'feature',
+            hasDescription: true
         });
     }
 
@@ -17,7 +17,7 @@ export default class DHFeature extends BaseDataItem {
         const fields = foundry.data.fields;
         return {
             ...super.defineSchema(),
-            
+
             //A type of feature seems unnecessary
             type: new fields.StringField({ choices: SYSTEM.ITEM.featureTypes }),
 
@@ -26,7 +26,7 @@ export default class DHFeature extends BaseDataItem {
                 choices: SYSTEM.ITEM.actionTypes,
                 initial: SYSTEM.ITEM.actionTypes.passive.id
             }),
-               //TODO: remove  featureType field
+            //TODO: remove  featureType field
             featureType: new fields.SchemaField({
                 type: new fields.StringField({
                     choices: SYSTEM.ITEM.valueTypes,
@@ -75,9 +75,10 @@ export default class DHFeature extends BaseDataItem {
                         { nullable: true, initial: null }
                     ),
                     dataField: new fields.StringField({}),
-                    appliesOn: new fields.StringField({
-                        choices: SYSTEM.EFFECTS.applyLocations,
-                    },
+                    appliesOn: new fields.StringField(
+                        {
+                            choices: SYSTEM.EFFECTS.applyLocations
+                        },
                         { nullable: true, initial: null }
                     ),
                     applyLocationChoices: new fields.TypedObjectField(new fields.StringField({}), {
@@ -92,7 +93,7 @@ export default class DHFeature extends BaseDataItem {
                     })
                 })
             ),
-            actions: new fields.ArrayField(new fields.EmbeddedDataField(DaggerheartAction))
+            actions: new fields.ArrayField(new fields.EmbeddedDataField(DHAction))
         };
     }
 

module/data/item/weapon.mjs

@@ -1,14 +1,20 @@
-import BaseDataItem from "./base.mjs";
-import FormulaField from "../fields/formulaField.mjs";
+import BaseDataItem from './base.mjs';
+import FormulaField from '../fields/formulaField.mjs';
+import PseudoDocumentsField from '../fields/pseudoDocumentsField.mjs';
+import BaseFeatureData from '../pseudo-documents/feature/baseFeatureData.mjs';
+import ActionField from '../fields/actionField.mjs';
 
 export default class DHWeapon extends BaseDataItem {
     /** @inheritDoc */
     static get metadata() {
         return foundry.utils.mergeObject(super.metadata, {
-            label: "TYPES.Item.weapon",
-            type: "weapon",
+            label: 'TYPES.Item.weapon',
+            type: 'weapon',
             hasDescription: true,
             isQuantifiable: true,
+            embedded: {
+                feature: 'featureTest'
+            }
         });
     }
 
@@ -33,8 +39,15 @@ export default class DHWeapon extends BaseDataItem {
                     initial: 'physical'
                 })
             }),
-
             feature: new fields.StringField({ choices: SYSTEM.ITEM.weaponFeatures, blank: true }),
+            featureTest: new PseudoDocumentsField(BaseFeatureData, {
+                required: true,
+                nullable: true,
+                max: 1,
+                validTypes: ['weapon']
+            }),
+            // actions: new fields.ArrayField(new fields.EmbeddedDataField(DHAttackAction))
+            actions: new fields.ArrayField(new ActionField())
         };
     }
 }

module/data/pseudo-documents/_module.mjs

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

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

@@ -0,0 +1,213 @@
+/**
+ * @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

@@ -0,0 +1,59 @@
+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

@@ -0,0 +1,158 @@
+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

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

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

@@ -0,0 +1,24 @@
+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

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