npm - @jini-ai/ui - Versions diffs - 0.1.2 → 0.3.1 - Mend

@jini-ai/ui 0.1.2 → 0.3.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1402) hide show

package/dist/features/html-editor/canvas-content-wrapper.js ADDED Viewed

@@ -0,0 +1,86 @@
+/**
+ * @file Wraps the canvas document's existing body content in a host-supplied ancestor DOM chain
+ * (`CanvasStyling.contentWrapper`) — e.g. `<main><article class="post-detail wrap"></article></main>`
+ * — so a document edited in the canvas is centered/padded/backgrounded the way its real template
+ * wraps it, instead of rendering full-bleed against the bare canvas body.
+ *
+ * **Why this runs on the LIVE canvas DOM, never through GrapesJS's `components` config.** GrapesJS's
+ * exported output (`editor.getHtml()`/`editor.getCss()`) is built entirely from its own component
+ * model — the tree `components: html` seeds at construction — never by reading the canvas iframe's
+ * live DOM (confirmed live by `useInteractiveHtmlEditor.ts`'s own investigation, restated in its
+ * `serializeEditorContent` doc). A wrapper folded into the `components` STRING before `grapesjs.init`
+ * would become real, exportable components — editable, draggable, deletable, and present in every
+ * saved document from then on, nesting deeper on every subsequent save. This module instead runs
+ * AFTER the editor has already parsed its initial `components` (see `useInteractiveHtmlEditor.ts`'s
+ * `editor.on('load', ...)` call site) and manipulates `editor.Canvas.getBody()` directly — plain DOM
+ * nodes GrapesJS's component model has no reference to and never scans when serializing. The wrapper
+ * therefore cannot appear in `getHtml()`/`getCss()` by construction, not because of a strip-on-export
+ * step that could be forgotten or miss a case — see `__tests__/canvas-content-wrapper.test.ts`'s
+ * "never touches componentless internals" framing and `useInteractiveHtmlEditor.test.ts`'s assertion
+ * that `components` passed to `grapesjs.init` is the raw, unwrapped host HTML.
+ *
+ * Existing content nodes are MOVED (native DOM re-parenting via `appendChild` on an already-attached
+ * node), never cloned or rebuilt — the same `Node` objects GrapesJS's component views hold `.el`
+ * references to keep their identity, so nothing already-initialized loses its live binding.
+ */
+/** Marks the outermost wrapper element this module inserts, so a second call (defensive — the
+ *  caller's `load` handler should fire once per mount, but re-entrancy here would otherwise nest a
+ *  second copy around the first) detects the existing wrapper and no-ops instead of double-wrapping. */
+const WRAPPER_ROOT_MARKER = 'data-tovu-canvas-wrapper-root';
+/**
+ * Builds one chain level's element and applies its attributes verbatim via `setAttribute` — plain
+ * HTML attribute names/values from the host's own template markup (`class`, `data-reveal`, …), not
+ * React props, so `setAttribute` is the correct primitive rather than `className`/camelCase DOM
+ * property assignment.
+ */
+function buildWrapperElement(doc, node) {
+    const el = doc.createElement(node.tagName);
+    for (const [name, value] of Object.entries(node.attributes ?? {})) {
+        el.setAttribute(name, value);
+    }
+    return el;
+}
+/**
+ * Wraps every current child node of `body` (elements, text, comments — whatever GrapesJS actually
+ * rendered there) in the given ancestor chain, outermost element first, then re-attaches the chain's
+ * outermost element to `body`.
+ *
+ * @param body - The canvas iframe's `<body>` element (`editor.Canvas.getBody()`), already populated
+ *   by GrapesJS's initial component render.
+ * @param chain - The ancestor chain to wrap with, outermost first — see
+ *   {@link CanvasContentWrapperNode}. `undefined` or `[]` is a no-op: the pre-existing "no wrapper"
+ *   behavior every caller had before this module existed.
+ * @complexity O(d + c) — d = chain depth (elements created), c = body's current child-node count
+ *   (each moved once, no copying).
+ */
+export function applyCanvasContentWrapper(body, chain) {
+    if (!chain || chain.length === 0)
+        return;
+    // Re-entrancy guard — see WRAPPER_ROOT_MARKER's own doc.
+    if (body.querySelector(`[${WRAPPER_ROOT_MARKER}]`))
+        return;
+    const doc = body.ownerDocument;
+    // Built innermost-first via `reduceRight` (each level's element wraps the previous result), which
+    // also hands back a reference to the innermost level in the same pass — avoids indexing into a
+    // built array by position, which `chain`'s `readonly T[]` (not a fixed-length tuple) type cannot
+    // statically prove is in bounds even though the length guard above makes it always true here.
+    let innermost;
+    const outermost = chain.reduceRight((child, node) => {
+        const el = buildWrapperElement(doc, node);
+        if (child)
+            el.appendChild(child);
+        innermost ??= el;
+        return el;
+    }, undefined);
+    if (!outermost || !innermost)
+        return; // Unreachable given the `chain.length === 0` guard above.
+    outermost.setAttribute(WRAPPER_ROOT_MARKER, '');
+    // Move body's existing children into the innermost wrapper level, preserving order. Snapshotted
+    // into an array first — `body.childNodes` is a LIVE collection that would shrink out from under a
+    // direct iteration as each node is moved.
+    for (const child of Array.from(body.childNodes)) {
+        innermost.appendChild(child);
+    }
+    body.appendChild(outermost);
+}
+//# sourceMappingURL=canvas-content-wrapper.js.map

