daggerheart/module/data/item/base.mjs

/**
 * Describes metadata about the item data model type
 * @typedef {Object} ItemDataModelMetadata
 * @property {string} label - A localizable label used on application.
 * @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 {boolean} isInventoryItem- Indicates whether items of this type is a Inventory Item
 */

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,
            isInventoryItem: false
        };
    }

    /** @inheritDoc */
    static defineSchema() {
        const schema = {};

        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 });

        return schema;
    }

    /**
     * Convenient access to the item's actor, if it exists.
     * @returns {foundry.documents.Actor | null}
     */
    get actor() {
        return this.parent.actor;
    }

    get actionsList() {
        return this.actions;
    }

    /**
     * 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;
    }

    /**@inheritdoc */
    async _preCreate(data, options, user) {
        // Skip if no initial action is required or actions already exist
        if (!this.constructor.metadata.hasInitialAction || !foundry.utils.isEmpty(this.actions)) return;

        const metadataType = this.constructor.metadata.type;
        const actionType = { weapon: 'attack' }[metadataType];
        const ActionClass = game.system.api.models.actions.actionsTypes[actionType];

        const action = new ActionClass(
            {
                _id: foundry.utils.randomID(),
                type: actionType,
                name: game.i18n.localize(CONFIG.DH.ACTIONS.actionTypes[actionType].name),
                ...ActionClass.getSourceConfig(this.parent)
            },
            {
                parent: this.parent
            }
        );

        this.updateSource({ actions: [action] });
    }

    _onCreate(data) {
        if (!this.actor || this.actor.type !== 'character' || !this.features) return;

        this.actor.createEmbeddedDocuments(
            'Item',
            this.features.map(feature => ({
                ...feature,
                system: {
                    ...feature.system,
                    type: this.parent.type,
                    originId: data._id,
                    identifier: feature.identifier
                }
            }))
        );
    }

    async _preDelete() {
        if (!this.actor || this.actor.type !== 'character') return;

        const items = this.actor.items.filter(item => item.system.originId === this.parent.id);
        if (items.length > 0)
            await this.actor.deleteEmbeddedDocuments(
                'Item',
                items.map(x => x.id)
            );
    }
}