@aglyn/plugins-logic 1.0.0-beta.244 → 1.0.0-beta.247

package/src/lib/model/formula.d.ts

@@ -0,0 +1,72 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * A function step's expression, built by picking an operation and its values
+ * instead of typing it (AGL-3757). What comes out is the SAME expression an
+ * author could have typed — the evaluator, the stored definition and every
+ * page that runs it are untouched; this only writes the text.
+ */
+export type FormulaOperation = 'value' | 'add' | 'subtract' | 'multiply' | 'divide' | 'min' | 'max' | 'round' | 'roundDown' | 'roundUp' | 'absolute' | 'currency' | 'number' | 'join';
+/** One value an operation works on. */
+export type FormulaOperand = 
+/** A parameter, a local variable, a site variable or a dictionary member. */
+{
+    source: 'name';
+    name: string;
+} | {
+    source: 'number';
+    value: string;
+} | {
+    source: 'text';
+    value: string;
+}
+/** Whatever the box holds already, so formulas can be layered. */
+ | {
+    source: 'current';
+};
+export interface FormulaDraft {
+    operation: FormulaOperation;
+    operands: FormulaOperand[];
+    /** Decimal places for round, currency and number. */
+    places?: number;
+    /** The sign written before a currency amount. */
+    symbol?: string;
+    /** What goes between joined texts. */
+    separator?: string;
+}
+interface FormulaOperationSpec {
+    label: string;
+    /** How many values it takes at least; `variadic` ones take more. */
+    minOperands: number;
+    variadic?: boolean;
+    /** What each value box is called, in order; the last repeats. */
+    operandLabels: string[];
+    places?: boolean;
+}
+export declare const FORMULA_OPERATIONS: Record<FormulaOperation, FormulaOperationSpec>;
+/** The operations, in the order the picker lists them. */
+export declare const FORMULA_OPERATION_ORDER: FormulaOperation[];
+/** The label for a value box at `index` of `operation`. */
+export declare function formulaOperandLabel(operation: FormulaOperation, index: number): string;
+/**
+ * The expression a draft writes, or `null` while a value it needs is blank.
+ * `current` is what the box held when the builder opened.
+ */
+export declare function buildFormula(draft: FormulaDraft, current?: string): string | null;
+/** A fresh draft for `operation`, carrying over the values already chosen. */
+export declare function formulaDraftFor(operation: FormulaOperation, previous?: FormulaDraft, current?: string): FormulaDraft;
+export {};

package/src/lib/model/formula.js

