@aglyn/besigner-ui 1.0.0-beta.143

package/src/lib/utils/attr-target.d.ts

@@ -0,0 +1,170 @@
+/**
+ * @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';
+/**
+ * Props an instance override must never write (AGL-1899).
+ *
+ * `sx` is refused at the RENDER layer too (`ATTR_OVERRIDE_REFUSED_PROPS` in
+ * `compose-reusable-components.ts`) — styling an instance already has its own
+ * override field one level up, and honouring both would leave two writers
+ * racing for one rendered value with no rule to say which wins.
+ *
+ * `children` and `html` are refused HERE, by the writer, and deliberately not
+ * at the render layer. They are CONTENT, and content inside a component
+ * already has two routes with an owner each: a declared `{{prop.*}}` filled
+ * in per instance, and AGL-1304's double-click-to-edit on the canvas, which
+ * writes through that same binding. A third control writing `children` on the
+ * instance would be a third writer on one rendered string — the shape behind
+ * the unreproduced "Maximum update depth exceeded" report on this panel — and
+ * it would silently win over a binding the component author put there on
+ * purpose. Refusing it in the writer (rather than in the graft) keeps the
+ * storage layer's meaning unchanged, so a later issue can offer content
+ * overrides deliberately instead of inheriting them by accident.
+ */
+export declare const ATTR_OVERRIDE_REFUSED_WRITE_PROPS: Set<string>;
+/**
+ * Where the Attributes panel's per-instance ATTRIBUTE overrides land for the
+ * selected node (AGL-1899) — the attribute-side twin of
+ * {@link getNodeStyleTarget}.
+ *
+ * A reusable-component instance's overrides read and write one slice of
+ * `node.attrOverrides`: the root slice by default, or the slice keyed by a
+ * DEFINITION-internal node id when the author has picked a leaf inside the
+ * component. The graft (`composeReusableComponentNodes`) merges that slice
+ * over the matching definition node's props, per named prop, so canvas,
+ * Preview and tenant SSR agree without any of them knowing this file exists.
+ *
+ * A PLAIN node has no attribute-override layer at all, and this target
+ * refuses to write one: a plain node's attributes are `node.props`, which the
+ * Attributes form itself owns through `updateNodeProps`. Handing back a
+ * second writer for the same record is exactly how two controls end up
+ * fighting over one value, so the plain-node target reports
+ * `isInstanceOverride: false` and its `setAttrs` does nothing.
+ *
+ * `attrs` is a GETTER so `observer` components track the underlying MobX
+ * state at read time; a snapshot captured when the target was built would go
+ * stale after the first write.
+ */
+export interface NodeAttrTarget {
+    /**
+     * The override slice edits read from and write to (live view), or
+     * `undefined` when this instance overrides nothing for this target.
+     *
+     * Deliberately NOT composed with the definition's own props: an override
+     * slice starts empty and empty MEANS "whatever the component says". Merging
+     * a base into the reading would make every inherited value look like an
+     * override this instance had chosen, and the ✕ on its chip would then
+     * appear to do nothing.
+     */
+    readonly attrs: Record<string, any> | undefined;
+    /** True when edits land in one of the instance's override slices. */
+    readonly isInstanceOverride: boolean;
+    /**
+     * The `attrOverrides` key being edited — `root`, or a definition-internal
+     * node id. Empty string for a plain node, which has no override layer.
+     */
+    readonly overrideKey: string;
+    /** True when the target is a leaf inside the component, not its root. */
+    readonly isLeafOverride: boolean;
+    /** Replaces the target slice wholesale (MobX action inside). */
+    setAttrs(next: Record<string, any> | undefined): void;
+    /** Removes ONE overridden prop, leaving this instance's others (MobX action inside). */
+    clearAttr(prop: string): void;
+}
+/**
+ * Whether a value the form produced is an OVERRIDE at all (AGL-1899).
+ *
+ * `strictNullChecks` is off repo-wide, so "absent" and "empty" fold together
+ * the moment anything tests an override slice for truthiness. This function is
+ * the one place that decision is made, and it is deliberately narrow:
+ *
+ * - `undefined` is not an override. A cleared field, and every prop the
+ *   definition declares that this instance has not touched, arrive as
+ *   `undefined`, and storing them would turn "I opened the panel" into an
+ *   override on every prop of the component.
+ * - `''` is not an override either. final-form gives a cleared text box an
+ *   empty string, so this is what "clear this field" actually looks like on
+ *   the way in; the explicit way to say "override, and render nothing" is not
+ *   offered by this panel, which does not edit content props at all.
+ * - `false` and `0` ARE overrides, and this is the case worth naming. They
+ *   are the values `strictNullChecks: false` code most often loses: an
+ *   instance that turns a component's `disableGutters` OFF, or sets an
+ *   `elevation` of `0`, is making a real choice, and folding it to "no
+ *   override" would render the component's own value instead — the override
+ *   would appear to save and then silently not apply.
+ */
+export declare function isAttrOverrideValue(value: unknown): boolean;
+/**
+ * The attribute-override target for a selected node — see
+ * {@link NodeAttrTarget}.
+ *
+ * `overrideKey` selects WHICH slice of an instance's overrides is edited. A
+ * falsy key falls back to the root, so a caller that has not resolved a
+ * definition yet still edits something real rather than writing an
+ * `undefined`-keyed slice no renderer reads.
+ */
+export declare function getNodeAttrTarget(node: Aglyn.NodeSchema<any> | null | undefined, overrideKey?: string | null): NodeAttrTarget;
+/**
+ * Attribute editors the override panel offers (AGL-1899).
+ *
+ * Every entry is registered in `elementPropsComponentMapper` AND resolves
+ * entirely from the component schema — no canvas context, no host callback,
+ * no second prop written beside it. An unregistered editor makes the form
+ * renderer THROW, which is what once blanked the whole email designer's
+ * attributes panel (AGL-584), so the filter is an allowlist rather than a
+ * denylist: a component declaring an editor nobody thought about here loses
+ * one row from the override list, not the panel.
+ *
+ * Deliberately NOT offered, and each for its own reason:
+ *
+ * - `ICON_PICKER` writes a SECOND prop beside the one it names (the
+ *   denormalized SVG path, AGL-1212). An override slice that carried the id
+ *   without the path would render the "help" glyph.
+ * - `SCREEN_LINK`, and the screen/entity/dataset/node selects, resolve their
+ *   options from editor context the graft never sees.
+ * - `MARKDOWN`, `CSS_GRADIENT`, `BREAKPOINT_SPAN` and `PLUGIN_SETTINGS` each
+ *   edit a composite value with its own rules; a per-instance override of one
+ *   is a design question, not a plumbing one.
+ */
+export declare const ATTR_OVERRIDE_SUPPORTED_EDITORS: Set<string>;
+/** One overridable attribute of a node inside a component definition. */
+export interface InstanceAttrField {
+    /** The prop name, which is also the form field name and the slice key. */
+    name: string;
+    /** The field schema handed to the form renderer. */
+    field: Record<string, unknown>;
+}
+/**
+ * The attributes of ONE node inside a component definition that this
+ * instance may override, in the component schema's own order (AGL-1899).
+ *
+ * The definition node's CURRENT value shows as the field's placeholder, which
+ * is the whole of how "empty means the component's value" is made legible:
+ * an author looking at a blank Variant box can see it says `contained`
+ * underneath, and knows what clearing an override goes back to.
+ *
+ * Field names are the prop names verbatim and the form is flat, so a name
+ * carrying a dot is skipped — final-form reads `a.b` as a nested path, so
+ * such a field would write a level the slice does not have and the value
+ * would silently never reach the node (the same trap
+ * `COMPONENT_PROP_NAME_PATTERN` exists for one layer up).
+ */
+export declare function listInstanceAttrFields(defNode: {
+    componentId?: string;
+    props?: Record<string, unknown>;
+} | null | undefined): InstanceAttrField[];
+export default getNodeAttrTarget;

