@aglyn/besigner-ui 1.0.0-beta.143

package/src/lib/utils/held-answers-store.d.ts

@@ -0,0 +1,59 @@
+/**
+ * @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.
+ */
+/**
+ * The canvas's side of a read it cannot make itself (AGL-2838, AGL-3111).
+ *
+ * The designer does not read Firestore — it renders inside a plugin sandbox,
+ * and the documents are the host app's to know. So a canvas element HOLDS what
+ * it needs read, the host app renders one reader per held request, and each
+ * reader files its answer back here under the request's key, where the element
+ * reads it.
+ */
+export interface HeldAnswersSource<Request, Answer> {
+    /**
+     * The answer filed under `key`, or `undefined` while nothing has answered.
+     */
+    get(key: string): Answer | undefined;
+    /**
+     * Keeps the request read while the caller holds it, and returns the
+     * release. Holds are counted, so two holders of one request share a read
+     * and the read ends with the last of them.
+     */
+    retain(request: Request): () => void;
+    /** Called after any answer changes. Returns the unsubscribe. */
+    subscribe(listener: () => void): () => void;
+    /** Moves on every change, so a subscriber can tell a new answer apart. */
+    getVersion(): number;
+}
+/** The source, plus the two ends the host app drives it from. */
+export interface HeldAnswersStore<Request, Answer> extends HeldAnswersSource<Request, Answer> {
+    /** Files a request's answer; no answer withdraws it. */
+    set(key: string, answer: Answer | undefined): void;
+    /**
+     * The requests something currently holds, one per key. The array is
+     * replaced only when that set changes, which is the stable snapshot
+     * `useSyncExternalStore` needs to render one reader per request.
+     */
+    getRetained(): readonly Request[];
+    /** Called after the held set changes. Returns the unsubscribe. */
+    subscribeRetained(listener: () => void): () => void;
+}
+/**
+ * An in-memory store keyed by `keyOf`. How each request is read is the host
+ * app's business.
+ */
+export declare function createHeldAnswersStore<Request, Answer>(keyOf: (request: Request) => string): HeldAnswersStore<Request, Answer>;

package/src/lib/utils/held-answers-store.js

@@ -0,0 +1,94 @@
+/**
+ * @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.
+ */ /**
+ * The canvas's side of a read it cannot make itself (AGL-2838, AGL-3111).
+ *
+ * The designer does not read Firestore — it renders inside a plugin sandbox,
+ * and the documents are the host app's to know. So a canvas element HOLDS what
+ * it needs read, the host app renders one reader per held request, and each
+ * reader files its answer back here under the request's key, where the element
+ * reads it.
+ */ /**
+ * An in-memory store keyed by `keyOf`. How each request is read is the host
+ * app's business.
+ */ export function createHeldAnswersStore(keyOf) {
+    const answers = new Map();
+    const holds = new Map();
+    const listeners = new Set();
+    const retainedListeners = new Set();
+    let version = 0;
+    let retained = [];
+    const notify = (targets)=>{
+        for (const listener of [
+            ...targets
+        ])listener();
+    };
+    const publishRetained = ()=>{
+        retained = [
+            ...holds.values()
+        ].map((hold)=>hold.request);
+        notify(retainedListeners);
+    };
+    return {
+        get: (key)=>answers.get(key),
+        getVersion: ()=>version,
+        subscribe: (listener)=>{
+            listeners.add(listener);
+            return ()=>{
+                listeners.delete(listener);
+            };
+        },
+        retain: (request)=>{
+            const key = keyOf(request);
+            const hold = holds.get(key);
+            if (hold) {
+                hold.count += 1;
+            } else {
+                holds.set(key, {
+                    request,
+                    count: 1
+                });
+                publishRetained();
+            }
+            let released = false;
+            return ()=>{
+                if (released) return;
+                released = true;
+                const current = holds.get(key);
+                if (!current) return;
+                current.count -= 1;
+                if (current.count > 0) return;
+                holds.delete(key);
+                publishRetained();
+            };
+        },
+        set: (key, answer)=>{
+            if (answer) answers.set(key, answer);
+            else if (!answers.delete(key)) return;
+            version += 1;
+            notify(listeners);
+        },
+        getRetained: ()=>retained,
+        subscribeRetained: (listener)=>{
+            retainedListeners.add(listener);
+            return ()=>{
+                retainedListeners.delete(listener);
+            };
+        }
+    };
+}
+
+//# sourceMappingURL=held-answers-store.js.map