package/dist/features/html-editor/canvas-content-wrapper.js.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"canvas-content-wrapper.js","sourceRoot":"","sources":["../../../src/features/html-editor/canvas-content-wrapper.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH;;wGAEwG;AACxG,MAAM,mBAAmB,GAAG,+BAA+B,CAAC;AAE5D;;;;;GAKG;AACH,SAAS,mBAAmB,CAAC,GAAa,EAAE,IAA8B;IACxE,MAAM,EAAE,GAAG,GAAG,CAAC,aAAa,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IAC3C,KAAK,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,UAAU,IAAI,EAAE,CAAC,EAAE,CAAC;QAClE,EAAE,CAAC,YAAY,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;IAC/B,CAAC;IACD,OAAO,EAAE,CAAC;AACZ,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,yBAAyB,CAAC,IAAiB,EAAE,KAAsD;IACjH,IAAI,CAAC,KAAK,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO;IACzC,yDAAyD;IACzD,IAAI,IAAI,CAAC,aAAa,CAAC,IAAI,mBAAmB,GAAG,CAAC;QAAE,OAAO;IAE3D,MAAM,GAAG,GAAG,IAAI,CAAC,aAAa,CAAC;IAC/B,kGAAkG;IAClG,+FAA+F;IAC/F,iGAAiG;IACjG,8FAA8F;IAC9F,IAAI,SAAkC,CAAC;IACvC,MAAM,SAAS,GAAG,KAAK,CAAC,WAAW,CAA0B,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE;QAC3E,MAAM,EAAE,GAAG,mBAAmB,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;QAC1C,IAAI,KAAK;YAAE,EAAE,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;QACjC,SAAS,KAAK,EAAE,CAAC;QACjB,OAAO,EAAE,CAAC;IACZ,CAAC,EAAE,SAAS,CAAC,CAAC;IACd,IAAI,CAAC,SAAS,IAAI,CAAC,SAAS;QAAE,OAAO,CAAC,0DAA0D;IAChG,SAAS,CAAC,YAAY,CAAC,mBAAmB,EAAE,EAAE,CAAC,CAAC;IAEhD,gGAAgG;IAChG,kGAAkG;IAClG,0CAA0C;IAC1C,KAAK,MAAM,KAAK,IAAI,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC;QAChD,SAAS,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;IAC/B,CAAC;IAED,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC,CAAC;AAC9B,CAAC"}

package/dist/features/html-editor/canvas-embed-placeholders.d.ts ADDED Viewed

