smoodly 0.0.62 → 0.0.63

package/dist/admin/editor/sample-frame.d.ts

@@ -0,0 +1,36 @@
+/** The frame's fixed viewport: a desktop width, and a height a section sized in viewport units cannot outgrow. */
+export declare const SAMPLE_VIEWPORT: {
+    readonly width: 1280;
+    readonly height: 800;
+};
+export type FrameElement = {
+    tagName: string;
+    parentElement: FrameElement | null;
+    children: ArrayLike<FrameElement>;
+    getAttribute(name: string): string | null;
+    getBoundingClientRect(): {
+        top: number;
+        height: number;
+    };
+};
+export type FrameDocument = {
+    body: FrameElement | null;
+    querySelectorAll(selector: string): ArrayLike<FrameElement>;
+};
+/** Smoodly rendered this document as a draft: the marker its renderers write is there. */
+export declare function isSmoodlyDraft(doc: FrameDocument): boolean;
+/** The rules that hide the site's layout around the samples: at every level from the body down to the samples'
+ *  common parent, everything beside the path (never a style, link or script). What shares the common parent with the
+ *  samples stays, since that parent is the zone's own container; the body is never one, so there everything else
+ *  goes. By position, as a stylesheet, and no element is touched: an attribute or an inline style written before
+ *  the site's own script takes the page over is a hydration mismatch (Next's dev overlay reports it), and a rule
+ *  also hides what the site adds to the body later. Empty when the document holds no sample. */
+export declare function isolationCss(doc: FrameDocument): string;
+/** A row's node in the frame; null when the site drew none, or drew the crash placeholder in its place. */
+export declare function sampleNode(doc: FrameDocument, id: string): FrameElement | null;
+/** Where the crop sits: the node's top in the document (its viewport top plus the frame's scroll) and its height,
+ *  capped at the viewport's (a taller section shows its first screen). Whole pixels. */
+export declare function sampleBox(node: FrameElement, scrollY: number): {
+    top: number;
+    height: number;
+};

package/dist/admin/editor/sample-frame.js

