@aglyn/besigner-ui 1.0.0-beta.143

package/src/lib/utils/rank-picker-results.js

@@ -0,0 +1,136 @@
+/**
+ * @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.
+ */ /**
+ * Best-match ranking for the element picker (AGL-2486).
+ *
+ * The picker searched a pile of fields with no ranking at all, so typing
+ * `icon` returned nearly the whole catalogue with the element actually
+ * CALLED `Icon` near the bottom — every component whose description merely
+ * mentions an icon scored the same as the one named after it.
+ *
+ * This does not narrow the search: the caller still hands over whatever the
+ * fuzzy pass found across every field. It only decides the ORDER, and the
+ * rule it enforces is that a hit on the name always outranks a hit in prose.
+ */ /** The fields that carry the element's NAME, best first. */ const NAME_KEYS = [
+    'displayName',
+    'label',
+    'title'
+];
+/**
+ * Everything else worth searching. A hit here can never outrank a name hit,
+ * which is the whole point — but it still has to COUNT, or the picker would
+ * stop finding "the one with the video in it" by typing `video`.
+ */ const OTHER_KEYS = [
+    'description',
+    'subtitle',
+    'category',
+    'tags',
+    'keywords',
+    'kind',
+    'pluginId',
+    '$id'
+];
+/**
+ * Match quality, best first. Lower sorts earlier.
+ *
+ * `FUZZY_ONLY` is the floor: the caller's fuzzy pass matched it but no field
+ * literally contains the term (a typo, a transposition). Those keep their
+ * incoming order and sit behind every literal hit.
+ */ export const PICKER_RANK = {
+    EXACT_NAME: 0,
+    NAME_PREFIX: 1,
+    NAME_WORD_PREFIX: 2,
+    NAME_SUBSTRING: 3,
+    OTHER_FIELD: 4,
+    FUZZY_ONLY: 5
+};
+/** Searchable text of one field: arrays (tags) join, everything else stringifies. */ function fieldText(value) {
+    if (typeof value === 'string') return value.toLowerCase();
+    if (Array.isArray(value)) {
+        return value.filter((i)=>typeof i === 'string').join(' ').toLowerCase();
+    }
+    return '';
+}
+function namesOf(item) {
+    const record = item != null ? item : {};
+    return NAME_KEYS.map((key)=>fieldText(record[key])).filter(Boolean);
+}
+function otherTextOf(item) {
+    const record = item != null ? item : {};
+    return OTHER_KEYS.map((key)=>fieldText(record[key])).filter(Boolean).join(' ');
+}
+/** Whether `term` starts a word inside `text` ("Icon button" for `but`). */ function hasWordPrefix(text, term) {
+    let from = text.indexOf(term);
+    while(from !== -1){
+        const before = from === 0 ? '' : text[from - 1];
+        if (!before || !/[a-z0-9]/.test(before)) return true;
+        from = text.indexOf(term, from + 1);
+    }
+    return false;
+}
+function rankOfTerm(item, term) {
+    const names = namesOf(item);
+    if (names.some((name)=>name === term)) return PICKER_RANK.EXACT_NAME;
+    if (names.some((name)=>name.startsWith(term))) return PICKER_RANK.NAME_PREFIX;
+    if (names.some((name)=>hasWordPrefix(name, term))) {
+        return PICKER_RANK.NAME_WORD_PREFIX;
+    }
+    if (names.some((name)=>name.includes(term))) return PICKER_RANK.NAME_SUBSTRING;
+    if (otherTextOf(item).includes(term)) return PICKER_RANK.OTHER_FIELD;
+    return PICKER_RANK.FUZZY_ONLY;
+}
+/**
+ * How well `item` matches `query`.
+ *
+ * A multi-word query is scored by its WEAKEST term: "icon button" must not
+ * be reported as an exact name match on the strength of `icon` alone.
+ */ export function rankPickerItem(item, query) {
+    const terms = String(query != null ? query : '').toLowerCase().split(/\s+/).filter(Boolean);
+    if (!terms.length) return PICKER_RANK.FUZZY_ONLY;
+    // Per-term, the WEAKEST term decides.
+    let byTerm = PICKER_RANK.EXACT_NAME;
+    for (const term of terms){
+        const termRank = rankOfTerm(item, term);
+        if (termRank > byTerm) byTerm = termRank;
+    }
+    // The whole query as one phrase can only ever help: `icon button` should
+    // read as an exact name match against an element called "Icon button",
+    // which per-term scoring alone would grade as a mid-word hit on `button`.
+    const byPhrase = terms.length > 1 ? rankOfTerm(item, terms.join(' ')) : byTerm;
+    return byPhrase < byTerm ? byPhrase : byTerm;
+}
+/** Shortest name, then alphabetical — a stable order inside a rank. */ function tieBreak(a, b) {
+    var _namesOf_, _namesOf_1;
+    const nameA = (_namesOf_ = namesOf(a)[0]) != null ? _namesOf_ : '';
+    const nameB = (_namesOf_1 = namesOf(b)[0]) != null ? _namesOf_1 : '';
+    return nameA.length - nameB.length || nameA.localeCompare(nameB);
+}
+/**
+ * `items` reordered best-match first. Nothing is dropped — the caller has
+ * already decided what matches.
+ */ export function rankPickerItems(items, query) {
+    if (!query || !Array.isArray(items)) return items != null ? items : [];
+    return items.map((item, index)=>({
+            item,
+            index,
+            rank: rankPickerItem(item, query)
+        })).sort((a, b)=>a.rank - b.rank || tieBreak(a.item, b.item) || // Incoming order last, so a fuzzy-only tail keeps the fuzzy
+        // matcher's own idea of which typo was closest.
+        a.index - b.index).map((i)=>i.item);
+}
+export default rankPickerItems;
+
+//# sourceMappingURL=rank-picker-results.js.map