@@ -0,0 +1,65 @@
+/**
+ * @file Decorates every canvas element a host recognizes as an unresolved embed marker with an
+ * explicit "this is a placeholder, not real content" card, so an operator editing a document in the
+ * canvas sees something intentional where an embed will render instead of an empty, unlabeled element
+ * that looks safe to delete by accident.
+ *
+ * Same seam as `canvas-content-wrapper.ts`, for the identical reason: this module has zero knowledge
+ * of what an "embed marker" IS (that convention — `data-embed-config`, a `{"type":...}` JSON payload —
+ * belongs to a host; see `@jini-ai/admin/react`'s `InteractiveHtmlEditor` for the one that supplies
+ * it), and it runs on GrapesJS's `load` event against the live canvas DOM
+ * (`editor.Canvas.getBody()`), never through the `components` string GrapesJS's exported
+ * `getHtml()`/`getCss()` are built from. See that sibling file's header for the fuller argument; the
+ * short version: GrapesJS's export walks its own component MODEL, which is fixed at
+ * `grapesjs.init({ components: html })` and never re-reads the canvas iframe's live DOM afterward, so
+ * anything this module adds to that DOM later is invisible to export by construction, not because of a
+ * strip-on-save step that could be forgotten or miss a case.
+ *
+ * **The marker element is never given new children of its own — a NEW wrapper is built around it
+ * instead, and the marker is MOVED inside that wrapper (never cloned), exactly the "move, never clone"
+ * technique `canvas-content-wrapper.ts` uses to keep GrapesJS's component-view `.el` references
+ * intact.** This is the one place this module's technique goes beyond a plain copy of that sibling's,
+ * and the reason is a real, currently-open hazard specific to embed markers: a marker element is not
+ * guaranteed to be excluded from GrapesJS's own RTE (rich-text-editing) machinery by a host's
+ * `isProtectedElement` predicate — see `InteractiveHtmlEditor.tsx` (`@jini-ai/admin/react`)'s own doc
+ * for that gap. If GrapesJS ever treats a marker element as an editable `text` component, an edit
+ * gesture on it triggers `ComponentTextView.syncContent`, which re-parses that element's LIVE
+ * `innerHTML` back into the component model. Putting the card's markup INSIDE the marker would hand
+ * that re-parse something real to capture into a saved document; putting it in a wrapper AROUND the
+ * (untouched, still literally empty) marker means there is nothing inside the marker for that re-parse
+ * to ever pick up, regardless of whether that `isProtectedElement` gap is ever closed.
+ *
+ * Re-entrancy (defensive, mirroring `canvas-content-wrapper.ts`'s own `WRAPPER_ROOT_MARKER` guard): a
+ * marker already sitting inside a placeholder card (`el.closest('[' + CARD_ROOT_MARKER + ']')`) is
+ * skipped, so a second call — or a caller's own `load` handler firing twice — cannot nest a second card
+ * around an already-decorated marker.
+ */
+/** What to show on one embed's placeholder card — supplied per-element by the host's own `describe`
+ *  callback, since only the host knows the marker convention (attribute name, JSON shape, and how to
+ *  turn a parsed config into words a human recognizes). */
+export interface CanvasEmbedPlaceholderDescriptor {
+    /** Short name for the embed's kind, shown as the card's heading — e.g. `"Media"`, `"Widget"`. */
+    kindLabel: string;
+    /** Human-identifiable target, shown under the heading — e.g. a name, or a truncated id, or a note
+     *  that none was set. Never fetched by this module; the host decides what's cheap enough to show. */
+    identityLabel: string;
+}
+/**
+ * Scans every element under `body` once and, for each one `describe` recognizes (returns a descriptor
+ * for), replaces its visible slot with an explicit placeholder card — see this file's header for the
+ * export-safety argument and for why the marker is wrapped rather than written into.
+ *
+ * @param body - The canvas iframe's `<body>` element (`editor.Canvas.getBody()`), already populated by
+ *   GrapesJS's initial component render — same input `applyCanvasContentWrapper` takes, and safe to
+ *   call after that function has already restructured `body`'s top level, since this walks the full
+ *   subtree regardless of how deep any one marker now sits.
+ * @param describe - Host-supplied recognizer/labeler. Returning `undefined` means "not a marker this
+ *   host owns" — the element is left completely untouched, no wrapping, no traversal into its own
+ *   children skipped either (a marker's own children, if any, are themselves ordinary elements this
+ *   function still visits, since `Array.from(body.querySelectorAll('*'))` is a flat snapshot of every
+ *   descendant, not a tree walk this function short-circuits).
+ * @complexity O(n) over the number of elements under `body` for the scan, plus O(1) per matched marker
+ *   for its card's fixed-size DOM (icon plus three text nodes) — independent of document size.
+ */
+export declare function applyCanvasEmbedPlaceholders(body: HTMLElement, describe: (el: Element) => CanvasEmbedPlaceholderDescriptor | undefined): void;
+//# sourceMappingURL=canvas-embed-placeholders.d.ts.map

package/dist/features/html-editor/canvas-embed-placeholders.d.ts.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"canvas-embed-placeholders.d.ts","sourceRoot":"","sources":["../../../src/features/html-editor/canvas-embed-placeholders.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAEH;;2DAE2D;AAC3D,MAAM,WAAW,gCAAgC;IAC/C,iGAAiG;IACjG,SAAS,EAAE,MAAM,CAAC;IAClB;yGACqG;IACrG,aAAa,EAAE,MAAM,CAAC;CACvB;AAgHD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,WAAW,EACjB,QAAQ,EAAE,CAAC,EAAE,EAAE,OAAO,KAAK,gCAAgC,GAAG,SAAS,GACtE,IAAI,CAgCN"}

package/dist/features/html-editor/canvas-embed-placeholders.js ADDED Viewed

