@aglyn/aglyn 1.0.0-beta.143

package/src/lib/app-utils/reusable-prop-values.js

@@ -0,0 +1,494 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+import { _ as _object_without_properties_loose } from "@swc/helpers/_/_object_without_properties_loose";
+/**
+ * @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.
+ */ import { compileLinearTest, explainLinearTest } from "@aglyn/shared-util-tools/linear-regex";
+import isEmpty from "lodash-es/isEmpty.js";
+import { reusablePropTakesSeveral, reusablePropValueClass } from "../foundation/definitions/property-kinds.js";
+import { COMPONENT_PROP_TOKEN_PREFIX } from "./reusable-component-keys.js";
+/**
+ * What a component or layout property is worth on one page (AGL-1247,
+ * AGL-2893): the page's own value where it set one, the declaration's default
+ * where it did not, and nothing at all where the property's condition does
+ * not hold.
+ *
+ * One module decides this for every surface that renders a property — the
+ * component graft, detach, the component and layout editors' canvases, and a
+ * layout composed around a screen — so no two of them can disagree about
+ * which value wins.
+ */ /**
+ * Spellings of "no" a visibility directive accepts, beyond a real `false`.
+ *
+ * `'false'` and `'0'` are in here because the substitution these run
+ * against is textual: every token substitutes as text, so a `boolean` prop set
+ * to `false` in the Attributes panel arrives as the STRING `'false'` — which
+ * plain JS truthiness would read as "yes, hide".
+ */ const FALSY_DIRECTIVE_VALUES = new Set([
+    '',
+    'false',
+    '0',
+    'off',
+    'no'
+]);
+/**
+ * Whether a value says yes, no, or nothing at all.
+ *
+ * The spellings a visibility directive accepts, because the value travels the
+ * same textual path to get here: `false`, `'false'`, `'0'`, `'off'`, `'no'` and
+ * `''` all read as no. `undefined` means there is nothing to read — the value
+ * is absent, or is still an unsubstituted token.
+ *
+ * The unresolved-token case is deliberately "no opinion": a definition binding
+ * a prop nobody declared leaves `{{prop.ghost}}` in place verbatim (only
+ * declared names are substituted), and the literal string is neither obviously
+ * true nor obviously false. Treating it as either would let one typo blank a
+ * section of a live page.
+ */ export function readYesNoValue(value) {
+    if (value == null) return undefined;
+    if (typeof value === 'boolean') return value;
+    if (typeof value === 'number') return value !== 0;
+    if (typeof value !== 'string') return Boolean(value);
+    const trimmed = value.trim();
+    if (trimmed.includes('{{')) return undefined;
+    return !FALSY_DIRECTIVE_VALUES.has(trimmed.toLowerCase());
+}
+/**
+ * The icon an instance picked for an `icon` prop, or `undefined` when it
+ * picked none.
+ *
+ * Stored as a whole {@link ReusableComponentIcon} so the path travels with the
+ * id. A bare id — written by anything other than the Attributes panel — still
+ * counts as a pick; it simply arrives with no path to draw on a published
+ * page.
+ */ export function readInstanceIconValue(value) {
+    if (typeof value === 'string') {
+        return value.trim() ? {
+            iconId: value.trim()
+        } : undefined;
+    }
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return undefined;
+    }
+    const { iconId, iconPath } = value;
+    if (typeof iconId !== 'string' || !iconId) return undefined;
+    return typeof iconPath === 'string' && iconPath ? {
+        iconId,
+        iconPath
+    } : {
+        iconId
+    };
+}
+/**
+ * What a stored value counts as for its property, or `undefined` where it set
+ * nothing.
+ *
+ * `''` is unset, so clearing a field hands the page back to the default. An
+ * icon pick is read whole. A list is a value only for a property that takes
+ * several, where a single stored answer counts as a list of one; any other
+ * object is unset too — the only object a property value is ever written as is
+ * an icon or a list, so one anywhere else is a value left behind when the
+ * property's type changed, and stringifying it would put `[object Object]` on
+ * the page.
+ */ export function readReusablePropValue(value, prop) {
+    if (value == null || value === '') return undefined;
+    const valueClass = reusablePropValueClass(prop);
+    if (valueClass === 'icon') return readInstanceIconValue(value);
+    if (reusablePropTakesSeveral(prop)) {
+        const list = Array.isArray(value) ? value : [
+            value
+        ];
+        const answers = list.filter((entry)=>typeof entry === 'string' || typeof entry === 'number');
+        return answers.length ? answers : undefined;
+    }
+    if (typeof value === 'object') return undefined;
+    return value;
+}
+/**
+ * What a property is worth where a page set nothing: its declared default,
+ * read the way a page's own value is read — an Icon's default as the pick it
+ * stands for, id and path together.
+ */ export function reusablePropDefaultValue(prop) {
+    return prop ? readDefaultValue(prop) : undefined;
+}
+/** A declaration's default, read the way a page's own value is read. */ function readDefaultValue(prop) {
+    if (reusablePropValueClass(prop) === 'icon') {
+        const iconId = typeof prop.defaultValue === 'string' ? prop.defaultValue : undefined;
+        if (!iconId) return undefined;
+        return prop.defaultIconPath ? {
+            iconId,
+            iconPath: prop.defaultIconPath
+        } : {
+            iconId
+        };
+    }
+    return readReusablePropValue(prop.defaultValue, prop);
+}
+/**
+ * The value a property's condition rules compare, given what it is worth: a
+ * Yes / no as a real boolean, a number as a number, an icon as its id, and
+ * everything else as stored — so a rule written against the value a control
+ * shows matches the value the page stored, whatever spelling it was stored in.
+ */ export function reusablePropConditionValue(prop, value) {
+    switch(reusablePropValueClass(prop)){
+        case 'boolean':
+            return readYesNoValue(value) === true;
+        case 'number':
+            {
+                if (typeof value === 'number') return value;
+                if (typeof value === 'string' && value.trim() !== '') {
+                    const numeric = Number(value);
+                    return Number.isFinite(numeric) ? numeric : value;
+                }
+                return value;
+            }
+        case 'icon':
+            var _readInstanceIconValue;
+            return (_readInstanceIconValue = readInstanceIconValue(value)) == null ? void 0 : _readInstanceIconValue.iconId;
+        default:
+            return value;
+    }
+}
+/**
+ * data-driven-forms' idea of empty: a number and `true` are never empty, an
+ * invalid date is, and everything else is empty the way lodash's `isEmpty`
+ * says.
+ */ function isEmptyValue(value) {
+    if (value instanceof Date) return Number.isNaN(value.getTime());
+    return typeof value === 'number' || value === true ? false : isEmpty(value);
+}
+/**
+ * The longest pattern a property condition may carry (AGL-2893) — the bound a
+ * marketplace declaration has always been held to.
+ */ export const REUSABLE_PROP_PATTERN_MAX_LENGTH = 500;
+/**
+ * The longest value a condition's pattern is matched against (AGL-2893). The
+ * match is linear in the value, and this keeps the most a page can be made to
+ * spend on one rule to a few milliseconds; a longer value holds no pattern
+ * rule, the way a pattern that cannot be matched holds none.
+ */ export const REUSABLE_PROP_PATTERN_INPUT_MAX_LENGTH = 2000;
+/**
+ * Why a condition's pattern cannot be matched on a page, or `undefined` when
+ * it can (AGL-2893).
+ *
+ * A condition is written by whoever declared the property — a marketplace
+ * publisher, a template, a document written without the Properties dialog —
+ * and matched on every page that places the component and in the console of
+ * everyone editing one. So a pattern is matched by a linear-time engine
+ * (`compileLinearTest`), never by `RegExp`: a backtracking matcher takes
+ * seconds on `^(a+)+$` against a 28-character value, and the time doubles
+ * with each character. No check of a pattern's shape can make `RegExp` safe —
+ * `^a*a*a*a*a*a*a*a*$` nests no quantifier and takes a minute on 61
+ * characters — so the engine is the bound, not a heuristic.
+ *
+ * What it names: a pattern that is not text or is longer than
+ * {@link REUSABLE_PROP_PATTERN_MAX_LENGTH}; flags `RegExp` would refuse or the
+ * engine does not implement (`u`, `v`); syntax outside the engine's subset
+ * (lookaround, backreferences, named groups); and anything
+ * `RegExp` itself refuses. One answer for the Properties dialog, every
+ * server-side write of a declaration, and the evaluator below.
+ */ export function reusablePropPatternProblem(pattern, flags) {
+    if (typeof pattern !== 'string') return 'a pattern is text';
+    if (flags !== undefined && typeof flags !== 'string') {
+        return 'its flags are not text';
+    }
+    if (pattern.length > REUSABLE_PROP_PATTERN_MAX_LENGTH) {
+        return `it is longer than ${REUSABLE_PROP_PATTERN_MAX_LENGTH} characters`;
+    }
+    const flagText = typeof flags === 'string' ? flags : '';
+    const reason = explainLinearTest(pattern, flagText);
+    if (reason) return reason;
+    try {
+        // Only ever constructed, never run: `RegExp` is the authority on what is
+        // a regular expression, and the engine on what it can match safely.
+        new RegExp(pattern, flagText);
+    } catch (unused) {
+        return 'it is not a regular expression';
+    }
+    return undefined;
+}
+/** Compiled patterns by flags and source; `null` for one that cannot be. */ const compiledPatterns = new Map();
+/** Enough for every pattern a site's components declare, and then some. */ const COMPILED_PATTERNS_MAX = 256;
+function compiledPattern(pattern, flags) {
+    if (typeof pattern !== 'string') return null;
+    if (flags !== undefined && typeof flags !== 'string') return null;
+    // A flags string never holds `/`, so no two pairs share a key.
+    const key = `${flags != null ? flags : ''}/${pattern}`;
+    const cached = compiledPatterns.get(key);
+    if (cached !== undefined) return cached;
+    const compiled = reusablePropPatternProblem(pattern, flags) === undefined ? compileLinearTest(pattern, flags != null ? flags : '') : null;
+    if (compiledPatterns.size >= COMPILED_PATTERNS_MAX) compiledPatterns.clear();
+    compiledPatterns.set(key, compiled);
+    return compiled;
+}
+/**
+ * Whether a value matches a condition's pattern — what
+ * `new RegExp(pattern, flags).test(value)` answers — or `undefined` when the
+ * pattern cannot be matched safely (see {@link reusablePropPatternProblem}) or
+ * the value is longer than {@link REUSABLE_PROP_PATTERN_INPUT_MAX_LENGTH}.
+ * Never throws.
+ */ export function matchReusablePropPattern(pattern, flags, value) {
+    const compiled = compiledPattern(pattern, flags);
+    if (!compiled) return undefined;
+    let text;
+    try {
+        // `test` reads its argument as text, and so must this.
+        text = String(value);
+    } catch (unused) {
+        return undefined;
+    }
+    if (text.length > REUSABLE_PROP_PATTERN_INPUT_MAX_LENGTH) return undefined;
+    return compiled.test(text);
+}
+/**
+ * One rule against the value it names, with data-driven-forms' own precedence
+ * — the same order `parseCondition` applies, which a spec runs both against so
+ * the Attributes panel and a published page can never disagree.
+ *
+ * A pattern rule whose pattern cannot be matched safely, or whose value is too
+ * long to match, holds nothing — whichever way it reads the pattern — so the
+ * property renders as one whose condition is unmet (AGL-2893). A throw here
+ * used to reach the tenant loader's catch and turn every page placing the
+ * component into a 404.
+ */ export function evaluateReusablePropRule(rule, value) {
+    if (rule.isNotEmpty) return !isEmptyValue(value);
+    if (rule.isEmpty) return isEmptyValue(value);
+    if (rule.pattern) {
+        const matched = matchReusablePropPattern(rule.pattern, rule.flags, value);
+        if (matched === undefined) return false;
+        return rule.notMatch ? !matched : matched;
+    }
+    const compare = value;
+    if (Object.prototype.hasOwnProperty.call(rule, 'greaterThan')) {
+        return compare > rule.greaterThan;
+    }
+    if (Object.prototype.hasOwnProperty.call(rule, 'greaterThanOrEqualTo')) {
+        return compare >= rule.greaterThanOrEqualTo;
+    }
+    if (Object.prototype.hasOwnProperty.call(rule, 'lessThan')) {
+        return compare < rule.lessThan;
+    }
+    if (Object.prototype.hasOwnProperty.call(rule, 'lessThanOrEqualTo')) {
+        return compare <= rule.lessThanOrEqualTo;
+    }
+    const matched = Array.isArray(rule.is) ? rule.is.includes(value) : value === rule.is;
+    return rule.notMatch ? !matched : matched;
+}
+/**
+ * Whether a condition holds against the values its rules name.
+ *
+ * A list must all hold, `and` must all hold, `or` needs one, `not` negates —
+ * data-driven-forms' `parseCondition`, minus what a stored document cannot
+ * carry. A shape it does not recognize holds nothing, which is also what
+ * `parseCondition` answers for a rule with no `when`.
+ */ export function evaluateReusablePropCondition(condition, values) {
+    if (condition == null) return true;
+    if (Array.isArray(condition)) {
+        return condition.every((entry)=>evaluateReusablePropCondition(entry, values));
+    }
+    if (typeof condition !== 'object') return false;
+    if ('and' in condition) {
+        const and = condition.and;
+        return (Array.isArray(and) ? and : [
+            and
+        ]).every((entry)=>evaluateReusablePropCondition(entry, values));
+    }
+    if ('or' in condition) {
+        const or = condition.or;
+        return (Array.isArray(or) ? or : [
+            or
+        ]).some((entry)=>evaluateReusablePropCondition(entry, values));
+    }
+    if ('not' in condition) {
+        return !evaluateReusablePropCondition(condition.not, values);
+    }
+    const rule = condition;
+    if (typeof rule.when !== 'string' || !rule.when) return false;
+    return evaluateReusablePropRule(rule, values[rule.when]);
+}
+/**
+ * A condition with every rule whose pattern cannot be matched removed
+ * (AGL-2893), or `undefined` when nothing is left of it. Handed back as it was
+ * when nothing needed removing.
+ *
+ * A rule that names a pattern is read for that pattern; the rest of it means
+ * nothing without one, so the whole rule goes, the way a rule that names no
+ * property does. A list or `and` keeps the rules left and goes when none are;
+ * an `or` likewise; a `not` goes with its rule. Removing a rule can loosen an
+ * `and` or tighten an `or`, and either is a condition a page can evaluate,
+ * where the rule removed was one no page could.
+ */ function withoutUnmatchablePatterns(condition) {
+    if (condition == null || typeof condition !== 'object') {
+        return condition;
+    }
+    const cleanList = (list)=>{
+        const kept = list.map((entry)=>withoutUnmatchablePatterns(entry)).filter((entry)=>entry !== undefined);
+        const unchanged = kept.length === list.length && kept.every((entry, at)=>entry === list[at]);
+        return {
+            kept: kept,
+            unchanged
+        };
+    };
+    if (Array.isArray(condition)) {
+        const { kept, unchanged } = cleanList(condition);
+        if (unchanged) return condition;
+        return kept.length ? kept : undefined;
+    }
+    const value = condition;
+    for (const key of [
+        'and',
+        'or'
+    ]){
+        if (!(key in value)) continue;
+        const inner = value[key];
+        const { kept, unchanged } = cleanList(Array.isArray(inner) ? inner : [
+            inner
+        ]);
+        if (unchanged) return condition;
+        return kept.length ? _extends({}, value, {
+            [key]: kept
+        }) : undefined;
+    }
+    if ('not' in value) {
+        const inner = withoutUnmatchablePatterns(value['not']);
+        if (inner === value['not']) return condition;
+        return inner === undefined ? undefined : _extends({}, value, {
+            not: inner
+        });
+    }
+    // Read as the evaluator reads it: an empty pattern names none.
+    if (value['pattern'] && reusablePropPatternProblem(value['pattern'], value['flags'])) {
+        return undefined;
+    }
+    return condition;
+}
+/**
+ * Declared properties as a server-side write stores them: each condition
+ * without the rules whose pattern cannot be matched, and a property whose
+ * condition is left with nothing stored with none (AGL-2893). Anything that is
+ * not a list of declarations comes back as it was, as does a list with nothing
+ * to remove.
+ *
+ * The page never needs this — a rule it cannot match holds nothing there — but
+ * a stored declaration is read by the Properties dialog, copied by templates
+ * and published to the marketplace, and a pattern that can never be matched
+ * should stop there rather than travel.
+ */ export function withMatchableConditions(props) {
+    if (!Array.isArray(props)) return props;
+    let changed = false;
+    const next = props.map((prop)=>{
+        if (!prop || typeof prop !== 'object' || !('condition' in prop)) return prop;
+        const { condition } = prop, rest = _object_without_properties_loose(prop, [
+            "condition"
+        ]);
+        const kept = withoutUnmatchablePatterns(condition);
+        if (kept === condition) return prop;
+        changed = true;
+        return kept === undefined ? rest : _extends({}, rest, {
+            condition: kept
+        });
+    });
+    return changed ? next : props;
+}
+/** Text a value substitutes as wherever its token sits inside other text. */ function substitutedText(value) {
+    if (value == null) return '';
+    if (Array.isArray(value)) return value.join(', ');
+    if (typeof value === 'object') {
+        var _ref;
+        var _readInstanceIconValue;
+        return (_ref = (_readInstanceIconValue = readInstanceIconValue(value)) == null ? void 0 : _readInstanceIconValue.iconId) != null ? _ref : '';
+    }
+    return String(value);
+}
+/**
+ * What each declared property is worth on one page.
+ *
+ * `values` is the page's own map — an instance's `propValues`, or a screen's
+ * values for its layout — and a property it leaves unset takes its default.
+ * A property whose condition does not hold renders as one with no value and no
+ * default. Conditions compare what each property is worth before any condition
+ * applies, which is what the Attributes panel compares too, so a field and the
+ * page it sets agree.
+ *
+ * `defaultsOnly` is the editor's view of its own definition: a property with no
+ * default keeps its token, so a slot nothing fills stays visible.
+ */ export function resolveReusablePropValues(declared, values, options) {
+    const resolved = {
+        tokens: {},
+        values: {},
+        iconPaths: {},
+        off: new Set()
+    };
+    const props = (declared != null ? declared : []).filter((prop)=>Boolean(prop == null ? void 0 : prop.name));
+    if (!props.length) return resolved;
+    const worth = new Map();
+    const compared = {};
+    for (const prop of props){
+        const own = (options == null ? void 0 : options.defaultsOnly) ? undefined : readReusablePropValue(values == null ? void 0 : values[prop.name], prop);
+        const value = own === undefined ? readDefaultValue(prop) : own;
+        worth.set(prop.name, value);
+        compared[prop.name] = reusablePropConditionValue(prop, value);
+    }
+    for (const prop of props){
+        if (!evaluateReusablePropCondition(prop.condition, compared)) {
+            resolved.off.add(prop.name);
+            if (!(options == null ? void 0 : options.defaultsOnly)) {
+                resolved.tokens[`${COMPONENT_PROP_TOKEN_PREFIX}${prop.name}`] = '';
+            }
+            continue;
+        }
+        const value = worth.get(prop.name);
+        if ((options == null ? void 0 : options.defaultsOnly) && value === undefined) continue;
+        resolved.tokens[`${COMPONENT_PROP_TOKEN_PREFIX}${prop.name}`] = substitutedText(value);
+        if (value !== undefined) resolved.values[prop.name] = value;
+        const iconPath = reusablePropValueClass(prop) === 'icon' ? value == null ? void 0 : value.iconPath : undefined;
+        if (iconPath) resolved.iconPaths[prop.name] = iconPath;
+    }
+    return resolved;
+}
+/**
+ * Token map of a definition's OWN defaults, with no instance in the picture.
+ *
+ * What the component editor draws with (AGL-2870). A page substitutes an unset
+ * prop as `''`, which is right there — an unset prop renders nothing — and
+ * wrong here, where a prop with no default has nothing to preview and should
+ * keep showing its raw token so the author can see at a glance which slots are
+ * still unfilled.
+ *
+ * `false` and `0` are real defaults and survive; only `null`, `undefined` and
+ * `''` are treated as "no default set".
+ */ export function buildComponentDefaultTokens(declared) {
+    return resolveReusablePropValues(declared, undefined, {
+        defaultsOnly: true
+    }).tokens;
+}
+/**
+ * The icon paths a definition's OWN defaults draw with — what the component
+ * editor shows beside {@link buildComponentDefaultTokens}.
+ */ export function buildComponentDefaultIconPaths(declared) {
+    return resolveReusablePropValues(declared, undefined, {
+        defaultsOnly: true
+    }).iconPaths;
+}
+/**
+ * The values a definition's OWN defaults hand their bound fields — what the
+ * component editor draws with beside {@link buildComponentDefaultTokens}.
+ */ export function buildComponentDefaultValues(declared) {
+    return resolveReusablePropValues(declared, undefined, {
+        defaultsOnly: true
+    }).values;
+}
+
+//# sourceMappingURL=reusable-prop-values.js.map