package/src/lib/utils/held-answers-store.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../libs/besigner/feature/designer/src/lib/utils/held-answers-store.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 * The canvas's side of a read it cannot make itself (AGL-2838, AGL-3111).\n *\n * The designer does not read Firestore — it renders inside a plugin sandbox,\n * and the documents are the host app's to know. So a canvas element HOLDS what\n * it needs read, the host app renders one reader per held request, and each\n * reader files its answer back here under the request's key, where the element\n * reads it.\n */\nexport interface HeldAnswersSource<Request, Answer> {\n  /**\n   * The answer filed under `key`, or `undefined` while nothing has answered.\n   */\n  get(key: string): Answer | undefined\n  /**\n   * Keeps the request read while the caller holds it, and returns the\n   * release. Holds are counted, so two holders of one request share a read\n   * and the read ends with the last of them.\n   */\n  retain(request: Request): () => void\n  /** Called after any answer changes. Returns the unsubscribe. */\n  subscribe(listener: () => void): () => void\n  /** Moves on every change, so a subscriber can tell a new answer apart. */\n  getVersion(): number\n}\n\n/** The source, plus the two ends the host app drives it from. */\nexport interface HeldAnswersStore<Request, Answer>\n  extends HeldAnswersSource<Request, Answer> {\n  /** Files a request's answer; no answer withdraws it. */\n  set(key: string, answer: Answer | undefined): void\n  /**\n   * The requests something currently holds, one per key. The array is\n   * replaced only when that set changes, which is the stable snapshot\n   * `useSyncExternalStore` needs to render one reader per request.\n   */\n  getRetained(): readonly Request[]\n  /** Called after the held set changes. Returns the unsubscribe. */\n  subscribeRetained(listener: () => void): () => void\n}\n\n/**\n * An in-memory store keyed by `keyOf`. How each request is read is the host\n * app's business.\n */\nexport function createHeldAnswersStore<Request, Answer>(\n  keyOf: (request: Request) => string,\n): HeldAnswersStore<Request, Answer> {\n  const answers = new Map<string, Answer>()\n  const holds = new Map<string, { request: Request; count: number }>()\n  const listeners = new Set<() => void>()\n  const retainedListeners = new Set<() => void>()\n  let version = 0\n  let retained: readonly Request[] = []\n  const notify = (targets: Set<() => void>) => {\n    for (const listener of [...targets]) listener()\n  }\n  const publishRetained = () => {\n    retained = [...holds.values()].map((hold) => hold.request)\n    notify(retainedListeners)\n  }\n  return {\n    get: (key) => answers.get(key),\n    getVersion: () => version,\n    subscribe: (listener) => {\n      listeners.add(listener)\n      return () => {\n        listeners.delete(listener)\n      }\n    },\n    retain: (request) => {\n      const key = keyOf(request)\n      const hold = holds.get(key)\n      if (hold) {\n        hold.count += 1\n      } else {\n        holds.set(key, { request, count: 1 })\n        publishRetained()\n      }\n      let released = false\n      return () => {\n        if (released) return\n        released = true\n        const current = holds.get(key)\n        if (!current) return\n        current.count -= 1\n        if (current.count > 0) return\n        holds.delete(key)\n        publishRetained()\n      }\n    },\n    set: (key, answer) => {\n      if (answer) answers.set(key, answer)\n      else if (!answers.delete(key)) return\n      version += 1\n      notify(listeners)\n    },\n    getRetained: () => retained,\n    subscribeRetained: (listener) => {\n      retainedListeners.add(listener)\n      return () => {\n        retainedListeners.delete(listener)\n      }\n    },\n  }\n}\n"],"names":["createHeldAnswersStore","keyOf","answers","Map","holds","listeners","Set","retainedListeners","version","retained","notify","targets","listener","publishRetained","values","map","hold","request","get","key","getVersion","subscribe","add","delete","retain","count","set","released","current","answer","getRetained","subscribeRetained"],"mappings":"AAAA;;;;;;;;;;;;;;;CAeC,GAED;;;;;;;;CAQC,GAiCD;;;CAGC,GACD,OAAO,SAASA,uBACdC,KAAmC;IAEnC,MAAMC,UAAU,IAAIC;IACpB,MAAMC,QAAQ,IAAID;IAClB,MAAME,YAAY,IAAIC;IACtB,MAAMC,oBAAoB,IAAID;IAC9B,IAAIE,UAAU;IACd,IAAIC,WAA+B,EAAE;IACrC,MAAMC,SAAS,CAACC;QACd,KAAK,MAAMC,YAAY;eAAID;SAAQ,CAAEC;IACvC;IACA,MAAMC,kBAAkB;QACtBJ,WAAW;eAAIL,MAAMU,MAAM;SAAG,CAACC,GAAG,CAAC,CAACC,OAASA,KAAKC,OAAO;QACzDP,OAAOH;IACT;IACA,OAAO;QACLW,KAAK,CAACC,MAAQjB,QAAQgB,GAAG,CAACC;QAC1BC,YAAY,IAAMZ;QAClBa,WAAW,CAACT;YACVP,UAAUiB,GAAG,CAACV;YACd,OAAO;gBACLP,UAAUkB,MAAM,CAACX;YACnB;QACF;QACAY,QAAQ,CAACP;YACP,MAAME,MAAMlB,MAAMgB;YAClB,MAAMD,OAAOZ,MAAMc,GAAG,CAACC;YACvB,IAAIH,MAAM;gBACRA,KAAKS,KAAK,IAAI;YAChB,OAAO;gBACLrB,MAAMsB,GAAG,CAACP,KAAK;oBAAEF;oBAASQ,OAAO;gBAAE;gBACnCZ;YACF;YACA,IAAIc,WAAW;YACf,OAAO;gBACL,IAAIA,UAAU;gBACdA,WAAW;gBACX,MAAMC,UAAUxB,MAAMc,GAAG,CAACC;gBAC1B,IAAI,CAACS,SAAS;gBACdA,QAAQH,KAAK,IAAI;gBACjB,IAAIG,QAAQH,KAAK,GAAG,GAAG;gBACvBrB,MAAMmB,MAAM,CAACJ;gBACbN;YACF;QACF;QACAa,KAAK,CAACP,KAAKU;YACT,IAAIA,QAAQ3B,QAAQwB,GAAG,CAACP,KAAKU;iBACxB,IAAI,CAAC3B,QAAQqB,MAAM,CAACJ,MAAM;YAC/BX,WAAW;YACXE,OAAOL;QACT;QACAyB,aAAa,IAAMrB;QACnBsB,mBAAmB,CAACnB;YAClBL,kBAAkBe,GAAG,CAACV;YACtB,OAAO;gBACLL,kBAAkBgB,MAAM,CAACX;YAC3B;QACF;IACF;AACF"}

package/src/lib/utils/in-place-edit-surface.d.ts