@@ -0,0 +1,264 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ /**
+ * A function step's expression, built by picking an operation and its values
+ * instead of typing it (AGL-3757). What comes out is the SAME expression an
+ * author could have typed — the evaluator, the stored definition and every
+ * page that runs it are untouched; this only writes the text.
+ */ export const FORMULA_OPERATIONS = {
+    value: {
+        label: 'Use a value',
+        minOperands: 1,
+        operandLabels: [
+            'Value'
+        ]
+    },
+    add: {
+        label: 'Add',
+        minOperands: 2,
+        variadic: true,
+        operandLabels: [
+            'Value',
+            'Plus'
+        ]
+    },
+    subtract: {
+        label: 'Subtract',
+        minOperands: 2,
+        operandLabels: [
+            'Value',
+            'Minus'
+        ]
+    },
+    multiply: {
+        label: 'Multiply',
+        minOperands: 2,
+        variadic: true,
+        operandLabels: [
+            'Value',
+            'Times'
+        ]
+    },
+    divide: {
+        label: 'Divide',
+        minOperands: 2,
+        operandLabels: [
+            'Value',
+            'Divided by'
+        ]
+    },
+    min: {
+        label: 'Smallest of',
+        minOperands: 2,
+        variadic: true,
+        operandLabels: [
+            'Value',
+            'Or'
+        ]
+    },
+    max: {
+        label: 'Largest of',
+        minOperands: 2,
+        variadic: true,
+        operandLabels: [
+            'Value',
+            'Or'
+        ]
+    },
+    round: {
+        label: 'Round',
+        minOperands: 1,
+        operandLabels: [
+            'Value'
+        ],
+        places: true
+    },
+    roundDown: {
+        label: 'Round down',
+        minOperands: 1,
+        operandLabels: [
+            'Value'
+        ]
+    },
+    roundUp: {
+        label: 'Round up',
+        minOperands: 1,
+        operandLabels: [
+            'Value'
+        ]
+    },
+    absolute: {
+        label: 'Without its minus sign',
+        minOperands: 1,
+        operandLabels: [
+            'Value'
+        ]
+    },
+    currency: {
+        label: 'Format as money',
+        minOperands: 1,
+        operandLabels: [
+            'Amount'
+        ],
+        places: true
+    },
+    number: {
+        label: 'Format with thousands separators',
+        minOperands: 1,
+        operandLabels: [
+            'Number'
+        ],
+        places: true
+    },
+    join: {
+        label: 'Join text',
+        minOperands: 2,
+        variadic: true,
+        operandLabels: [
+            'Text',
+            'Then'
+        ]
+    }
+};
+/** The operations, in the order the picker lists them. */ export const FORMULA_OPERATION_ORDER = Object.keys(FORMULA_OPERATIONS);
+/** The label for a value box at `index` of `operation`. */ export function formulaOperandLabel(operation, index) {
+    const labels = FORMULA_OPERATIONS[operation].operandLabels;
+    return labels[Math.min(index, labels.length - 1)];
+}
+/**
+ * A text as the evaluator reads it. Its strings have no escapes, so the
+ * quote the text does not contain is used; a text holding both loses its
+ * double quotes rather than writing an expression that cannot be read.
+ */ function quoteText(value) {
+    if (!value.includes("'")) return `'${value}'`;
+    if (!value.includes('"')) return `"${value}"`;
+    return `'${value.replace(/"/g, '')}'`;
+}
+const SIMPLE_EXPRESSION = /^\s*(?:-?[0-9]*\.?[0-9]+|[a-zA-Z_][a-zA-Z0-9_.]*)\s*$/;
+/**
+ * One operand as expression text, or `null` while it is still blank. `bare`
+ * is a built-in's argument, which its own parentheses already delimit.
+ */ function operandText(operand, current, bare = false) {
+    switch(operand.source){
+        case 'name':
+            return operand.name ? operand.name : null;
+        case 'number':
+            {
+                const text = operand.value.trim();
+                if (!text) return null;
+                const parsed = Number(text);
+                return Number.isFinite(parsed) ? String(parsed) : null;
+            }
+        case 'text':
+            return quoteText(operand.value);
+        case 'current':
+            {
+                const text = current.trim();
+                if (!text) return null;
+                return bare || SIMPLE_EXPRESSION.test(text) ? text : `(${text})`;
+            }
+    }
+}
+function placesOf(draft, fallback) {
+    var _draft_places;
+    const places = Number((_draft_places = draft.places) != null ? _draft_places : fallback);
+    return Number.isInteger(places) && places >= 0 && places <= 6 ? places : fallback;
+}
+/**
+ * The expression a draft writes, or `null` while a value it needs is blank.
+ * `current` is what the box held when the builder opened.
+ */ export function buildFormula(draft, current = '') {
+    const spec = FORMULA_OPERATIONS[draft.operation];
+    const operands = draft.operands.slice(0, spec.variadic ? draft.operands.length : spec.minOperands);
+    if (operands.length < spec.minOperands) return null;
+    const arithmetic = [
+        'add',
+        'subtract',
+        'multiply',
+        'divide',
+        'join'
+    ].includes(draft.operation);
+    const parts = operands.map((operand)=>operandText(operand, current, !arithmetic && draft.operation !== 'value'));
+    if (parts.some((part)=>part === null)) return null;
+    const values = parts;
+    const [first] = values;
+    switch(draft.operation){
+        case 'value':
+            return first;
+        case 'add':
+            return values.join(' + ');
+        case 'subtract':
+            return values.join(' - ');
+        case 'multiply':
+            return values.join(' * ');
+        case 'divide':
+            return values.join(' / ');
+        case 'min':
+            return `min(${values.join(', ')})`;
+        case 'max':
+            return `max(${values.join(', ')})`;
+        case 'round':
+            return `round(${first}, ${placesOf(draft, 0)})`;
+        case 'roundDown':
+            return `floor(${first})`;
+        case 'roundUp':
+            return `ceil(${first})`;
+        case 'absolute':
+            return `abs(${first})`;
+        case 'currency':
+            var _draft_symbol;
+            return `${quoteText((_draft_symbol = draft.symbol) != null ? _draft_symbol : '$')} + format(${first}, ${placesOf(draft, 2)})`;
+        case 'number':
+            return `format(${first}, ${placesOf(draft, 0)})`;
+        case 'join':
+            {
+                var _draft_separator;
+                // A leading '' keeps two numbers joined as text rather than added.
+                const separator = (_draft_separator = draft.separator) != null ? _draft_separator : ' ';
+                return separator ? values.join(` + ${quoteText(separator)} + `) : [
+                    '\'\'',
+                    ...values
+                ].join(' + ');
+            }
+    }
+}
+/** A fresh draft for `operation`, carrying over the values already chosen. */ export function formulaDraftFor(operation, previous, current = '') {
+    const spec = FORMULA_OPERATIONS[operation];
+    const blank = (index)=>index === 0 && current.trim() ? {
+            source: 'current'
+        } : operation === 'join' ? {
+            source: 'text',
+            value: ''
+        } : {
+            source: 'name',
+            name: ''
+        };
+    const operands = Array.from({
+        length: spec.minOperands
+    }, (_, index)=>{
+        var _ref;
+        return (_ref = previous == null ? void 0 : previous.operands[index]) != null ? _ref : blank(index);
+    });
+    return {
+        operation,
+        operands,
+        places: previous == null ? void 0 : previous.places,
+        symbol: previous == null ? void 0 : previous.symbol,
+        separator: previous == null ? void 0 : previous.separator
+    };
+}
+
+//# sourceMappingURL=formula.js.map

