Refactor/84 data models structure (#131)

* - Move all DataModel item files to a new 'items' subfolder for better organization
- Add _module.mjs file to simplify imports
- Update all import paths
- Rename class for use the new acronym DH

* FIX: remove unnecessary import

* FEAT: BaseDataItem class
add TODO comments for future improvements
FIX: Remove effect field on template
FIX: remove unused DhpEffects file

* FEAT: new FormulaField class
FEAT: add getRollData on BaseDataItem Class
FEAT: weapon
FIX: remove inventoryWeapon field on Weapon Data Model

* FEAT: add class prepareBaseData for domains

* FEAT: new ForeignDocumentUUIDField
FIX: Remove unnecessary fields
FEAT: use ForeignDocumentUUIDField in the Item Class DataModel

* FIX: remove wrong option in String Field

* FIX: remove unused import

* FIX: ADD htmlFields description in manifest

* FIX: minor fixes

* REFACTOR: rename folder `data/items` -> `data/item`
REFACTOR: rename folder `data/messages` -> `data/chat-message`.

* FIX: imports
FIX: items sheet new paths
FIX: ItemDataModelMetadata type jsdoc

* FEAT: formatting code
FIX: fix fields used
FEAT: add jsdoc

* 110 - Class Data Model (#111)

* Added PreCreate/Create/Delete logic for Class/Subclass and set it as foreignUUID fields in PC

* Moved methods into TypedModelData

* Simplified Subclass

* Fixed up data model and a basic placeholder template (#117)

* 118 - adversary data model (#119)

* Fixed datamodel and set up basic template in new style

* Added in a temp attack button, because why not

* Restored HitPoints counting up

* 113 - Character Data Model (#114)

* Improved Character datamodel

* Removed additional unneccessary getters

* Preliminary cleanup in the class sheet

* Cleanup of 'pc' references

* Corrected Duality rolling from Character

* Fix to damage roll

* Added a basic BaseDataActor data model

* Gathered exports

* getRollData recursion fix

* Feature/112 items use action datamodel (#127)

* Create new actions classes

* actions types - attack roll

* fixes before merge

* First PR

* Add daggerheart.css to gitignore

* Update ToDo

* Remove console log

* Fixed chat /dr roll

* Remove jQuery

* Fixed so the different chat themes work again

* Fixed duality roll buttons

* Fix to advantage/disadvantage shortcut

* Extand action to other item types

* Roll fixes

* Fixes to adversary rolls

* resources

* Fixed adversary dice

---------

Co-authored-by: WBHarry <williambjrklund@gmail.com>

* Feature/116-implementation-of-pseudo-documents (#125)

* FEAT: add baseDataModel logic

* FEAT: new PseudoDocumentsField
FIX: BasePseudoDocument 's getEmbeddedDocument

* FEAT: PseudoDocument class

* FEAT: add TypedPseudoDocument
REFACTOR: PreudoDocument
FIX: Typos Bug

* FIX: CONFIG types

* FEAT: basic PseudoDocumentSheet

* FIX: remove schema
ADD: input of example

---------

Co-authored-by: Joaquin Pereyra <joaquinpereyra98@users.noreply.github.com>
Co-authored-by: WBHarry <williambjrklund@gmail.com>

* Levelup Followup (#126)

* Levelup applies bonuses to character

* Added visualisation of domain card levels

* Fixed domaincard level max for selections in a tier

* A trait can now only be level up once within the same tier

---------

Co-authored-by: Joaquin Pereyra <joaquinpereyra98@users.noreply.github.com>
Co-authored-by: joaquinpereyra98 <24190917+joaquinpereyra98@users.noreply.github.com>
Co-authored-by: Dapoulp <74197441+Dapoulp@users.noreply.github.com>

module/data/fields/_module.mjs

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

@@ -0,0 +1,41 @@
+/**
+ * A subclass of {@link foundry.data.fields.DocumentUUIDField} to allow selecting a foreign document reference
+ * that resolves to either the document, the index(for items in compenidums) or the UUID string.
+ */
+export default class ForeignDocumentUUIDField extends foundry.data.fields.DocumentUUIDField {
+    /**
+     * @param {foundry.data.types.DocumentUUIDFieldOptions} [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, {
+            nullable: true,
+            readonly: false,
+            idOnly: false
+        });
+    }
+
+    /**@override */
+    initialize(value, _model, _options = {}) {
+        if (this.idOnly) return value;
+        return (() => {
+            try {
+                const doc = fromUuidSync(value);
+                return doc;
+            } catch (error) {
+                console.error(error);
+                return value ?? null;
+            }
+        })();
+    }
+
+    /**@override */
+    toObject(value) {
+        return value?.uuid ?? value;
+    }
+}

module/data/fields/formulaField.mjs

@@ -0,0 +1,93 @@
+/**
+ * @typedef {foundry.data.types.StringFieldOptions} StringFieldOptions
+ * @typedef {foundry.data.types.DataFieldContext} DataFieldContext
+ */
+
+/**
+ * @typedef _FormulaFieldOptions
+ * @property {boolean} [deterministic] - Is this formula not allowed to have dice values?
+ */
+
+/**
+ * @typedef {StringFieldOptions & _FormulaFieldOptions} FormulaFieldOptions
+ */
+
+/**
+ * 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);
+    }
+
+    /** @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);
+    }
+
+    /* -------------------------------------------- */
+    /*  Active Effect Integration                   */
+    /* -------------------------------------------- */
+
+    /** @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 */
+    _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 */
+    _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;
+    }
+}