package/src/lib/app-utils/reusable-prop-values.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../libs/aglyn/src/lib/app-utils/reusable-prop-values.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\nimport {\n  compileLinearTest,\n  explainLinearTest,\n  type LinearTest,\n} from '@aglyn/shared-util-tools/linear-regex'\nimport isEmpty from 'lodash-es/isEmpty.js'\nimport type {\n  ReusableComponentIcon,\n  ReusableComponentProp,\n  ReusableComponentPropCondition,\n  ReusableComponentPropRule,\n} from '../foundation/definitions/platform.types'\nimport {\n  reusablePropTakesSeveral,\n  reusablePropValueClass,\n} from '../foundation/definitions/property-kinds'\nimport { COMPONENT_PROP_TOKEN_PREFIX } from './reusable-component-keys'\n\n/**\n * What a component or layout property is worth on one page (AGL-1247,\n * AGL-2893): the page's own value where it set one, the declaration's default\n * where it did not, and nothing at all where the property's condition does\n * not hold.\n *\n * One module decides this for every surface that renders a property — the\n * component graft, detach, the component and layout editors' canvases, and a\n * layout composed around a screen — so no two of them can disagree about\n * which value wins.\n */\n\n/**\n * Spellings of \"no\" a visibility directive accepts, beyond a real `false`.\n *\n * `'false'` and `'0'` are in here because the substitution these run\n * against is textual: every token substitutes as text, so a `boolean` prop set\n * to `false` in the Attributes panel arrives as the STRING `'false'` — which\n * plain JS truthiness would read as \"yes, hide\".\n */\nconst FALSY_DIRECTIVE_VALUES = new Set(['', 'false', '0', 'off', 'no'])\n\n/**\n * Whether a value says yes, no, or nothing at all.\n *\n * The spellings a visibility directive accepts, because the value travels the\n * same textual path to get here: `false`, `'false'`, `'0'`, `'off'`, `'no'` and\n * `''` all read as no. `undefined` means there is nothing to read — the value\n * is absent, or is still an unsubstituted token.\n *\n * The unresolved-token case is deliberately \"no opinion\": a definition binding\n * a prop nobody declared leaves `{{prop.ghost}}` in place verbatim (only\n * declared names are substituted), and the literal string is neither obviously\n * true nor obviously false. Treating it as either would let one typo blank a\n * section of a live page.\n */\nexport function readYesNoValue(value: unknown): boolean | undefined {\n  if (value == null) return undefined\n  if (typeof value === 'boolean') return value\n  if (typeof value === 'number') return value !== 0\n  if (typeof value !== 'string') return Boolean(value)\n  const trimmed = value.trim()\n  if (trimmed.includes('{{')) return undefined\n  return !FALSY_DIRECTIVE_VALUES.has(trimmed.toLowerCase())\n}\n\n/**\n * The icon an instance picked for an `icon` prop, or `undefined` when it\n * picked none.\n *\n * Stored as a whole {@link ReusableComponentIcon} so the path travels with the\n * id. A bare id — written by anything other than the Attributes panel — still\n * counts as a pick; it simply arrives with no path to draw on a published\n * page.\n */\nexport function readInstanceIconValue(\n  value: unknown,\n): ReusableComponentIcon | undefined {\n  if (typeof value === 'string') {\n    return value.trim() ? { iconId: value.trim() } : undefined\n  }\n  if (!value || typeof value !== 'object' || Array.isArray(value)) {\n    return undefined\n  }\n  const { iconId, iconPath } = value as ReusableComponentIcon\n  if (typeof iconId !== 'string' || !iconId) return undefined\n  return typeof iconPath === 'string' && iconPath\n    ? { iconId, iconPath }\n    : { iconId }\n}\n\ntype DeclaredProp = Pick<\n  ReusableComponentProp,\n  'name' | 'type' | 'options' | 'settings' | 'defaultValue' | 'defaultIconPath' | 'condition'\n>\n\n/**\n * What a stored value counts as for its property, or `undefined` where it set\n * nothing.\n *\n * `''` is unset, so clearing a field hands the page back to the default. An\n * icon pick is read whole. A list is a value only for a property that takes\n * several, where a single stored answer counts as a list of one; any other\n * object is unset too — the only object a property value is ever written as is\n * an icon or a list, so one anywhere else is a value left behind when the\n * property's type changed, and stringifying it would put `[object Object]` on\n * the page.\n */\nexport function readReusablePropValue(\n  value: unknown,\n  prop: Pick<ReusableComponentProp, 'type' | 'options' | 'settings'> | null | undefined,\n): unknown {\n  if (value == null || value === '') return undefined\n  const valueClass = reusablePropValueClass(prop)\n  if (valueClass === 'icon') return readInstanceIconValue(value)\n  if (reusablePropTakesSeveral(prop)) {\n    const list = Array.isArray(value) ? value : [value]\n    const answers = list.filter(\n      (entry) => typeof entry === 'string' || typeof entry === 'number',\n    )\n    return answers.length ? answers : undefined\n  }\n  if (typeof value === 'object') return undefined\n  return value\n}\n\n/**\n * What a property is worth where a page set nothing: its declared default,\n * read the way a page's own value is read — an Icon's default as the pick it\n * stands for, id and path together.\n */\nexport function reusablePropDefaultValue(\n  prop: DeclaredProp | null | undefined,\n): unknown {\n  return prop ? readDefaultValue(prop) : undefined\n}\n\n/** A declaration's default, read the way a page's own value is read. */\nfunction readDefaultValue(prop: DeclaredProp): unknown {\n  if (reusablePropValueClass(prop) === 'icon') {\n    const iconId =\n      typeof prop.defaultValue === 'string' ? prop.defaultValue : undefined\n    if (!iconId) return undefined\n    return prop.defaultIconPath\n      ? { iconId, iconPath: prop.defaultIconPath }\n      : { iconId }\n  }\n  return readReusablePropValue(prop.defaultValue, prop)\n}\n\n/**\n * The value a property's condition rules compare, given what it is worth: a\n * Yes / no as a real boolean, a number as a number, an icon as its id, and\n * everything else as stored — so a rule written against the value a control\n * shows matches the value the page stored, whatever spelling it was stored in.\n */\nexport function reusablePropConditionValue(\n  prop: Pick<ReusableComponentProp, 'type' | 'options' | 'settings'> | null | undefined,\n  value: unknown,\n): unknown {\n  switch (reusablePropValueClass(prop)) {\n    case 'boolean':\n      return readYesNoValue(value) === true\n    case 'number': {\n      if (typeof value === 'number') return value\n      if (typeof value === 'string' && value.trim() !== '') {\n        const numeric = Number(value)\n        return Number.isFinite(numeric) ? numeric : value\n      }\n      return value\n    }\n    case 'icon':\n      return readInstanceIconValue(value)?.iconId\n    default:\n      return value\n  }\n}\n\n/**\n * data-driven-forms' idea of empty: a number and `true` are never empty, an\n * invalid date is, and everything else is empty the way lodash's `isEmpty`\n * says.\n */\nfunction isEmptyValue(value: unknown): boolean {\n  if (value instanceof Date) return Number.isNaN(value.getTime())\n  return typeof value === 'number' || value === true ? false : isEmpty(value)\n}\n\n/**\n * The longest pattern a property condition may carry (AGL-2893) — the bound a\n * marketplace declaration has always been held to.\n */\nexport const REUSABLE_PROP_PATTERN_MAX_LENGTH = 500\n\n/**\n * The longest value a condition's pattern is matched against (AGL-2893). The\n * match is linear in the value, and this keeps the most a page can be made to\n * spend on one rule to a few milliseconds; a longer value holds no pattern\n * rule, the way a pattern that cannot be matched holds none.\n */\nexport const REUSABLE_PROP_PATTERN_INPUT_MAX_LENGTH = 2000\n\n/**\n * Why a condition's pattern cannot be matched on a page, or `undefined` when\n * it can (AGL-2893).\n *\n * A condition is written by whoever declared the property — a marketplace\n * publisher, a template, a document written without the Properties dialog —\n * and matched on every page that places the component and in the console of\n * everyone editing one. So a pattern is matched by a linear-time engine\n * (`compileLinearTest`), never by `RegExp`: a backtracking matcher takes\n * seconds on `^(a+)+$` against a 28-character value, and the time doubles\n * with each character. No check of a pattern's shape can make `RegExp` safe —\n * `^a*a*a*a*a*a*a*a*$` nests no quantifier and takes a minute on 61\n * characters — so the engine is the bound, not a heuristic.\n *\n * What it names: a pattern that is not text or is longer than\n * {@link REUSABLE_PROP_PATTERN_MAX_LENGTH}; flags `RegExp` would refuse or the\n * engine does not implement (`u`, `v`); syntax outside the engine's subset\n * (lookaround, backreferences, named groups); and anything\n * `RegExp` itself refuses. One answer for the Properties dialog, every\n * server-side write of a declaration, and the evaluator below.\n */\nexport function reusablePropPatternProblem(\n  pattern: unknown,\n  flags?: unknown,\n): string | undefined {\n  if (typeof pattern !== 'string') return 'a pattern is text'\n  if (flags !== undefined && typeof flags !== 'string') {\n    return 'its flags are not text'\n  }\n  if (pattern.length > REUSABLE_PROP_PATTERN_MAX_LENGTH) {\n    return `it is longer than ${REUSABLE_PROP_PATTERN_MAX_LENGTH} characters`\n  }\n  const flagText = typeof flags === 'string' ? flags : ''\n  const reason = explainLinearTest(pattern, flagText)\n  if (reason) return reason\n  try {\n    // Only ever constructed, never run: `RegExp` is the authority on what is\n    // a regular expression, and the engine on what it can match safely.\n    new RegExp(pattern, flagText)\n  } catch {\n    return 'it is not a regular expression'\n  }\n  return undefined\n}\n\n/** Compiled patterns by flags and source; `null` for one that cannot be. */\nconst compiledPatterns = new Map<string, LinearTest | null>()\n\n/** Enough for every pattern a site's components declare, and then some. */\nconst COMPILED_PATTERNS_MAX = 256\n\nfunction compiledPattern(pattern: unknown, flags: unknown): LinearTest | null {\n  if (typeof pattern !== 'string') return null\n  if (flags !== undefined && typeof flags !== 'string') return null\n  // A flags string never holds `/`, so no two pairs share a key.\n  const key = `${flags ?? ''}/${pattern}`\n  const cached = compiledPatterns.get(key)\n  if (cached !== undefined) return cached\n  const compiled =\n    reusablePropPatternProblem(pattern, flags) === undefined\n      ? compileLinearTest(pattern, (flags as string | undefined) ?? '')\n      : null\n  if (compiledPatterns.size >= COMPILED_PATTERNS_MAX) compiledPatterns.clear()\n  compiledPatterns.set(key, compiled)\n  return compiled\n}\n\n/**\n * Whether a value matches a condition's pattern — what\n * `new RegExp(pattern, flags).test(value)` answers — or `undefined` when the\n * pattern cannot be matched safely (see {@link reusablePropPatternProblem}) or\n * the value is longer than {@link REUSABLE_PROP_PATTERN_INPUT_MAX_LENGTH}.\n * Never throws.\n */\nexport function matchReusablePropPattern(\n  pattern: unknown,\n  flags: unknown,\n  value: unknown,\n): boolean | undefined {\n  const compiled = compiledPattern(pattern, flags)\n  if (!compiled) return undefined\n  let text: string\n  try {\n    // `test` reads its argument as text, and so must this.\n    text = String(value)\n  } catch {\n    return undefined\n  }\n  if (text.length > REUSABLE_PROP_PATTERN_INPUT_MAX_LENGTH) return undefined\n  return compiled.test(text)\n}\n\n/**\n * One rule against the value it names, with data-driven-forms' own precedence\n * — the same order `parseCondition` applies, which a spec runs both against so\n * the Attributes panel and a published page can never disagree.\n *\n * A pattern rule whose pattern cannot be matched safely, or whose value is too\n * long to match, holds nothing — whichever way it reads the pattern — so the\n * property renders as one whose condition is unmet (AGL-2893). A throw here\n * used to reach the tenant loader's catch and turn every page placing the\n * component into a 404.\n */\nexport function evaluateReusablePropRule(\n  rule: Omit<ReusableComponentPropRule, 'when'>,\n  value: unknown,\n): boolean {\n  if (rule.isNotEmpty) return !isEmptyValue(value)\n  if (rule.isEmpty) return isEmptyValue(value)\n  if (rule.pattern) {\n    const matched = matchReusablePropPattern(rule.pattern, rule.flags, value)\n    if (matched === undefined) return false\n    return rule.notMatch ? !matched : matched\n  }\n  const compare = value as number\n  if (Object.prototype.hasOwnProperty.call(rule, 'greaterThan')) {\n    return compare > (rule.greaterThan as number)\n  }\n  if (Object.prototype.hasOwnProperty.call(rule, 'greaterThanOrEqualTo')) {\n    return compare >= (rule.greaterThanOrEqualTo as number)\n  }\n  if (Object.prototype.hasOwnProperty.call(rule, 'lessThan')) {\n    return compare < (rule.lessThan as number)\n  }\n  if (Object.prototype.hasOwnProperty.call(rule, 'lessThanOrEqualTo')) {\n    return compare <= (rule.lessThanOrEqualTo as number)\n  }\n  const matched = Array.isArray(rule.is)\n    ? (rule.is as unknown[]).includes(value)\n    : value === rule.is\n  return rule.notMatch ? !matched : matched\n}\n\n/**\n * Whether a condition holds against the values its rules name.\n *\n * A list must all hold, `and` must all hold, `or` needs one, `not` negates —\n * data-driven-forms' `parseCondition`, minus what a stored document cannot\n * carry. A shape it does not recognize holds nothing, which is also what\n * `parseCondition` answers for a rule with no `when`.\n */\nexport function evaluateReusablePropCondition(\n  condition: ReusableComponentPropCondition | ReusableComponentPropCondition[] | null | undefined,\n  values: Readonly<Record<string, unknown>>,\n): boolean {\n  if (condition == null) return true\n  if (Array.isArray(condition)) {\n    return condition.every((entry) => evaluateReusablePropCondition(entry, values))\n  }\n  if (typeof condition !== 'object') return false\n  if ('and' in condition) {\n    const and = (condition as { and: unknown }).and\n    return (Array.isArray(and) ? and : [and]).every((entry) =>\n      evaluateReusablePropCondition(entry as ReusableComponentPropCondition, values),\n    )\n  }\n  if ('or' in condition) {\n    const or = (condition as { or: unknown }).or\n    return (Array.isArray(or) ? or : [or]).some((entry) =>\n      evaluateReusablePropCondition(entry as ReusableComponentPropCondition, values),\n    )\n  }\n  if ('not' in condition) {\n    return !evaluateReusablePropCondition(\n      (condition as { not: ReusableComponentPropCondition }).not,\n      values,\n    )\n  }\n  const rule = condition as ReusableComponentPropRule\n  if (typeof rule.when !== 'string' || !rule.when) return false\n  return evaluateReusablePropRule(rule, values[rule.when])\n}\n\ntype StoredCondition =\n  | ReusableComponentPropCondition\n  | ReusableComponentPropCondition[]\n\n/**\n * A condition with every rule whose pattern cannot be matched removed\n * (AGL-2893), or `undefined` when nothing is left of it. Handed back as it was\n * when nothing needed removing.\n *\n * A rule that names a pattern is read for that pattern; the rest of it means\n * nothing without one, so the whole rule goes, the way a rule that names no\n * property does. A list or `and` keeps the rules left and goes when none are;\n * an `or` likewise; a `not` goes with its rule. Removing a rule can loosen an\n * `and` or tighten an `or`, and either is a condition a page can evaluate,\n * where the rule removed was one no page could.\n */\nfunction withoutUnmatchablePatterns(\n  condition: unknown,\n): StoredCondition | undefined {\n  if (condition == null || typeof condition !== 'object') {\n    return condition as StoredCondition | undefined\n  }\n  const cleanList = (list: unknown[]) => {\n    const kept = list\n      .map((entry) => withoutUnmatchablePatterns(entry))\n      .filter((entry) => entry !== undefined)\n    const unchanged =\n      kept.length === list.length && kept.every((entry, at) => entry === list[at])\n    return { kept: kept as ReusableComponentPropCondition[], unchanged }\n  }\n  if (Array.isArray(condition)) {\n    const { kept, unchanged } = cleanList(condition)\n    if (unchanged) return condition as ReusableComponentPropCondition[]\n    return kept.length ? kept : undefined\n  }\n  const value = condition as Record<string, unknown>\n  for (const key of ['and', 'or'] as const) {\n    if (!(key in value)) continue\n    const inner = value[key]\n    const { kept, unchanged } = cleanList(Array.isArray(inner) ? inner : [inner])\n    if (unchanged) return condition as ReusableComponentPropCondition\n    return kept.length\n      ? ({ ...value, [key]: kept } as ReusableComponentPropCondition)\n      : undefined\n  }\n  if ('not' in value) {\n    const inner = withoutUnmatchablePatterns(value['not'])\n    if (inner === value['not']) return condition as ReusableComponentPropCondition\n    return inner === undefined\n      ? undefined\n      : ({ ...value, not: inner } as ReusableComponentPropCondition)\n  }\n  // Read as the evaluator reads it: an empty pattern names none.\n  if (value['pattern'] && reusablePropPatternProblem(value['pattern'], value['flags'])) {\n    return undefined\n  }\n  return condition as ReusableComponentPropCondition\n}\n\n/**\n * Declared properties as a server-side write stores them: each condition\n * without the rules whose pattern cannot be matched, and a property whose\n * condition is left with nothing stored with none (AGL-2893). Anything that is\n * not a list of declarations comes back as it was, as does a list with nothing\n * to remove.\n *\n * The page never needs this — a rule it cannot match holds nothing there — but\n * a stored declaration is read by the Properties dialog, copied by templates\n * and published to the marketplace, and a pattern that can never be matched\n * should stop there rather than travel.\n */\nexport function withMatchableConditions<T>(props: T): T {\n  if (!Array.isArray(props)) return props\n  let changed = false\n  const next = props.map((prop) => {\n    if (!prop || typeof prop !== 'object' || !('condition' in prop)) return prop\n    const { condition, ...rest } = prop as { condition?: unknown }\n    const kept = withoutUnmatchablePatterns(condition)\n    if (kept === condition) return prop\n    changed = true\n    return kept === undefined ? rest : { ...rest, condition: kept }\n  })\n  return (changed ? next : props) as T\n}\n\n/** Text a value substitutes as wherever its token sits inside other text. */\nfunction substitutedText(value: unknown): string {\n  if (value == null) return ''\n  if (Array.isArray(value)) return value.join(', ')\n  if (typeof value === 'object') {\n    return readInstanceIconValue(value)?.iconId ?? ''\n  }\n  return String(value)\n}\n\n/** Every property's value for one page, in the three forms the graft reads. */\nexport interface ResolvedReusablePropValues {\n  /** `prop.<name>` → the text each `{{prop.<name>}}` substitutes as. */\n  tokens: Record<string, string>\n  /**\n   * Name → what a field bound to exactly that token receives, before its kind\n   * finishes it; absent where the property has nothing to give.\n   */\n  values: Record<string, unknown>\n  /** Name → the SVG path an Icon property's pick or default draws with. */\n  iconPaths: Record<string, string>\n  /** The names whose condition does not hold on this page. */\n  off: Set<string>\n}\n\n/**\n * What each declared property is worth on one page.\n *\n * `values` is the page's own map — an instance's `propValues`, or a screen's\n * values for its layout — and a property it leaves unset takes its default.\n * A property whose condition does not hold renders as one with no value and no\n * default. Conditions compare what each property is worth before any condition\n * applies, which is what the Attributes panel compares too, so a field and the\n * page it sets agree.\n *\n * `defaultsOnly` is the editor's view of its own definition: a property with no\n * default keeps its token, so a slot nothing fills stays visible.\n */\nexport function resolveReusablePropValues(\n  declared: readonly DeclaredProp[] | null | undefined,\n  values?: Readonly<Record<string, unknown>> | null,\n  options?: { defaultsOnly?: boolean },\n): ResolvedReusablePropValues {\n  const resolved: ResolvedReusablePropValues = {\n    tokens: {},\n    values: {},\n    iconPaths: {},\n    off: new Set(),\n  }\n  const props = (declared ?? []).filter(\n    (prop): prop is DeclaredProp => Boolean(prop?.name),\n  )\n  if (!props.length) return resolved\n  const worth = new Map<string, unknown>()\n  const compared: Record<string, unknown> = {}\n  for (const prop of props) {\n    const own = options?.defaultsOnly\n      ? undefined\n      : readReusablePropValue(values?.[prop.name], prop)\n    const value = own === undefined ? readDefaultValue(prop) : own\n    worth.set(prop.name, value)\n    compared[prop.name] = reusablePropConditionValue(prop, value)\n  }\n  for (const prop of props) {\n    if (!evaluateReusablePropCondition(prop.condition, compared)) {\n      resolved.off.add(prop.name)\n      if (!options?.defaultsOnly) {\n        resolved.tokens[`${COMPONENT_PROP_TOKEN_PREFIX}${prop.name}`] = ''\n      }\n      continue\n    }\n    const value = worth.get(prop.name)\n    if (options?.defaultsOnly && value === undefined) continue\n    resolved.tokens[`${COMPONENT_PROP_TOKEN_PREFIX}${prop.name}`] =\n      substitutedText(value)\n    if (value !== undefined) resolved.values[prop.name] = value\n    const iconPath =\n      reusablePropValueClass(prop) === 'icon'\n        ? (value as ReusableComponentIcon | undefined)?.iconPath\n        : undefined\n    if (iconPath) resolved.iconPaths[prop.name] = iconPath\n  }\n  return resolved\n}\n\n/**\n * Token map of a definition's OWN defaults, with no instance in the picture.\n *\n * What the component editor draws with (AGL-2870). A page substitutes an unset\n * prop as `''`, which is right there — an unset prop renders nothing — and\n * wrong here, where a prop with no default has nothing to preview and should\n * keep showing its raw token so the author can see at a glance which slots are\n * still unfilled.\n *\n * `false` and `0` are real defaults and survive; only `null`, `undefined` and\n * `''` are treated as \"no default set\".\n */\nexport function buildComponentDefaultTokens(\n  declared: readonly DeclaredProp[] | null | undefined,\n): Record<string, string> {\n  return resolveReusablePropValues(declared, undefined, { defaultsOnly: true })\n    .tokens\n}\n\n/**\n * The icon paths a definition's OWN defaults draw with — what the component\n * editor shows beside {@link buildComponentDefaultTokens}.\n */\nexport function buildComponentDefaultIconPaths(\n  declared: readonly DeclaredProp[] | null | undefined,\n): Record<string, string> {\n  return resolveReusablePropValues(declared, undefined, { defaultsOnly: true })\n    .iconPaths\n}\n\n/**\n * The values a definition's OWN defaults hand their bound fields — what the\n * component editor draws with beside {@link buildComponentDefaultTokens}.\n */\nexport function buildComponentDefaultValues(\n  declared: readonly DeclaredProp[] | null | undefined,\n): Record<string, unknown> {\n  return resolveReusablePropValues(declared, undefined, { defaultsOnly: true })\n    .values\n}\n"],"names":["compileLinearTest","explainLinearTest","isEmpty","reusablePropTakesSeveral","reusablePropValueClass","COMPONENT_PROP_TOKEN_PREFIX","FALSY_DIRECTIVE_VALUES","Set","readYesNoValue","value","undefined","Boolean","trimmed","trim","includes","has","toLowerCase","readInstanceIconValue","iconId","Array","isArray","iconPath","readReusablePropValue","prop","valueClass","list","answers","filter","entry","length","reusablePropDefaultValue","readDefaultValue","defaultValue","defaultIconPath","reusablePropConditionValue","numeric","Number","isFinite","isEmptyValue","Date","isNaN","getTime","REUSABLE_PROP_PATTERN_MAX_LENGTH","REUSABLE_PROP_PATTERN_INPUT_MAX_LENGTH","reusablePropPatternProblem","pattern","flags","flagText","reason","RegExp","compiledPatterns","Map","COMPILED_PATTERNS_MAX","compiledPattern","key","cached","get","compiled","size","clear","set","matchReusablePropPattern","text","String","test","evaluateReusablePropRule","rule","isNotEmpty","matched","notMatch","compare","Object","prototype","hasOwnProperty","call","greaterThan","greaterThanOrEqualTo","lessThan","lessThanOrEqualTo","is","evaluateReusablePropCondition","condition","values","every","and","or","some","not","when","withoutUnmatchablePatterns","cleanList","kept","map","unchanged","at","inner","withMatchableConditions","props","changed","next","rest","substitutedText","join","resolveReusablePropValues","declared","options","resolved","tokens","iconPaths","off","name","worth","compared","own","defaultsOnly","add","buildComponentDefaultTokens","buildComponentDefaultIconPaths","buildComponentDefaultValues"],"mappings":"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"}

package/src/lib/app-utils/safe-json-ld.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @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.
+ */
+/**
+ * Serialize a value for embedding inside an inline
+ * `<script type="application/ld+json">` via `dangerouslySetInnerHTML`
+ * (AGL-496). `JSON.stringify` does NOT escape `<`, `>` or `&`, so a
+ * user-authored string containing `</script>` closes the element and any
+ * following markup executes — a stored-XSS breakout on tenant sites whose
+ * JSON-LD is built from editor-authored titles/descriptions.
+ *
+ * Escape those characters (plus the JS line separators U+2028/U+2029) to
+ * their `\uXXXX` forms — still valid JSON, no longer able to break out of
+ * the element.
+ */
+export declare function safeJsonLd(value: unknown): string;

package/src/lib/app-utils/safe-json-ld.js

@@ -0,0 +1,37 @@
+/**
+ * @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.
+ */ // U+2028/U+2029 are valid inside JSON strings but terminate an inline
+// <script>; matched via fromCharCode so no irregular-whitespace lands in
+// source.
+const LINE_SEP = new RegExp(String.fromCharCode(0x2028), 'g');
+const PARA_SEP = new RegExp(String.fromCharCode(0x2029), 'g');
+/**
+ * Serialize a value for embedding inside an inline
+ * `<script type="application/ld+json">` via `dangerouslySetInnerHTML`
+ * (AGL-496). `JSON.stringify` does NOT escape `<`, `>` or `&`, so a
+ * user-authored string containing `</script>` closes the element and any
+ * following markup executes — a stored-XSS breakout on tenant sites whose
+ * JSON-LD is built from editor-authored titles/descriptions.
+ *
+ * Escape those characters (plus the JS line separators U+2028/U+2029) to
+ * their `\uXXXX` forms — still valid JSON, no longer able to break out of
+ * the element.
+ */ export function safeJsonLd(value) {
+    var _JSON_stringify;
+    return ((_JSON_stringify = JSON.stringify(value)) != null ? _JSON_stringify : 'null').replace(/</g, '\\u003c').replace(/>/g, '\\u003e').replace(/&/g, '\\u0026').replace(LINE_SEP, '\\u2028').replace(PARA_SEP, '\\u2029');
+}
+
+//# sourceMappingURL=safe-json-ld.js.map

package/src/lib/app-utils/safe-json-ld.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../libs/aglyn/src/lib/app-utils/safe-json-ld.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// U+2028/U+2029 are valid inside JSON strings but terminate an inline\n// <script>; matched via fromCharCode so no irregular-whitespace lands in\n// source.\nconst LINE_SEP = new RegExp(String.fromCharCode(0x2028), 'g')\nconst PARA_SEP = new RegExp(String.fromCharCode(0x2029), 'g')\n\n/**\n * Serialize a value for embedding inside an inline\n * `<script type=\"application/ld+json\">` via `dangerouslySetInnerHTML`\n * (AGL-496). `JSON.stringify` does NOT escape `<`, `>` or `&`, so a\n * user-authored string containing `</script>` closes the element and any\n * following markup executes — a stored-XSS breakout on tenant sites whose\n * JSON-LD is built from editor-authored titles/descriptions.\n *\n * Escape those characters (plus the JS line separators U+2028/U+2029) to\n * their `\\uXXXX` forms — still valid JSON, no longer able to break out of\n * the element.\n */\nexport function safeJsonLd(value: unknown): string {\n  return (JSON.stringify(value) ?? 'null')\n    .replace(/</g, '\\\\u003c')\n    .replace(/>/g, '\\\\u003e')\n    .replace(/&/g, '\\\\u0026')\n    .replace(LINE_SEP, '\\\\u2028')\n    .replace(PARA_SEP, '\\\\u2029')\n}\n"],"names":["LINE_SEP","RegExp","String","fromCharCode","PARA_SEP","safeJsonLd","value","JSON","stringify","replace"],"mappings":"AAAA;;;;;;;;;;;;;;;CAeC,GAED,sEAAsE;AACtE,yEAAyE;AACzE,UAAU;AACV,MAAMA,WAAW,IAAIC,OAAOC,OAAOC,YAAY,CAAC,SAAS;AACzD,MAAMC,WAAW,IAAIH,OAAOC,OAAOC,YAAY,CAAC,SAAS;AAEzD;;;;;;;;;;;CAWC,GACD,OAAO,SAASE,WAAWC,KAAc;QAC/BC;IAAR,OAAO,EAACA,kBAAAA,KAAKC,SAAS,CAACF,kBAAfC,kBAAyB,QAC9BE,OAAO,CAAC,MAAM,WACdA,OAAO,CAAC,MAAM,WACdA,OAAO,CAAC,MAAM,WACdA,OAAO,CAACT,UAAU,WAClBS,OAAO,CAACL,UAAU;AACvB"}