package/src/lib/model/formula.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../libs/plugins/logic/src/lib/model/formula.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2026 Aglyn LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * A function step's expression, built by picking an operation and its values\n * instead of typing it (AGL-3757). What comes out is the SAME expression an\n * author could have typed — the evaluator, the stored definition and every\n * page that runs it are untouched; this only writes the text.\n */\n\nexport type FormulaOperation =\n  | 'value'\n  | 'add'\n  | 'subtract'\n  | 'multiply'\n  | 'divide'\n  | 'min'\n  | 'max'\n  | 'round'\n  | 'roundDown'\n  | 'roundUp'\n  | 'absolute'\n  | 'currency'\n  | 'number'\n  | 'join'\n\n/** One value an operation works on. */\nexport type FormulaOperand =\n  /** A parameter, a local variable, a site variable or a dictionary member. */\n  | { source: 'name'; name: string }\n  | { source: 'number'; value: string }\n  | { source: 'text'; value: string }\n  /** Whatever the box holds already, so formulas can be layered. */\n  | { source: 'current' }\n\nexport interface FormulaDraft {\n  operation: FormulaOperation\n  operands: FormulaOperand[]\n  /** Decimal places for round, currency and number. */\n  places?: number\n  /** The sign written before a currency amount. */\n  symbol?: string\n  /** What goes between joined texts. */\n  separator?: string\n}\n\ninterface FormulaOperationSpec {\n  label: string\n  /** How many values it takes at least; `variadic` ones take more. */\n  minOperands: number\n  variadic?: boolean\n  /** What each value box is called, in order; the last repeats. */\n  operandLabels: string[]\n  places?: boolean\n}\n\nexport const FORMULA_OPERATIONS: Record<FormulaOperation, FormulaOperationSpec> = {\n  value: { label: 'Use a value', minOperands: 1, operandLabels: ['Value'] },\n  add: {\n    label: 'Add',\n    minOperands: 2,\n    variadic: true,\n    operandLabels: ['Value', 'Plus'],\n  },\n  subtract: {\n    label: 'Subtract',\n    minOperands: 2,\n    operandLabels: ['Value', 'Minus'],\n  },\n  multiply: {\n    label: 'Multiply',\n    minOperands: 2,\n    variadic: true,\n    operandLabels: ['Value', 'Times'],\n  },\n  divide: {\n    label: 'Divide',\n    minOperands: 2,\n    operandLabels: ['Value', 'Divided by'],\n  },\n  min: {\n    label: 'Smallest of',\n    minOperands: 2,\n    variadic: true,\n    operandLabels: ['Value', 'Or'],\n  },\n  max: {\n    label: 'Largest of',\n    minOperands: 2,\n    variadic: true,\n    operandLabels: ['Value', 'Or'],\n  },\n  round: {\n    label: 'Round',\n    minOperands: 1,\n    operandLabels: ['Value'],\n    places: true,\n  },\n  roundDown: { label: 'Round down', minOperands: 1, operandLabels: ['Value'] },\n  roundUp: { label: 'Round up', minOperands: 1, operandLabels: ['Value'] },\n  absolute: {\n    label: 'Without its minus sign',\n    minOperands: 1,\n    operandLabels: ['Value'],\n  },\n  currency: {\n    label: 'Format as money',\n    minOperands: 1,\n    operandLabels: ['Amount'],\n    places: true,\n  },\n  number: {\n    label: 'Format with thousands separators',\n    minOperands: 1,\n    operandLabels: ['Number'],\n    places: true,\n  },\n  join: {\n    label: 'Join text',\n    minOperands: 2,\n    variadic: true,\n    operandLabels: ['Text', 'Then'],\n  },\n}\n\n/** The operations, in the order the picker lists them. */\nexport const FORMULA_OPERATION_ORDER = Object.keys(\n  FORMULA_OPERATIONS,\n) as FormulaOperation[]\n\n/** The label for a value box at `index` of `operation`. */\nexport function formulaOperandLabel(\n  operation: FormulaOperation,\n  index: number,\n): string {\n  const labels = FORMULA_OPERATIONS[operation].operandLabels\n  return labels[Math.min(index, labels.length - 1)]\n}\n\n/**\n * A text as the evaluator reads it. Its strings have no escapes, so the\n * quote the text does not contain is used; a text holding both loses its\n * double quotes rather than writing an expression that cannot be read.\n */\nfunction quoteText(value: string): string {\n  if (!value.includes(\"'\")) return `'${value}'`\n  if (!value.includes('\"')) return `\"${value}\"`\n  return `'${value.replace(/\"/g, '')}'`\n}\n\nconst SIMPLE_EXPRESSION = /^\\s*(?:-?[0-9]*\\.?[0-9]+|[a-zA-Z_][a-zA-Z0-9_.]*)\\s*$/\n\n/**\n * One operand as expression text, or `null` while it is still blank. `bare`\n * is a built-in's argument, which its own parentheses already delimit.\n */\nfunction operandText(\n  operand: FormulaOperand,\n  current: string,\n  bare = false,\n): string | null {\n  switch (operand.source) {\n    case 'name':\n      return operand.name ? operand.name : null\n    case 'number': {\n      const text = operand.value.trim()\n      if (!text) return null\n      const parsed = Number(text)\n      return Number.isFinite(parsed) ? String(parsed) : null\n    }\n    case 'text':\n      return quoteText(operand.value)\n    case 'current': {\n      const text = current.trim()\n      if (!text) return null\n      return bare || SIMPLE_EXPRESSION.test(text) ? text : `(${text})`\n    }\n  }\n}\n\nfunction placesOf(draft: FormulaDraft, fallback: number): number {\n  const places = Number(draft.places ?? fallback)\n  return Number.isInteger(places) && places >= 0 && places <= 6 ? places : fallback\n}\n\n/**\n * The expression a draft writes, or `null` while a value it needs is blank.\n * `current` is what the box held when the builder opened.\n */\nexport function buildFormula(draft: FormulaDraft, current = ''): string | null {\n  const spec = FORMULA_OPERATIONS[draft.operation]\n  const operands = draft.operands.slice(\n    0,\n    spec.variadic ? draft.operands.length : spec.minOperands,\n  )\n  if (operands.length < spec.minOperands) return null\n  const arithmetic = ['add', 'subtract', 'multiply', 'divide', 'join'].includes(\n    draft.operation,\n  )\n  const parts = operands.map((operand) =>\n    operandText(operand, current, !arithmetic && draft.operation !== 'value'),\n  )\n  if (parts.some((part) => part === null)) return null\n  const values = parts as string[]\n  const [first] = values\n  switch (draft.operation) {\n    case 'value':\n      return first\n    case 'add':\n      return values.join(' + ')\n    case 'subtract':\n      return values.join(' - ')\n    case 'multiply':\n      return values.join(' * ')\n    case 'divide':\n      return values.join(' / ')\n    case 'min':\n      return `min(${values.join(', ')})`\n    case 'max':\n      return `max(${values.join(', ')})`\n    case 'round':\n      return `round(${first}, ${placesOf(draft, 0)})`\n    case 'roundDown':\n      return `floor(${first})`\n    case 'roundUp':\n      return `ceil(${first})`\n    case 'absolute':\n      return `abs(${first})`\n    case 'currency':\n      return `${quoteText(draft.symbol ?? '$')} + format(${first}, ${placesOf(draft, 2)})`\n    case 'number':\n      return `format(${first}, ${placesOf(draft, 0)})`\n    case 'join': {\n      // A leading '' keeps two numbers joined as text rather than added.\n      const separator = draft.separator ?? ' '\n      return separator\n        ? values.join(` + ${quoteText(separator)} + `)\n        : ['\\'\\'', ...values].join(' + ')\n    }\n  }\n}\n\n/** A fresh draft for `operation`, carrying over the values already chosen. */\nexport function formulaDraftFor(\n  operation: FormulaOperation,\n  previous?: FormulaDraft,\n  current = '',\n): FormulaDraft {\n  const spec = FORMULA_OPERATIONS[operation]\n  const blank = (index: number): FormulaOperand =>\n    index === 0 && current.trim()\n      ? { source: 'current' }\n      : operation === 'join'\n        ? { source: 'text', value: '' }\n        : { source: 'name', name: '' }\n  const operands = Array.from(\n    { length: spec.minOperands },\n    (_, index) => previous?.operands[index] ?? blank(index),\n  )\n  return {\n    operation,\n    operands,\n    places: previous?.places,\n    symbol: previous?.symbol,\n    separator: previous?.separator,\n  }\n}\n"],"names":["FORMULA_OPERATIONS","value","label","minOperands","operandLabels","add","variadic","subtract","multiply","divide","min","max","round","places","roundDown","roundUp","absolute","currency","number","join","FORMULA_OPERATION_ORDER","Object","keys","formulaOperandLabel","operation","index","labels","Math","length","quoteText","includes","replace","SIMPLE_EXPRESSION","operandText","operand","current","bare","source","name","text","trim","parsed","Number","isFinite","String","test","placesOf","draft","fallback","isInteger","buildFormula","spec","operands","slice","arithmetic","parts","map","some","part","values","first","symbol","separator","formulaDraftFor","previous","blank","Array","from","_"],"mappings":"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"}