@@ -0,0 +1,190 @@
+/**
+ * @file Decorates every canvas element a host recognizes as an unresolved embed marker with an
+ * explicit "this is a placeholder, not real content" card, so an operator editing a document in the
+ * canvas sees something intentional where an embed will render instead of an empty, unlabeled element
+ * that looks safe to delete by accident.
+ *
+ * Same seam as `canvas-content-wrapper.ts`, for the identical reason: this module has zero knowledge
+ * of what an "embed marker" IS (that convention — `data-embed-config`, a `{"type":...}` JSON payload —
+ * belongs to a host; see `@jini-ai/admin/react`'s `InteractiveHtmlEditor` for the one that supplies
+ * it), and it runs on GrapesJS's `load` event against the live canvas DOM
+ * (`editor.Canvas.getBody()`), never through the `components` string GrapesJS's exported
+ * `getHtml()`/`getCss()` are built from. See that sibling file's header for the fuller argument; the
+ * short version: GrapesJS's export walks its own component MODEL, which is fixed at
+ * `grapesjs.init({ components: html })` and never re-reads the canvas iframe's live DOM afterward, so
+ * anything this module adds to that DOM later is invisible to export by construction, not because of a
+ * strip-on-save step that could be forgotten or miss a case.
+ *
+ * **The marker element is never given new children of its own — a NEW wrapper is built around it
+ * instead, and the marker is MOVED inside that wrapper (never cloned), exactly the "move, never clone"
+ * technique `canvas-content-wrapper.ts` uses to keep GrapesJS's component-view `.el` references
+ * intact.** This is the one place this module's technique goes beyond a plain copy of that sibling's,
+ * and the reason is a real, currently-open hazard specific to embed markers: a marker element is not
+ * guaranteed to be excluded from GrapesJS's own RTE (rich-text-editing) machinery by a host's
+ * `isProtectedElement` predicate — see `InteractiveHtmlEditor.tsx` (`@jini-ai/admin/react`)'s own doc
+ * for that gap. If GrapesJS ever treats a marker element as an editable `text` component, an edit
+ * gesture on it triggers `ComponentTextView.syncContent`, which re-parses that element's LIVE
+ * `innerHTML` back into the component model. Putting the card's markup INSIDE the marker would hand
+ * that re-parse something real to capture into a saved document; putting it in a wrapper AROUND the
+ * (untouched, still literally empty) marker means there is nothing inside the marker for that re-parse
+ * to ever pick up, regardless of whether that `isProtectedElement` gap is ever closed.
+ *
+ * Re-entrancy (defensive, mirroring `canvas-content-wrapper.ts`'s own `WRAPPER_ROOT_MARKER` guard): a
+ * marker already sitting inside a placeholder card (`el.closest('[' + CARD_ROOT_MARKER + ']')`) is
+ * skipped, so a second call — or a caller's own `load` handler firing twice — cannot nest a second card
+ * around an already-decorated marker.
+ */
+/** Marks a placeholder card's own root, so a later pass (this function called again, or a re-entrant
+ *  `load`) can recognize an already-decorated marker via `el.closest` and skip it — see this file's
+ *  header. */
+const CARD_ROOT_MARKER = 'data-tovu-embed-placeholder-root';
+/** One CSS declaration list, as `property:value` pairs, for the card's own opaque chrome. Deliberately
+ *  NOT derived from the host's theme in any way — themes are arbitrary and downloadable, and this card
+ *  must stay legible whether the canvas underneath is a light theme, a dark theme, or (mid-edit) no
+ *  theme at all. An opaque background plus a fixed, high-contrast foreground guarantees that
+ *  regardless of what renders behind it, unlike a translucent or theme-token-based treatment would. */
+const CARD_STYLE = [
+    'display:flex',
+    'align-items:flex-start',
+    'gap:8px',
+    'box-sizing:border-box',
+    'border:2px dashed #f59e0b',
+    'border-radius:8px',
+    'background:#1f2937',
+    'color:#f9fafb',
+    'padding:10px 12px',
+    "font:13px/1.4 -apple-system,BlinkMacSystemFont,'Segoe UI',sans-serif",
+].join(';');
+/** Builds the small dashed-square-with-a-plus glyph that opens every card — assembled via
+ *  `createElementNS`/`setAttribute` rather than an `innerHTML` template string, so its element nodes
+ *  are unambiguously in the SVG namespace regardless of parser quirks around fragment-parsing SVG
+ *  content on an element that itself was just created and not yet attached to a document. */
+function buildPlaceholderIcon(doc) {
+    const SVG_NS = 'http://www.w3.org/2000/svg';
+    const icon = doc.createElementNS(SVG_NS, 'svg');
+    icon.setAttribute('width', '18');
+    icon.setAttribute('height', '18');
+    icon.setAttribute('viewBox', '0 0 24 24');
+    icon.setAttribute('fill', 'none');
+    icon.setAttribute('stroke', '#f59e0b');
+    icon.setAttribute('stroke-width', '2');
+    icon.setAttribute('style', 'flex-shrink:0;margin-top:1px;');
+    const rect = doc.createElementNS(SVG_NS, 'rect');
+    rect.setAttribute('x', '3');
+    rect.setAttribute('y', '3');
+    rect.setAttribute('width', '18');
+    rect.setAttribute('height', '18');
+    rect.setAttribute('rx', '3');
+    rect.setAttribute('stroke-dasharray', '4 3');
+    const plus = doc.createElementNS(SVG_NS, 'path');
+    plus.setAttribute('d', 'M8 12h8M12 8v8');
+    icon.append(rect, plus);
+    return icon;
+}
+/** Builds one card's full DOM: icon, kind heading, identity line, and a short explanatory note so an
+ *  operator unfamiliar with the convention still understands what they're looking at (REQ from the
+ *  owner's own ask: "make it very explicit as a placeholder"). Every piece of text goes through
+ *  `textContent`, never string-concatenated markup, so a marker's own config values (which flow into
+ *  `descriptor.identityLabel`) can never be interpreted as HTML. */
+function buildPlaceholderCard(doc, descriptor) {
+    const card = doc.createElement('div');
+    card.setAttribute(CARD_ROOT_MARKER, '');
+    card.setAttribute('style', CARD_STYLE);
+    const text = doc.createElement('div');
+    const heading = doc.createElement('div');
+    heading.setAttribute('style', 'font-weight:600;');
+    heading.textContent = `Placeholder — ${descriptor.kindLabel}`;
+    const identity = doc.createElement('div');
+    identity.setAttribute('style', 'opacity:.8;margin-top:2px;');
+    identity.textContent = descriptor.identityLabel;
+    const note = doc.createElement('div');
+    note.setAttribute('style', 'opacity:.6;margin-top:4px;font-size:11px;');
+    note.textContent = 'Shown here for editing only — the real content renders on the published page.';
+    text.append(heading, identity, note);
+    card.append(buildPlaceholderIcon(doc), text);
+    return card;
+}
+/**
+ * Carries the marker's own RESOLVED `max-width`, if it has one, onto the card — a second,
+ * complementary mechanism to the literal `style` attribute copy in `applyCanvasEmbedPlaceholders`,
+ * and the one that actually matters against a real GrapesJS canvas.
+ *
+ * **Why a second mechanism is needed at all.** Confirmed live against a real canvas (not discoverable
+ * in a plain-DOM unit test — GrapesJS itself hangs under jsdom, see this file's own testing note):
+ * GrapesJS's parser does NOT leave an authored `style="max-width:600px"` as a literal attribute on the
+ * live element it renders. It converts it into a scoped CSS rule instead (`CssComposer`, keyed by the
+ * component's own generated id — `#iow1b { max-width: 600px }` in a canvas `<style>` tag), so
+ * `el.getAttribute('style')` finds nothing to copy for every REAL marker despite working correctly
+ * against a bare, non-GrapesJS element. `getComputedStyle` reads the RESOLVED value regardless of
+ * which of those two forms produced it, so it is what actually reaches a real canvas.
+ *
+ * Scoped to `max-width` alone (not a wholesale computed-style copy) on purpose: copying every resolved
+ * property would fight this card's own deliberately theme-independent, opaque chrome (font, colors,
+ * spacing) with whatever the surrounding page happens to compute — the one thing worth inheriting is
+ * the box-width constraint the "respect the author's own wrapper" requirement is actually about, not
+ * the marker's full computed style.
+ *
+ * A no-op wherever `getComputedStyle` cannot resolve anything meaningful — no global (a non-browser
+ * test environment), or a marker with no width constraint at all (`'none'`, the property's initial
+ * value, or an empty string for a detached node with no attached window) — which is also exactly the
+ * behavior every existing caller of this module had before this function existed.
+ */
+function applyResolvedMaxWidth(marker, card) {
+    if (typeof getComputedStyle !== 'function')
+        return;
+    const maxWidth = getComputedStyle(marker).maxWidth;
+    if (maxWidth && maxWidth !== 'none')
+        card.style.setProperty('max-width', maxWidth);
+}
+/**
+ * Scans every element under `body` once and, for each one `describe` recognizes (returns a descriptor
+ * for), replaces its visible slot with an explicit placeholder card — see this file's header for the
+ * export-safety argument and for why the marker is wrapped rather than written into.
+ *
+ * @param body - The canvas iframe's `<body>` element (`editor.Canvas.getBody()`), already populated by
+ *   GrapesJS's initial component render — same input `applyCanvasContentWrapper` takes, and safe to
+ *   call after that function has already restructured `body`'s top level, since this walks the full
+ *   subtree regardless of how deep any one marker now sits.
+ * @param describe - Host-supplied recognizer/labeler. Returning `undefined` means "not a marker this
+ *   host owns" — the element is left completely untouched, no wrapping, no traversal into its own
+ *   children skipped either (a marker's own children, if any, are themselves ordinary elements this
+ *   function still visits, since `Array.from(body.querySelectorAll('*'))` is a flat snapshot of every
+ *   descendant, not a tree walk this function short-circuits).
+ * @complexity O(n) over the number of elements under `body` for the scan, plus O(1) per matched marker
+ *   for its card's fixed-size DOM (icon plus three text nodes) — independent of document size.
+ */
+export function applyCanvasEmbedPlaceholders(body, describe) {
+    const doc = body.ownerDocument;
+    // Snapshotted into an array before any mutation starts: this function inserts new ancestors as it
+    // goes, and a live `querySelectorAll` result must never be iterated while the tree it was taken over
+    // is being restructured underneath it — same discipline `applyCanvasContentWrapper` applies to
+    // `body.childNodes` for the same reason.
+    const candidates = Array.from(body.querySelectorAll('*'));
+    for (const el of candidates) {
+        // Already inside a placeholder card from an earlier pass over this same element — see this file's
+        // header on re-entrancy. Checked via ancestor lookup rather than a marker attribute on `el` itself,
+        // so a decorated marker's own attributes stay completely untouched by this function, not just its
+        // children.
+        if (el.closest(`[${CARD_ROOT_MARKER}]`))
+            continue;
+        const descriptor = describe(el);
+        if (!descriptor)
+            continue;
+        const parent = el.parentNode;
+        if (!parent)
+            continue; // Unreachable for a live `body` descendant; defensive only.
+        const card = buildPlaceholderCard(doc, descriptor);
+        // Respect the author's own box (e.g. `style="max-width:600px"` on the marker) by carrying its
+        // inline style onto the card BEFORE the card's own chrome declarations, so same-named properties
+        // in `CARD_STYLE` win on the cascade's normal "last declaration wins" rule while anything the
+        // author set that `CARD_STYLE` doesn't touch (like `max-width`) still applies unopposed. Guarded
+        // on presence so a marker with no `style` attribute at all is a no-op, not a leading `;`.
+        const authoredStyle = el.getAttribute('style');
+        if (authoredStyle)
+            card.setAttribute('style', `${authoredStyle};${card.getAttribute('style')}`);
+        applyResolvedMaxWidth(el, card);
+        parent.insertBefore(card, el);
+        card.appendChild(el); // Moves the SAME node (auto-detaches from `parent`) — never cloned.
+    }
+}
+//# sourceMappingURL=canvas-embed-placeholders.js.map