@@ -0,0 +1,118 @@
+/**
+ * @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.
+ */
+/** Marks the element currently being edited in place, for tests and probes. */
+export declare const IN_PLACE_EDITING_ATTR = "data-aglyn-editing";
+export interface InPlaceEditSurface {
+    /** The element the author is typing into — the canvas leaf itself. */
+    readonly element: HTMLElement;
+    /** The selection root to ask for the caret; see {@link selectionOf}. */
+    readonly selection: () => Selection | null;
+    /** Ends the edit and gives the element back to React, untouched. */
+    dispose(): void;
+}
+/**
+ * The caret, across a CLOSED shadow root.
+ *
+ * The canvas renders into `mode="closed"` (`viewport-frame.component.tsx`),
+ * so `document.getSelection()` cannot see a caret inside it — it retargets to
+ * the host, and `host.shadowRoot` is null from outside. What still works is
+ * that a node INSIDE the tree can always reach its own root:
+ * `Node.getRootNode()` returns the `ShadowRoot` whatever its mode, and Chrome
+ * implements `ShadowRoot.getSelection()`. So the caret is readable as long as
+ * you ask from an element that is already in there — which the edited leaf
+ * is.
+ *
+ * Falls back to the document selection for a light-DOM element and for
+ * engines without the non-standard accessor, so this is never the reason an
+ * edit fails.
+ */
+export declare function selectionOf(element: Node): Selection | null;
+/**
+ * Turns the canvas leaf ITSELF into the editing surface (AGL-2486).
+ *
+ * A boxed editing overlay is a rectangle; the thing it stands in for is a
+ * flow of line boxes, and those two geometries always end up disagreeing.
+ * Every bug in this area — the surface wrapping before the element does, the
+ * reserved space not growing, an inline run overflowing onto its sibling — is
+ * one instance of that disagreement.
+ *
+ * Editing the element directly does not solve the geometry problem; it
+ * deletes it. There is no second rectangle to keep in sync, so the text
+ * cannot move, resize or restyle when editing begins, the surrounding layout
+ * re-flows because the real element really did grow, and the
+ * transparent-if-and-only-if-reserved invariant is satisfied by construction
+ * rather than by a check. The sizing ghost this replaces is no longer needed
+ * for the same reason.
+ *
+ * ## Living with React
+ *
+ * The leaf's children are React's. `contentEditable` hands the same subtree
+ * to the browser, which will split, merge and delete those nodes as the
+ * author types — so the two owners have to be separated for the duration.
+ *
+ * The separation is the same one the layout ghost used, and it is the whole
+ * trick: the original child nodes are PARKED BY REFERENCE, not serialized.
+ * Editing happens on a fresh subtree; on dispose the parked nodes — the very
+ * same objects — go back under the very same parent. React's fibers still
+ * point at live nodes in their expected places, so a later update or unmount
+ * finds what it is looking for instead of throwing `NotFoundError` on a node
+ * that was replaced by an equal-looking copy.
+ *
+ * While the edit is open nothing writes to the store, so React has no reason
+ * to reconcile this subtree at all: `props.children` does not change, and a
+ * re-render for an unrelated reason (hover, selection) leaves an unchanged
+ * text child alone. The single `updateNodeProps` at commit is the only
+ * crossing, exactly as it is for the rest of this editor.
+ *
+ * `contentEditable` is set as a DOM property rather than through React, so a
+ * re-render cannot clear it: React only removes properties it set itself.
+ */
+export declare function beginInPlaceEdit(anchor: Element | undefined | null, build: (surface: HTMLElement) => void): InPlaceEditSurface | undefined;
+/**
+ * The `<aglyn-text>` holding THIS node's authored text, when it renders one.
+ *
+ * `beginInPlaceEdit` empties whatever element it is handed, so the choice of
+ * element decides how much of a component survives being edited. Handing it
+ * the node's ROOT is only harmless when the root is itself the text host —
+ * `Typography` renders `<p><aglyn-text>…</aglyn-text></p>` and losing the
+ * `<aglyn-text>` for the duration costs nothing.
+ *
+ * It is not harmless for a COMPOSITE. `Accordion Summary` renders a MUI
+ * `<button>` whose children are `.MuiAccordionSummary-content` and the
+ * chevron wrapper, and MUI puts `textAlign: 'start'` on that content div for
+ * one reason: the UA stylesheet centres text in a `<button>`, and the div is
+ * what cancels it. Wipe the button's children and the authored text lands
+ * directly in a `text-align: center` button — the label centres itself and
+ * the chevron disappears, both for as long as the edit is open (AGL-2556).
+ * `Button` and `Screen Link` have the same shape, one icon slot along.
+ *
+ * The `<aglyn-text>` is the authored text by construction — `Leaf` renders
+ * `<Component>{children}<AglynText>{textContent}</AglynText></Component>` —
+ * so editing it leaves every sibling the component built untouched, and the
+ * text stays in the box whose styling it was authored against.
+ *
+ * Scoped by the leaf stamp `Leaf` puts on every node root: a candidate whose
+ * nearest stamped ancestor is not `root` belongs to a CHILD node rendered
+ * into this one's slot, and editing that would write this node's commit onto
+ * someone else's text. An unstamped root (a test, a bare render) has no such
+ * ancestor and its first candidate stands.
+ *
+ * Returns undefined when there is none, and the caller falls back to the
+ * root — a component that renders its text without the leaf wrapper keeps
+ * exactly the behaviour it had.
+ */
+export declare function findLeafTextElement(root: Element | null | undefined): HTMLElement | undefined;

package/src/lib/utils/in-place-edit-surface.js