package/src/lib/model/structured-value.d.ts

@@ -0,0 +1,51 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * A dictionary or collection variable, as rows an author fills in rather than
+ * JSON they type (AGL-3757). The stored value is unchanged — the same JSON
+ * string `formatVariableValue` and a function's `name.member` read — so this
+ * module only translates between that string and the rows the editor shows.
+ */
+/** What one entry holds; `kept` is a nested value the rows cannot edit. */
+export type StructuredValueKind = 'text' | 'number' | 'boolean' | 'kept';
+export interface StructuredValueRow {
+    /** The dictionary key; ignored for a collection. */
+    key: string;
+    kind: StructuredValueKind;
+    /** Text as shown in the box; `'true'`/`'false'` for a true/false entry. */
+    value: string;
+    /** The original nested value, carried through untouched for a `kept` row. */
+    kept?: unknown;
+}
+export interface ParsedStructuredValue {
+    rows: StructuredValueRow[];
+    /**
+     * True when a stored value could not be read as the expected shape — an
+     * old hand-typed value with a stray comma, or a list stored on a
+     * dictionary. The editor starts from what it could read and says so.
+     */
+    unreadable: boolean;
+}
+/** The rows a stored dictionary or collection value reads as. */
+export declare function parseStructuredValue(raw: string | undefined, shape: 'dictionary' | 'collection'): ParsedStructuredValue;
+/**
+ * The JSON string rows store as. A dictionary drops rows without a key and
+ * keeps the LAST row of a repeated key, as reading the JSON back would.
+ */
+export declare function serializeStructuredValue(rows: readonly StructuredValueRow[], shape: 'dictionary' | 'collection'): string;
+/** The dictionary keys used more than once, which the editor flags. */
+export declare function duplicateStructuredKeys(rows: readonly StructuredValueRow[]): Set<string>;