package/dist/features/html-editor/canvas-embed-placeholders.js.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"canvas-embed-placeholders.js","sourceRoot":"","sources":["../../../src/features/html-editor/canvas-embed-placeholders.ts"],"names":[],"mappings":"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"}

package/dist/features/html-editor/canvas-style.d.ts ADDED Viewed

@@ -0,0 +1,73 @@
+/**
+ * @file Builds the `canvas.frameStyle` GrapesJS injects into its editing canvas, so a host that
+ * supplies its own canvas styling is not silently overruled by GrapesJS's own defaults.
+ *
+ * GrapesJS injects `canvas.frameStyle` as a `<style>` element in the canvas document's **`<body>`**,
+ * after everything `canvas.styles` puts in `<head>` — confirmed live in Chrome by reading
+ * `iframe.contentDocument`: the head held only the host's `<link>`, and the `body { background-color:
+ * #fff }` rule that beat it sat in a body-level `<style>`. Its default value therefore wins the
+ * cascade against any host stylesheet that sets a body background, at equal specificity, purely on
+ * document order. Left alone, a host loading a dark theme's stylesheet into the canvas gets that
+ * theme's near-white `color` on GrapesJS's hardcoded white background — white-on-white text, which is
+ * strictly worse than the unstyled canvas it replaced.
+ *
+ * So the white body background is emitted only when the host supplies no canvas styling of its own.
+ * The scrollbar rules are kept either way: they are chrome for GrapesJS's own scrolling canvas, not a
+ * statement about the edited document.
+ */
+/**
+ * One level of a {@link CanvasStyling.contentWrapper} ancestor chain — a tag name plus the
+ * attributes it carried in the host's real template, minus whatever marker attribute the host used
+ * to find it (its own concern, not this module's — see `contentWrapper`'s own doc).
+ */
+export interface CanvasContentWrapperNode {
+    /** Lowercase HTML tag name, e.g. `"main"`, `"article"`. */
+    tagName: string;
+    /** Attribute name/value pairs, e.g. `{ class: "post-detail wrap", "data-reveal": "" }`. Omitted or
+     *  empty means a bare tag with no attributes. */
+    attributes?: Readonly<Record<string, string>>;
+}
+/** What a host wants the canvas document styled with. All fields optional; supplying none is the
+ *  "GrapesJS defaults" case. */
+export interface CanvasStyling {
+    /** Stylesheet URLs, appended to the canvas document's `<head>` as `<link>` elements by GrapesJS
+     *  (`canvas.styles`). Not included in the editor's exported HTML. */
+    stylesheets?: readonly string[];
+    /** Raw CSS appended after the scrollbar rules, so it wins against them and against anything
+     *  `stylesheets` loaded. For declarations that have no stylesheet to load from — a theme's design
+     *  tokens, say. Not included in the editor's exported HTML. */
+    css?: string;
+    /**
+     * The real DOM ancestor chain the host's own page template wraps the editable content in —
+     * outermost element first — so the canvas centers/pads/backgrounds its content the same way the
+     * published page does instead of rendering it full-bleed. E.g. `[{tagName: "main"}, {tagName:
+     * "article", attributes: {class: "post-detail wrap", "data-reveal": ""}}]`.
+     *
+     * Applied to the LIVE canvas DOM only, after the editor has already parsed its initial
+     * `components` — see `react/hooks/useInteractiveHtmlEditor.ts`'s `applyCanvasContentWrapper` call
+     * and `canvas-content-wrapper.ts`'s own file header for why that ordering is what keeps this out of
+     * `getHtml()`/`getCss()` by construction rather than by a strip-on-export step. Omit for the
+     * pre-existing behavior: the editable content renders directly in the canvas body with no wrapper.
+     */
+    contentWrapper?: readonly CanvasContentWrapperNode[];
+}
+/** The `canvas` slice of a GrapesJS editor config — structurally the subset of its `CanvasConfig`
+ *  this module decides, kept as its own type so the builder is assertable without a live editor. */
+export interface CanvasStyleConfig {
+    styles: string[];
+    frameStyle: string;
+}
+/**
+ * Translates host canvas styling into the GrapesJS `canvas` config that applies it. The two halves
+ * are decided together on purpose: whether the white body background is emitted depends on whether
+ * any stylesheet was supplied, so splitting them would let a caller pass one without the other and
+ * reintroduce the white-on-white failure this module exists to prevent.
+ *
+ * @param styling - See {@link CanvasStyling}. An empty object reproduces GrapesJS's own defaults.
+ * @returns `styles` (stylesheet URLs GrapesJS links into the canvas `<head>`) and `frameStyle` (the
+ *   CSS it injects into the canvas `<body>`). Neither appears in the editor's exported HTML.
+ * @complexity O(n) in the number of stylesheets plus the length of `styling.css` — copies and joins,
+ *   no parsing.
+ */
+export declare function buildCanvasStyleConfig(styling: CanvasStyling): CanvasStyleConfig;
+//# sourceMappingURL=canvas-style.d.ts.map