@@ -0,0 +1,164 @@
+/**
+ * @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.
+ */ /** Marks the element currently being edited in place, for tests and probes. */ export const IN_PLACE_EDITING_ATTR = 'data-aglyn-editing';
+/**
+ * The caret, across a CLOSED shadow root.
+ *
+ * The canvas renders into `mode="closed"` (`viewport-frame.component.tsx`),
+ * so `document.getSelection()` cannot see a caret inside it — it retargets to
+ * the host, and `host.shadowRoot` is null from outside. What still works is
+ * that a node INSIDE the tree can always reach its own root:
+ * `Node.getRootNode()` returns the `ShadowRoot` whatever its mode, and Chrome
+ * implements `ShadowRoot.getSelection()`. So the caret is readable as long as
+ * you ask from an element that is already in there — which the edited leaf
+ * is.
+ *
+ * Falls back to the document selection for a light-DOM element and for
+ * engines without the non-standard accessor, so this is never the reason an
+ * edit fails.
+ */ export function selectionOf(element) {
+    const root = element.getRootNode();
+    const scoped = root;
+    if (typeof scoped.getSelection === 'function') return scoped.getSelection();
+    if (typeof document !== 'undefined') return document.getSelection();
+    return null;
+}
+/**
+ * Turns the canvas leaf ITSELF into the editing surface (AGL-2486).
+ *
+ * A boxed editing overlay is a rectangle; the thing it stands in for is a
+ * flow of line boxes, and those two geometries always end up disagreeing.
+ * Every bug in this area — the surface wrapping before the element does, the
+ * reserved space not growing, an inline run overflowing onto its sibling — is
+ * one instance of that disagreement.
+ *
+ * Editing the element directly does not solve the geometry problem; it
+ * deletes it. There is no second rectangle to keep in sync, so the text
+ * cannot move, resize or restyle when editing begins, the surrounding layout
+ * re-flows because the real element really did grow, and the
+ * transparent-if-and-only-if-reserved invariant is satisfied by construction
+ * rather than by a check. The sizing ghost this replaces is no longer needed
+ * for the same reason.
+ *
+ * ## Living with React
+ *
+ * The leaf's children are React's. `contentEditable` hands the same subtree
+ * to the browser, which will split, merge and delete those nodes as the
+ * author types — so the two owners have to be separated for the duration.
+ *
+ * The separation is the same one the layout ghost used, and it is the whole
+ * trick: the original child nodes are PARKED BY REFERENCE, not serialized.
+ * Editing happens on a fresh subtree; on dispose the parked nodes — the very
+ * same objects — go back under the very same parent. React's fibers still
+ * point at live nodes in their expected places, so a later update or unmount
+ * finds what it is looking for instead of throwing `NotFoundError` on a node
+ * that was replaced by an equal-looking copy.
+ *
+ * While the edit is open nothing writes to the store, so React has no reason
+ * to reconcile this subtree at all: `props.children` does not change, and a
+ * re-render for an unrelated reason (hover, selection) leaves an unchanged
+ * text child alone. The single `updateNodeProps` at commit is the only
+ * crossing, exactly as it is for the rest of this editor.
+ *
+ * `contentEditable` is set as a DOM property rather than through React, so a
+ * re-render cannot clear it: React only removes properties it set itself.
+ */ export function beginInPlaceEdit(anchor, build) {
+    const element = anchor;
+    if (!element || typeof element.style !== 'object') return undefined;
+    if (!element.isConnected || !element.ownerDocument) return undefined;
+    // Same objects, kept alive off-tree — see "Living with React".
+    const parked = Array.from(element.childNodes);
+    const previousEditable = element.getAttribute('contenteditable');
+    while(element.firstChild)element.removeChild(element.firstChild);
+    try {
+        build(element);
+    } catch (unused) {
+        // A failed build must not leave the leaf empty on the canvas.
+        while(element.firstChild)element.removeChild(element.firstChild);
+        for (const child of parked)element.appendChild(child);
+        return undefined;
+    }
+    element.setAttribute(IN_PLACE_EDITING_ATTR, '');
+    // The ATTRIBUTE, not the property: the property is what a browser reflects
+    // from it, and setting it alone leaves nothing for a non-browser DOM (or a
+    // serializer, or a test) to see.
+    element.setAttribute('contenteditable', 'true');
+    element.spellcheck = true;
+    let disposed = false;
+    return {
+        element,
+        selection: ()=>selectionOf(element),
+        dispose () {
+            if (disposed) return;
+            disposed = true;
+            element.removeAttribute(IN_PLACE_EDITING_ATTR);
+            // `removeAttribute`, not `contentEditable = 'false'`: an explicit
+            // `false` would override an editable ancestor, which the element did
+            // not do before this edit.
+            if (previousEditable === null) {
+                element.removeAttribute('contenteditable');
+            } else {
+                element.setAttribute('contenteditable', previousEditable);
+            }
+            while(element.firstChild)element.removeChild(element.firstChild);
+            for (const child of parked)element.appendChild(child);
+        }
+    };
+}
+/**
+ * The `<aglyn-text>` holding THIS node's authored text, when it renders one.
+ *
+ * `beginInPlaceEdit` empties whatever element it is handed, so the choice of
+ * element decides how much of a component survives being edited. Handing it
+ * the node's ROOT is only harmless when the root is itself the text host —
+ * `Typography` renders `<p><aglyn-text>…</aglyn-text></p>` and losing the
+ * `<aglyn-text>` for the duration costs nothing.
+ *
+ * It is not harmless for a COMPOSITE. `Accordion Summary` renders a MUI
+ * `<button>` whose children are `.MuiAccordionSummary-content` and the
+ * chevron wrapper, and MUI puts `textAlign: 'start'` on that content div for
+ * one reason: the UA stylesheet centres text in a `<button>`, and the div is
+ * what cancels it. Wipe the button's children and the authored text lands
+ * directly in a `text-align: center` button — the label centres itself and
+ * the chevron disappears, both for as long as the edit is open (AGL-2556).
+ * `Button` and `Screen Link` have the same shape, one icon slot along.
+ *
+ * The `<aglyn-text>` is the authored text by construction — `Leaf` renders
+ * `<Component>{children}<AglynText>{textContent}</AglynText></Component>` —
+ * so editing it leaves every sibling the component built untouched, and the
+ * text stays in the box whose styling it was authored against.
+ *
+ * Scoped by the leaf stamp `Leaf` puts on every node root: a candidate whose
+ * nearest stamped ancestor is not `root` belongs to a CHILD node rendered
+ * into this one's slot, and editing that would write this node's commit onto
+ * someone else's text. An unstamped root (a test, a bare render) has no such
+ * ancestor and its first candidate stands.
+ *
+ * Returns undefined when there is none, and the caller falls back to the
+ * root — a component that renders its text without the leaf wrapper keeps
+ * exactly the behaviour it had.
+ */ export function findLeafTextElement(root) {
+    if (!root || typeof root.querySelectorAll !== 'function') return undefined;
+    for (const candidate of Array.from(root.querySelectorAll('aglyn-text'))){
+        var _candidate_parentElement;
+        const owner = (_candidate_parentElement = candidate.parentElement) == null ? void 0 : _candidate_parentElement.closest('[data-aglyn^="leaf:"]');
+        if (owner && owner !== root) continue;
+        return candidate;
+    }
+    return undefined;
+}
+
+//# sourceMappingURL=in-place-edit-surface.js.map