package/src/lib/model/structured-value.js

@@ -0,0 +1,135 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ /**
+ * A dictionary or collection variable, as rows an author fills in rather than
+ * JSON they type (AGL-3757). The stored value is unchanged — the same JSON
+ * string `formatVariableValue` and a function's `name.member` read — so this
+ * module only translates between that string and the rows the editor shows.
+ */ /** What one entry holds; `kept` is a nested value the rows cannot edit. */ function rowFor(key, value) {
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        return {
+            key,
+            kind: 'number',
+            value: String(value)
+        };
+    }
+    if (typeof value === 'boolean') {
+        return {
+            key,
+            kind: 'boolean',
+            value: value ? 'true' : 'false'
+        };
+    }
+    if (typeof value === 'string') return {
+        key,
+        kind: 'text',
+        value
+    };
+    if (value === null || value === undefined) {
+        return {
+            key,
+            kind: 'text',
+            value: ''
+        };
+    }
+    return {
+        key,
+        kind: 'kept',
+        value: JSON.stringify(value),
+        kept: value
+    };
+}
+/** The rows a stored dictionary or collection value reads as. */ export function parseStructuredValue(raw, shape) {
+    const text = String(raw != null ? raw : '').trim();
+    if (!text) return {
+        rows: [],
+        unreadable: false
+    };
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    } catch (unused) {
+        return {
+            rows: [],
+            unreadable: true
+        };
+    }
+    if (shape === 'collection') {
+        if (!Array.isArray(parsed)) return {
+            rows: [],
+            unreadable: true
+        };
+        return {
+            rows: parsed.map((item)=>rowFor('', item)),
+            unreadable: false
+        };
+    }
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        return {
+            rows: [],
+            unreadable: true
+        };
+    }
+    return {
+        rows: Object.entries(parsed).map(([key, value])=>rowFor(key, value)),
+        unreadable: false
+    };
+}
+/**
+ * One row's stored value. A number box that does not hold a number stores
+ * nothing rather than a string a calculation would then trip over.
+ */ function rowValue(row) {
+    switch(row.kind){
+        case 'number':
+            {
+                const text = row.value.trim();
+                const parsed = Number(text);
+                return text !== '' && Number.isFinite(parsed) ? parsed : null;
+            }
+        case 'boolean':
+            return row.value === 'true';
+        case 'kept':
+            return row.kept;
+        case 'text':
+        default:
+            return row.value;
+    }
+}
+/**
+ * The JSON string rows store as. A dictionary drops rows without a key and
+ * keeps the LAST row of a repeated key, as reading the JSON back would.
+ */ export function serializeStructuredValue(rows, shape) {
+    if (shape === 'collection') return JSON.stringify(rows.map(rowValue));
+    const entries = {};
+    for (const row of rows){
+        const key = row.key.trim();
+        if (key) entries[key] = rowValue(row);
+    }
+    return JSON.stringify(entries);
+}
+/** The dictionary keys used more than once, which the editor flags. */ export function duplicateStructuredKeys(rows) {
+    const seen = new Set();
+    const duplicates = new Set();
+    for (const row of rows){
+        const key = row.key.trim();
+        if (!key) continue;
+        if (seen.has(key)) duplicates.add(key);
+        seen.add(key);
+    }
+    return duplicates;
+}
+
+//# sourceMappingURL=structured-value.js.map

