daggerheart/module/data/feature.mjs

import { getTier } from '../helpers/utils.mjs';
import DaggerheartAction from './action.mjs';
import { MappingField } from './fields.mjs';
import DhpEffect from './interface/effects.mjs';

export default class DhpFeature extends DhpEffect {
    static defineSchema() {
        const fields = foundry.data.fields;
        return foundry.utils.mergeObject(
            {},
            {
                type: new fields.StringField({ choices: SYSTEM.ITEM.featureTypes }),
                actionType: new fields.StringField({
                    choices: SYSTEM.ITEM.actionTypes,
                    initial: SYSTEM.ITEM.actionTypes.passive.id
                }),
                featureType: new fields.SchemaField({
                    type: new fields.StringField({
                        choices: SYSTEM.ITEM.valueTypes,
                        initial: Object.keys(SYSTEM.ITEM.valueTypes).find(x => x === 'normal')
                    }),
                    data: new fields.SchemaField({
                        value: new fields.StringField({}),
                        property: new fields.StringField({
                            choices: SYSTEM.ACTOR.featureProperties,
                            initial: Object.keys(SYSTEM.ACTOR.featureProperties).find(x => x === 'spellcastingTrait')
                        }),
                        max: new fields.NumberField({ initial: 1, integer: true }),
                        numbers: new MappingField(
                            new fields.SchemaField({
                                value: new fields.NumberField({ integer: true }),
                                used: new fields.BooleanField({ initial: false })
                            })
                        )
                    })
                }),
                refreshData: new fields.SchemaField(
                    {
                        type: new fields.StringField({ choices: SYSTEM.GENERAL.refreshTypes }),
                        uses: new fields.NumberField({ initial: 1, integer: true }),
                        refreshed: new fields.BooleanField({ initial: true })
                    },
                    { nullable: true, initial: null }
                ),
                multiclass: new fields.NumberField({ initial: null, nullable: true, integer: true }),
                disabled: new fields.BooleanField({ initial: false }),
                description: new fields.HTMLField({}),
                effects: new MappingField(
                    new fields.SchemaField({
                        type: new fields.StringField({ choices: SYSTEM.EFFECTS.effectTypes }),
                        valueType: new fields.StringField({ choices: SYSTEM.EFFECTS.valueTypes }),
                        parseType: new fields.StringField({ choices: SYSTEM.EFFECTS.parseTypes }),
                        initiallySelected: new fields.BooleanField({ initial: true }),
                        options: new fields.ArrayField(
                            new fields.SchemaField({
                                name: new fields.StringField({}),
                                value: new fields.StringField({})
                            }),
                            { nullable: true, initial: null }
                        ),
                        dataField: new fields.StringField({}),
                        appliesOn: new fields.StringField(
                            { choices: SYSTEM.EFFECTS.applyLocations },
                            { nullable: true, initial: null }
                        ),
                        applyLocationChoices: new MappingField(new fields.StringField({}), {
                            nullable: true,
                            initial: null
                        }),
                        valueData: new fields.SchemaField({
                            value: new fields.StringField({}),
                            fromValue: new fields.StringField({ initial: null, nullable: true }),
                            type: new fields.StringField({ initial: null, nullable: true }),
                            hopeIncrease: new fields.StringField({ initial: null, nullable: true })
                        })
                    })
                ),
                actions: new fields.ArrayField(new fields.EmbeddedDataField(DaggerheartAction))
            }
        );
    }

    get multiclassTier() {
        return getTier(this.multiclass);
    }

    async refresh() {
        if (this.refreshData) {
            if (this.featureType.type === SYSTEM.ITEM.valueTypes.dice.id) {
                const update = { 'system.refreshData.refreshed': true };
                Object.keys(this.featureType.data.numbers).forEach(
                    x => (update[`system.featureType.data.numbers.-=${x}`] = null)
                );
                await this.parent.update(update);
            } else {
                await this.parent.update({ 'system.refreshData.refreshed': true });
            }
        }
    }

    // prepareDerivedData(){
    //   if(this.featureType.type === SYSTEM.ITEM.valueTypes.dice.id){
    //     this.featureType.numbers = ;
    //   }
    // }
}