package/src/lib/utils/in-place-edit-surface.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../libs/besigner/feature/designer/src/lib/utils/in-place-edit-surface.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/** Marks the element currently being edited in place, for tests and probes. */\nexport const IN_PLACE_EDITING_ATTR = 'data-aglyn-editing'\n\nexport interface InPlaceEditSurface {\n  /** The element the author is typing into — the canvas leaf itself. */\n  readonly element: HTMLElement\n  /** The selection root to ask for the caret; see {@link selectionOf}. */\n  readonly selection: () => Selection | null\n  /** Ends the edit and gives the element back to React, untouched. */\n  dispose(): void\n}\n\n/**\n * The caret, across a CLOSED shadow root.\n *\n * The canvas renders into `mode=\"closed\"` (`viewport-frame.component.tsx`),\n * so `document.getSelection()` cannot see a caret inside it — it retargets to\n * the host, and `host.shadowRoot` is null from outside. What still works is\n * that a node INSIDE the tree can always reach its own root:\n * `Node.getRootNode()` returns the `ShadowRoot` whatever its mode, and Chrome\n * implements `ShadowRoot.getSelection()`. So the caret is readable as long as\n * you ask from an element that is already in there — which the edited leaf\n * is.\n *\n * Falls back to the document selection for a light-DOM element and for\n * engines without the non-standard accessor, so this is never the reason an\n * edit fails.\n */\nexport function selectionOf(element: Node): Selection | null {\n  const root = element.getRootNode() as Document | ShadowRoot\n  const scoped = root as { getSelection?: () => Selection | null }\n  if (typeof scoped.getSelection === 'function') return scoped.getSelection()\n  if (typeof document !== 'undefined') return document.getSelection()\n  return null\n}\n\n/**\n * Turns the canvas leaf ITSELF into the editing surface (AGL-2486).\n *\n * A boxed editing overlay is a rectangle; the thing it stands in for is a\n * flow of line boxes, and those two geometries always end up disagreeing.\n * Every bug in this area — the surface wrapping before the element does, the\n * reserved space not growing, an inline run overflowing onto its sibling — is\n * one instance of that disagreement.\n *\n * Editing the element directly does not solve the geometry problem; it\n * deletes it. There is no second rectangle to keep in sync, so the text\n * cannot move, resize or restyle when editing begins, the surrounding layout\n * re-flows because the real element really did grow, and the\n * transparent-if-and-only-if-reserved invariant is satisfied by construction\n * rather than by a check. The sizing ghost this replaces is no longer needed\n * for the same reason.\n *\n * ## Living with React\n *\n * The leaf's children are React's. `contentEditable` hands the same subtree\n * to the browser, which will split, merge and delete those nodes as the\n * author types — so the two owners have to be separated for the duration.\n *\n * The separation is the same one the layout ghost used, and it is the whole\n * trick: the original child nodes are PARKED BY REFERENCE, not serialized.\n * Editing happens on a fresh subtree; on dispose the parked nodes — the very\n * same objects — go back under the very same parent. React's fibers still\n * point at live nodes in their expected places, so a later update or unmount\n * finds what it is looking for instead of throwing `NotFoundError` on a node\n * that was replaced by an equal-looking copy.\n *\n * While the edit is open nothing writes to the store, so React has no reason\n * to reconcile this subtree at all: `props.children` does not change, and a\n * re-render for an unrelated reason (hover, selection) leaves an unchanged\n * text child alone. The single `updateNodeProps` at commit is the only\n * crossing, exactly as it is for the rest of this editor.\n *\n * `contentEditable` is set as a DOM property rather than through React, so a\n * re-render cannot clear it: React only removes properties it set itself.\n */\nexport function beginInPlaceEdit(\n  anchor: Element | undefined | null,\n  build: (surface: HTMLElement) => void,\n): InPlaceEditSurface | undefined {\n  const element = anchor as HTMLElement | null | undefined\n  if (!element || typeof element.style !== 'object') return undefined\n  if (!element.isConnected || !element.ownerDocument) return undefined\n\n  // Same objects, kept alive off-tree — see \"Living with React\".\n  const parked = Array.from(element.childNodes)\n  const previousEditable = element.getAttribute('contenteditable')\n\n  while (element.firstChild) element.removeChild(element.firstChild)\n  try {\n    build(element)\n  } catch {\n    // A failed build must not leave the leaf empty on the canvas.\n    while (element.firstChild) element.removeChild(element.firstChild)\n    for (const child of parked) element.appendChild(child)\n    return undefined\n  }\n\n  element.setAttribute(IN_PLACE_EDITING_ATTR, '')\n  // The ATTRIBUTE, not the property: the property is what a browser reflects\n  // from it, and setting it alone leaves nothing for a non-browser DOM (or a\n  // serializer, or a test) to see.\n  element.setAttribute('contenteditable', 'true')\n  element.spellcheck = true\n\n  let disposed = false\n  return {\n    element,\n    selection: () => selectionOf(element),\n    dispose() {\n      if (disposed) return\n      disposed = true\n      element.removeAttribute(IN_PLACE_EDITING_ATTR)\n      // `removeAttribute`, not `contentEditable = 'false'`: an explicit\n      // `false` would override an editable ancestor, which the element did\n      // not do before this edit.\n      if (previousEditable === null) {\n        element.removeAttribute('contenteditable')\n      } else {\n        element.setAttribute('contenteditable', previousEditable)\n      }\n      while (element.firstChild) element.removeChild(element.firstChild)\n      for (const child of parked) element.appendChild(child)\n    },\n  }\n}\n\n/**\n * The `<aglyn-text>` holding THIS node's authored text, when it renders one.\n *\n * `beginInPlaceEdit` empties whatever element it is handed, so the choice of\n * element decides how much of a component survives being edited. Handing it\n * the node's ROOT is only harmless when the root is itself the text host —\n * `Typography` renders `<p><aglyn-text>…</aglyn-text></p>` and losing the\n * `<aglyn-text>` for the duration costs nothing.\n *\n * It is not harmless for a COMPOSITE. `Accordion Summary` renders a MUI\n * `<button>` whose children are `.MuiAccordionSummary-content` and the\n * chevron wrapper, and MUI puts `textAlign: 'start'` on that content div for\n * one reason: the UA stylesheet centres text in a `<button>`, and the div is\n * what cancels it. Wipe the button's children and the authored text lands\n * directly in a `text-align: center` button — the label centres itself and\n * the chevron disappears, both for as long as the edit is open (AGL-2556).\n * `Button` and `Screen Link` have the same shape, one icon slot along.\n *\n * The `<aglyn-text>` is the authored text by construction — `Leaf` renders\n * `<Component>{children}<AglynText>{textContent}</AglynText></Component>` —\n * so editing it leaves every sibling the component built untouched, and the\n * text stays in the box whose styling it was authored against.\n *\n * Scoped by the leaf stamp `Leaf` puts on every node root: a candidate whose\n * nearest stamped ancestor is not `root` belongs to a CHILD node rendered\n * into this one's slot, and editing that would write this node's commit onto\n * someone else's text. An unstamped root (a test, a bare render) has no such\n * ancestor and its first candidate stands.\n *\n * Returns undefined when there is none, and the caller falls back to the\n * root — a component that renders its text without the leaf wrapper keeps\n * exactly the behaviour it had.\n */\nexport function findLeafTextElement(\n  root: Element | null | undefined,\n): HTMLElement | undefined {\n  if (!root || typeof root.querySelectorAll !== 'function') return undefined\n  for (const candidate of Array.from(root.querySelectorAll('aglyn-text'))) {\n    const owner = candidate.parentElement?.closest('[data-aglyn^=\"leaf:\"]')\n    if (owner && owner !== root) continue\n    return candidate as HTMLElement\n  }\n  return undefined\n}\n"],"names":["IN_PLACE_EDITING_ATTR","selectionOf","element","root","getRootNode","scoped","getSelection","document","beginInPlaceEdit","anchor","build","style","undefined","isConnected","ownerDocument","parked","Array","from","childNodes","previousEditable","getAttribute","firstChild","removeChild","child","appendChild","setAttribute","spellcheck","disposed","selection","dispose","removeAttribute","findLeafTextElement","querySelectorAll","candidate","owner","parentElement","closest"],"mappings":"AAAA;;;;;;;;;;;;;;;CAeC,GAED,6EAA6E,GAC7E,OAAO,MAAMA,wBAAwB,qBAAoB;AAWzD;;;;;;;;;;;;;;;CAeC,GACD,OAAO,SAASC,YAAYC,OAAa;IACvC,MAAMC,OAAOD,QAAQE,WAAW;IAChC,MAAMC,SAASF;IACf,IAAI,OAAOE,OAAOC,YAAY,KAAK,YAAY,OAAOD,OAAOC,YAAY;IACzE,IAAI,OAAOC,aAAa,aAAa,OAAOA,SAASD,YAAY;IACjE,OAAO;AACT;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuCC,GACD,OAAO,SAASE,iBACdC,MAAkC,EAClCC,KAAqC;IAErC,MAAMR,UAAUO;IAChB,IAAI,CAACP,WAAW,OAAOA,QAAQS,KAAK,KAAK,UAAU,OAAOC;IAC1D,IAAI,CAACV,QAAQW,WAAW,IAAI,CAACX,QAAQY,aAAa,EAAE,OAAOF;IAE3D,+DAA+D;IAC/D,MAAMG,SAASC,MAAMC,IAAI,CAACf,QAAQgB,UAAU;IAC5C,MAAMC,mBAAmBjB,QAAQkB,YAAY,CAAC;IAE9C,MAAOlB,QAAQmB,UAAU,CAAEnB,QAAQoB,WAAW,CAACpB,QAAQmB,UAAU;IACjE,IAAI;QACFX,MAAMR;IACR,EAAE,eAAM;QACN,8DAA8D;QAC9D,MAAOA,QAAQmB,UAAU,CAAEnB,QAAQoB,WAAW,CAACpB,QAAQmB,UAAU;QACjE,KAAK,MAAME,SAASR,OAAQb,QAAQsB,WAAW,CAACD;QAChD,OAAOX;IACT;IAEAV,QAAQuB,YAAY,CAACzB,uBAAuB;IAC5C,2EAA2E;IAC3E,2EAA2E;IAC3E,iCAAiC;IACjCE,QAAQuB,YAAY,CAAC,mBAAmB;IACxCvB,QAAQwB,UAAU,GAAG;IAErB,IAAIC,WAAW;IACf,OAAO;QACLzB;QACA0B,WAAW,IAAM3B,YAAYC;QAC7B2B;YACE,IAAIF,UAAU;YACdA,WAAW;YACXzB,QAAQ4B,eAAe,CAAC9B;YACxB,kEAAkE;YAClE,qEAAqE;YACrE,2BAA2B;YAC3B,IAAImB,qBAAqB,MAAM;gBAC7BjB,QAAQ4B,eAAe,CAAC;YAC1B,OAAO;gBACL5B,QAAQuB,YAAY,CAAC,mBAAmBN;YAC1C;YACA,MAAOjB,QAAQmB,UAAU,CAAEnB,QAAQoB,WAAW,CAACpB,QAAQmB,UAAU;YACjE,KAAK,MAAME,SAASR,OAAQb,QAAQsB,WAAW,CAACD;QAClD;IACF;AACF;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgCC,GACD,OAAO,SAASQ,oBACd5B,IAAgC;IAEhC,IAAI,CAACA,QAAQ,OAAOA,KAAK6B,gBAAgB,KAAK,YAAY,OAAOpB;IACjE,KAAK,MAAMqB,aAAajB,MAAMC,IAAI,CAACd,KAAK6B,gBAAgB,CAAC,eAAgB;YACzDC;QAAd,MAAMC,SAAQD,2BAAAA,UAAUE,aAAa,qBAAvBF,yBAAyBG,OAAO,CAAC;QAC/C,IAAIF,SAASA,UAAU/B,MAAM;QAC7B,OAAO8B;IACT;IACA,OAAOrB;AACT"}

package/src/lib/utils/inline-markdown-edit.store.d.ts

@@ -0,0 +1,71 @@
+/**
+ * @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';
+export interface InlineMarkdownEditRect {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}
+/**
+ * The attribute a double-click edits in place, or `undefined` when the
+ * component declares none.
+ *
+ * The trigger is the component schema's OWN declaration — the same
+ * `FieldComponentType.MARKDOWN` that already makes the attributes panel render
+ * the WYSIWYG (AGL-1616) — not a component id and not a bespoke DOM attribute.
+ * The canvas exposes no per-leaf marker to hang one on, and a hardcoded
+ * `componentId === 'markdown'` would leave the next component that declares a
+ * document attribute (an email block, a plugin's own) editable in the panel and
+ * not on the canvas. One declaration, both surfaces.
+ */
+export declare function findMarkdownAttributeName(node: Aglyn.NodeSchema<any> | undefined): string | undefined;
+/**
+ * State for the in-place canvas markdown editor (AGL-1624): which node is
+ * being edited, which of its attributes holds the document, the value the
+ * editor opened on, and where the element sits in viewport coordinates.
+ *
+ * Screen coordinates because the editor renders as a fixed overlay OUTSIDE the
+ * closed canvas shadow root — the same frame of reference `inlineTextEdit`
+ * uses, and the only one the two sides share.
+ *
+ * `anchor` is the element the rect was measured from, kept so the editor can
+ * re-measure instead of drifting when the canvas scrolls (AGL-1644). `rect` is
+ * still carried and still used: it is the value the first paint positions on,
+ * before any layout effect has run, and the fallback when there is no anchor.
+ *
+ * It is an `observable.ref` — a DOM node is a foreign object graph and mobx has
+ * no business walking into it.
+ *
+ * `initialValue` is captured at open and never re-read. The editor re-parses
+ * its row model whenever the incoming value differs from the string it last
+ * emitted, which resets the undo history and drops the caret; feeding the
+ * node's live props back in would do that on every commit, and again whenever
+ * a co-editing peer touched the same node.
+ */
+declare class InlineMarkdownEditStore {
+    node?: Aglyn.NodeSchema<any>;
+    rect?: InlineMarkdownEditRect;
+    anchor?: Element;
+    attributeName?: string;
+    initialValue: string;
+    constructor();
+    open(node: Aglyn.NodeSchema<any>, rect: InlineMarkdownEditRect, attributeName: string, initialValue: string, anchor?: Element): void;
+    close(): void;
+}
+export declare const inlineMarkdownEdit: InlineMarkdownEditStore;
+export default inlineMarkdownEdit;

package/src/lib/utils/inline-markdown-edit.store.js

@@ -0,0 +1,90 @@
+/**
+ * @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 { FieldComponentType } from "@aglyn/aglyn";
+import { makeAutoObservable, observable } from "mobx";
+/**
+ * The attribute a double-click edits in place, or `undefined` when the
+ * component declares none.
+ *
+ * The trigger is the component schema's OWN declaration — the same
+ * `FieldComponentType.MARKDOWN` that already makes the attributes panel render
+ * the WYSIWYG (AGL-1616) — not a component id and not a bespoke DOM attribute.
+ * The canvas exposes no per-leaf marker to hang one on, and a hardcoded
+ * `componentId === 'markdown'` would leave the next component that declares a
+ * document attribute (an email block, a plugin's own) editable in the panel and
+ * not on the canvas. One declaration, both surfaces.
+ */ export function findMarkdownAttributeName(node) {
+    var _ref;
+    var _node_componentSchema;
+    for (const attribute of (_ref = node == null ? void 0 : (_node_componentSchema = node.componentSchema) == null ? void 0 : _node_componentSchema.attributes) != null ? _ref : []){
+        if ((attribute == null ? void 0 : attribute.component) === FieldComponentType.MARKDOWN) {
+            return attribute.name;
+        }
+    }
+    return undefined;
+}
+/**
+ * State for the in-place canvas markdown editor (AGL-1624): which node is
+ * being edited, which of its attributes holds the document, the value the
+ * editor opened on, and where the element sits in viewport coordinates.
+ *
+ * Screen coordinates because the editor renders as a fixed overlay OUTSIDE the
+ * closed canvas shadow root — the same frame of reference `inlineTextEdit`
+ * uses, and the only one the two sides share.
+ *
+ * `anchor` is the element the rect was measured from, kept so the editor can
+ * re-measure instead of drifting when the canvas scrolls (AGL-1644). `rect` is
+ * still carried and still used: it is the value the first paint positions on,
+ * before any layout effect has run, and the fallback when there is no anchor.
+ *
+ * It is an `observable.ref` — a DOM node is a foreign object graph and mobx has
+ * no business walking into it.
+ *
+ * `initialValue` is captured at open and never re-read. The editor re-parses
+ * its row model whenever the incoming value differs from the string it last
+ * emitted, which resets the undo history and drops the caret; feeding the
+ * node's live props back in would do that on every commit, and again whenever
+ * a co-editing peer touched the same node.
+ */ let InlineMarkdownEditStore = class InlineMarkdownEditStore {
+    open(node, rect, attributeName, initialValue, anchor) {
+        this.node = node;
+        this.rect = rect;
+        this.anchor = anchor;
+        this.attributeName = attributeName;
+        this.initialValue = initialValue;
+    }
+    close() {
+        this.node = undefined;
+        this.rect = undefined;
+        this.anchor = undefined;
+        this.attributeName = undefined;
+        this.initialValue = '';
+    }
+    constructor(){
+        this.node = undefined;
+        this.rect = undefined;
+        this.anchor = undefined;
+        this.attributeName = undefined;
+        this.initialValue = '';
+        makeAutoObservable(this, {
+            anchor: observable.ref
+        });
+    }
+};
+export const inlineMarkdownEdit = new InlineMarkdownEditStore();
+export default inlineMarkdownEdit;
+
+//# sourceMappingURL=inline-markdown-edit.store.js.map

package/src/lib/utils/inline-markdown-edit.store.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../libs/besigner/feature/designer/src/lib/utils/inline-markdown-edit.store.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 { FieldComponentType } from '@aglyn/aglyn'\nimport { makeAutoObservable, observable } from 'mobx'\n\nexport interface InlineMarkdownEditRect {\n  left: number\n  top: number\n  width: number\n  height: number\n}\n\n/**\n * The attribute a double-click edits in place, or `undefined` when the\n * component declares none.\n *\n * The trigger is the component schema's OWN declaration — the same\n * `FieldComponentType.MARKDOWN` that already makes the attributes panel render\n * the WYSIWYG (AGL-1616) — not a component id and not a bespoke DOM attribute.\n * The canvas exposes no per-leaf marker to hang one on, and a hardcoded\n * `componentId === 'markdown'` would leave the next component that declares a\n * document attribute (an email block, a plugin's own) editable in the panel and\n * not on the canvas. One declaration, both surfaces.\n */\nexport function findMarkdownAttributeName(\n  node: Aglyn.NodeSchema<any> | undefined,\n): string | undefined {\n  for (const attribute of node?.componentSchema?.attributes ?? []) {\n    if (attribute?.component === FieldComponentType.MARKDOWN) {\n      return attribute.name\n    }\n  }\n  return undefined\n}\n\n/**\n * State for the in-place canvas markdown editor (AGL-1624): which node is\n * being edited, which of its attributes holds the document, the value the\n * editor opened on, and where the element sits in viewport coordinates.\n *\n * Screen coordinates because the editor renders as a fixed overlay OUTSIDE the\n * closed canvas shadow root — the same frame of reference `inlineTextEdit`\n * uses, and the only one the two sides share.\n *\n * `anchor` is the element the rect was measured from, kept so the editor can\n * re-measure instead of drifting when the canvas scrolls (AGL-1644). `rect` is\n * still carried and still used: it is the value the first paint positions on,\n * before any layout effect has run, and the fallback when there is no anchor.\n *\n * It is an `observable.ref` — a DOM node is a foreign object graph and mobx has\n * no business walking into it.\n *\n * `initialValue` is captured at open and never re-read. The editor re-parses\n * its row model whenever the incoming value differs from the string it last\n * emitted, which resets the undo history and drops the caret; feeding the\n * node's live props back in would do that on every commit, and again whenever\n * a co-editing peer touched the same node.\n */\nclass InlineMarkdownEditStore {\n  node?: Aglyn.NodeSchema<any> = undefined\n  rect?: InlineMarkdownEditRect = undefined\n  anchor?: Element = undefined\n  attributeName?: string = undefined\n  initialValue = ''\n\n  constructor() {\n    makeAutoObservable(this, { anchor: observable.ref })\n  }\n\n  open(\n    node: Aglyn.NodeSchema<any>,\n    rect: InlineMarkdownEditRect,\n    attributeName: string,\n    initialValue: string,\n    anchor?: Element,\n  ) {\n    this.node = node\n    this.rect = rect\n    this.anchor = anchor\n    this.attributeName = attributeName\n    this.initialValue = initialValue\n  }\n\n  close() {\n    this.node = undefined\n    this.rect = undefined\n    this.anchor = undefined\n    this.attributeName = undefined\n    this.initialValue = ''\n  }\n}\n\nexport const inlineMarkdownEdit = new InlineMarkdownEditStore()\nexport default inlineMarkdownEdit\n"],"names":["FieldComponentType","makeAutoObservable","observable","findMarkdownAttributeName","node","attribute","componentSchema","attributes","component","MARKDOWN","name","undefined","InlineMarkdownEditStore","open","rect","attributeName","initialValue","anchor","close","ref","inlineMarkdownEdit"],"mappings":"AAAA;;;;;;;;;;;;;;;CAeC,GAGD,SAASA,kBAAkB,QAAQ,eAAc;AACjD,SAASC,kBAAkB,EAAEC,UAAU,QAAQ,OAAM;AASrD;;;;;;;;;;;CAWC,GACD,OAAO,SAASC,0BACdC,IAAuC;;QAEfA;IAAxB,KAAK,MAAMC,qBAAaD,yBAAAA,wBAAAA,KAAME,eAAe,qBAArBF,sBAAuBG,UAAU,mBAAI,EAAE,CAAE;QAC/D,IAAIF,CAAAA,6BAAAA,UAAWG,SAAS,MAAKR,mBAAmBS,QAAQ,EAAE;YACxD,OAAOJ,UAAUK,IAAI;QACvB;IACF;IACA,OAAOC;AACT;AAEA;;;;;;;;;;;;;;;;;;;;;;CAsBC,GACD,IAAA,AAAMC,0BAAN,MAAMA;IAWJC,KACET,IAA2B,EAC3BU,IAA4B,EAC5BC,aAAqB,EACrBC,YAAoB,EACpBC,MAAgB,EAChB;QACA,IAAI,CAACb,IAAI,GAAGA;QACZ,IAAI,CAACU,IAAI,GAAGA;QACZ,IAAI,CAACG,MAAM,GAAGA;QACd,IAAI,CAACF,aAAa,GAAGA;QACrB,IAAI,CAACC,YAAY,GAAGA;IACtB;IAEAE,QAAQ;QACN,IAAI,CAACd,IAAI,GAAGO;QACZ,IAAI,CAACG,IAAI,GAAGH;QACZ,IAAI,CAACM,MAAM,GAAGN;QACd,IAAI,CAACI,aAAa,GAAGJ;QACrB,IAAI,CAACK,YAAY,GAAG;IACtB;IAxBA,aAAc;aANdZ,OAA+BO;aAC/BG,OAAgCH;aAChCM,SAAmBN;aACnBI,gBAAyBJ;aACzBK,eAAe;QAGbf,mBAAmB,IAAI,EAAE;YAAEgB,QAAQf,WAAWiB,GAAG;QAAC;IACpD;AAuBF;AAEA,OAAO,MAAMC,qBAAqB,IAAIR,0BAAyB;AAC/D,eAAeQ,mBAAkB"}