efficient-easel 0.101.1 → 0.103.0

package/dist/screen/lib/puck/use-section-ops.d.ts

@@ -0,0 +1,86 @@
+import { Data } from '../../../blocks/index.js';
+import { TreeItem } from './content-tree.js';
+import 'react';
+import '../../../types-E3HrTPg2.js';
+import '../../../data/index.js';
+import '../../../types-41704JE4.js';
+import '../../../resolve-D68pb3Bx.js';
+import '../../../plan-DChbUXdS.js';
+
+type NodeSelector = {
+    index: number;
+    zone?: string;
+} | null;
+type ComponentData = TreeItem;
+type SectionOps = {
+    /** Insert a component into a zone at an index; returns the generated id. */
+    insertComponent: (zone: string, type: string, index: number) => string;
+    /** Insert into ROOT_ZONE (top-level section); returns the generated id. */
+    insertSection: (type: string, index: number) => string;
+    /** Atomically replace the node at (zone, index) — heal, reseed, hide toggle. */
+    replaceComponent: (zone: string, index: number, data: ComponentData) => void;
+    /** Seed a freshly-inserted slot child's props (insert THEN replace at a stable id). */
+    seedChild: (zone: string, index: number, childType: string, props: Record<string, unknown>) => void;
+    /**
+     * Insert a FULL node — type + props, including inline slot children — at
+     * (zone, index); returns its id. The same insert-then-replace pattern as
+     * seedChild, one level up: how a saved section template lands in a page.
+     * Callers pass a node whose ids are already fresh (cloneNodeWithFreshIds).
+     */
+    insertNode: (zone: string, index: number, node: TreeItem) => string;
+    /** Remove the node at (zone, index). A normal dispatch, so Undo restores it. */
+    removeComponent: (zone: string, index: number) => void;
+    /**
+     * Move the node at (zone, sourceIndex) to destinationIndex WITHIN THE SAME
+     * zone. `destinationIndex` is the node's final resting index in the array
+     * (Puck's `reorder` reducer splices it out then back in), so a caller moving a
+     * node DOWN must account for the one-slot shift itself.
+     */
+    reorderComponent: (zone: string, sourceIndex: number, destinationIndex: number) => void;
+    /** Duplicate the node at (zone, index). */
+    duplicateComponent: (zone: string, index: number) => void;
+    /** Set (or clear) the Puck selection by index-based address. */
+    select: (selector: NodeSelector) => void;
+    /** Replace the whole working document (used by Reset). */
+    setDocument: (data: Data) => void;
+    /**
+     * Write the next document as ONE undo step — the commit behind the block
+     * operations (`efficient-easel/node-ops`, blueprint step 2.4b: the menu's
+     * Delete, Duplicate, Move, Copy / Cut / Paste and Hide, and the rows'
+     * hover-delete). Each of those is planned whole and lands here once, instead
+     * of the two or three dispatches it used to be.
+     *
+     * Recorded in Puck's history on purpose (`setData` is not, by default), and
+     * handed a FUNCTION: the object form logs "`setData` is expensive" on every
+     * call, and both rebuild Puck's index the same way. Behind the read-only gate
+     * like every other mutation here.
+     */
+    commitDocument: (data: Data) => void;
+};
+type SectionOpsOptions = {
+    /**
+     * SOMEBODY ELSE holds the open document: every MUTATION below becomes a no-op.
+     *
+     * This is the one place the editor's read-only state is enforced on the
+     * document, and it is here rather than on each button because this hook is
+     * already the single source of truth for every mutation — the tree rows, the
+     * canvas "+" seams, the inspector head buttons and the lifecycle effects all
+     * come through it. A gate on the buttons would be a gate on the ones somebody
+     * remembered.
+     *
+     * `select` and `setUi` are NOT mutations and stay live: a read-only viewer must
+     * still be able to click a section and read its settings.
+     *
+     * Deliberately keyed on "somebody else has it" and NOT on the wider save gate.
+     * The save gate is also false while the lock claim is still `checking`, and the
+     * pinned Header/Footer seed runs in the chrome's mount commit, inside that
+     * window, through these very ops. Its WRITE is what is held there — by
+     * `onChange`, released by the claim if it is granted — so the seed must be
+     * allowed to lay the node down (card 1096). Blocking it here would silently
+     * un-fix that card.
+     */
+    readOnly?: boolean;
+};
+declare function useSectionOps(options?: SectionOpsOptions): SectionOps;
+
+export { type NodeSelector, type SectionOps, type SectionOpsOptions, useSectionOps };

package/dist/screen/lib/puck/use-section-ops.js

@@ -0,0 +1 @@
+export{useSectionOps}from"../../../chunk-VV5ADNBR.js";import"../../../chunk-FUDHI5I4.js";import"../../../chunk-P67FP7PG.js";import"../../../chunk-AELNNAFM.js";import"../../../chunk-YRLPFZW3.js";import"../../../chunk-D2BCHTQR.js";import"../../../chunk-MFIRYGHW.js";import"../../../chunk-ZNCEOSXO.js";import"../../../chunk-KRXQM65X.js";import"../../../chunk-NKB3KVAB.js";