intelligent-system-design-language 0.3.21 → 0.3.23

package/out/cli/components/vue/base-components/vue-roll-visualizer.js

@@ -7,115 +7,292 @@ export default function generateRollVisualizerComponent(destination) {
     if (!fs.existsSync(generatedFileDir)) {
         fs.mkdirSync(generatedFileDir, { recursive: true });
     }
-    const fileNode = expandToNode `
-    <script setup>
-        import { ref, computed, watch } from "vue";
-
-        const props = defineProps({});
-
-        const resultText = ref("Not Evaluated");
-        const roll = ref("2d20 + d6 + 5");
-
-        let estimated = true;
-
-        const iterations = ref(1000);
-        const labels = ref([]);
-        const values = ref([]);
-        const min = ref(0);
-        const max = ref(0);
-
-        const countAndSplitNumbers = (arr) => {
-            // Count occurrences
-            const countMap = arr.reduce((acc, num) => {
-                acc[num] = (acc[num] || 0) + 1;
-                return acc;
-            }, {});
-
-            // Sort and split into two arrays
-            const sortedEntries = Object.entries(countMap).sort(([a], [b]) => a - b);
-            const labels = sortedEntries.map(([num]) => Number(num));
-            const values = sortedEntries.map(([, count]) => count);
-
-            return { labels, values };
-        }
-
-        watch(roll, async () => {
-
-            if (!Roll.validate(roll.value)) {
-                return;
-            }
-
-            // Whenever the roll changes, we need to re-calculate the value. First we do a quick simulation, then we do a more accurate one and reload the results
-            let result = await Roll.simulate(roll.value, 1000);
-            let counted = countAndSplitNumbers(result);
-            iterations.value = 1000;
-
-            // If there are more than 20 labels, only show every other label
-            if (counted.labels.length > 20) {
-                counted.labels = counted.labels.filter((_, i) => i % 2 === 0);
-                counted.values = counted.values.filter((_, i) => i % 2 === 0);
-            }
-
-            labels.value = counted.labels;
-            values.value = counted.values;
-            min.value = Math.min(...counted.labels);
-            max.value = Math.max(...counted.labels);
-
-            setTimeout(async () => {
-                Roll.simulate(roll.value, 10000).then(result2 => {
-                    let counted2 = countAndSplitNumbers(result2);
-                    iterations.value = 10000;
-
-                    // If there are more than 20 labels, only show every other label
-                    if (counted2.labels.length > 20) {
-                        counted2.labels = counted.labels.filter((_, i) => i % 2 === 0);
-                        counted2.values = counted.values.filter((_, i) => i % 2 === 0);
-                    }
-
-                    labels.value = counted2.labels;
-                    values.value = counted2.values;
-                });
-            }, 0);
-        });
-
-
-    </script>
-
-    <template>
-        <v-card class="mt-8 mx-auto overflow-visible" style="min-width: 600px;">
-            <v-sheet
-            class="v-sheet--offset mx-auto"
-            color="cyan"
-            elevation="12"
-            max-width="calc(100% - 32px)"
-            rounded="lg"
-            >
-                <v-sparkline
-                    :labels="labels"
-                    :model-value="values"
-                    color="white"
-                    line-width="2"
-                    padding="16"
-                    smooth="8"
-                    label-size="6"
-                ></v-sparkline>
-            </v-sheet>
-
-            <v-card-text class="pt-0">
-                <div class="text-h6 font-weight-light mb-2">
-                <v-text-field v-model="roll"></v-text-field>    
-                </div>
-                <div class="subheading font-weight-light text-grey" v-if="values.length > 0">
-                    Min: {{min}} Max: {{max}}
-                </div>
-                <v-divider class="my-2"></v-divider>
-                <span class="text-caption text-grey font-weight-light">
-                    Approximate results based on {{iterations}} simulations
-                </span>
-            </v-card-text>
-        </v-card>
-    </template>
-    `;
+    const fileNode = expandToNode `
+    <script>
+        // Module-scoped cache (shared across all roll-visualizer instances for the page
+        // session, and surviving sheet re-renders/re-opens). Keyed by the RESOLVED formula
+        // (after @refs are substituted), so the same dice math -- especially the expensive
+        // simulation path -- is only computed once. Cleared on page reload.
+        const __rollVisualizerCache = new Map();
+    </script>
+    <script setup>
+        import { ref, watch, computed, inject } from "vue";
+
+        const props = defineProps({
+            label: String,
+            icon: String,
+            color: String,
+            systemPath: String,
+            context: Object,
+            // The Foundry roll formula (may contain @refs), compiled from the field's value: expression.
+            formula: { type: String, default: "" },
+            // Data object resolving the @refs, bound from the live (reactive) document/prompt data.
+            rollData: { type: Object, default: () => ({}) }
+        });
+
+        // ----- Distribution engine ---------------------------------------------------
+        // For purely additive dice formulas (dice + constants, +/- only, no dice
+        // modifiers) we compute the EXACT probability distribution by convolution.
+        // Anything more exotic (keep-highest/lowest, exploding, rerolls, multiplied
+        // dice, fate dice, pools, functions) falls back to Monte Carlo simulation.
+
+        // A distribution is a Map<outcomeValue, probability>.
+        const dieDist = (faces) => {
+            const m = new Map();
+            for (let f = 1; f <= faces; f++) m.set(f, 1 / faces);
+            return m;
+        };
+        const convolve = (a, b) => {
+            const out = new Map();
+            for (const [va, pa] of a) {
+                for (const [vb, pb] of b) {
+                    const v = va + vb;
+                    out.set(v, (out.get(v) || 0) + pa * pb);
+                }
+            }
+            return out;
+        };
+        const negate = (a) => {
+            const m = new Map();
+            for (const [v, p] of a) m.set(-v, p);
+            return m;
+        };
+        const shift = (a, k) => {
+            const m = new Map();
+            for (const [v, p] of a) m.set(v + k, p);
+            return m;
+        };
+
+        // Classify a Foundry roll term. Foundry does not minify these class names in
+        // either v12 or v13, so constructor.name is a reliable signal.
+        const classify = (term) => {
+            const n = term?.constructor?.name;
+            if (n === "Die") return "die";
+            if (n === "NumericTerm") return "num";
+            if (n === "OperatorTerm") return "op";
+            return "other";
+        };
+
+        // Decide whether a parsed roll can be solved exactly. Guard the convolution
+        // against pathological sizes (huge dice pools) by falling back to simulation.
+        const MAX_BUCKETS = 5000;
+        const canConvolve = (terms) => {
+            let minTotal = 0, maxTotal = 0;
+            for (const term of terms) {
+                const kind = classify(term);
+                if (kind === "op") {
+                    if (term.operator !== "+" && term.operator !== "-") return false;
+                    continue;
+                }
+                if (kind === "die") {
+                    if (Array.isArray(term.modifiers) && term.modifiers.length > 0) return false;
+                    const number = Number(term.number);
+                    const faces = Number(term.faces);
+                    if (!Number.isInteger(number) || !Number.isInteger(faces) || faces < 1 || number < 0) return false;
+                    minTotal += number;
+                    maxTotal += number * faces;
+                    continue;
+                }
+                if (kind === "num") {
+                    if (!Number.isFinite(Number(term.number))) return false;
+                    continue;
+                }
+                return false; // unknown term type
+            }
+            return (maxTotal - minTotal) <= MAX_BUCKETS;
+        };
+
+        // Build the exact PMF for an additive term list.
+        const convolveTerms = (terms) => {
+            let acc = new Map([[0, 1]]);
+            let sign = 1;
+            for (const term of terms) {
+                const kind = classify(term);
+                if (kind === "op") {
+                    sign = term.operator === "-" ? -1 : 1;
+                    continue;
+                }
+                if (kind === "die") {
+                    let dist = new Map([[0, 1]]);
+                    for (let i = 0; i < Number(term.number); i++) dist = convolve(dist, dieDist(Number(term.faces)));
+                    if (sign < 0) dist = negate(dist);
+                    acc = convolve(acc, dist);
+                }
+                else if (kind === "num") {
+                    acc = shift(acc, sign * Number(term.number));
+                }
+                sign = 1;
+            }
+            return acc;
+        };
+
+        // Derive the display payload (average, min, max, chart series) from a PMF.
+        const summarize = (dist, approximate) => {
+            const entries = [...dist.entries()].sort((a, b) => a[0] - b[0]);
+            let average = 0, min = Infinity, max = -Infinity;
+            for (const [v, p] of entries) {
+                average += v * p;
+                if (v < min) min = v;
+                if (v > max) max = v;
+            }
+            const outcomeValues = entries.map(([v]) => v);
+            const values = entries.map(([, p]) => +(p * 100).toFixed(2));
+            // Thin the x-axis labels so they don't cluster/overlap: pick a "nice" step
+            // (1, 2, 5, 10, ...) targeting ~8 labels, and only label outcomes that land on
+            // a multiple of it -- so the axis reads in round numbers (5, 10, 15, 20 ...).
+            const lo = outcomeValues.length ? outcomeValues[0] : 0;
+            const hi = outcomeValues.length ? outcomeValues[outcomeValues.length - 1] : 0;
+            const span = Math.max(1, hi - lo);
+            const rawStep = span / 8;
+            const pow = Math.pow(10, Math.floor(Math.log10(rawStep)));
+            const norm = rawStep / pow;
+            const niceStep = (norm <= 1 ? 1 : norm <= 2 ? 2 : norm <= 5 ? 5 : 10) * pow;
+            const step = Math.max(1, Math.round(niceStep));
+            return {
+                average: +average.toFixed(2),
+                min: entries.length ? min : 0,
+                max: entries.length ? max : 0,
+                labels: outcomeValues,
+                values,
+                step,
+                approximate,
+                hasData: entries.length > 0
+            };
+        };
+
+        // ----- Reactive computation --------------------------------------------------
+
+        const result = ref({ average: 0, min: 0, max: 0, labels: [], values: [], step: 1, approximate: false, hasData: false });
+        const iterations = ref(0);
+        let runToken = 0;
+
+        // Monte Carlo fallback. Roll.simulate builds a full Roll per sample (~0.2ms each),
+        // so a large batch blocks the main thread for seconds and freezes the sheet on
+        // render. Instead, sample a modest target in small chunks and yield to the event
+        // loop between each, refining the curve in place. The sheet stays responsive and
+        // the chart fills in progressively.
+        const SIM_TARGET = 2000;
+        const SIM_CHUNK = 200;
+        const runSimulation = async (formula, token, cacheKey) => {
+            const counts = new Map();
+            let done = 0;
+            while (done < SIM_TARGET) {
+                if (token !== runToken) return; // a newer run superseded us
+                const n = Math.min(SIM_CHUNK, SIM_TARGET - done);
+                const batch = await Roll.simulate(formula, n);
+                if (token !== runToken) return;
+                for (const v of batch) counts.set(v, (counts.get(v) || 0) + 1);
+                done += n;
+                const dist = new Map();
+                for (const [v, c] of counts) dist.set(v, c / done);
+                result.value = summarize(dist, true);
+                iterations.value = done;
+                // Yield so the browser can paint and handle input between chunks.
+                await new Promise(r => setTimeout(r, 0));
+            }
+            // Cache the completed estimate so this formula isn't re-simulated later.
+            __rollVisualizerCache.set(cacheKey, result.value);
+        };
+
+        const recompute = () => {
+            const token = ++runToken;
+            const raw = (props.formula || "").trim();
+            if (!raw) {
+                result.value = { average: 0, min: 0, max: 0, labels: [], values: [], step: 1, approximate: false, hasData: false };
+                return;
+            }
+            let roll;
+            try {
+                roll = new Roll(raw, props.rollData || {});
+            }
+            catch (e) {
+                result.value = { average: 0, min: 0, max: 0, labels: [], values: [], step: 1, approximate: false, hasData: false };
+                return;
+            }
+            // Cache hit on the resolved formula -> reuse the result, no recompute.
+            const cacheKey = roll.formula;
+            const cached = __rollVisualizerCache.get(cacheKey);
+            if (cached) {
+                result.value = cached;
+                iterations.value = cached.approximate ? SIM_TARGET : 0;
+                return;
+            }
+            // After construction Foundry has substituted @refs into the terms.
+            const terms = roll.terms || [];
+            if (canConvolve(terms)) {
+                iterations.value = 0;
+                const summary = summarize(convolveTerms(terms), false);
+                __rollVisualizerCache.set(cacheKey, summary);
+                result.value = summary;
+            }
+            else {
+                // Simulate against the resolved formula (no @refs remain in roll.formula).
+                runSimulation(roll.formula, token, cacheKey);
+            }
+        };
+
+        // Debounce so rapid field edits don't kick off redundant simulations.
+        let debounceHandle = null;
+        watch(
+            () => [props.formula, JSON.stringify(props.rollData || {})],
+            () => {
+                if (debounceHandle) clearTimeout(debounceHandle);
+                debounceHandle = setTimeout(recompute, 200);
+            },
+            { immediate: true }
+        );
+
+        const getLabel = computed(() => {
+            const localized = game.i18n.localize(props.label);
+            if (props.icon) return \`<i class="fa-solid \${props.icon}"></i> \${localized}\`;
+            return localized;
+        });
+        const accentColor = computed(() => props.color || "#92aed9");
+        const averageText = computed(() => (result.value.approximate ? "≈ " : "") + result.value.average);
+    </script>
+
+    <template>
+        <v-card class="isdl-roll-visualizer" :name="systemPath" variant="tonal" density="compact">
+            <div class="isdl-roll-visualizer__header">
+                <span class="isdl-roll-visualizer__label" v-html="getLabel"></span>
+                <span class="isdl-roll-visualizer__avg" :style="{ color: accentColor }">{{ averageText }}</span>
+            </div>
+            <v-sparkline
+                v-if="result.hasData"
+                :labels="result.labels"
+                :model-value="result.values"
+                :color="accentColor"
+                line-width="2"
+                padding="8"
+                smooth="6"
+                :label-size="10"
+                auto-draw
+                preserveAspectRatio="none"
+            >
+                <!-- Render a label only on "nice" round outcomes; blank elsewhere so the
+                     axis doesn't cluster and never falls back to showing the raw value. -->
+                <template #label="item">
+                    {{ Number(item.value) % result.step === 0 ? item.value : "" }}
+                </template>
+            </v-sparkline>
+            <div v-else class="isdl-roll-visualizer__empty text-caption">
+                {{ game.i18n.localize("ROLLVISUALIZER.NoFormula") }}
+            </div>
+            <div class="isdl-roll-visualizer__footer text-caption">
+                <span v-if="result.hasData">
+                    {{ game.i18n.localize("ROLLVISUALIZER.Min") }}: {{ result.min }}
+                    &middot;
+                    {{ game.i18n.localize("ROLLVISUALIZER.Max") }}: {{ result.max }}
+                    &middot;
+                    {{ game.i18n.localize("ROLLVISUALIZER.Average") }}: {{ averageText }}
+                </span>
+                <span v-if="result.approximate && iterations > 0" class="isdl-roll-visualizer__approx">
+                    ({{ iterations }} {{ game.i18n.localize("ROLLVISUALIZER.Simulations") }})
+                </span>
+            </div>
+        </v-card>
+    </template>
+    `.appendNewLine();
     fs.writeFileSync(generatedFilePath, toString(fileNode));
 }
 //# sourceMappingURL=vue-roll-visualizer.js.map