package/dist/features/html-editor/canvas-style.d.ts.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"canvas-style.d.ts","sourceRoot":"","sources":["../../../src/features/html-editor/canvas-style.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH;;;;GAIG;AACH,MAAM,WAAW,wBAAwB;IACvC,2DAA2D;IAC3D,OAAO,EAAE,MAAM,CAAC;IAChB;qDACiD;IACjD,UAAU,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;CAC/C;AAED;gCACgC;AAChC,MAAM,WAAW,aAAa;IAC5B;yEACqE;IACrE,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAChC;;mEAE+D;IAC/D,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;;;;;;;;;;;OAWG;IACH,cAAc,CAAC,EAAE,SAAS,wBAAwB,EAAE,CAAC;CACtD;AAmCD;oGACoG;AACpG,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,aAAa,GAAG,iBAAiB,CAEhF"}

package/dist/features/html-editor/canvas-style.js ADDED Viewed

@@ -0,0 +1,64 @@
+/**
+ * @file Builds the `canvas.frameStyle` GrapesJS injects into its editing canvas, so a host that
+ * supplies its own canvas styling is not silently overruled by GrapesJS's own defaults.
+ *
+ * GrapesJS injects `canvas.frameStyle` as a `<style>` element in the canvas document's **`<body>`**,
+ * after everything `canvas.styles` puts in `<head>` — confirmed live in Chrome by reading
+ * `iframe.contentDocument`: the head held only the host's `<link>`, and the `body { background-color:
+ * #fff }` rule that beat it sat in a body-level `<style>`. Its default value therefore wins the
+ * cascade against any host stylesheet that sets a body background, at equal specificity, purely on
+ * document order. Left alone, a host loading a dark theme's stylesheet into the canvas gets that
+ * theme's near-white `color` on GrapesJS's hardcoded white background — white-on-white text, which is
+ * strictly worse than the unstyled canvas it replaced.
+ *
+ * So the white body background is emitted only when the host supplies no canvas styling of its own.
+ * The scrollbar rules are kept either way: they are chrome for GrapesJS's own scrolling canvas, not a
+ * statement about the edited document.
+ */
+/** GrapesJS's own default scrollbar chrome for the canvas, restated verbatim from its
+ *  `canvas.frameStyle` default so overriding that option does not silently drop it. */
+const CANVAS_SCROLLBAR_STYLE = [
+    "* ::-webkit-scrollbar-track { background: rgba(0, 0, 0, 0.1) }",
+    "* ::-webkit-scrollbar-thumb { background: rgba(255, 255, 255, 0.2) }",
+    "* ::-webkit-scrollbar { width: 10px }",
+].join("\n");
+/** The half of GrapesJS's default `canvas.frameStyle` this module conditionally drops — see the file
+ *  header for why it cannot simply be left in place. */
+const CANVAS_DEFAULT_BODY_BACKGROUND = "body { background-color: #fff }";
+/**
+ * Whether the host has taken over the canvas document's appearance. Either input is enough: a
+ * stylesheet alone is the common case (a real theme's CSS), and raw `css` alone is enough for a host
+ * that only injects variables or a background.
+ */
+function hostStylesTheCanvas(styling) {
+    return (styling.stylesheets?.length ?? 0) > 0 || Boolean(styling.css);
+}
+/**
+ * The value to pass as GrapesJS's `canvas.frameStyle` for the given host styling: the scrollbar
+ * chrome, preceded by the default white body background only when the host styles nothing itself,
+ * and followed by the host's raw `css` when supplied.
+ */
+function buildCanvasFrameStyle(styling) {
+    const rules = [CANVAS_SCROLLBAR_STYLE];
+    if (!hostStylesTheCanvas(styling))
+        rules.unshift(CANVAS_DEFAULT_BODY_BACKGROUND);
+    if (styling.css)
+        rules.push(styling.css);
+    return rules.join("\n");
+}
+/**
+ * Translates host canvas styling into the GrapesJS `canvas` config that applies it. The two halves
+ * are decided together on purpose: whether the white body background is emitted depends on whether
+ * any stylesheet was supplied, so splitting them would let a caller pass one without the other and
+ * reintroduce the white-on-white failure this module exists to prevent.
+ *
+ * @param styling - See {@link CanvasStyling}. An empty object reproduces GrapesJS's own defaults.
+ * @returns `styles` (stylesheet URLs GrapesJS links into the canvas `<head>`) and `frameStyle` (the
+ *   CSS it injects into the canvas `<body>`). Neither appears in the editor's exported HTML.
+ * @complexity O(n) in the number of stylesheets plus the length of `styling.css` — copies and joins,
+ *   no parsing.
+ */
+export function buildCanvasStyleConfig(styling) {
+    return { styles: [...(styling.stylesheets ?? [])], frameStyle: buildCanvasFrameStyle(styling) };
+}
+//# sourceMappingURL=canvas-style.js.map