@@ -0,0 +1,58 @@
+// The picker's samples frame, read from outside (spec 2026-11-14 add section previews): the frame is the site's own
+// draft page with a zone's samples in place of its content, same-origin, so the admin reads its document directly.
+// It hides the site's layout around the samples (a sticky header would sit over every picture) and crops the frame
+// to one row's node. Pure over the few members of a document it uses, so the unit suite runs it without a DOM.
+import { CRASHED_ATTR, NODE_ATTR } from "../../marks.js";
+import { DRAFT_META_NAME } from "./canvas-diagnosis.js";
+/** The frame's fixed viewport: a desktop width, and a height a section sized in viewport units cannot outgrow. */
+export const SAMPLE_VIEWPORT = { width: 1280, height: 800 };
+const SAMPLE_PREFIX = "sample-";
+const nodesOf = (doc) => Array.from(doc.querySelectorAll(`[${NODE_ATTR}]`));
+const chainOf = (el) => { const out = []; for (let cur = el; cur; cur = cur.parentElement)
+    out.push(cur); return out; };
+/** Smoodly rendered this document as a draft: the marker its renderers write is there. */
+export function isSmoodlyDraft(doc) {
+    return doc.querySelectorAll(`meta[name="${DRAFT_META_NAME}"]`).length > 0;
+}
+/** The rules that hide the site's layout around the samples: at every level from the body down to the samples'
+ *  common parent, everything beside the path (never a style, link or script). What shares the common parent with the
+ *  samples stays, since that parent is the zone's own container; the body is never one, so there everything else
+ *  goes. By position, as a stylesheet, and no element is touched: an attribute or an inline style written before
+ *  the site's own script takes the page over is a hydration mismatch (Next's dev overlay reports it), and a rule
+ *  also hides what the site adds to the body later. Empty when the document holds no sample. */
+export function isolationCss(doc) {
+    const body = doc.body;
+    const samples = nodesOf(doc).filter((n) => n.getAttribute(NODE_ATTR).startsWith(SAMPLE_PREFIX));
+    if (!body || samples.length === 0)
+        return "";
+    // The sample nodes and everything above them: never hidden.
+    const kept = new Set(samples.flatMap(chainOf));
+    // The common parent: the deepest element above the first sample that is above them all.
+    const above = samples.map((n) => new Set(chainOf(n).slice(1)));
+    const common = chainOf(samples[0]).slice(1).find((el) => above.every((set) => set.has(el)));
+    if (!common || !chainOf(common).includes(body))
+        return "";
+    const indexIn = (parent, child) => Array.from(parent.children).indexOf(child) + 1;
+    const selectorOf = (el) => (el === body || !el.parentElement ? "html > body" : `${selectorOf(el.parentElement)} > :nth-child(${indexIn(el.parentElement, el)})`);
+    const rule = (parent) => {
+        const keep = Array.from(parent.children).map((child, i) => (kept.has(child) ? `:not(:nth-child(${i + 1}))` : "")).join("");
+        return `${selectorOf(parent)} > :not(style):not(link):not(script)${keep}{display:none!important}`;
+    };
+    const rules = [];
+    if (common === body)
+        rules.push(rule(body));
+    for (let cur = common; cur !== body && cur.parentElement; cur = cur.parentElement)
+        rules.push(rule(cur.parentElement));
+    return rules.join("");
+}
+/** A row's node in the frame; null when the site drew none, or drew the crash placeholder in its place. */
+export function sampleNode(doc, id) {
+    const node = nodesOf(doc).find((n) => n.getAttribute(NODE_ATTR) === id);
+    return node && node.getAttribute(CRASHED_ATTR) === null ? node : null;
+}
+/** Where the crop sits: the node's top in the document (its viewport top plus the frame's scroll) and its height,
+ *  capped at the viewport's (a taller section shows its first screen). Whole pixels. */
+export function sampleBox(node, scrollY) {
+    const rect = node.getBoundingClientRect();
+    return { top: Math.max(0, Math.round(rect.top + scrollY)), height: Math.max(0, Math.min(Math.round(rect.height), SAMPLE_VIEWPORT.height)) };
+}

package/dist/admin/editor/sample-picks.d.ts

@@ -0,0 +1,34 @@
+import type { AdminOps } from "../ops.ts";
+import type { AdminSection } from "../serialize.ts";
+import { type SamplePicks } from "../../sample-fill.ts";
+/** `images: false`: store no image placeholder. `retry`: the call failed for a reason that may pass (the network, a
+ *  session), so the next insert asks again; absent, the answer stands for the editor's life. */
+export type PicksAnswer = {
+    picks: SamplePicks;
+    images: boolean;
+    retry?: true;
+};
+/** One operation call for every collection a top-level reference field of these sections targets. It is made even
+ *  when there are none: the answer is how the admin learns that the service knows the placeholder. */
+export declare function loadPicks(ops: Pick<AdminOps, "entries">, sections: Pick<AdminSection, "fields">[], locale: string): Promise<PicksAnswer>;
+/** One answer per locale for a page editor's life. An answer that may be retried is handed out once and forgotten. */
+export declare function picksCache(): {
+    get(locale: string, load: () => Promise<PicksAnswer>): Promise<PicksAnswer>;
+    /** The answer already in hand, for a caller that cannot wait. */
+    known: (locale: string) => PicksAnswer | undefined;
+};
+/** Where the editor stood when an insert asked for the picks: the page, the locale, which load of the draft, and the
+ *  picker that was clicked (null for a gesture with no modal). */
+export type InsertAsk = {
+    page: string;
+    locale: string;
+    load: number;
+    picker: {
+        zone: string;
+        index: number;
+    } | null;
+};
+/** Whether an insert that waited for the picks may still land (final review 2026-11-14): the same page, locale and
+ *  load, and the picker it was clicked in still open at the same place. An editor who closed the modal, opened
+ *  another, switched page or locale, or left, gets nothing inserted behind their back. */
+export declare const insertStands: (asked: InsertAsk, now: InsertAsk) => boolean;