package/src/lib/utils/attr-target.js

@@ -0,0 +1,229 @@
+/**
+ * @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 { _ as _extends } from "@swc/helpers/_/_extends";
+import { components, FieldComponentType, REUSABLE_INSTANCE_COMPONENT_ID, STYLE_OVERRIDES_ROOT_KEY } from "@aglyn/aglyn";
+import { action, toJS } from "mobx";
+/**
+ * Props an instance override must never write (AGL-1899).
+ *
+ * `sx` is refused at the RENDER layer too (`ATTR_OVERRIDE_REFUSED_PROPS` in
+ * `compose-reusable-components.ts`) — styling an instance already has its own
+ * override field one level up, and honouring both would leave two writers
+ * racing for one rendered value with no rule to say which wins.
+ *
+ * `children` and `html` are refused HERE, by the writer, and deliberately not
+ * at the render layer. They are CONTENT, and content inside a component
+ * already has two routes with an owner each: a declared `{{prop.*}}` filled
+ * in per instance, and AGL-1304's double-click-to-edit on the canvas, which
+ * writes through that same binding. A third control writing `children` on the
+ * instance would be a third writer on one rendered string — the shape behind
+ * the unreproduced "Maximum update depth exceeded" report on this panel — and
+ * it would silently win over a binding the component author put there on
+ * purpose. Refusing it in the writer (rather than in the graft) keeps the
+ * storage layer's meaning unchanged, so a later issue can offer content
+ * overrides deliberately instead of inheriting them by accident.
+ */ export const ATTR_OVERRIDE_REFUSED_WRITE_PROPS = new Set([
+    'sx',
+    'children',
+    'html'
+]);
+const isPlainRecord = (value)=>typeof value === 'object' && value !== null && !Array.isArray(value);
+/**
+ * Whether a value the form produced is an OVERRIDE at all (AGL-1899).
+ *
+ * `strictNullChecks` is off repo-wide, so "absent" and "empty" fold together
+ * the moment anything tests an override slice for truthiness. This function is
+ * the one place that decision is made, and it is deliberately narrow:
+ *
+ * - `undefined` is not an override. A cleared field, and every prop the
+ *   definition declares that this instance has not touched, arrive as
+ *   `undefined`, and storing them would turn "I opened the panel" into an
+ *   override on every prop of the component.
+ * - `''` is not an override either. final-form gives a cleared text box an
+ *   empty string, so this is what "clear this field" actually looks like on
+ *   the way in; the explicit way to say "override, and render nothing" is not
+ *   offered by this panel, which does not edit content props at all.
+ * - `false` and `0` ARE overrides, and this is the case worth naming. They
+ *   are the values `strictNullChecks: false` code most often loses: an
+ *   instance that turns a component's `disableGutters` OFF, or sets an
+ *   `elevation` of `0`, is making a real choice, and folding it to "no
+ *   override" would render the component's own value instead — the override
+ *   would appear to save and then silently not apply.
+ */ export function isAttrOverrideValue(value) {
+    return value !== undefined && value !== '';
+}
+/**
+ * The slice as it may be STORED: refused props dropped, and every
+ * non-override value dropped by KEY (AGL-1899).
+ *
+ * Deleting the key rather than storing `undefined` is load-bearing, not
+ * tidiness. The graft applies a slice by spreading it over the definition's
+ * props, so a stored `{ variant: undefined }` would set `variant` to
+ * `undefined` on the rendered node — while `CanvasManager.toJSON`'s
+ * `stripUndefinedDeep` removes that same key on the way to storage. The
+ * instance would then render one way on the canvas and another way after a
+ * reload, which is precisely the canvas/Preview/SSR disagreement this whole
+ * override layer is built as a single merge point to prevent.
+ */ function storableSlice(next) {
+    const slice = {};
+    if (!isPlainRecord(next)) return slice;
+    for (const [prop, value] of Object.entries(next)){
+        if (!prop || ATTR_OVERRIDE_REFUSED_WRITE_PROPS.has(prop)) continue;
+        if (!isAttrOverrideValue(value)) continue;
+        slice[prop] = value;
+    }
+    return slice;
+}
+/** A no-op target for nodes with no attribute-override layer. */ function plainNodeTarget() {
+    return {
+        isInstanceOverride: false,
+        overrideKey: '',
+        isLeafOverride: false,
+        get attrs () {
+            return undefined;
+        },
+        setAttrs: ()=>undefined,
+        clearAttr: ()=>undefined
+    };
+}
+/**
+ * The attribute-override target for a selected node — see
+ * {@link NodeAttrTarget}.
+ *
+ * `overrideKey` selects WHICH slice of an instance's overrides is edited. A
+ * falsy key falls back to the root, so a caller that has not resolved a
+ * definition yet still edits something real rather than writing an
+ * `undefined`-keyed slice no renderer reads.
+ */ export function getNodeAttrTarget(node, overrideKey) {
+    const isInstance = (node == null ? void 0 : node.componentId) === REUSABLE_INSTANCE_COMPONENT_ID;
+    if (!node || !isInstance) return plainNodeTarget();
+    const key = overrideKey || STYLE_OVERRIDES_ROOT_KEY;
+    return {
+        isInstanceOverride: true,
+        overrideKey: key,
+        isLeafOverride: key !== STYLE_OVERRIDES_ROOT_KEY,
+        get attrs () {
+            var _node_attrOverrides;
+            return (_node_attrOverrides = node.attrOverrides) == null ? void 0 : _node_attrOverrides[key];
+        },
+        setAttrs: action((next)=>{
+            var _node_attrOverrides;
+            const overrides = _extends({}, toJS((_node_attrOverrides = node.attrOverrides) != null ? _node_attrOverrides : {}));
+            const slice = storableSlice(next);
+            if (Object.keys(slice).length > 0) {
+                overrides[key] = slice;
+            } else {
+                // An emptied override is REMOVED, not stored as `{}`: the panel's
+                // override chip and the graft's "has an override" check must both
+                // read a cleared instance as clean. Only THIS slice goes — the
+                // instance's other targets keep theirs.
+                delete overrides[key];
+            }
+            node.attrOverrides = Object.keys(overrides).length > 0 ? overrides : undefined;
+        }),
+        clearAttr: action((prop)=>{
+            var _node_attrOverrides;
+            var _node_attrOverrides1;
+            const current = (_node_attrOverrides1 = node.attrOverrides) == null ? void 0 : _node_attrOverrides1[key];
+            if (!isPlainRecord(current) || !(prop in current)) return;
+            const nextSlice = _extends({}, toJS(current));
+            delete nextSlice[prop];
+            const overrides = _extends({}, toJS((_node_attrOverrides = node.attrOverrides) != null ? _node_attrOverrides : {}));
+            if (Object.keys(nextSlice).length > 0) overrides[key] = nextSlice;
+            else delete overrides[key];
+            node.attrOverrides = Object.keys(overrides).length > 0 ? overrides : undefined;
+        })
+    };
+}
+/**
+ * Attribute editors the override panel offers (AGL-1899).
+ *
+ * Every entry is registered in `elementPropsComponentMapper` AND resolves
+ * entirely from the component schema — no canvas context, no host callback,
+ * no second prop written beside it. An unregistered editor makes the form
+ * renderer THROW, which is what once blanked the whole email designer's
+ * attributes panel (AGL-584), so the filter is an allowlist rather than a
+ * denylist: a component declaring an editor nobody thought about here loses
+ * one row from the override list, not the panel.
+ *
+ * Deliberately NOT offered, and each for its own reason:
+ *
+ * - `ICON_PICKER` writes a SECOND prop beside the one it names (the
+ *   denormalized SVG path, AGL-1212). An override slice that carried the id
+ *   without the path would render the "help" glyph.
+ * - `SCREEN_LINK`, and the screen/entity/dataset/node selects, resolve their
+ *   options from editor context the graft never sees.
+ * - `MARKDOWN`, `CSS_GRADIENT`, `BREAKPOINT_SPAN` and `PLUGIN_SETTINGS` each
+ *   edit a composite value with its own rules; a per-instance override of one
+ *   is a design question, not a plumbing one.
+ */ export const ATTR_OVERRIDE_SUPPORTED_EDITORS = new Set([
+    FieldComponentType.TEXT_FIELD,
+    FieldComponentType.TEXTAREA,
+    FieldComponentType.SELECT,
+    FieldComponentType.SWITCH,
+    FieldComponentType.CHECKBOX,
+    FieldComponentType.COLOR_PICKER,
+    FieldComponentType.CSS_DIMENSION
+]);
+/**
+ * The attributes of ONE node inside a component definition that this
+ * instance may override, in the component schema's own order (AGL-1899).
+ *
+ * The definition node's CURRENT value shows as the field's placeholder, which
+ * is the whole of how "empty means the component's value" is made legible:
+ * an author looking at a blank Variant box can see it says `contained`
+ * underneath, and knows what clearing an override goes back to.
+ *
+ * Field names are the prop names verbatim and the form is flat, so a name
+ * carrying a dot is skipped — final-form reads `a.b` as a nested path, so
+ * such a field would write a level the slice does not have and the value
+ * would silently never reach the node (the same trap
+ * `COMPONENT_PROP_NAME_PATTERN` exists for one layer up).
+ */ export function listInstanceAttrFields(defNode) {
+    var _ref;
+    var _components_getSchema;
+    const attributes = (defNode == null ? void 0 : defNode.componentId) ? (_ref = (_components_getSchema = components.getSchema(defNode.componentId)) == null ? void 0 : _components_getSchema.attributes) != null ? _ref : [] : [];
+    const fields = [];
+    const seen = new Set();
+    for (const attribute of attributes){
+        var _defNode_props;
+        const name = attribute == null ? void 0 : attribute.name;
+        const component = attribute == null ? void 0 : attribute.component;
+        if (!name || seen.has(name)) continue;
+        if (name.includes('.') || name.includes('[')) continue;
+        if (ATTR_OVERRIDE_REFUSED_WRITE_PROPS.has(name)) continue;
+        if (!component || !ATTR_OVERRIDE_SUPPORTED_EDITORS.has(component)) continue;
+        seen.add(name);
+        const inherited = defNode == null ? void 0 : (_defNode_props = defNode.props) == null ? void 0 : _defNode_props[name];
+        fields.push({
+            name,
+            field: _extends({}, attribute, {
+                name,
+                // An override field is never required: leaving it empty is the
+                // supported state, and a `required` copied off the component's own
+                // schema would make the form invalid — and therefore unsavable — the
+                // moment the panel opened.
+                isRequired: false,
+                validate: undefined,
+                placeholder: typeof inherited === 'string' || typeof inherited === 'number' ? String(inherited) : undefined
+            })
+        });
+    }
+    return fields;
+}
+export default getNodeAttrTarget;
+
+//# sourceMappingURL=attr-target.js.map

