pagepilot-visual-editor 1.0.26 → 1.0.27

package/CHANGELOG.md

@@ -6,6 +6,28 @@ adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+## [1.0.27] — 2026-09-21
+
+### Added
+- `render-core/repeatRowManagement.ts`, exported from the `./render` subpath:
+  `reconcileRepeatFieldRowCount(documentTree, field, targetRowCount, growDirection?)`
+  — grows or shrinks a container-repeat field's materialized row-block count
+  (cloning via `addRepeatRow`/growing the container via `growContainerToFit`,
+  or removing trailing row subtrees via `removeSubtree` +
+  `shrinkContainerToFit`) to match a target row count, e.g. so
+  server-side-regenerated HTML can show exactly as many cards as a live API
+  response returned, not just whatever was authored at Save time. Pure port
+  of the editor's `documentUtils.ts` block-tree mutators (`cloneSubtree`,
+  `addRepeatRow`, `removeSubtree`, `growContainerToFit`,
+  `shrinkContainerToFit`, `findRepeatableContainerOf`,
+  `getRepeatableContainerInfo`), rewritten to thread a plain document value
+  instead of the editor's Zustand-backed store — no new dependencies, no
+  editor/MUI imports, safe for the render-only bundle (same precedent as the
+  already-ported `collectSubtreeIds`). Grid's two-axis growth direction has
+  no default encoded in the pure logic (the editor asks the author via
+  `GrowDirectionDialog`); callers must pass `growDirection` explicitly for
+  serve-time use.
+
 ## [1.0.0] — 2026-07-06
 
 Initial public release.

package/dist/render-core/repeatRowManagement.d.ts

@@ -0,0 +1,96 @@
+export type TemplateArrayRow = Record<string, string>;
+/**
+ * Deep-clone a subtree under fresh block ids. Returns the new blocks keyed
+ * by new id, the idMap (oldId → newId) and the new root id. Pure — caller
+ * splices.
+ */
+export declare function cloneSubtree(documentTree: Record<string, any>, rootId: string): {
+    newBlocks: Record<string, any>;
+    idMap: Record<string, string>;
+    newRootId: string;
+};
+export declare function insertDocument(documentTree: Record<string, any>, targetChildId: string, insertedChildId: string): {
+    parentId: string;
+    updatedParent: any;
+} | null;
+/**
+ * Materialize one repeat row: clone the `sourceBlockId` subtree and place
+ * the clone after `afterBlockId` (the previous row's block). Returns the
+ * updated document + the new clone's root id, or `null` when the
+ * container has no room and can't auto-grow (caller decides whether to
+ * grow the container first via `growContainerToFit` and retry).
+ */
+export declare function addRepeatRow(documentTree: Record<string, any>, sourceBlockId: string, afterBlockId: string): {
+    updatedDocument: Record<string, any>;
+    newRootId: string;
+} | null;
+/**
+ * Remove a set of block ids and filter them out of every parent's
+ * child-id arrays. Used to delete a repeat row's cloned container
+ * subtree.
+ */
+export declare function removeSubtree(documentTree: Record<string, any>, idsToRemove: Set<string>): Record<string, any>;
+export type RepeatableSlot = {
+    childrenIds: string[];
+};
+export type RepeatableContainerInfo = {
+    containerId: string;
+    type: "Grid" | "FlexColumns" | "Carousel" | "Marquee" | "Pagination" | "TabsBlock";
+    slotCount: number;
+    slots: RepeatableSlot[];
+    firstFilledSlot: number;
+    emptySlotCount: number;
+};
+export declare function isRepeatableContainerType(type: string | undefined): boolean;
+export declare function getRepeatableContainerInfo(documentTree: Record<string, any>, containerId: string): RepeatableContainerInfo | null;
+/** Find the repeatable container whose slots hold `childId`. */
+export declare function findRepeatableContainerOf(documentTree: Record<string, any>, childId: string): string | null;
+/**
+ * Grow a repeatable container so it has at least `neededSlots` slots.
+ * Grid is the one two-axis case needing a `direction` choice (no default
+ * encoded in the pure logic — there's no human to ask at serve time, so
+ * callers must pass one explicitly). Every other container type ignores
+ * `direction` and grows its single axis. Capped by each block type's
+ * schema max (Carousel 20, Marquee 30, TabsBlock 10) — returns the
+ * unchanged document if the cap is already hit.
+ */
+export declare function growContainerToFit(documentTree: Record<string, any>, containerId: string, neededSlots: number, direction: "rows" | "columns"): Record<string, any>;
+/**
+ * Shrink a repeatable container back down to `neededSlots`. Only trailing
+ * EMPTY slots are dropped — a filled slot always stops the shrink, so
+ * authored content already emptied by a prior `removeSubtree` call is what
+ * actually gets trimmed here, never content that's still in use.
+ */
+export declare function shrinkContainerToFit(documentTree: Record<string, any>, containerId: string, neededSlots: number): Record<string, any>;
+export interface ReconcileRowCountResult {
+    /** Updated document tree (same reference as input if nothing changed). */
+    document: Record<string, any>;
+    /** The field's new sourceBlockId (only ever changes if row 0 itself had to move — in
+     *  practice it never does; kept for symmetry/future-proofing). */
+    sourceBlockId: string;
+    /** The field's new rowIds (one per materialized row beyond row 0). */
+    rowIds: string[];
+    /** How many rows are actually materialized after this call (1 + rowIds.length). */
+    achievedRowCount: number;
+    /** True if `achievedRowCount < targetRowCount` — the container ran out of room
+     *  and could not grow further (e.g. a full non-auto-growing Grid/Carousel/Marquee). */
+    capacityLimited: boolean;
+}
+/**
+ * Reconcile a container-repeat field's materialized row-block count to
+ * exactly `targetRowCount`. Grows by cloning (`addRepeatRow`, growing the
+ * container first via `growContainerToFit` if every slot is already full)
+ * or shrinks by removing trailing rows' subtrees (`removeSubtree` +
+ * `shrinkContainerToFit`). Never touches row 0 (the field's own
+ * `sourceBlockId`) — `targetRowCount` is clamped to at least 1.
+ *
+ * Pure: does not mutate `documentTree`. Fails open in the sense that if
+ * growth runs out of room partway through, it returns whatever was
+ * achieved (`capacityLimited: true`) rather than throwing — callers decide
+ * how to handle a partial reconciliation (e.g. drop the data beyond what
+ * fit, log a warning).
+ */
+export declare function reconcileRepeatFieldRowCount(documentTree: Record<string, any>, field: {
+    sourceBlockId?: string;
+    rowIds?: string[];
+}, targetRowCount: number, growDirection?: "rows" | "columns"): ReconcileRowCountResult | null;