package/dist/features/html-editor/canvas-style.js.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"canvas-style.js","sourceRoot":"","sources":["../../../src/features/html-editor/canvas-style.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAwCH;uFACuF;AACvF,MAAM,sBAAsB,GAAG;IAC7B,gEAAgE;IAChE,sEAAsE;IACtE,uCAAuC;CACxC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAEb;wDACwD;AACxD,MAAM,8BAA8B,GAAG,iCAAiC,CAAC;AAEzE;;;;GAIG;AACH,SAAS,mBAAmB,CAAC,OAAsB;IACjD,OAAO,CAAC,OAAO,CAAC,WAAW,EAAE,MAAM,IAAI,CAAC,CAAC,GAAG,CAAC,IAAI,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;AACxE,CAAC;AAED;;;;GAIG;AACH,SAAS,qBAAqB,CAAC,OAAsB;IACnD,MAAM,KAAK,GAAG,CAAC,sBAAsB,CAAC,CAAC;IACvC,IAAI,CAAC,mBAAmB,CAAC,OAAO,CAAC;QAAE,KAAK,CAAC,OAAO,CAAC,8BAA8B,CAAC,CAAC;IACjF,IAAI,OAAO,CAAC,GAAG;QAAE,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;IACzC,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAC1B,CAAC;AASD;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,sBAAsB,CAAC,OAAsB;IAC3D,OAAO,EAAE,MAAM,EAAE,CAAC,GAAG,CAAC,OAAO,CAAC,WAAW,IAAI,EAAE,CAAC,CAAC,EAAE,UAAU,EAAE,qBAAqB,CAAC,OAAO,CAAC,EAAE,CAAC;AAClG,CAAC"}