package/src/lib/utils/attr-target.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../libs/besigner/feature/designer/src/lib/utils/attr-target.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 {\n  components,\n  FieldComponentType,\n  REUSABLE_INSTANCE_COMPONENT_ID,\n  STYLE_OVERRIDES_ROOT_KEY,\n} from '@aglyn/aglyn'\nimport { action, toJS } from 'mobx'\n\n/**\n * Props an instance override must never write (AGL-1899).\n *\n * `sx` is refused at the RENDER layer too (`ATTR_OVERRIDE_REFUSED_PROPS` in\n * `compose-reusable-components.ts`) — styling an instance already has its own\n * override field one level up, and honouring both would leave two writers\n * racing for one rendered value with no rule to say which wins.\n *\n * `children` and `html` are refused HERE, by the writer, and deliberately not\n * at the render layer. They are CONTENT, and content inside a component\n * already has two routes with an owner each: a declared `{{prop.*}}` filled\n * in per instance, and AGL-1304's double-click-to-edit on the canvas, which\n * writes through that same binding. A third control writing `children` on the\n * instance would be a third writer on one rendered string — the shape behind\n * the unreproduced \"Maximum update depth exceeded\" report on this panel — and\n * it would silently win over a binding the component author put there on\n * purpose. Refusing it in the writer (rather than in the graft) keeps the\n * storage layer's meaning unchanged, so a later issue can offer content\n * overrides deliberately instead of inheriting them by accident.\n */\nexport const ATTR_OVERRIDE_REFUSED_WRITE_PROPS = new Set([\n  'sx',\n  'children',\n  'html',\n])\n\n/**\n * Where the Attributes panel's per-instance ATTRIBUTE overrides land for the\n * selected node (AGL-1899) — the attribute-side twin of\n * {@link getNodeStyleTarget}.\n *\n * A reusable-component instance's overrides read and write one slice of\n * `node.attrOverrides`: the root slice by default, or the slice keyed by a\n * DEFINITION-internal node id when the author has picked a leaf inside the\n * component. The graft (`composeReusableComponentNodes`) merges that slice\n * over the matching definition node's props, per named prop, so canvas,\n * Preview and tenant SSR agree without any of them knowing this file exists.\n *\n * A PLAIN node has no attribute-override layer at all, and this target\n * refuses to write one: a plain node's attributes are `node.props`, which the\n * Attributes form itself owns through `updateNodeProps`. Handing back a\n * second writer for the same record is exactly how two controls end up\n * fighting over one value, so the plain-node target reports\n * `isInstanceOverride: false` and its `setAttrs` does nothing.\n *\n * `attrs` is a GETTER so `observer` components track the underlying MobX\n * state at read time; a snapshot captured when the target was built would go\n * stale after the first write.\n */\nexport interface NodeAttrTarget {\n  /**\n   * The override slice edits read from and write to (live view), or\n   * `undefined` when this instance overrides nothing for this target.\n   *\n   * Deliberately NOT composed with the definition's own props: an override\n   * slice starts empty and empty MEANS \"whatever the component says\". Merging\n   * a base into the reading would make every inherited value look like an\n   * override this instance had chosen, and the ✕ on its chip would then\n   * appear to do nothing.\n   */\n  readonly attrs: Record<string, any> | undefined\n  /** True when edits land in one of the instance's override slices. */\n  readonly isInstanceOverride: boolean\n  /**\n   * The `attrOverrides` key being edited — `root`, or a definition-internal\n   * node id. Empty string for a plain node, which has no override layer.\n   */\n  readonly overrideKey: string\n  /** True when the target is a leaf inside the component, not its root. */\n  readonly isLeafOverride: boolean\n  /** Replaces the target slice wholesale (MobX action inside). */\n  setAttrs(next: Record<string, any> | undefined): void\n  /** Removes ONE overridden prop, leaving this instance's others (MobX action inside). */\n  clearAttr(prop: string): void\n}\n\nconst isPlainRecord = (value: unknown): value is Record<string, any> =>\n  typeof value === 'object' && value !== null && !Array.isArray(value)\n\n/**\n * Whether a value the form produced is an OVERRIDE at all (AGL-1899).\n *\n * `strictNullChecks` is off repo-wide, so \"absent\" and \"empty\" fold together\n * the moment anything tests an override slice for truthiness. This function is\n * the one place that decision is made, and it is deliberately narrow:\n *\n * - `undefined` is not an override. A cleared field, and every prop the\n *   definition declares that this instance has not touched, arrive as\n *   `undefined`, and storing them would turn \"I opened the panel\" into an\n *   override on every prop of the component.\n * - `''` is not an override either. final-form gives a cleared text box an\n *   empty string, so this is what \"clear this field\" actually looks like on\n *   the way in; the explicit way to say \"override, and render nothing\" is not\n *   offered by this panel, which does not edit content props at all.\n * - `false` and `0` ARE overrides, and this is the case worth naming. They\n *   are the values `strictNullChecks: false` code most often loses: an\n *   instance that turns a component's `disableGutters` OFF, or sets an\n *   `elevation` of `0`, is making a real choice, and folding it to \"no\n *   override\" would render the component's own value instead — the override\n *   would appear to save and then silently not apply.\n */\nexport function isAttrOverrideValue(value: unknown): boolean {\n  return value !== undefined && value !== ''\n}\n\n/**\n * The slice as it may be STORED: refused props dropped, and every\n * non-override value dropped by KEY (AGL-1899).\n *\n * Deleting the key rather than storing `undefined` is load-bearing, not\n * tidiness. The graft applies a slice by spreading it over the definition's\n * props, so a stored `{ variant: undefined }` would set `variant` to\n * `undefined` on the rendered node — while `CanvasManager.toJSON`'s\n * `stripUndefinedDeep` removes that same key on the way to storage. The\n * instance would then render one way on the canvas and another way after a\n * reload, which is precisely the canvas/Preview/SSR disagreement this whole\n * override layer is built as a single merge point to prevent.\n */\nfunction storableSlice(\n  next: Record<string, any> | undefined,\n): Record<string, any> {\n  const slice: Record<string, any> = {}\n  if (!isPlainRecord(next)) return slice\n  for (const [prop, value] of Object.entries(next)) {\n    if (!prop || ATTR_OVERRIDE_REFUSED_WRITE_PROPS.has(prop)) continue\n    if (!isAttrOverrideValue(value)) continue\n    slice[prop] = value\n  }\n  return slice\n}\n\n/** A no-op target for nodes with no attribute-override layer. */\nfunction plainNodeTarget(): NodeAttrTarget {\n  return {\n    isInstanceOverride: false,\n    overrideKey: '',\n    isLeafOverride: false,\n    get attrs() {\n      return undefined\n    },\n    setAttrs: () => undefined,\n    clearAttr: () => undefined,\n  }\n}\n\n/**\n * The attribute-override target for a selected node — see\n * {@link NodeAttrTarget}.\n *\n * `overrideKey` selects WHICH slice of an instance's overrides is edited. A\n * falsy key falls back to the root, so a caller that has not resolved a\n * definition yet still edits something real rather than writing an\n * `undefined`-keyed slice no renderer reads.\n */\nexport function getNodeAttrTarget(\n  node: Aglyn.NodeSchema<any> | null | undefined,\n  overrideKey?: string | null,\n): NodeAttrTarget {\n  const isInstance = node?.componentId === REUSABLE_INSTANCE_COMPONENT_ID\n  if (!node || !isInstance) return plainNodeTarget()\n  const key = overrideKey || STYLE_OVERRIDES_ROOT_KEY\n  return {\n    isInstanceOverride: true,\n    overrideKey: key,\n    isLeafOverride: key !== STYLE_OVERRIDES_ROOT_KEY,\n    get attrs() {\n      return (node.attrOverrides as Record<string, any> | undefined)?.[key]\n    },\n    setAttrs: action((next: Record<string, any> | undefined) => {\n      const overrides: Record<string, any> = {\n        ...toJS(node.attrOverrides ?? {}),\n      }\n      const slice = storableSlice(next)\n      if (Object.keys(slice).length > 0) {\n        overrides[key] = slice\n      } else {\n        // An emptied override is REMOVED, not stored as `{}`: the panel's\n        // override chip and the graft's \"has an override\" check must both\n        // read a cleared instance as clean. Only THIS slice goes — the\n        // instance's other targets keep theirs.\n        delete overrides[key]\n      }\n      node.attrOverrides =\n        Object.keys(overrides).length > 0 ? overrides : undefined\n    }),\n    clearAttr: action((prop: string) => {\n      const current = (node.attrOverrides as Record<string, any> | undefined)?.[\n        key\n      ]\n      if (!isPlainRecord(current) || !(prop in current)) return\n      const nextSlice = { ...toJS(current) }\n      delete nextSlice[prop]\n      const overrides: Record<string, any> = {\n        ...toJS(node.attrOverrides ?? {}),\n      }\n      if (Object.keys(nextSlice).length > 0) overrides[key] = nextSlice\n      else delete overrides[key]\n      node.attrOverrides =\n        Object.keys(overrides).length > 0 ? overrides : undefined\n    }),\n  }\n}\n\n/**\n * Attribute editors the override panel offers (AGL-1899).\n *\n * Every entry is registered in `elementPropsComponentMapper` AND resolves\n * entirely from the component schema — no canvas context, no host callback,\n * no second prop written beside it. An unregistered editor makes the form\n * renderer THROW, which is what once blanked the whole email designer's\n * attributes panel (AGL-584), so the filter is an allowlist rather than a\n * denylist: a component declaring an editor nobody thought about here loses\n * one row from the override list, not the panel.\n *\n * Deliberately NOT offered, and each for its own reason:\n *\n * - `ICON_PICKER` writes a SECOND prop beside the one it names (the\n *   denormalized SVG path, AGL-1212). An override slice that carried the id\n *   without the path would render the \"help\" glyph.\n * - `SCREEN_LINK`, and the screen/entity/dataset/node selects, resolve their\n *   options from editor context the graft never sees.\n * - `MARKDOWN`, `CSS_GRADIENT`, `BREAKPOINT_SPAN` and `PLUGIN_SETTINGS` each\n *   edit a composite value with its own rules; a per-instance override of one\n *   is a design question, not a plumbing one.\n */\nexport const ATTR_OVERRIDE_SUPPORTED_EDITORS = new Set<string>([\n  FieldComponentType.TEXT_FIELD,\n  FieldComponentType.TEXTAREA,\n  FieldComponentType.SELECT,\n  FieldComponentType.SWITCH,\n  FieldComponentType.CHECKBOX,\n  FieldComponentType.COLOR_PICKER,\n  FieldComponentType.CSS_DIMENSION,\n])\n\n/** One overridable attribute of a node inside a component definition. */\nexport interface InstanceAttrField {\n  /** The prop name, which is also the form field name and the slice key. */\n  name: string\n  /** The field schema handed to the form renderer. */\n  field: Record<string, unknown>\n}\n\n/**\n * The attributes of ONE node inside a component definition that this\n * instance may override, in the component schema's own order (AGL-1899).\n *\n * The definition node's CURRENT value shows as the field's placeholder, which\n * is the whole of how \"empty means the component's value\" is made legible:\n * an author looking at a blank Variant box can see it says `contained`\n * underneath, and knows what clearing an override goes back to.\n *\n * Field names are the prop names verbatim and the form is flat, so a name\n * carrying a dot is skipped — final-form reads `a.b` as a nested path, so\n * such a field would write a level the slice does not have and the value\n * would silently never reach the node (the same trap\n * `COMPONENT_PROP_NAME_PATTERN` exists for one layer up).\n */\nexport function listInstanceAttrFields(\n  defNode:\n    | { componentId?: string; props?: Record<string, unknown> }\n    | null\n    | undefined,\n): InstanceAttrField[] {\n  const attributes = defNode?.componentId\n    ? (components.getSchema(defNode.componentId)?.attributes ?? [])\n    : []\n  const fields: InstanceAttrField[] = []\n  const seen = new Set<string>()\n  for (const attribute of attributes) {\n    const name = (attribute as { name?: string })?.name\n    const component = (attribute as { component?: string })?.component\n    if (!name || seen.has(name)) continue\n    if (name.includes('.') || name.includes('[')) continue\n    if (ATTR_OVERRIDE_REFUSED_WRITE_PROPS.has(name)) continue\n    if (!component || !ATTR_OVERRIDE_SUPPORTED_EDITORS.has(component)) continue\n    seen.add(name)\n    const inherited = (defNode?.props as Record<string, unknown> | undefined)?.[\n      name\n    ]\n    fields.push({\n      name,\n      field: {\n        ...(attribute as Record<string, unknown>),\n        name,\n        // An override field is never required: leaving it empty is the\n        // supported state, and a `required` copied off the component's own\n        // schema would make the form invalid — and therefore unsavable — the\n        // moment the panel opened.\n        isRequired: false,\n        validate: undefined,\n        placeholder:\n          typeof inherited === 'string' || typeof inherited === 'number'\n            ? String(inherited)\n            : undefined,\n      },\n    })\n  }\n  return fields\n}\n\nexport default getNodeAttrTarget\n"],"names":["components","FieldComponentType","REUSABLE_INSTANCE_COMPONENT_ID","STYLE_OVERRIDES_ROOT_KEY","action","toJS","ATTR_OVERRIDE_REFUSED_WRITE_PROPS","Set","isPlainRecord","value","Array","isArray","isAttrOverrideValue","undefined","storableSlice","next","slice","prop","Object","entries","has","plainNodeTarget","isInstanceOverride","overrideKey","isLeafOverride","attrs","setAttrs","clearAttr","getNodeAttrTarget","node","isInstance","componentId","key","attrOverrides","overrides","keys","length","current","nextSlice","ATTR_OVERRIDE_SUPPORTED_EDITORS","TEXT_FIELD","TEXTAREA","SELECT","SWITCH","CHECKBOX","COLOR_PICKER","CSS_DIMENSION","listInstanceAttrFields","defNode","attributes","getSchema","fields","seen","attribute","name","component","includes","add","inherited","props","push","field","isRequired","validate","placeholder","String"],"mappings":"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"}

package/src/lib/utils/attribute-field-value.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * A dotted form path read out of a values object, the way final-form reads
+ * one: `propValues.headline` is the `headline` inside `propValues`.
+ */
+export declare function readAttributeFieldValue(values: Record<string, unknown> | null | undefined, name: string): unknown;

package/src/lib/utils/attribute-field-value.js

@@ -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.
+ */ /**
+ * A dotted form path read out of a values object, the way final-form reads
+ * one: `propValues.headline` is the `headline` inside `propValues`.
+ */ export function readAttributeFieldValue(values, name) {
+    let current = values;
+    for (const key of String(name).split('.')){
+        if (!current || typeof current !== 'object') return undefined;
+        current = current[key];
+    }
+    return current;
+}
+
+//# sourceMappingURL=attribute-field-value.js.map

package/src/lib/utils/attribute-field-value.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../libs/besigner/feature/designer/src/lib/utils/attribute-field-value.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2026 Aglyn LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * A dotted form path read out of a values object, the way final-form reads\n * one: `propValues.headline` is the `headline` inside `propValues`.\n */\nexport function readAttributeFieldValue(\n  values: Record<string, unknown> | null | undefined,\n  name: string,\n): unknown {\n  let current: unknown = values\n  for (const key of String(name).split('.')) {\n    if (!current || typeof current !== 'object') return undefined\n    current = (current as Record<string, unknown>)[key]\n  }\n  return current\n}\n"],"names":["readAttributeFieldValue","values","name","current","key","String","split","undefined"],"mappings":"AAAA;;;;;;;;;;;;;;;CAeC,GAED;;;CAGC,GACD,OAAO,SAASA,wBACdC,MAAkD,EAClDC,IAAY;IAEZ,IAAIC,UAAmBF;IACvB,KAAK,MAAMG,OAAOC,OAAOH,MAAMI,KAAK,CAAC,KAAM;QACzC,IAAI,CAACH,WAAW,OAAOA,YAAY,UAAU,OAAOI;QACpDJ,UAAU,AAACA,OAAmC,CAACC,IAAI;IACrD;IACA,OAAOD;AACT"}

package/src/lib/utils/canvas-context-menu.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.
+ */
+/** Ask for the menu on this node; supersedes any earlier request. */
+export declare function requestCanvasContextMenu(nodeId: string | undefined): void;
+/** Whether the open menu was asked for on this node. */
+export declare function isCanvasContextMenuRequested(nodeId: string | undefined): boolean;
+/**
+ * Withdraw the request.
+ *
+ * Called when the menu closes, and unconditionally rather than only for the
+ * node that asked: a request left standing re-opens the menu the next time
+ * that node's overlay mounts, which reads as the menu opening by itself.
+ */
+export declare function clearCanvasContextMenu(): void;

package/src/lib/utils/canvas-context-menu.js

@@ -0,0 +1,56 @@
+/**
+ * @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 { observable, runInAction } from "mobx";
+/**
+ * Right-click on the canvas opens the element's ⋮ menu (AGL-1405).
+ *
+ * The hierarchy row can open its own menu directly — the row and the menu are
+ * the same component. The canvas cannot: the menu is rendered by
+ * `node-quick-actions`, inside the overlay, which only mounts for a node that
+ * is already selected or hovered. The right-click happens on the LEAF, in a
+ * closed shadow root, and the two never meet.
+ *
+ * So the leaf asks and the overlay answers. One node id in module-scope
+ * observable state, which is also what makes the ordering work: the leaf
+ * selects the node and records the request, the overlay mounts BECAUSE of
+ * that selection, and reads the request on its first render.
+ *
+ * A single id rather than a queue — only one context menu can be open, and a
+ * second right-click supersedes the first rather than stacking.
+ */ const state = observable({
+    nodeId: null
+});
+/** Ask for the menu on this node; supersedes any earlier request. */ export function requestCanvasContextMenu(nodeId) {
+    runInAction(()=>{
+        state.nodeId = nodeId != null ? nodeId : null;
+    });
+}
+/** Whether the open menu was asked for on this node. */ export function isCanvasContextMenuRequested(nodeId) {
+    return Boolean(nodeId) && state.nodeId === nodeId;
+}
+/**
+ * Withdraw the request.
+ *
+ * Called when the menu closes, and unconditionally rather than only for the
+ * node that asked: a request left standing re-opens the menu the next time
+ * that node's overlay mounts, which reads as the menu opening by itself.
+ */ export function clearCanvasContextMenu() {
+    runInAction(()=>{
+        state.nodeId = null;
+    });
+}
+
+//# sourceMappingURL=canvas-context-menu.js.map

package/src/lib/utils/canvas-context-menu.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../libs/besigner/feature/designer/src/lib/utils/canvas-context-menu.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 { observable, runInAction } from 'mobx'\n\n/**\n * Right-click on the canvas opens the element's ⋮ menu (AGL-1405).\n *\n * The hierarchy row can open its own menu directly — the row and the menu are\n * the same component. The canvas cannot: the menu is rendered by\n * `node-quick-actions`, inside the overlay, which only mounts for a node that\n * is already selected or hovered. The right-click happens on the LEAF, in a\n * closed shadow root, and the two never meet.\n *\n * So the leaf asks and the overlay answers. One node id in module-scope\n * observable state, which is also what makes the ordering work: the leaf\n * selects the node and records the request, the overlay mounts BECAUSE of\n * that selection, and reads the request on its first render.\n *\n * A single id rather than a queue — only one context menu can be open, and a\n * second right-click supersedes the first rather than stacking.\n */\nconst state = observable<{ nodeId: string | null }>({ nodeId: null })\n\n/** Ask for the menu on this node; supersedes any earlier request. */\nexport function requestCanvasContextMenu(nodeId: string | undefined): void {\n  runInAction(() => {\n    state.nodeId = nodeId ?? null\n  })\n}\n\n/** Whether the open menu was asked for on this node. */\nexport function isCanvasContextMenuRequested(\n  nodeId: string | undefined,\n): boolean {\n  return Boolean(nodeId) && state.nodeId === nodeId\n}\n\n/**\n * Withdraw the request.\n *\n * Called when the menu closes, and unconditionally rather than only for the\n * node that asked: a request left standing re-opens the menu the next time\n * that node's overlay mounts, which reads as the menu opening by itself.\n */\nexport function clearCanvasContextMenu(): void {\n  runInAction(() => {\n    state.nodeId = null\n  })\n}\n"],"names":["observable","runInAction","state","nodeId","requestCanvasContextMenu","isCanvasContextMenuRequested","Boolean","clearCanvasContextMenu"],"mappings":"AAAA;;;;;;;;;;;;;;;CAeC,GAED,SAASA,UAAU,EAAEC,WAAW,QAAQ,OAAM;AAE9C;;;;;;;;;;;;;;;;CAgBC,GACD,MAAMC,QAAQF,WAAsC;IAAEG,QAAQ;AAAK;AAEnE,mEAAmE,GACnE,OAAO,SAASC,yBAAyBD,MAA0B;IACjEF,YAAY;QACVC,MAAMC,MAAM,GAAGA,iBAAAA,SAAU;IAC3B;AACF;AAEA,sDAAsD,GACtD,OAAO,SAASE,6BACdF,MAA0B;IAE1B,OAAOG,QAAQH,WAAWD,MAAMC,MAAM,KAAKA;AAC7C;AAEA;;;;;;CAMC,GACD,OAAO,SAASI;IACdN,YAAY;QACVC,MAAMC,MAAM,GAAG;IACjB;AACF"}