package/out/cli/components/vue/base-components/vue-roll-visualizer.js.map

@@ -1 +1 @@
-{"version":3,"file":"vue-roll-visualizer.js","sourceRoot":"","sources":["../../../../../src/cli/components/vue/base-components/vue-roll-visualizer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAClC,OAAO,KAAK,EAAE,MAAM,SAAS,CAAC;AAC9B,OAAO,EAAC,YAAY,EAAE,QAAQ,EAAC,MAAM,kBAAkB,CAAC;AAExD,MAAM,CAAC,OAAO,UAAU,+BAA+B,CAAC,WAAmB;IACvE,MAAM,gBAAgB,GAAG,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,QAAQ,EAAE,WAAW,EAAE,KAAK,EAAE,YAAY,CAAC,CAAC;IAC5F,MAAM,iBAAiB,GAAG,IAAI,CAAC,IAAI,CAAC,gBAAgB,EAAE,qBAAqB,CAAC,CAAC;IAE7E,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,gBAAgB,CAAC,EAAE;QAClC,EAAE,CAAC,SAAS,CAAC,gBAAgB,EAAE,EAAC,SAAS,EAAE,IAAI,EAAC,CAAC,CAAC;KACrD;IAED,MAAM,QAAQ,GAAG,YAAY,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA4G5B,CAAC;IAEF,EAAE,CAAC,aAAa,CAAC,iBAAiB,EAAE,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC;AAC5D,CAAC"}
+{"version":3,"file":"vue-roll-visualizer.js","sourceRoot":"","sources":["../../../../../src/cli/components/vue/base-components/vue-roll-visualizer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAClC,OAAO,KAAK,EAAE,MAAM,SAAS,CAAC;AAC9B,OAAO,EAAC,YAAY,EAAE,QAAQ,EAAC,MAAM,kBAAkB,CAAC;AAExD,MAAM,CAAC,OAAO,UAAU,+BAA+B,CAAC,WAAmB;IACvE,MAAM,gBAAgB,GAAG,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,QAAQ,EAAE,WAAW,EAAE,KAAK,EAAE,YAAY,CAAC,CAAC;IAC5F,MAAM,iBAAiB,GAAG,IAAI,CAAC,IAAI,CAAC,gBAAgB,EAAE,qBAAqB,CAAC,CAAC;IAE7E,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,gBAAgB,CAAC,EAAE;QAClC,EAAE,CAAC,SAAS,CAAC,gBAAgB,EAAE,EAAC,SAAS,EAAE,IAAI,EAAC,CAAC,CAAC;KACrD;IAED,MAAM,QAAQ,GAAG,YAAY,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA6R5B,CAAC,aAAa,EAAE,CAAC;IAElB,EAAE,CAAC,aAAa,CAAC,iBAAiB,EAAE,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC;AAC5D,CAAC"}

package/out/cli/components/vue/base-components/vue-self-property-reference.js

@@ -7,68 +7,68 @@ export default function generateSelfPropertyReferenceComponent(destination, entr
     if (!fs.existsSync(generatedFileDir)) {
         fs.mkdirSync(generatedFileDir, { recursive: true });
     }
-    const fileNode = expandToNode `
-    <script setup>
-        import { ref, computed, inject } from "vue";
-
-        const props = defineProps({
-            label: String,
-            systemPath: String,
-            context: Object,
-            disabled: Boolean,
-            icon: String,
-            color: String,
-            propertyType: String,
-            choices: Array
-        });
-
-        const document = inject("rawDocument");
-
-        const value = computed({
-            get: () => foundry.utils.getProperty(props.context, props.systemPath),
-            set: (newValue) => foundry.utils.setProperty(props.context, props.systemPath, newValue)
-        });
-
-        // Filter choices based on property type if provided
-        const availableChoices = computed(() => {
-            if (!props.choices || !props.propertyType) return [];
-            
-            // Filter properties based on type
-            return props.choices.filter(choice => {
-                // Here we would check if the choice matches the expected property type
-                // For now, return all choices - this could be enhanced with type checking
-                return true;
-            });
-        });
-
-
-        const fieldColor = computed(() => {
-            return props.color || 'primary';
-        });
-    </script>
-
-    <template>
-        <div class="isdl-self-property-reference single-wide">
-            <v-select
-                :model-value="value"
-                @update:model-value="(v) => { value = v; if (document) document.update({ [props.systemPath]: v }); }"
-                :items="availableChoices"
-                :name="props.systemPath"
-                :disabled="disabled"
-                :color="fieldColor"
-                variant="outlined"
-                density="compact"
-                clearable
-            >
-                <template #label>
-                    <span class="field-label">
-                        <v-icon v-if="props.icon" :icon="props.icon" size="small" class="me-1"></v-icon>
-                        {{ game.i18n.localize(props.label) }}
-                    </span>
-                </template>
-            </v-select>
-        </div>
-    </template>
+    const fileNode = expandToNode `
+    <script setup>
+        import { ref, computed, inject } from "vue";
+
+        const props = defineProps({
+            label: String,
+            systemPath: String,
+            context: Object,
+            disabled: Boolean,
+            icon: String,
+            color: String,
+            propertyType: String,
+            choices: Array
+        });
+
+        const document = inject("rawDocument");
+
+        const value = computed({
+            get: () => foundry.utils.getProperty(props.context, props.systemPath),
+            set: (newValue) => foundry.utils.setProperty(props.context, props.systemPath, newValue)
+        });
+
+        // Filter choices based on property type if provided
+        const availableChoices = computed(() => {
+            if (!props.choices || !props.propertyType) return [];
+            
+            // Filter properties based on type
+            return props.choices.filter(choice => {
+                // Here we would check if the choice matches the expected property type
+                // For now, return all choices - this could be enhanced with type checking
+                return true;
+            });
+        });
+
+
+        const fieldColor = computed(() => {
+            return props.color || 'primary';
+        });
+    </script>
+
+    <template>
+        <div class="isdl-self-property-reference single-wide">
+            <v-select
+                :model-value="value"
+                @update:model-value="(v) => { value = v; if (document) document.update({ [props.systemPath]: v }); }"
+                :items="availableChoices"
+                :name="props.systemPath"
+                :disabled="disabled"
+                :color="fieldColor"
+                variant="outlined"
+                density="compact"
+                clearable
+            >
+                <template #label>
+                    <span class="field-label">
+                        <v-icon v-if="props.icon" :icon="props.icon" size="small" class="me-1"></v-icon>
+                        {{ game.i18n.localize(props.label) }}
+                    </span>
+                </template>
+            </v-select>
+        </div>
+    </template>
     `.appendNewLine();
     fs.writeFileSync(generatedFilePath, toString(fileNode));
 }