package/dist/features/html-editor/css.d.ts ADDED Viewed

@@ -0,0 +1,22 @@
+/**
+ * `editor.getCss()` always returns single-line, semicolon-packed CSS — confirmed directly in
+ * GrapesJS's own bundled source (`CssRule.prototype.toCSS`/`getDeclaration`): there is no
+ * formatting/indent option anywhere in that path, minification is unconditional. Left as-is, a host
+ * reopening an HTML-source view after an Interactive-tab edit would find hand-authored, readable CSS
+ * replaced by one dense blob. A real CSS parser (e.g. `postcss` + a printer, or a browser-bundle
+ * build of `prettier`) is unwarranted weight for a formatting-only pass over CSS this function's own
+ * caller already generated — the input is always GrapesJS's own regular, predictable serialization,
+ * never arbitrary untrusted CSS, so a small tokenizer is sufficient and safe here specifically (it
+ * would not be a safe substitute for a real parser on attacker-controlled input).
+ *
+ * Tracks brace depth (indentation), quote state (so `;`/`{`/`}` inside a string literal, e.g.
+ * `content: "a;b"`, are never mistaken for structure), and paren depth (so the same characters
+ * inside a function value are left alone too — the concrete case that broke without this: a
+ * `url(data:image/svg+xml;base64,...)` value's own semicolon, which naive brace/semicolon splitting
+ * mistakes for a declaration terminator and corrupts the value).
+ *
+ * @complexity O(n) single pass over the CSS string, O(1) additional space beyond the output buffer.
+ * @overallScore 100
+ */
+export declare function prettifyCss(css: string): string;
+//# sourceMappingURL=css.d.ts.map

package/dist/features/html-editor/css.d.ts.map ADDED Viewed

	@@ -0,0 +1 @@
1	+ {"version":3,"file":"css.d.ts","sourceRoot":"","sources":["../../../src/features/html-editor/css.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAyH/C"}