package/src/lib/utils/rank-picker-results.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../libs/besigner/feature/designer/src/lib/utils/rank-picker-results.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 * Best-match ranking for the element picker (AGL-2486).\n *\n * The picker searched a pile of fields with no ranking at all, so typing\n * `icon` returned nearly the whole catalogue with the element actually\n * CALLED `Icon` near the bottom — every component whose description merely\n * mentions an icon scored the same as the one named after it.\n *\n * This does not narrow the search: the caller still hands over whatever the\n * fuzzy pass found across every field. It only decides the ORDER, and the\n * rule it enforces is that a hit on the name always outranks a hit in prose.\n */\n\n/** The fields that carry the element's NAME, best first. */\nconst NAME_KEYS = ['displayName', 'label', 'title'] as const\n\n/**\n * Everything else worth searching. A hit here can never outrank a name hit,\n * which is the whole point — but it still has to COUNT, or the picker would\n * stop finding \"the one with the video in it\" by typing `video`.\n */\nconst OTHER_KEYS = [\n  'description',\n  'subtitle',\n  'category',\n  'tags',\n  'keywords',\n  'kind',\n  'pluginId',\n  '$id',\n] as const\n\n/**\n * Match quality, best first. Lower sorts earlier.\n *\n * `FUZZY_ONLY` is the floor: the caller's fuzzy pass matched it but no field\n * literally contains the term (a typo, a transposition). Those keep their\n * incoming order and sit behind every literal hit.\n */\nexport const PICKER_RANK = {\n  EXACT_NAME: 0,\n  NAME_PREFIX: 1,\n  NAME_WORD_PREFIX: 2,\n  NAME_SUBSTRING: 3,\n  OTHER_FIELD: 4,\n  FUZZY_ONLY: 5,\n} as const\n\nexport type PickerRank = (typeof PICKER_RANK)[keyof typeof PICKER_RANK]\n\n/** Searchable text of one field: arrays (tags) join, everything else stringifies. */\nfunction fieldText(value: unknown): string {\n  if (typeof value === 'string') return value.toLowerCase()\n  if (Array.isArray(value)) {\n    return value.filter((i) => typeof i === 'string').join(' ').toLowerCase()\n  }\n  return ''\n}\n\nfunction namesOf(item: unknown): string[] {\n  const record = (item ?? {}) as Record<string, unknown>\n  return NAME_KEYS.map((key) => fieldText(record[key])).filter(Boolean)\n}\n\nfunction otherTextOf(item: unknown): string {\n  const record = (item ?? {}) as Record<string, unknown>\n  return OTHER_KEYS.map((key) => fieldText(record[key]))\n    .filter(Boolean)\n    .join(' ')\n}\n\n/** Whether `term` starts a word inside `text` (\"Icon button\" for `but`). */\nfunction hasWordPrefix(text: string, term: string): boolean {\n  let from = text.indexOf(term)\n  while (from !== -1) {\n    const before = from === 0 ? '' : text[from - 1]\n    if (!before || !/[a-z0-9]/.test(before)) return true\n    from = text.indexOf(term, from + 1)\n  }\n  return false\n}\n\nfunction rankOfTerm(item: unknown, term: string): PickerRank {\n  const names = namesOf(item)\n  if (names.some((name) => name === term)) return PICKER_RANK.EXACT_NAME\n  if (names.some((name) => name.startsWith(term))) return PICKER_RANK.NAME_PREFIX\n  if (names.some((name) => hasWordPrefix(name, term))) {\n    return PICKER_RANK.NAME_WORD_PREFIX\n  }\n  if (names.some((name) => name.includes(term))) return PICKER_RANK.NAME_SUBSTRING\n  if (otherTextOf(item).includes(term)) return PICKER_RANK.OTHER_FIELD\n  return PICKER_RANK.FUZZY_ONLY\n}\n\n/**\n * How well `item` matches `query`.\n *\n * A multi-word query is scored by its WEAKEST term: \"icon button\" must not\n * be reported as an exact name match on the strength of `icon` alone.\n */\nexport function rankPickerItem(item: unknown, query: string): PickerRank {\n  const terms = String(query ?? '')\n    .toLowerCase()\n    .split(/\\s+/)\n    .filter(Boolean)\n  if (!terms.length) return PICKER_RANK.FUZZY_ONLY\n  // Per-term, the WEAKEST term decides.\n  let byTerm: PickerRank = PICKER_RANK.EXACT_NAME\n  for (const term of terms) {\n    const termRank = rankOfTerm(item, term)\n    if (termRank > byTerm) byTerm = termRank\n  }\n  // The whole query as one phrase can only ever help: `icon button` should\n  // read as an exact name match against an element called \"Icon button\",\n  // which per-term scoring alone would grade as a mid-word hit on `button`.\n  const byPhrase = terms.length > 1 ? rankOfTerm(item, terms.join(' ')) : byTerm\n  return byPhrase < byTerm ? byPhrase : byTerm\n}\n\n/** Shortest name, then alphabetical — a stable order inside a rank. */\nfunction tieBreak(a: unknown, b: unknown): number {\n  const nameA = namesOf(a)[0] ?? ''\n  const nameB = namesOf(b)[0] ?? ''\n  return nameA.length - nameB.length || nameA.localeCompare(nameB)\n}\n\n/**\n * `items` reordered best-match first. Nothing is dropped — the caller has\n * already decided what matches.\n */\nexport function rankPickerItems<T>(items: T[], query: string): T[] {\n  if (!query || !Array.isArray(items)) return items ?? []\n  return items\n    .map((item, index) => ({ item, index, rank: rankPickerItem(item, query) }))\n    .sort(\n      (a, b) =>\n        a.rank - b.rank ||\n        tieBreak(a.item, b.item) ||\n        // Incoming order last, so a fuzzy-only tail keeps the fuzzy\n        // matcher's own idea of which typo was closest.\n        a.index - b.index,\n    )\n    .map((i) => i.item)\n}\n\nexport default rankPickerItems\n"],"names":["NAME_KEYS","OTHER_KEYS","PICKER_RANK","EXACT_NAME","NAME_PREFIX","NAME_WORD_PREFIX","NAME_SUBSTRING","OTHER_FIELD","FUZZY_ONLY","fieldText","value","toLowerCase","Array","isArray","filter","i","join","namesOf","item","record","map","key","Boolean","otherTextOf","hasWordPrefix","text","term","from","indexOf","before","test","rankOfTerm","names","some","name","startsWith","includes","rankPickerItem","query","terms","String","split","length","byTerm","termRank","byPhrase","tieBreak","a","b","nameA","nameB","localeCompare","rankPickerItems","items","index","rank","sort"],"mappings":"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"}

package/src/lib/utils/responsive-sx.d.ts

@@ -0,0 +1,65 @@
+/**
+ * @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 { type SxScheme } from '@aglyn/aglyn-node-renderer';
+import { BesignerDeviceFlag } from '@aglyn/besigner';
+import type { HostThemeScheme } from '@aglyn/shared-data-types';
+/** MUI breakpoint keys, smallest to largest (`xs` doubles as the base). */
+export declare const SX_BREAKPOINTS: readonly ["xs", "sm", "md", "lg", "xl"];
+export type SxBreakpoint = (typeof SX_BREAKPOINTS)[number];
+/**
+ * The sx scheme scope a styles-panel edit should target for the given
+ * artboard canvas scheme (AGL-588). Light is the base — only the dark
+ * preview scopes edits into the {@link SX_SCHEME_DARK_KEY} slice — so
+ * this returns null unless the artboard previews dark.
+ */
+export declare function canvasSchemeToSxScheme(scheme: HostThemeScheme | undefined): SxScheme | null;
+/**
+ * The breakpoint a styles-panel edit should scope to for the given
+ * artboard preview mode (AGL-333). Fluid/scale preview edits the base
+ * value, so they return null.
+ */
+export declare function deviceFlagToBreakpoint(flag: BesignerDeviceFlag | undefined): SxBreakpoint | null;
+/**
+ * The value a property resolves to at a breakpoint, following MUI's
+ * mobile-first cascade (a breakpoint inherits the nearest smaller slice).
+ * `breakpoint: null` reads the base value.
+ *
+ * Scheme dimension (AGL-588): the persisted nesting is scheme OUTER,
+ * breakpoints INNER — `sx['@scheme dark']` holds ordinary properties
+ * whose values may be responsive objects. `scheme: 'dark'` reads the
+ * dark slice first and falls back to the base, mirroring how the
+ * renderer merges the slice over base styles at render time; `'light'`,
+ * null, and undefined all read the base (light IS the base).
+ */
+export declare function readSxValue(sx: Record<string, any> | undefined, property: string, breakpoint: SxBreakpoint | null, scheme?: SxScheme | null): unknown;
+/** Whether the property carries per-breakpoint overrides beyond the base. */
+export declare function sxHasBreakpointOverrides(sx: Record<string, any> | undefined, property: string): boolean;
+/**
+ * Returns a new sx object with `property` written at `breakpoint`
+ * (`null` = base). Plain values promote to MUI's responsive-object form
+ * only when a non-base breakpoint diverges; single-`xs` objects collapse
+ * back to plain values; `undefined` clears the slice (and the property
+ * once no slice remains).
+ *
+ * Scheme dimension (AGL-588): `scheme: 'dark'` applies the exact same
+ * write to the {@link SX_SCHEME_DARK_KEY} slice instead of the base
+ * (scheme OUTER, breakpoints INNER — see {@link readSxValue}); an empty
+ * slice is removed entirely. `'light'`/null/undefined write the base.
+ * Purely additive: sx documents without dark overrides never change
+ * shape.
+ */
+export declare function writeSxValue(sx: Record<string, any> | undefined, property: string, value: unknown, breakpoint: SxBreakpoint | null, scheme?: SxScheme | null): Record<string, any>;

package/src/lib/utils/responsive-sx.js

@@ -0,0 +1,129 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+/**
+ * @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 { SX_SCHEME_DARK_KEY } from "@aglyn/aglyn-node-renderer";
+import { BesignerDeviceFlag } from "@aglyn/besigner";
+/** MUI breakpoint keys, smallest to largest (`xs` doubles as the base). */ export const SX_BREAKPOINTS = [
+    'xs',
+    'sm',
+    'md',
+    'lg',
+    'xl'
+];
+/**
+ * The sx scheme scope a styles-panel edit should target for the given
+ * artboard canvas scheme (AGL-588). Light is the base — only the dark
+ * preview scopes edits into the {@link SX_SCHEME_DARK_KEY} slice — so
+ * this returns null unless the artboard previews dark.
+ */ export function canvasSchemeToSxScheme(scheme) {
+    return scheme === 'dark' ? 'dark' : null;
+}
+/**
+ * The breakpoint a styles-panel edit should scope to for the given
+ * artboard preview mode (AGL-333). Fluid/scale preview edits the base
+ * value, so they return null.
+ */ export function deviceFlagToBreakpoint(flag) {
+    switch(flag){
+        case BesignerDeviceFlag.XS:
+            return 'xs';
+        case BesignerDeviceFlag.SM:
+            return 'sm';
+        case BesignerDeviceFlag.MD:
+            return 'md';
+        case BesignerDeviceFlag.LG:
+            return 'lg';
+        case BesignerDeviceFlag.XL:
+            return 'xl';
+        default:
+            return null;
+    }
+}
+const isResponsiveObject = (value)=>typeof value === 'object' && value !== null && !Array.isArray(value) && Object.keys(value).every((key)=>SX_BREAKPOINTS.includes(key)) && Object.keys(value).length > 0;
+/**
+ * The value a property resolves to at a breakpoint, following MUI's
+ * mobile-first cascade (a breakpoint inherits the nearest smaller slice).
+ * `breakpoint: null` reads the base value.
+ *
+ * Scheme dimension (AGL-588): the persisted nesting is scheme OUTER,
+ * breakpoints INNER — `sx['@scheme dark']` holds ordinary properties
+ * whose values may be responsive objects. `scheme: 'dark'` reads the
+ * dark slice first and falls back to the base, mirroring how the
+ * renderer merges the slice over base styles at render time; `'light'`,
+ * null, and undefined all read the base (light IS the base).
+ */ export function readSxValue(sx, property, breakpoint, scheme) {
+    if (scheme === 'dark') {
+        const slice = sx == null ? void 0 : sx[SX_SCHEME_DARK_KEY];
+        const override = readSxValue(slice, property, breakpoint);
+        if (override !== undefined) return override;
+        return readSxValue(sx, property, breakpoint);
+    }
+    const value = sx == null ? void 0 : sx[property];
+    if (!isResponsiveObject(value)) return value;
+    if (breakpoint === null) return value['xs'];
+    const index = SX_BREAKPOINTS.indexOf(breakpoint);
+    for(let i = index; i >= 0; i -= 1){
+        const slice = value[SX_BREAKPOINTS[i]];
+        if (slice !== undefined) return slice;
+    }
+    return undefined;
+}
+/** Whether the property carries per-breakpoint overrides beyond the base. */ export function sxHasBreakpointOverrides(sx, property) {
+    const value = sx == null ? void 0 : sx[property];
+    return isResponsiveObject(value) && Object.keys(value).some((key)=>key !== 'xs');
+}
+/**
+ * Returns a new sx object with `property` written at `breakpoint`
+ * (`null` = base). Plain values promote to MUI's responsive-object form
+ * only when a non-base breakpoint diverges; single-`xs` objects collapse
+ * back to plain values; `undefined` clears the slice (and the property
+ * once no slice remains).
+ *
+ * Scheme dimension (AGL-588): `scheme: 'dark'` applies the exact same
+ * write to the {@link SX_SCHEME_DARK_KEY} slice instead of the base
+ * (scheme OUTER, breakpoints INNER — see {@link readSxValue}); an empty
+ * slice is removed entirely. `'light'`/null/undefined write the base.
+ * Purely additive: sx documents without dark overrides never change
+ * shape.
+ */ export function writeSxValue(sx, property, value, breakpoint, scheme) {
+    if (scheme === 'dark') {
+        var _ref;
+        const current = (_ref = sx == null ? void 0 : sx[SX_SCHEME_DARK_KEY]) != null ? _ref : {};
+        const slice = writeSxValue(current, property, value, breakpoint);
+        const next = _extends({}, sx);
+        if (Object.keys(slice).length === 0) delete next[SX_SCHEME_DARK_KEY];
+        else next[SX_SCHEME_DARK_KEY] = slice;
+        return next;
+    }
+    const next = _extends({}, sx);
+    const current = next[property];
+    const key = breakpoint != null ? breakpoint : 'xs';
+    const slices = isResponsiveObject(current) ? _extends({}, current) : current !== undefined ? {
+        xs: current
+    } : {};
+    if (value === undefined || value === '') delete slices[key];
+    else slices[key] = value;
+    const keys = Object.keys(slices);
+    if (keys.length === 0) {
+        delete next[property];
+    } else if (keys.length === 1 && keys[0] === 'xs') {
+        next[property] = slices['xs'];
+    } else {
+        next[property] = slices;
+    }
+    return next;
+}
+
+//# sourceMappingURL=responsive-sx.js.map

package/src/lib/utils/responsive-sx.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../libs/besigner/feature/designer/src/lib/utils/responsive-sx.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 { SX_SCHEME_DARK_KEY, type SxScheme } from '@aglyn/aglyn-node-renderer'\nimport { BesignerDeviceFlag } from '@aglyn/besigner'\nimport type { HostThemeScheme } from '@aglyn/shared-data-types'\n\n/** MUI breakpoint keys, smallest to largest (`xs` doubles as the base). */\nexport const SX_BREAKPOINTS = ['xs', 'sm', 'md', 'lg', 'xl'] as const\nexport type SxBreakpoint = (typeof SX_BREAKPOINTS)[number]\n\n/**\n * The sx scheme scope a styles-panel edit should target for the given\n * artboard canvas scheme (AGL-588). Light is the base — only the dark\n * preview scopes edits into the {@link SX_SCHEME_DARK_KEY} slice — so\n * this returns null unless the artboard previews dark.\n */\nexport function canvasSchemeToSxScheme(\n  scheme: HostThemeScheme | undefined,\n): SxScheme | null {\n  return scheme === 'dark' ? 'dark' : null\n}\n\n/**\n * The breakpoint a styles-panel edit should scope to for the given\n * artboard preview mode (AGL-333). Fluid/scale preview edits the base\n * value, so they return null.\n */\nexport function deviceFlagToBreakpoint(\n  flag: BesignerDeviceFlag | undefined,\n): SxBreakpoint | null {\n  switch (flag) {\n    case BesignerDeviceFlag.XS:\n      return 'xs'\n    case BesignerDeviceFlag.SM:\n      return 'sm'\n    case BesignerDeviceFlag.MD:\n      return 'md'\n    case BesignerDeviceFlag.LG:\n      return 'lg'\n    case BesignerDeviceFlag.XL:\n      return 'xl'\n    default:\n      return null\n  }\n}\n\nconst isResponsiveObject = (value: unknown): value is Record<string, unknown> =>\n  typeof value === 'object' &&\n  value !== null &&\n  !Array.isArray(value) &&\n  Object.keys(value).every((key) =>\n    (SX_BREAKPOINTS as readonly string[]).includes(key),\n  ) &&\n  Object.keys(value).length > 0\n\n/**\n * The value a property resolves to at a breakpoint, following MUI's\n * mobile-first cascade (a breakpoint inherits the nearest smaller slice).\n * `breakpoint: null` reads the base value.\n *\n * Scheme dimension (AGL-588): the persisted nesting is scheme OUTER,\n * breakpoints INNER — `sx['@scheme dark']` holds ordinary properties\n * whose values may be responsive objects. `scheme: 'dark'` reads the\n * dark slice first and falls back to the base, mirroring how the\n * renderer merges the slice over base styles at render time; `'light'`,\n * null, and undefined all read the base (light IS the base).\n */\nexport function readSxValue(\n  sx: Record<string, any> | undefined,\n  property: string,\n  breakpoint: SxBreakpoint | null,\n  scheme?: SxScheme | null,\n): unknown {\n  if (scheme === 'dark') {\n    const slice = sx?.[SX_SCHEME_DARK_KEY] as Record<string, any> | undefined\n    const override = readSxValue(slice, property, breakpoint)\n    if (override !== undefined) return override\n    return readSxValue(sx, property, breakpoint)\n  }\n  const value = sx?.[property]\n  if (!isResponsiveObject(value)) return value\n  if (breakpoint === null) return value['xs']\n  const index = SX_BREAKPOINTS.indexOf(breakpoint)\n  for (let i = index; i >= 0; i -= 1) {\n    const slice = value[SX_BREAKPOINTS[i]]\n    if (slice !== undefined) return slice\n  }\n  return undefined\n}\n\n/** Whether the property carries per-breakpoint overrides beyond the base. */\nexport function sxHasBreakpointOverrides(\n  sx: Record<string, any> | undefined,\n  property: string,\n): boolean {\n  const value = sx?.[property]\n  return (\n    isResponsiveObject(value) &&\n    Object.keys(value).some((key) => key !== 'xs')\n  )\n}\n\n/**\n * Returns a new sx object with `property` written at `breakpoint`\n * (`null` = base). Plain values promote to MUI's responsive-object form\n * only when a non-base breakpoint diverges; single-`xs` objects collapse\n * back to plain values; `undefined` clears the slice (and the property\n * once no slice remains).\n *\n * Scheme dimension (AGL-588): `scheme: 'dark'` applies the exact same\n * write to the {@link SX_SCHEME_DARK_KEY} slice instead of the base\n * (scheme OUTER, breakpoints INNER — see {@link readSxValue}); an empty\n * slice is removed entirely. `'light'`/null/undefined write the base.\n * Purely additive: sx documents without dark overrides never change\n * shape.\n */\nexport function writeSxValue(\n  sx: Record<string, any> | undefined,\n  property: string,\n  value: unknown,\n  breakpoint: SxBreakpoint | null,\n  scheme?: SxScheme | null,\n): Record<string, any> {\n  if (scheme === 'dark') {\n    const current = (sx?.[SX_SCHEME_DARK_KEY] ?? {}) as Record<string, any>\n    const slice = writeSxValue(current, property, value, breakpoint)\n    const next: Record<string, any> = { ...sx }\n    if (Object.keys(slice).length === 0) delete next[SX_SCHEME_DARK_KEY]\n    else next[SX_SCHEME_DARK_KEY] = slice\n    return next\n  }\n  const next: Record<string, any> = { ...sx }\n  const current = next[property]\n  const key: SxBreakpoint = breakpoint ?? 'xs'\n\n  const slices: Record<string, unknown> = isResponsiveObject(current)\n    ? { ...current }\n    : current !== undefined\n      ? { xs: current }\n      : {}\n\n  if (value === undefined || value === '') delete slices[key]\n  else slices[key] = value\n\n  const keys = Object.keys(slices)\n  if (keys.length === 0) {\n    delete next[property]\n  } else if (keys.length === 1 && keys[0] === 'xs') {\n    next[property] = slices['xs']\n  } else {\n    next[property] = slices\n  }\n  return next\n}\n"],"names":["SX_SCHEME_DARK_KEY","BesignerDeviceFlag","SX_BREAKPOINTS","canvasSchemeToSxScheme","scheme","deviceFlagToBreakpoint","flag","XS","SM","MD","LG","XL","isResponsiveObject","value","Array","isArray","Object","keys","every","key","includes","length","readSxValue","sx","property","breakpoint","slice","override","undefined","index","indexOf","i","sxHasBreakpointOverrides","some","writeSxValue","current","next","slices","xs"],"mappings":";AAAA;;;;;;;;;;;;;;;CAeC,GAED,SAASA,kBAAkB,QAAuB,6BAA4B;AAC9E,SAASC,kBAAkB,QAAQ,kBAAiB;AAGpD,yEAAyE,GACzE,OAAO,MAAMC,iBAAiB;IAAC;IAAM;IAAM;IAAM;IAAM;CAAK,CAAS;AAGrE;;;;;CAKC,GACD,OAAO,SAASC,uBACdC,MAAmC;IAEnC,OAAOA,WAAW,SAAS,SAAS;AACtC;AAEA;;;;CAIC,GACD,OAAO,SAASC,uBACdC,IAAoC;IAEpC,OAAQA;QACN,KAAKL,mBAAmBM,EAAE;YACxB,OAAO;QACT,KAAKN,mBAAmBO,EAAE;YACxB,OAAO;QACT,KAAKP,mBAAmBQ,EAAE;YACxB,OAAO;QACT,KAAKR,mBAAmBS,EAAE;YACxB,OAAO;QACT,KAAKT,mBAAmBU,EAAE;YACxB,OAAO;QACT;YACE,OAAO;IACX;AACF;AAEA,MAAMC,qBAAqB,CAACC,QAC1B,OAAOA,UAAU,YACjBA,UAAU,QACV,CAACC,MAAMC,OAAO,CAACF,UACfG,OAAOC,IAAI,CAACJ,OAAOK,KAAK,CAAC,CAACC,MACxB,AAACjB,eAAqCkB,QAAQ,CAACD,SAEjDH,OAAOC,IAAI,CAACJ,OAAOQ,MAAM,GAAG;AAE9B;;;;;;;;;;;CAWC,GACD,OAAO,SAASC,YACdC,EAAmC,EACnCC,QAAgB,EAChBC,UAA+B,EAC/BrB,MAAwB;IAExB,IAAIA,WAAW,QAAQ;QACrB,MAAMsB,QAAQH,sBAAAA,EAAI,CAACvB,mBAAmB;QACtC,MAAM2B,WAAWL,YAAYI,OAAOF,UAAUC;QAC9C,IAAIE,aAAaC,WAAW,OAAOD;QACnC,OAAOL,YAAYC,IAAIC,UAAUC;IACnC;IACA,MAAMZ,QAAQU,sBAAAA,EAAI,CAACC,SAAS;IAC5B,IAAI,CAACZ,mBAAmBC,QAAQ,OAAOA;IACvC,IAAIY,eAAe,MAAM,OAAOZ,KAAK,CAAC,KAAK;IAC3C,MAAMgB,QAAQ3B,eAAe4B,OAAO,CAACL;IACrC,IAAK,IAAIM,IAAIF,OAAOE,KAAK,GAAGA,KAAK,EAAG;QAClC,MAAML,QAAQb,KAAK,CAACX,cAAc,CAAC6B,EAAE,CAAC;QACtC,IAAIL,UAAUE,WAAW,OAAOF;IAClC;IACA,OAAOE;AACT;AAEA,2EAA2E,GAC3E,OAAO,SAASI,yBACdT,EAAmC,EACnCC,QAAgB;IAEhB,MAAMX,QAAQU,sBAAAA,EAAI,CAACC,SAAS;IAC5B,OACEZ,mBAAmBC,UACnBG,OAAOC,IAAI,CAACJ,OAAOoB,IAAI,CAAC,CAACd,MAAQA,QAAQ;AAE7C;AAEA;;;;;;;;;;;;;CAaC,GACD,OAAO,SAASe,aACdX,EAAmC,EACnCC,QAAgB,EAChBX,KAAc,EACdY,UAA+B,EAC/BrB,MAAwB;IAExB,IAAIA,WAAW,QAAQ;;QACrB,MAAM+B,kBAAWZ,sBAAAA,EAAI,CAACvB,mBAAmB,mBAAI,CAAC;QAC9C,MAAM0B,QAAQQ,aAAaC,SAASX,UAAUX,OAAOY;QACrD,MAAMW,OAA4B,aAAKb;QACvC,IAAIP,OAAOC,IAAI,CAACS,OAAOL,MAAM,KAAK,GAAG,OAAOe,IAAI,CAACpC,mBAAmB;aAC/DoC,IAAI,CAACpC,mBAAmB,GAAG0B;QAChC,OAAOU;IACT;IACA,MAAMA,OAA4B,aAAKb;IACvC,MAAMY,UAAUC,IAAI,CAACZ,SAAS;IAC9B,MAAML,MAAoBM,qBAAAA,aAAc;IAExC,MAAMY,SAAkCzB,mBAAmBuB,WACvD,aAAKA,WACLA,YAAYP,YACV;QAAEU,IAAIH;IAAQ,IACd,CAAC;IAEP,IAAItB,UAAUe,aAAaf,UAAU,IAAI,OAAOwB,MAAM,CAAClB,IAAI;SACtDkB,MAAM,CAAClB,IAAI,GAAGN;IAEnB,MAAMI,OAAOD,OAAOC,IAAI,CAACoB;IACzB,IAAIpB,KAAKI,MAAM,KAAK,GAAG;QACrB,OAAOe,IAAI,CAACZ,SAAS;IACvB,OAAO,IAAIP,KAAKI,MAAM,KAAK,KAAKJ,IAAI,CAAC,EAAE,KAAK,MAAM;QAChDmB,IAAI,CAACZ,SAAS,GAAGa,MAAM,CAAC,KAAK;IAC/B,OAAO;QACLD,IAAI,CAACZ,SAAS,GAAGa;IACnB;IACA,OAAOD;AACT"}

package/src/lib/utils/rich-text-commands.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @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 type * as Aglyn from '@aglyn/aglyn';
+/**
+ * The formatting groups this component's inline editor may offer.
+ *
+ * An EMPTY declared list is read as "nothing declared" rather than as "no
+ * formatting". A schema turns formatting off by leaving `richTextEditable`
+ * alone, which is the switch the editor already reads; `richTextCommands: []`
+ * is what a mistaken spread or a stripped-empty-array produces, and reading
+ * it as a silent opt-out would give an author a rich surface with an empty
+ * toolbar and no way to tell why.
+ */
+export declare function richTextCommandGroups(schema: Aglyn.ComponentSchema<any> | undefined | null): ReadonlySet<Aglyn.RICH_TEXT_COMMANDS>;

package/src/lib/utils/rich-text-commands.js

@@ -0,0 +1,43 @@
+/**
+ * @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 { RICH_TEXT_COMMANDS } from "@aglyn/aglyn";
+/**
+ * What a schema gets when it names nothing — everything (AGL-2557).
+ *
+ * The default has to be permissive rather than restrictive: `richTextEditable`
+ * meant "the whole toolbar" before this existed, and Typography, the one
+ * component carrying it, says nothing about groups. A restrictive default
+ * would silently take bold away from the element that had it.
+ */ const EVERY_GROUP = [
+    RICH_TEXT_COMMANDS.EMPHASIS,
+    RICH_TEXT_COMMANDS.LIST,
+    RICH_TEXT_COMMANDS.LINK
+];
+/**
+ * The formatting groups this component's inline editor may offer.
+ *
+ * An EMPTY declared list is read as "nothing declared" rather than as "no
+ * formatting". A schema turns formatting off by leaving `richTextEditable`
+ * alone, which is the switch the editor already reads; `richTextCommands: []`
+ * is what a mistaken spread or a stripped-empty-array produces, and reading
+ * it as a silent opt-out would give an author a rich surface with an empty
+ * toolbar and no way to tell why.
+ */ export function richTextCommandGroups(schema) {
+    const declared = schema == null ? void 0 : schema.richTextCommands;
+    return new Set((declared == null ? void 0 : declared.length) ? declared : EVERY_GROUP);
+}
+
+//# sourceMappingURL=rich-text-commands.js.map

package/src/lib/utils/rich-text-commands.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../libs/besigner/feature/designer/src/lib/utils/rich-text-commands.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 type * as Aglyn from '@aglyn/aglyn'\nimport { RICH_TEXT_COMMANDS } from '@aglyn/aglyn'\n\n/**\n * What a schema gets when it names nothing — everything (AGL-2557).\n *\n * The default has to be permissive rather than restrictive: `richTextEditable`\n * meant \"the whole toolbar\" before this existed, and Typography, the one\n * component carrying it, says nothing about groups. A restrictive default\n * would silently take bold away from the element that had it.\n */\nconst EVERY_GROUP: readonly Aglyn.RICH_TEXT_COMMANDS[] = [\n  RICH_TEXT_COMMANDS.EMPHASIS,\n  RICH_TEXT_COMMANDS.LIST,\n  RICH_TEXT_COMMANDS.LINK,\n]\n\n/**\n * The formatting groups this component's inline editor may offer.\n *\n * An EMPTY declared list is read as \"nothing declared\" rather than as \"no\n * formatting\". A schema turns formatting off by leaving `richTextEditable`\n * alone, which is the switch the editor already reads; `richTextCommands: []`\n * is what a mistaken spread or a stripped-empty-array produces, and reading\n * it as a silent opt-out would give an author a rich surface with an empty\n * toolbar and no way to tell why.\n */\nexport function richTextCommandGroups(\n  schema: Aglyn.ComponentSchema<any> | undefined | null,\n): ReadonlySet<Aglyn.RICH_TEXT_COMMANDS> {\n  const declared = schema?.richTextCommands\n  return new Set(declared?.length ? declared : EVERY_GROUP)\n}\n"],"names":["RICH_TEXT_COMMANDS","EVERY_GROUP","EMPHASIS","LIST","LINK","richTextCommandGroups","schema","declared","richTextCommands","Set","length"],"mappings":"AAAA;;;;;;;;;;;;;;;CAeC,GAGD,SAASA,kBAAkB,QAAQ,eAAc;AAEjD;;;;;;;CAOC,GACD,MAAMC,cAAmD;IACvDD,mBAAmBE,QAAQ;IAC3BF,mBAAmBG,IAAI;IACvBH,mBAAmBI,IAAI;CACxB;AAED;;;;;;;;;CASC,GACD,OAAO,SAASC,sBACdC,MAAqD;IAErD,MAAMC,WAAWD,0BAAAA,OAAQE,gBAAgB;IACzC,OAAO,IAAIC,IAAIF,CAAAA,4BAAAA,SAAUG,MAAM,IAAGH,WAAWN;AAC/C"}

package/src/lib/utils/sanitize-rich-text.d.ts

@@ -0,0 +1,52 @@
+/**
+ * @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.
+ */
+/** How much markup one commit may keep — see {@link PHRASING_TAGS}. */
+export interface SanitizeRichTextOptions {
+    phrasingOnly?: boolean;
+}
+/**
+ * Allowlist HTML sanitizer for inline rich text: keeps basic formatting
+ * tags, strips every attribute except a safe `href` on links (which gains
+ * `rel="noopener noreferrer"`), and unwraps disallowed elements to their
+ * text content (so nothing script-capable survives). Runs at commit time in
+ * the editor (browser DOM available).
+ *
+ * `options.phrasingOnly` narrows the allowlist for a surface that ships
+ * inside a control (AGL-2557); omitted, every existing caller is unchanged.
+ */
+export declare function sanitizeRichText(html: string, options?: SanitizeRichTextOptions): string;
+/**
+ * Plain-text projection of markup, for the `children` fallback prop.
+ *
+ * Line breaks SURVIVE (AGL-2486). A node that carries one stores
+ * `html: "Your entire web <div>presence. </div>"` beside
+ * `children: "Your entire web presence. "`. The canvas renders `html` and
+ * shows two lines; the Attributes panel renders `children`. Projected with
+ * `template.content.textContent` the panel shows one, because `textContent`
+ * concatenates across every element boundary — a `<div>` fork and a `<br>`
+ * both vanish into nothing.
+ *
+ * That is a real break silently dropped by the projection, not the soft wrap
+ * a bounding box misreports. `children` is not a display detail either: it is
+ * what every
+ * plain renderer, the SSR fallback and the panel field all read, so the
+ * break was being lost to all three.
+ *
+ * Only the trailing newline is trimmed — a block element closes at the end
+ * of the string and that boundary separates nothing.
+ */
+export declare function richTextToPlain(html: string): string;