intelligent-system-design-language 0.3.13

package/out/cli/components/datamodel-generator.js

@@ -0,0 +1,672 @@
+import { isActor, isNumberExp, isHtmlExp, isStringExp, isBooleanExp, isResourceExp, isAttributeExp, isDamageTrackExp, isSingleDocumentExp, isNumberParamInitial, isNumberParamMin, isNumberParamMax, isStringParamChoices, isConfigExpression, isStatusProperty, isStatusParamWhen, isDateExp, isTimeExp, isDateTimeExp, isPaperDollExp, isParentPropertyRefExp, isSelfPropertyRefExp, isDocumentChoiceExp, isDocumentChoicesExp, isAction, isVariableExpression, isPrompt, isTrackerExp, isDiceFields, isDieField, isDieInitialParam, isDiceField, isLayout, isMacroField, isMeasuredTemplateField, isLabelParam, isChoiceStringValue, isStringExtendedChoice, isStringChoiceField, isDamageTypeChoiceField, isChoiceCustomProperty, isStringChoicesField, isMoneyField, isDamageTrackTypesParam } from "../../language/generated/ast.js";
+import { expandToNode, joinToNode, toString } from 'langium/generate';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { getAllOfType, toMachineIdentifier } from './utils.js';
+import { translateExpression } from './method-generator.js';
+import { AstUtils } from 'langium';
+export function generateDocumentDataModel(entry, document, destination) {
+    const typePath = isActor(document) ? 'actor' : 'item';
+    const dataModelPath = path.join(destination, "system", "datamodels", typePath);
+    const generatedFilePath = `${path.join(dataModelPath, document.name.toLowerCase())}.mjs`;
+    const config = entry.config;
+    const id = config.body.find(x => isConfigExpression(x) && x.type == "id").value;
+    function generateField(property) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+        if (isNumberExp(property)) {
+            // Check to see if we have literal values for min, initial, and max
+            let options = "integer: true";
+            const minParam = property.params.find(p => isNumberParamMin(p));
+            const maxParam = property.params.find(p => isNumberParamMax(p));
+            const initialParam = property.params.find(p => isNumberParamInitial(p));
+            if (initialParam && typeof (initialParam.value) === 'number') {
+                options += `, initial: ${initialParam.value}`;
+            }
+            if (minParam && typeof (minParam.value) === 'number') {
+                options += `, min: ${minParam.value}`;
+            }
+            if (maxParam && typeof (maxParam.value) === 'number') {
+                options += `, max: ${maxParam.value}`;
+            }
+            return expandToNode `
+                ${property.name.toLowerCase()}: new fields.NumberField({${options}}),
+            `;
+        }
+        if (isMoneyField(property)) {
+            // Check if this money field has denominations
+            if (property.denominations && property.denominations.length > 0) {
+                // Multi-denomination money - store as SchemaField with individual denomination fields
+                const denominationFields = property.denominations.map(denom => {
+                    return `${denom.name.toLowerCase()}: new fields.NumberField({initial: 0, nullable: false})`;
+                }).join(',\n                    ');
+                return expandToNode `
+                    ${property.name.toLowerCase()}: new fields.SchemaField({
+                        ${denominationFields}
+                    }),
+                `;
+            }
+            else {
+                // Single currency money - store as simple NumberField
+                const initialParam = property.params.find(p => p.$type === 'NumberParamInitial');
+                const initial = (initialParam === null || initialParam === void 0 ? void 0 : initialParam.value) || 0;
+                return expandToNode `
+                    ${property.name.toLowerCase()}: new fields.NumberField({initial: ${initial}, nullable: false}),
+                `;
+            }
+        }
+        if (isStringExp(property)) {
+            return expandToNode `
+                ${property.name.toLowerCase()}: new fields.StringField({initial: ""}),
+            `;
+        }
+        if (isStringChoiceField(property)) {
+            let choices = property.params.find(p => isStringParamChoices(p));
+            function choiceValue(choice) {
+                if (!isStringExtendedChoice(choice.value)) {
+                    return toMachineIdentifier(choice.value);
+                }
+                let value = choice.value.properties.find(isChoiceStringValue);
+                if (value) {
+                    return toMachineIdentifier(value.value);
+                }
+                let label = choice.value.properties.find(isLabelParam);
+                if (label) {
+                    return toMachineIdentifier(label.value);
+                }
+                return "unknown";
+            }
+            function getDefaultValueForType(type) {
+                switch (type) {
+                    case 'string':
+                        return '';
+                    case 'number':
+                        return 0;
+                    case 'boolean':
+                        return false;
+                    default:
+                        return null; // or throw an error if you prefer
+                }
+            }
+            // For each extended choice, we need to gather a list of additional custom fields such as  bonus: 0 and add them to the datamodel
+            let additionalFields = choices.choices.reduce((acc, choice) => {
+                if (isStringExtendedChoice(choice.value)) {
+                    let customProperties = choice.value.properties.filter(isChoiceCustomProperty);
+                    customProperties.forEach(prop => {
+                        // Only add if we haven't seen this field name before
+                        if (!acc.find(field => field.key === prop.key)) {
+                            acc.push({
+                                key: prop.key,
+                                type: typeof prop.value,
+                                defaultValue: getDefaultValueForType(typeof prop.value)
+                            });
+                        }
+                    });
+                }
+                return acc;
+            }, []);
+            if (additionalFields.length > 0) {
+                return expandToNode `
+                ${property.name.toLowerCase()}: new fields.SchemaField({
+                    value: new fields.StringField({
+                        choices: [${choices.choices.map(x => `"${choiceValue(x)}"`).join(", ")}],
+                        initial: "${choiceValue(choices.choices[0])}"
+                    }),
+                    icon: new fields.StringField({initial: ""}),
+                    color: new fields.StringField({initial: "#ffffff"}),
+                    ${joinToNode(additionalFields, field => `${field.key.toLowerCase()}: new fields.${field.type.charAt(0).toUpperCase() + field.type.slice(1)}Field({initial: ${JSON.stringify(field.defaultValue)}})`, { appendNewLineIfNotEmpty: true, separator: ',' })}
+                }),
+                `;
+            }
+            return expandToNode `
+                ${property.name.toLowerCase()}: new fields.SchemaField({
+                    value: new fields.StringField({
+                        choices: [${choices.choices.map(x => `"${choiceValue(x)}"`).join(", ")}],
+                        initial: "${choiceValue(choices.choices[0])}"
+                    }),
+                    icon: new fields.StringField({initial: ""}),
+                    color: new fields.StringField({initial: "#ffffff"})
+                }),
+            `;
+        }
+        if (isDamageTypeChoiceField(property)) {
+            let choices = property.params.find(p => isStringParamChoices(p));
+            function choiceValue(choice) {
+                if (!isStringExtendedChoice(choice.value)) {
+                    return toMachineIdentifier(choice.value);
+                }
+                let value = choice.value.properties.find(isChoiceStringValue);
+                if (value) {
+                    return toMachineIdentifier(value.value);
+                }
+                let label = choice.value.properties.find(isLabelParam);
+                if (label) {
+                    return toMachineIdentifier(label.value);
+                }
+                return "unknown";
+            }
+            function getDefaultValueForType(type) {
+                switch (type) {
+                    case 'string':
+                        return '';
+                    case 'number':
+                        return 0;
+                    case 'boolean':
+                        return false;
+                    default:
+                        return null; // or throw an error if you prefer
+                }
+            }
+            // For each extended choice, we need to gather a list of additional custom fields such as  bonus: 0 and add them to the datamodel
+            let additionalFields = choices.choices.reduce((acc, choice) => {
+                if (isStringExtendedChoice(choice.value)) {
+                    let customProperties = choice.value.properties.filter(isChoiceCustomProperty);
+                    customProperties.forEach(prop => {
+                        // Only add if we haven't seen this field name before
+                        if (!acc.find(field => field.key === prop.key)) {
+                            acc.push({
+                                key: prop.key,
+                                type: typeof prop.value,
+                                defaultValue: getDefaultValueForType(typeof prop.value)
+                            });
+                        }
+                    });
+                }
+                return acc;
+            }, []);
+            if (additionalFields.length > 0) {
+                return expandToNode `
+                ${property.name.toLowerCase()}: new fields.SchemaField({
+                    value: new fields.StringField({
+                        choices: [${choices.choices.map(x => `"${choiceValue(x)}"`).join(", ")}],
+                        initial: "${choiceValue(choices.choices[0])}"
+                    }),
+                    icon: new fields.StringField({initial: ""}),
+                    color: new fields.StringField({initial: "#ffffff"}),
+                    ${joinToNode(additionalFields, field => `${field.key.toLowerCase()}: new fields.${field.type.charAt(0).toUpperCase() + field.type.slice(1)}Field({initial: ${JSON.stringify(field.defaultValue)}})`, { appendNewLineIfNotEmpty: true, separator: ',' })}
+                }),
+                `;
+            }
+            return expandToNode `
+                ${property.name.toLowerCase()}: new fields.SchemaField({
+                    value: new fields.StringField({
+                        choices: [${choices.choices.map(x => `"${choiceValue(x)}"`).join(", ")}],
+                        initial: "${choiceValue(choices.choices[0])}"
+                    }),
+                    icon: new fields.StringField({initial: ""}),
+                    color: new fields.StringField({initial: "#ffffff"})
+                }),
+            `;
+        }
+        if (isStringChoicesField(property)) {
+            let choices = property.params.find(p => p.$type === 'StringChoicesParamChoices');
+            if (!choices || !choices.choices || choices.choices.length === 0) {
+                // Fallback for simple string array if no choices defined
+                return expandToNode `
+                    ${property.name.toLowerCase()}: new fields.ArrayField(
+                        new fields.StringField({}),
+                        {initial: []}
+                    ),
+                `;
+            }
+            function choiceValue(choice) {
+                if (!isStringExtendedChoice(choice.value)) {
+                    return toMachineIdentifier(choice.value);
+                }
+                let value = choice.value.properties.find(isChoiceStringValue);
+                if (value) {
+                    return toMachineIdentifier(value.value);
+                }
+                let label = choice.value.properties.find(isLabelParam);
+                if (label) {
+                    return toMachineIdentifier(label.value);
+                }
+                return "unknown";
+            }
+            function getDefaultValueForType(type) {
+                switch (type) {
+                    case 'string':
+                        return '';
+                    case 'number':
+                        return 0;
+                    case 'boolean':
+                        return false;
+                    default:
+                        return null;
+                }
+            }
+            // Check if any choices are extended (have metadata)
+            let hasExtendedChoices = choices.choices.some((choice) => isStringExtendedChoice(choice.value));
+            if (!hasExtendedChoices) {
+                // Simple string choices - use array of strings
+                return expandToNode `
+                    ${property.name.toLowerCase()}: new fields.ArrayField(
+                        new fields.StringField({
+                            choices: [${choices.choices.map((x) => `"${choiceValue(x)}"`).join(", ")}]
+                        }),
+                        {initial: []}
+                    ),
+                `;
+            }
+            // Extended choices - use array of schema objects like choice<string>
+            let additionalFields = choices.choices.reduce((acc, choice) => {
+                if (isStringExtendedChoice(choice.value)) {
+                    let customProperties = choice.value.properties.filter(isChoiceCustomProperty);
+                    customProperties.forEach(prop => {
+                        // Only add if we haven't seen this field name before
+                        if (!acc.find(field => field.key === prop.key)) {
+                            acc.push({
+                                key: prop.key,
+                                type: typeof prop.value,
+                                defaultValue: getDefaultValueForType(typeof prop.value)
+                            });
+                        }
+                    });
+                }
+                return acc;
+            }, []);
+            if (additionalFields.length > 0) {
+                return expandToNode `
+                    ${property.name.toLowerCase()}: new fields.ArrayField(
+                        new fields.SchemaField({
+                            value: new fields.StringField({
+                                choices: [${choices.choices.map((x) => `"${choiceValue(x)}"`).join(", ")}]
+                            }),
+                            icon: new fields.StringField({initial: ""}),
+                            color: new fields.StringField({initial: "#ffffff"}),
+                            ${joinToNode(additionalFields, (field) => `${field.key.toLowerCase()}: new fields.${field.type.charAt(0).toUpperCase() + field.type.slice(1)}Field({initial: ${JSON.stringify(field.defaultValue)}})`, { appendNewLineIfNotEmpty: true, separator: ',' })}
+                        }),
+                        {initial: []}
+                    ),
+                `;
+            }
+            return expandToNode `
+                ${property.name.toLowerCase()}: new fields.ArrayField(
+                    new fields.SchemaField({
+                        value: new fields.StringField({
+                            choices: [${choices.choices.map((x) => `"${choiceValue(x)}"`).join(", ")}]
+                        }),
+                        icon: new fields.StringField({initial: ""}),
+                        color: new fields.StringField({initial: "#ffffff"})
+                    }),
+                    {initial: []}
+                ),
+            `;
+        }
+        if (isDateExp(property)) {
+            return expandToNode `
+                ${property.name.toLowerCase()}: new fields.StringField({initial: new Intl.DateTimeFormat('en-CA').format(new Date()) }),
+            `;
+        }
+        if (isTimeExp(property)) {
+            return expandToNode `
+                ${property.name.toLowerCase()}: new fields.StringField({initial: new Date().toTimeString().slice(0, 5) }),
+            `;
+        }
+        if (isDateTimeExp(property)) {
+            return expandToNode `
+                ${property.name.toLowerCase()}: new fields.StringField({initial: new Date().toISOString().slice(0, 16) }),
+            `;
+        }
+        if (isHtmlExp(property)) {
+            return expandToNode `
+                ${property.name.toLowerCase()}: new fields.HTMLField({required: false, blank: true, initial: ""}),
+            `;
+        }
+        if (isBooleanExp(property)) {
+            return expandToNode `
+                ${property.name.toLowerCase()}: new fields.BooleanField(),
+            `;
+        }
+        function getNumberOrNothing(param) {
+            if (param && typeof (param.value) === 'number') {
+                return param.value;
+            }
+            return undefined;
+        }
+        if (isResourceExp(property)) {
+            const minParam = property.params.find(p => isNumberParamMin(p));
+            const maxParam = property.params.find(p => isNumberParamMax(p));
+            const initialParam = property.params.find(p => isNumberParamInitial(p));
+            const min = (_a = getNumberOrNothing(minParam)) !== null && _a !== void 0 ? _a : -100;
+            const max = (_b = getNumberOrNothing(maxParam)) !== null && _b !== void 0 ? _b : 100;
+            const initial = (_c = getNumberOrNothing(initialParam)) !== null && _c !== void 0 ? _c : 0;
+            return expandToNode `
+                ${property.name.toLowerCase()}: new fields.SchemaField({
+                    value: new fields.NumberField({min: ${min}, initial: ${initial}, integer: true}),
+                    temp: new fields.NumberField({initial: 0, min: 0, integer: true}),
+                    max: new fields.NumberField({min: 0, initial: ${max}, integer: true}),
+                }),
+            `;
+        }
+        if (isAttributeExp(property)) {
+            const minParam = property.params.find(p => isNumberParamMin(p));
+            const maxParam = property.params.find(p => isNumberParamMax(p));
+            const min = (_d = minParam === null || minParam === void 0 ? void 0 : minParam.value) !== null && _d !== void 0 ? _d : 0;
+            const max = (_e = maxParam === null || maxParam === void 0 ? void 0 : maxParam.value) !== null && _e !== void 0 ? _e : 100;
+            return expandToNode `
+                ${property.name.toLowerCase()}: new fields.SchemaField({
+                    value: new fields.NumberField({integer: true, min: ${min}, initial: ${min}}),
+                    max: new fields.NumberField({integer: true, min: 0, initial: ${max}}),
+                }),
+            `;
+        }
+        if (isTrackerExp(property)) {
+            const minParam = property.params.find(p => isNumberParamMin(p));
+            const maxParam = property.params.find(p => isNumberParamMax(p));
+            const initialParam = property.params.find(p => isNumberParamInitial(p));
+            const min = (_f = getNumberOrNothing(minParam)) !== null && _f !== void 0 ? _f : -10;
+            const max = (_g = getNumberOrNothing(maxParam)) !== null && _g !== void 0 ? _g : 10;
+            const initial = (_h = getNumberOrNothing(initialParam)) !== null && _h !== void 0 ? _h : 0;
+            return expandToNode `
+                ${property.name.toLowerCase()}: new fields.SchemaField({
+                    min: new fields.NumberField({integer: true, initial: ${min}}),
+                    value: new fields.NumberField({integer: true, initial: ${initial}}),
+                    temp: new fields.NumberField({initial: 0, min: 0, integer: true}),
+                    max: new fields.NumberField({integer: true, min: 0, initial: ${max}}),
+                }),
+            `;
+        }
+        if (isDamageTrackExp(property)) {
+            const maxParam = property.params.find(x => isNumberParamMax(x));
+            const max = (_j = maxParam === null || maxParam === void 0 ? void 0 : maxParam.value) !== null && _j !== void 0 ? _j : 5;
+            const typesParam = property.params.find(x => isDamageTrackTypesParam(x));
+            const types = (_k = typesParam === null || typesParam === void 0 ? void 0 : typesParam.types) !== null && _k !== void 0 ? _k : [];
+            return expandToNode `
+                ${property.name.toLowerCase()}: new fields.SchemaField({
+                    empty: new fields.NumberField({initial: ${max}, min: 0, max: ${max}, integer: true}),
+                    ${joinToNode(types, type => `${type}: new fields.NumberField({initial: 0, min: 0, max: ${max}, integer: true}),`, { appendNewLineIfNotEmpty: true })}
+                }),
+            `;
+        }
+        if (isSingleDocumentExp(property) || isMacroField(property)) {
+            return expandToNode `
+                ${property.name.toLowerCase()}: new UuidDocumentField(),
+            `;
+        }
+        if (isDocumentChoiceExp(property)) {
+            // const multiple = (property.params.find(p => isMultipleParam(p)) as MultipleParam | undefined)?.value ?? false;
+            // if (multiple) {
+            //     return expandToNode`
+            //         ${property.name.toLowerCase()}: new fields.ArrayField(new UuidDocumentField()),
+            //     `;
+            // }
+            return expandToNode `
+                ${property.name.toLowerCase()}: new UuidDocumentField(),
+            `;
+        }
+        if (isDocumentChoicesExp(property)) {
+            return expandToNode `
+                ${property.name.toLowerCase()}: new UuidDocumentArrayField(),
+            `;
+        }
+        if (isPaperDollExp(property)) {
+            function generatePaperDollElementField(property) {
+                return expandToNode `
+                    ${property.name.toLowerCase()}: new UuidDocumentField()
+                `;
+            }
+            return expandToNode `
+                ${property.name.toLowerCase()}: new fields.SchemaField({
+                    ${joinToNode(property.elements, property => generatePaperDollElementField(property), { appendNewLineIfNotEmpty: true, separator: ',' })}
+                }),
+            `;
+        }
+        if (isParentPropertyRefExp(property)) {
+            console.log(`Parent property ref: ${property.name}`);
+            return expandToNode `
+                ${property.name.toLowerCase()}: new fields.StringField({initial: ""}),
+            `;
+        }
+        if (isSelfPropertyRefExp(property)) {
+            console.log(`Self property ref: ${property.name}`);
+            return expandToNode `
+                ${property.name.toLowerCase()}: new fields.StringField({initial: ""}),
+            `;
+        }
+        if (isDiceFields(property)) {
+            let initialParam = property.params.find(p => isDieInitialParam(p));
+            let initialDie = (_l = initialParam === null || initialParam === void 0 ? void 0 : initialParam.value) !== null && _l !== void 0 ? _l : "d20";
+            if (isDieField(property)) {
+                return expandToNode `
+                    ${property.name.toLowerCase()}: new fields.StringField({initial: "${initialDie}"}),
+                `;
+            }
+            if (isDiceField(property)) {
+                return expandToNode `
+                    ${property.name.toLowerCase()}: new fields.SchemaField({
+                        die: new fields.StringField({initial: "${initialDie}"}),
+                        number: new fields.NumberField({integer: true, initial: 0, min: 0}),
+                    }),
+                `;
+            }
+        }
+        if (isMeasuredTemplateField(property)) {
+            return expandToNode `
+                ${property.name.toLowerCase()}: new fields.SchemaField({
+                    type: new fields.StringField({initial: "circle"}),
+                    distance: new fields.NumberField({integer: true, initial: 5}),
+                    direction: new fields.NumberField({integer: true, initial: 0}),
+                    angle: new fields.NumberField({integer: true, initial: 0}),
+                    width: new fields.NumberField({integer: true, initial: 0}),
+                }),
+            `;
+        }
+        if (isLayout(property)) {
+            return joinToNode(property.body, property => generateField(property), { appendNewLineIfNotEmpty: true });
+        }
+        return;
+    }
+    function generateCalculatedStatusEffect(property) {
+        let whenParam = property.params.find(p => isStatusParamWhen(p));
+        if (whenParam == undefined || whenParam.when == undefined)
+            return undefined;
+        console.log(`Generating calculated status effect for ${property.name}`);
+        return expandToNode `
+            get ${property.name.toLowerCase()}() {
+                return ${translateExpression(entry, id, whenParam === null || whenParam === void 0 ? void 0 : whenParam.when, true, property)};
+            }
+        `.appendNewLine().appendNewLine();
+    }
+    function generateStatusEffect(property) {
+        return expandToNode `
+            get ${property.name.toLowerCase()}() {
+                return this.parent.statuses.has("${property.name.toLowerCase()}");
+            }
+        `;
+    }
+    let statusEffects = getAllOfType(document.body, isStatusProperty);
+    let calculatedStatusEffects = statusEffects.filter(x => x.params.some(p => isStatusParamWhen(p)));
+    let nonCalculatedStatusEffects = statusEffects.filter(x => !x.params.some(p => isStatusParamWhen(p)));
+    // Name and img come with all docs. We'll go ahead and staple Description on as well
+    // Collect all damage types from the entry
+    function collectDamageTypes(entry) {
+        var _a;
+        const damageTypes = new Set();
+        // Search through all documents for damage type choice fields
+        for (const document of entry.documents) {
+            const damageTypeFields = getAllOfType(document.body, isDamageTypeChoiceField);
+            for (const field of damageTypeFields) {
+                const damageField = field; // Cast to access params
+                const choicesParam = (_a = damageField.params) === null || _a === void 0 ? void 0 : _a.find((p) => isStringParamChoices(p));
+                if (choicesParam && choicesParam.choices) {
+                    for (const choice of choicesParam.choices) {
+                        // Handle simple string choices like "None"
+                        if (typeof choice.value === 'string') {
+                            damageTypes.add(choice.value);
+                        }
+                        // Handle extended choices like { label: "🔥Fire", value: "Fire", ... }
+                        else if (choice.value && typeof choice.value === 'object') {
+                            const extendedChoice = choice.value;
+                            // Try direct access to value property first
+                            if (extendedChoice.value && typeof extendedChoice.value === 'string') {
+                                damageTypes.add(extendedChoice.value);
+                            }
+                            // Try properties array access
+                            else if (extendedChoice.properties && Array.isArray(extendedChoice.properties)) {
+                                // Based on the ISDL syntax { label: "🔥Fire", value: "Fire", icon: "...", color: "...", ... }
+                                // Property 0 = label, Property 1 = value, Property 2 = icon, Property 3 = color, rest = custom
+                                if (extendedChoice.properties.length > 1 && extendedChoice.properties[1].value) {
+                                    const damageTypeValue = extendedChoice.properties[1].value;
+                                    damageTypes.add(damageTypeValue);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return Array.from(damageTypes).sort();
+    }
+    // Generate damage type fields for Active Effects
+    function generateDamageTypeFields(entry) {
+        const damageTypes = collectDamageTypes(entry);
+        if (damageTypes.length === 0) {
+            return expandToNode ``;
+        }
+        const damageTypeFields = damageTypes.map(damageType => {
+            const safeTypeName = damageType.toLowerCase().replace(/[^a-z0-9]/g, '');
+            return expandToNode `
+                // ${damageType} damage type fields
+                ${safeTypeName}bonusdamage: new fields.NumberField({required: false, initial: 0, integer: true}),
+                ${safeTypeName}damageresistanceflat: new fields.NumberField({required: false, initial: 0, integer: true}),
+                ${safeTypeName}damageresistancepercent: new fields.NumberField({required: false, initial: 0, min: 0, max: 100, integer: true}),
+            `;
+        });
+        return expandToNode `
+            // Auto-generated damage type Active Effect fields
+            ${joinToNode(damageTypeFields, field => field, { appendNewLineIfNotEmpty: true })}
+        `;
+    }
+    const fileNode = expandToNode `
+        import ${config.name}Actor from "../../documents/actor.mjs";
+        import ${config.name}Item from "../../documents/item.mjs";
+        import UuidDocumentField from "../UuidDocumentField.mjs";
+        import UuidDocumentArrayField from "../UuidDocumentArrayField.mjs";
+
+        export default class ${document.name}TypeDataModel extends foundry.abstract.DataModel {
+            /** @inheritDoc */
+            static defineSchema() {
+                const fields = foundry.data.fields;
+                return {
+                    description: new fields.HTMLField({required: false, blank: true, initial: ""}),
+                    ${joinToNode(document.body, property => generateField(property), { appendNewLineIfNotEmpty: true })}
+                    ${expandToNode `${generateDocumentPromptModels(document)}`.appendNewLineIfNotEmpty()}
+                    ${isActor(document) ? expandToNode `${generateDamageTypeFields(entry)}`.appendNewLineIfNotEmpty() : ""}
+                    ${!isActor(document) ? "pinned: new fields.BooleanField({initial: false})," : ""}
+                };
+            }
+
+            /* -------------------------------------------- */
+
+            ${joinToNode(calculatedStatusEffects, effect => generateCalculatedStatusEffect(effect), { appendNewLineIfNotEmpty: true })}
+            ${joinToNode(nonCalculatedStatusEffects, effect => generateStatusEffect(effect), { appendNewLineIfNotEmpty: true })}
+        };
+    `.appendNewLineIfNotEmpty();
+    if (!fs.existsSync(dataModelPath)) {
+        fs.mkdirSync(dataModelPath, { recursive: true });
+    }
+    fs.writeFileSync(generatedFilePath, toString(fileNode));
+    function generateDocumentPromptModels(document) {
+        const actions = getAllOfType(document.body, isAction, false);
+        return joinToNode(actions.map(x => generatePromptModels(x, document)).filter(x => x !== undefined).map(x => x), { appendNewLineIfNotEmpty: true });
+    }
+    function generatePromptModels(action, document) {
+        const variables = action.method.body.filter(x => isVariableExpression(x));
+        const prompts = variables.filter(x => isPrompt(x.value)).map(x => x.value);
+        return joinToNode(prompts.map(p => generatePromptModel(p)), { appendNewLineIfNotEmpty: true });
+    }
+    function generatePromptModel(prompt) {
+        const variable = AstUtils.getContainerOfType(prompt.$container, isVariableExpression);
+        const action = AstUtils.getContainerOfType(prompt.$container, isAction);
+        return expandToNode `
+            ${action === null || action === void 0 ? void 0 : action.name.toLowerCase()}${variable === null || variable === void 0 ? void 0 : variable.name.toLowerCase()}: new foundry.data.fields.SchemaField({
+                ${joinToNode(prompt.body, property => generateField(property), { appendNewLineIfNotEmpty: true })}
+            }),
+        `;
+    }
+}
+export function generateUuidDocumentField(destination) {
+    const dataModelPath = path.join(destination, "system", "datamodels");
+    const generatedFilePath = path.join(dataModelPath, "UuidDocumentField.mjs");
+    const fileNode = expandToNode `
+        export default class UuidDocumentField extends foundry.data.fields.StringField {
+
+            /** @inheritdoc */
+            static get _defaults() {
+            return foundry.utils.mergeObject(super._defaults, {
+                required: true,
+                blank: false,
+                nullable: true,
+                initial: null,
+                readonly: false,
+                validationError: "is not a valid Document UUID string"
+            });
+            }
+        
+            /** @override */
+            _cast(value) {
+                if ( value instanceof foundry.abstract.Document ) return value.uuid;
+                else return String(value);
+            }
+
+            /** @inheritdoc */
+            initialize(value, model, options={}) {
+                if ( !game.collections ) return value; // server-side
+
+                return () => fromUuidSync(value);
+            }
+        }
+    `.appendNewLineIfNotEmpty();
+    if (!fs.existsSync(dataModelPath)) {
+        fs.mkdirSync(dataModelPath, { recursive: true });
+    }
+    fs.writeFileSync(generatedFilePath, toString(fileNode));
+}
+export function generateUuidDocumentArrayField(destination) {
+    const dataModelPath = path.join(destination, "system", "datamodels");
+    const generatedFilePath = path.join(dataModelPath, "UuidDocumentArrayField.mjs");
+    const fileNode = expandToNode `
+        export default class UuidDocumentArrayField extends foundry.data.fields.ArrayField {
+
+            constructor(options = {}) {
+                super(new foundry.data.fields.StringField({
+                    required: false,
+                    blank: false,
+                    nullable: false,
+                    initial: null,
+                    readonly: false,
+                    validationError: "is not a valid Document UUID string"
+                }), foundry.utils.mergeObject({
+                    initial: []
+                }, options));
+            }
+        
+            /** @override */
+            _cast(value) {
+                if (!Array.isArray(value)) return [];
+                return value.map(item => {
+                    if (item instanceof foundry.abstract.Document) return item.uuid;
+                    return String(item);
+                }).filter(uuid => uuid && uuid !== "null" && uuid !== "undefined");
+            }
+
+            /** @inheritdoc */
+            initialize(value, model, options={}) {
+                if (!game.collections) return value; // server-side
+                if (!Array.isArray(value)) return [];
+
+                return () => { 
+                    return value.map(uuid => {
+                        if (!uuid || uuid === "null" || uuid === "undefined") return null;
+                        return fromUuidSync(uuid);
+                    }).filter(Boolean);
+                }
+            }
+        }
+    `.appendNewLineIfNotEmpty();
+    if (!fs.existsSync(dataModelPath)) {
+        fs.mkdirSync(dataModelPath, { recursive: true });
+    }
+    fs.writeFileSync(generatedFilePath, toString(fileNode));
+}
+//# sourceMappingURL=datamodel-generator.js.map