package/src/lib/model/structured-value.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../libs/plugins/logic/src/lib/model/structured-value.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2026 Aglyn LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * A dictionary or collection variable, as rows an author fills in rather than\n * JSON they type (AGL-3757). The stored value is unchanged — the same JSON\n * string `formatVariableValue` and a function's `name.member` read — so this\n * module only translates between that string and the rows the editor shows.\n */\n\n/** What one entry holds; `kept` is a nested value the rows cannot edit. */\nexport type StructuredValueKind = 'text' | 'number' | 'boolean' | 'kept'\n\nexport interface StructuredValueRow {\n  /** The dictionary key; ignored for a collection. */\n  key: string\n  kind: StructuredValueKind\n  /** Text as shown in the box; `'true'`/`'false'` for a true/false entry. */\n  value: string\n  /** The original nested value, carried through untouched for a `kept` row. */\n  kept?: unknown\n}\n\nexport interface ParsedStructuredValue {\n  rows: StructuredValueRow[]\n  /**\n   * True when a stored value could not be read as the expected shape — an\n   * old hand-typed value with a stray comma, or a list stored on a\n   * dictionary. The editor starts from what it could read and says so.\n   */\n  unreadable: boolean\n}\n\nfunction rowFor(key: string, value: unknown): StructuredValueRow {\n  if (typeof value === 'number' && Number.isFinite(value)) {\n    return { key, kind: 'number', value: String(value) }\n  }\n  if (typeof value === 'boolean') {\n    return { key, kind: 'boolean', value: value ? 'true' : 'false' }\n  }\n  if (typeof value === 'string') return { key, kind: 'text', value }\n  if (value === null || value === undefined) {\n    return { key, kind: 'text', value: '' }\n  }\n  return { key, kind: 'kept', value: JSON.stringify(value), kept: value }\n}\n\n/** The rows a stored dictionary or collection value reads as. */\nexport function parseStructuredValue(\n  raw: string | undefined,\n  shape: 'dictionary' | 'collection',\n): ParsedStructuredValue {\n  const text = String(raw ?? '').trim()\n  if (!text) return { rows: [], unreadable: false }\n  let parsed: unknown\n  try {\n    parsed = JSON.parse(text)\n  } catch {\n    return { rows: [], unreadable: true }\n  }\n  if (shape === 'collection') {\n    if (!Array.isArray(parsed)) return { rows: [], unreadable: true }\n    return { rows: parsed.map((item) => rowFor('', item)), unreadable: false }\n  }\n  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {\n    return { rows: [], unreadable: true }\n  }\n  return {\n    rows: Object.entries(parsed as Record<string, unknown>).map(\n      ([key, value]) => rowFor(key, value),\n    ),\n    unreadable: false,\n  }\n}\n\n/**\n * One row's stored value. A number box that does not hold a number stores\n * nothing rather than a string a calculation would then trip over.\n */\nfunction rowValue(row: StructuredValueRow): unknown {\n  switch (row.kind) {\n    case 'number': {\n      const text = row.value.trim()\n      const parsed = Number(text)\n      return text !== '' && Number.isFinite(parsed) ? parsed : null\n    }\n    case 'boolean':\n      return row.value === 'true'\n    case 'kept':\n      return row.kept\n    case 'text':\n    default:\n      return row.value\n  }\n}\n\n/**\n * The JSON string rows store as. A dictionary drops rows without a key and\n * keeps the LAST row of a repeated key, as reading the JSON back would.\n */\nexport function serializeStructuredValue(\n  rows: readonly StructuredValueRow[],\n  shape: 'dictionary' | 'collection',\n): string {\n  if (shape === 'collection') return JSON.stringify(rows.map(rowValue))\n  const entries: Record<string, unknown> = {}\n  for (const row of rows) {\n    const key = row.key.trim()\n    if (key) entries[key] = rowValue(row)\n  }\n  return JSON.stringify(entries)\n}\n\n/** The dictionary keys used more than once, which the editor flags. */\nexport function duplicateStructuredKeys(\n  rows: readonly StructuredValueRow[],\n): Set<string> {\n  const seen = new Set<string>()\n  const duplicates = new Set<string>()\n  for (const row of rows) {\n    const key = row.key.trim()\n    if (!key) continue\n    if (seen.has(key)) duplicates.add(key)\n    seen.add(key)\n  }\n  return duplicates\n}\n"],"names":["rowFor","key","value","Number","isFinite","kind","String","undefined","JSON","stringify","kept","parseStructuredValue","raw","shape","text","trim","rows","unreadable","parsed","parse","Array","isArray","map","item","Object","entries","rowValue","row","serializeStructuredValue","duplicateStructuredKeys","seen","Set","duplicates","has","add"],"mappings":"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"}