package/dist/admin/editor/sample-picks.js

@@ -0,0 +1,49 @@
+import { sampleCollections } from "../../sample-fill.js";
+/** One operation call for every collection a top-level reference field of these sections targets. It is made even
+ *  when there are none: the answer is how the admin learns that the service knows the placeholder. */
+export async function loadPicks(ops, sections, locale) {
+    try {
+        const r = await ops.entries.samplePicks(sampleCollections(sections), locale);
+        if (!r.ok)
+            return r.code === "not_found" ? { picks: {}, images: false } : { picks: {}, images: false, retry: true };
+        const picks = {};
+        if (r.data && typeof r.data === "object") {
+            for (const [collection, ids] of Object.entries(r.data)) {
+                if (Array.isArray(ids))
+                    picks[collection] = ids.filter((id) => typeof id === "string");
+            }
+        }
+        return { picks, images: true };
+    }
+    catch {
+        return { picks: {}, images: false, retry: true };
+    }
+}
+/** One answer per locale for a page editor's life. An answer that may be retried is handed out once and forgotten. */
+export function picksCache() {
+    const asked = new Map();
+    const answers = new Map();
+    return {
+        get(locale, load) {
+            let pending = asked.get(locale);
+            if (!pending) {
+                pending = load().then((answer) => {
+                    if (answer.retry)
+                        asked.delete(locale);
+                    else
+                        answers.set(locale, answer);
+                    return answer;
+                });
+                asked.set(locale, pending);
+            }
+            return pending;
+        },
+        /** The answer already in hand, for a caller that cannot wait. */
+        known: (locale) => answers.get(locale),
+    };
+}
+/** Whether an insert that waited for the picks may still land (final review 2026-11-14): the same page, locale and
+ *  load, and the picker it was clicked in still open at the same place. An editor who closed the modal, opened
+ *  another, switched page or locale, or left, gets nothing inserted behind their back. */
+export const insertStands = (asked, now) => asked.page === now.page && asked.locale === now.locale && asked.load === now.load &&
+    (asked.picker === null || (now.picker !== null && now.picker.zone === asked.picker.zone && now.picker.index === asked.picker.index));

package/dist/admin/editor/view-memory.d.ts

@@ -6,4 +6,9 @@ type Storage = {
 };
 export declare function rememberedView(storage?: Storage): EditorViewMode;
 export declare function rememberView(view: EditorViewMode, storage?: Storage): void;
+/** The insert picker's "Insert filled" switch (spec 2026-11-14 filled samples): one setting for the whole browser,
+ *  not per page or zone. On unless the stored value is exactly "0"; a storage that throws leaves it on. */
+export declare const FILLED_KEY = "smoodly-insert-filled";
+export declare function rememberedFilled(storage?: Storage): boolean;
+export declare function rememberFilled(filled: boolean, storage?: Storage): void;
 export {};

package/dist/admin/editor/view-memory.js

@@ -15,3 +15,22 @@ export function rememberView(view, storage) {
         // not remembered — the view still switches
     }
 }
+/** The insert picker's "Insert filled" switch (spec 2026-11-14 filled samples): one setting for the whole browser,
+ *  not per page or zone. On unless the stored value is exactly "0"; a storage that throws leaves it on. */
+export const FILLED_KEY = "smoodly-insert-filled";
+export function rememberedFilled(storage) {
+    try {
+        return (storage ?? window.localStorage).getItem(FILLED_KEY) !== "0";
+    }
+    catch {
+        return true;
+    }
+}
+export function rememberFilled(filled, storage) {
+    try {
+        (storage ?? window.localStorage).setItem(FILLED_KEY, filled ? "1" : "0");
+    }
+    catch {
+        // not remembered — the switch still turns
+    }
+}