@juo/blocks 1.13.0 → 1.15.0

package/dist/index-JSv6UH_o.js

@@ -0,0 +1,169 @@
+const target = typeof window !== "undefined" ? window : typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : {};
+const isBrowser = typeof window !== "undefined";
+const PROTOCOL_VERSION = 1;
+function isDevtoolsEvent(x) {
+  return typeof x === "object" && x !== null && x.v === PROTOCOL_VERSION && typeof x.kind === "string" && typeof x.ts === "number";
+}
+const HOOK_KEY = "__JUO_BLOCKS_DEVTOOLS_HOOK__";
+function createHook() {
+  const listeners = /* @__PURE__ */ new Set();
+  return {
+    version: PROTOCOL_VERSION,
+    emit(kind, payload) {
+      const event = {
+        v: PROTOCOL_VERSION,
+        kind,
+        ts: Date.now(),
+        payload
+      };
+      listeners.forEach((cb) => cb(event));
+    },
+    on(cb) {
+      listeners.add(cb);
+      return () => listeners.delete(cb);
+    },
+    off(cb) {
+      listeners.delete(cb);
+    }
+  };
+}
+function installHook() {
+  return target[HOOK_KEY] ?? (target[HOOK_KEY] = createHook());
+}
+function getHook() {
+  return target[HOOK_KEY];
+}
+let readDefinedBlocks = () => [];
+function __setDefinedBlocksReader(fn) {
+  readDefinedBlocks = fn;
+}
+const noop = {
+  onBlockRegistered() {
+  },
+  onBlockRendered() {
+  },
+  onBlockUnmounted() {
+  },
+  onContextProvided() {
+  },
+  onContextRequested() {
+  },
+  resolveProps: (block) => block.props ?? {},
+  bindLiveProps: (block) => block.props ?? {}
+};
+function getState(hook) {
+  const holder = hook;
+  return holder.__blockDevtoolsState ?? (holder.__blockDevtoolsState = {
+    instances: /* @__PURE__ */ new Map(),
+    propSetters: /* @__PURE__ */ new Map(),
+    propOverrides: /* @__PURE__ */ new Map()
+  });
+}
+function applyOverride(state, id, props) {
+  const override = state.propOverrides.get(id);
+  return override ? { ...props, ...override } : props;
+}
+function getPropsSchema(type) {
+  var _a;
+  const def = readDefinedBlocks().find((d) => d.name === type);
+  const schema = def == null ? void 0 : def.schema;
+  const props = (_a = schema == null ? void 0 : schema.properties) == null ? void 0 : _a.props;
+  return props && typeof props === "object" ? props : null;
+}
+function createDevtoolsInstrumentation(hook) {
+  const state = getState(hook);
+  const getBlockState = (id) => {
+    const inst = state.instances.get(id);
+    if (!inst) return null;
+    return {
+      props: applyOverride(state, id, inst.props),
+      propsSchema: getPropsSchema(inst.type)
+    };
+  };
+  const setBlockProp = (id, key, value) => {
+    const inst = state.instances.get(id);
+    if (!inst) return null;
+    state.propOverrides.set(id, {
+      ...state.propOverrides.get(id) ?? {},
+      [key]: value
+    });
+    const setter = state.propSetters.get(id);
+    if (setter) {
+      setter(key, value);
+    } else if (inst.el) {
+      inst.el[key] = value;
+    }
+    return { props: applyOverride(state, id, inst.props) };
+  };
+  const getBlockCatalog = () => {
+    const catalog = {};
+    for (const def of readDefinedBlocks()) {
+      catalog[def.name] = def.displayName ?? def.name;
+    }
+    return catalog;
+  };
+  if (!hook.resolvers) {
+    hook.resolvers = { getBlockState, setBlockProp, getBlockCatalog };
+  }
+  return {
+    onBlockRegistered(def) {
+      hook.emit("block:registered", {
+        name: def.name,
+        group: def.group,
+        displayName: def.displayName ?? def.name
+      });
+    },
+    onBlockRendered(block, el) {
+      state.instances.set(block.id, {
+        type: block.type,
+        props: block.props ?? {},
+        el
+      });
+      hook.emit("block:mounted", {
+        id: block.id,
+        type: block.type,
+        slot: null,
+        parentId: null,
+        propKeys: Object.keys(block.props ?? {})
+      });
+    },
+    onBlockUnmounted(id) {
+      state.instances.delete(id);
+      state.propSetters.delete(id);
+      state.propOverrides.delete(id);
+      hook.emit("block:unmounted", { id });
+    },
+    onContextProvided(context) {
+      hook.emit("context:provide", { context: String(context) });
+    },
+    onContextRequested(context) {
+      hook.emit("context:request", { context: String(context) });
+    },
+    resolveProps(block) {
+      return applyOverride(state, block.id, block.props ?? {});
+    },
+    bindLiveProps(block, rerender, getBaseProps = () => block.props ?? {}) {
+      state.propSetters.set(block.id, () => {
+        rerender(applyOverride(state, block.id, getBaseProps()));
+      });
+      return applyOverride(state, block.id, block.props ?? {});
+    }
+  };
+}
+function getInstrumentation() {
+  const hook = getHook();
+  if (!hook) return noop;
+  const holder = hook;
+  return holder.__instrumentation ?? (holder.__instrumentation = createDevtoolsInstrumentation(hook));
+}
+export {
+  PROTOCOL_VERSION as P,
+  __setDefinedBlocksReader as _,
+  getHook as a,
+  isBrowser as b,
+  createHook as c,
+  isDevtoolsEvent as d,
+  getInstrumentation as g,
+  installHook as i,
+  target as t
+};

package/dist/layout/css-runtime.d.ts

@@ -0,0 +1,41 @@
+import { LayoutDocument } from './types';
+/** Attribute that scopes a runtime grid container's generated stylesheet. */
+export declare const LAYOUT_SCOPE_ATTR = "data-juo-layout";
+/** CSS attribute selector for a given grid scope id. */
+export declare function layoutScopeSelector(scopeId: string): string;
+/**
+ * Build the scoped CSS Grid stylesheet for a layout, reconciled against the
+ * block ids actually being rendered (prune orphans / autofill unplaced).
+ * Pure: no DOM access.
+ */
+export declare function buildLayoutCss(layout: LayoutDocument, blockIds: string[], scopeId: string): string;
+export type GridLayoutRuntime = {
+    css: string;
+    /**
+     * Leader block ids (leftmost block of each divider row) — draw the full-width
+     * bare-style divider line above their row.
+     */
+    dividerBlockIds: Set<string>;
+    /**
+     * Every block on a divider row — get the extra divider-row spacing so the gap
+     * grows (gap | divider | gap) only where a divider is drawn.
+     */
+    dividerRowBlockIds: Set<string>;
+    /**
+     * Blocks with the sticky `fill` flag set. Used to reflect the "fill" toggle's
+     * active/pressed state onto the block wrapper chrome (only the block the
+     * merchant filled — never its neighbours).
+     */
+    fullWidthBlockIds: Set<string>;
+};
+/**
+ * Reconcile layout, emit scoped CSS, and classify bare-style row dividers in
+ * one pass (avoids double reconciliation in ExtensionRoot).
+ *
+ * Empty-block collapse is handled entirely in CSS (see `collapseRule` in
+ * project-css): an empty block sets `display:none` and, because row spacing is a
+ * per-item bottom margin rather than row-gap, its row closes up with no ghost
+ * gap — no runtime re-projection needed.
+ */
+export declare function buildGridLayout(layout: LayoutDocument, blockIds: string[], scopeId: string): GridLayoutRuntime;
+//# sourceMappingURL=css-runtime.d.ts.map

package/dist/layout/css-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"css-runtime.d.ts","sourceRoot":"","sources":["../../src/layout/css-runtime.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE9C,6EAA6E;AAC7E,eAAO,MAAM,iBAAiB,oBAAoB,CAAC;AAEnD,wDAAwD;AACxD,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAE3D;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,cAAc,EACtB,QAAQ,EAAE,MAAM,EAAE,EAClB,OAAO,EAAE,MAAM,GACd,MAAM,CAMR;AAED,MAAM,MAAM,iBAAiB,GAAG;IAC9B,GAAG,EAAE,MAAM,CAAC;IACZ;;;OAGG;IACH,eAAe,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC7B;;;OAGG;IACH,kBAAkB,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAChC;;;;OAIG;IACH,iBAAiB,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CAChC,CAAC;AAEF;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,cAAc,EACtB,QAAQ,EAAE,MAAM,EAAE,EAClB,OAAO,EAAE,MAAM,GACd,iBAAiB,CAsBnB"}

package/dist/layout/css-runtime.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=css-runtime.test.d.ts.map

package/dist/layout/css-runtime.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"css-runtime.test.d.ts","sourceRoot":"","sources":["../../src/layout/css-runtime.test.ts"],"names":[],"mappings":""}

package/dist/layout/derive.d.ts

@@ -0,0 +1,4 @@
+import { BreakpointDef, LayoutDocument, LayoutForBreakpoint } from './types';
+export declare function deriveLayout(base: LayoutForBreakpoint, target: BreakpointDef): LayoutForBreakpoint;
+export declare function resolveLayout(doc: LayoutDocument, breakpointId: string): LayoutForBreakpoint;
+//# sourceMappingURL=derive.d.ts.map

package/dist/layout/derive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"derive.d.ts","sourceRoot":"","sources":["../../src/layout/derive.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAY,cAAc,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAE5F,wBAAgB,YAAY,CAC1B,IAAI,EAAE,mBAAmB,EACzB,MAAM,EAAE,aAAa,GACpB,mBAAmB,CAWrB;AAED,wBAAgB,aAAa,CAC3B,GAAG,EAAE,cAAc,EACnB,YAAY,EAAE,MAAM,GACnB,mBAAmB,CAYrB"}

package/dist/layout/derive.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=derive.test.d.ts.map

package/dist/layout/derive.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"derive.test.d.ts","sourceRoot":"","sources":["../../src/layout/derive.test.ts"],"names":[],"mappings":""}

package/dist/layout/dividers.d.ts

@@ -0,0 +1,34 @@
+import { GridRect } from './types';
+export type RowDividerClassification = {
+    /**
+     * Leftmost block (reading order) of each divider row — draws the full-width
+     * horizontal divider line above its row. A subset of `rowBlockIds`.
+     */
+    leaderBlockIds: Set<string>;
+    /**
+     * Every block belonging to a divider row. These receive the extra
+     * divider-row spacing (a top margin) so the boundary grows to
+     * gap | divider | gap ONLY where a divider is actually drawn — boundaries
+     * without a divider keep the regular single row-gap. Tagging all members
+     * (not just the leader) keeps side-by-side blocks on the same row aligned.
+     */
+    rowBlockIds: Set<string>;
+};
+/**
+ * Classify "divider rows": grid rows below the first whose top boundary is a
+ * clean full-width break (not crossed by any spanning block). Such a boundary
+ * gets a horizontal divider line plus extra breathing room.
+ *
+ * Rules:
+ *   1. The first row is never a divider row (no divider above the content top).
+ *   2. If any block spans across a row boundary (a tall block with
+ *      `r < boundary < r + h`), that boundary is NOT a clean break — drawing a
+ *      full-width line there would slice through the spanning block, and the
+ *      rows beside it should read as a single band. Such rows are skipped, so
+ *      they keep the regular gap with no divider (e.g. a tall "Upcoming items"
+ *      next to a stacked "Upcoming renewal" / "Subscription notifications").
+ *   3. Only the leftmost block of a divider row leads the line (drawn once,
+ *      full canvas width); every block on that row gets the spacing margin.
+ */
+export declare function classifyRowDividers(items: Record<string, GridRect>, blockIds: readonly string[]): RowDividerClassification;
+//# sourceMappingURL=dividers.d.ts.map

package/dist/layout/dividers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dividers.d.ts","sourceRoot":"","sources":["../../src/layout/dividers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAExC,MAAM,MAAM,wBAAwB,GAAG;IACrC;;;OAGG;IACH,cAAc,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC5B;;;;;;OAMG;IACH,WAAW,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CAC1B,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,EAC/B,QAAQ,EAAE,SAAS,MAAM,EAAE,GAC1B,wBAAwB,CA8B1B"}

package/dist/layout/dividers.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=dividers.test.d.ts.map

package/dist/layout/dividers.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dividers.test.d.ts","sourceRoot":"","sources":["../../src/layout/dividers.test.ts"],"names":[],"mappings":""}

package/dist/layout/engine.d.ts

@@ -0,0 +1,3 @@
+import { LayoutEngine } from './types';
+export declare const gridV1Engine: LayoutEngine;
+//# sourceMappingURL=engine.d.ts.map

package/dist/layout/engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../../src/layout/engine.ts"],"names":[],"mappings":"AAMA,OAAO,EAEL,KAAK,YAAY,EAElB,MAAM,SAAS,CAAC;AAEjB,eAAO,MAAM,YAAY,EAAE,YAiG1B,CAAC"}

package/dist/layout/engine.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=engine.test.d.ts.map

package/dist/layout/engine.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.test.d.ts","sourceRoot":"","sources":["../../src/layout/engine.test.ts"],"names":[],"mappings":""}

package/dist/layout/grid-utils.d.ts

@@ -0,0 +1,57 @@
+import { GridRect } from './types';
+export declare function clampRect(rect: GridRect, cols: number): GridRect;
+export declare function rectsOverlap(a: GridRect, b: GridRect): boolean;
+export declare function readingOrder(items: Record<string, GridRect>): string[];
+/**
+ * Compact items with GridStack `float:false` gravity: pull every block up as
+ * far as it fits, preserving its column (`c`) and size (`w`/`h`), in reading
+ * order (row then column). This:
+ *  - removes vertical gaps (e.g. left behind by a deleted block), and
+ *  - resolves overlaps (e.g. after a block is stretched to full width over its
+ *    row-mates) by pushing later blocks down instead of letting them overlay.
+ *
+ * The result is deterministic and idempotent for an already-compact layout, so
+ * it matches what layout mode (GridStack) shows and is safe to re-run.
+ */
+export declare function compactItems(items: Record<string, GridRect>, cols: number): Record<string, GridRect>;
+/**
+ * Compute the free horizontal span available to `target` within its row band
+ * (the rows it vertically overlaps), given the other blocks in `items`.
+ *
+ *  - `left`  = the right edge (c + w) of the nearest block sitting to the left of
+ *    `target` in the same band, or 0 if none.
+ *  - `right` = the left edge (c) of the nearest block sitting to the right of
+ *    `target` in the same band, or `cols` if none.
+ *
+ * Blocks that don't share any row with `target`, and the target itself
+ * (`target.id` compared via reference is not possible here, so pass `excludeId`),
+ * are ignored. This defines the maximum width a block can grow to WITHOUT moving
+ * any neighbour — the basis for the "fill" toggle.
+ */
+export declare function rowBandBounds(items: Record<string, GridRect>, target: GridRect, cols: number, excludeId?: string): {
+    left: number;
+    right: number;
+};
+/**
+ * Re-apply every sticky `fill` block's layout. Fill blocks that share a row band
+ * and the same free segment (the span between the non-fill blocks that bound
+ * them) split that segment EQUALLY, laid left→right in reading order. As a
+ * neighbour is stretched the segment shrinks and the fill blocks squeeze down
+ * together; once a block's equal share would fall below the minimum width
+ * (`ceil(cols / MAX_BLOCKS_PER_ROW)`) it can no longer squeeze, so the overflow
+ * blocks wrap to their own fresh full-width rows below the band.
+ *
+ * When nothing overflows, non-fill blocks are never moved and no compaction runs
+ * — fill only ever consumes empty columns in place, so it can't create overlaps.
+ * When a block wraps, the layout is compacted so the vacated/added rows close up.
+ *
+ * Run after any mutation (drag, delete, resize, reflow) so filled blocks reclaim
+ * the space a neighbour vacates and re-equalise as row-mates come and go.
+ */
+export declare function applyFillExpansion(items: Record<string, GridRect>, cols: number): Record<string, GridRect>;
+/** Finds the first free cell scanning rows top-to-bottom, columns left-to-right. @param cols must be >= 1. */
+export declare function findFreeRect(items: Record<string, GridRect>, size: {
+    w: number;
+    h: number;
+}, cols: number): GridRect;
+//# sourceMappingURL=grid-utils.d.ts.map

package/dist/layout/grid-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grid-utils.d.ts","sourceRoot":"","sources":["../../src/layout/grid-utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,KAAK,QAAQ,EAAE,MAAM,SAAS,CAAC;AAY5D,wBAAgB,SAAS,CAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,GAAG,QAAQ,CAOhE;AAED,wBAAgB,YAAY,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,GAAG,OAAO,CAO9D;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,GAAG,MAAM,EAAE,CAOtE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,EAC/B,IAAI,EAAE,MAAM,GACX,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAe1B;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,EAC/B,MAAM,EAAE,QAAQ,EAChB,IAAI,EAAE,MAAM,EACZ,SAAS,CAAC,EAAE,MAAM,GACjB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAejC;AAmCD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,EAC/B,IAAI,EAAE,MAAM,GACX,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CA6E1B;AAED,8GAA8G;AAC9G,wBAAgB,YAAY,CAC1B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,EAC/B,IAAI,EAAE;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,EAC9B,IAAI,EAAE,MAAM,GACX,QAAQ,CAYV"}

package/dist/layout/grid-utils.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=grid-utils.test.d.ts.map

package/dist/layout/grid-utils.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grid-utils.test.d.ts","sourceRoot":"","sources":["../../src/layout/grid-utils.test.ts"],"names":[],"mappings":""}

package/dist/layout/index.d.ts

@@ -0,0 +1,13 @@
+export type { BreakpointId, GridRect, GridConfig, ContainerQuery, BreakpointDef, LayoutForBreakpoint, LayoutDocument, GridCtx, LayoutCommand, LayoutEngine, LayoutEngineId, } from './types';
+export { GRID_V1_ENGINE_ID, DEFAULT_GRID, DEFAULT_BREAKPOINTS, PAGE_ROOT_SLOT, } from './types';
+export { clampRect, rectsOverlap, readingOrder, findFreeRect, compactItems, } from './grid-utils';
+export { gridV1Engine } from './engine';
+export { deriveLayout, resolveLayout } from './derive';
+export { resetBreakpoint } from './override';
+export { projectToCss } from './project-css';
+export { projectToGridStack, type GridStackProjection, type GridStackWidgetProjection, } from './project-gridstack';
+export { createDefaultLayoutDocument, reconcileLayout, compactLayoutDocument, expandFillLayoutDocument, } from './reconcile';
+export { classifyRowDividers, type RowDividerClassification, } from './dividers';
+export { DEFAULT_NEW_BLOCK_HEIGHT, insertRectRelative, type InsertPosition, } from './insert';
+export { LAYOUT_SCOPE_ATTR, layoutScopeSelector, buildLayoutCss, buildGridLayout, type GridLayoutRuntime, } from './css-runtime';
+//# sourceMappingURL=index.d.ts.map

package/dist/layout/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/layout/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,YAAY,EACZ,QAAQ,EACR,UAAU,EACV,cAAc,EACd,aAAa,EACb,mBAAmB,EACnB,cAAc,EACd,OAAO,EACP,aAAa,EACb,YAAY,EACZ,cAAc,GACf,MAAM,SAAS,CAAC;AACjB,OAAO,EACL,iBAAiB,EACjB,YAAY,EACZ,mBAAmB,EACnB,cAAc,GACf,MAAM,SAAS,CAAC;AACjB,OAAO,EACL,SAAS,EACT,YAAY,EACZ,YAAY,EACZ,YAAY,EACZ,YAAY,GACb,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AACxC,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AACvD,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAC7C,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAC7C,OAAO,EACL,kBAAkB,EAClB,KAAK,mBAAmB,EACxB,KAAK,yBAAyB,GAC/B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,2BAA2B,EAC3B,eAAe,EACf,qBAAqB,EACrB,wBAAwB,GACzB,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,mBAAmB,EACnB,KAAK,wBAAwB,GAC9B,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,wBAAwB,EACxB,kBAAkB,EAClB,KAAK,cAAc,GACpB,MAAM,UAAU,CAAC;AAClB,OAAO,EACL,iBAAiB,EACjB,mBAAmB,EACnB,cAAc,EACd,eAAe,EACf,KAAK,iBAAiB,GACvB,MAAM,eAAe,CAAC"}

package/dist/layout/index.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.test.d.ts.map

package/dist/layout/index.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.test.d.ts","sourceRoot":"","sources":["../../src/layout/index.test.ts"],"names":[],"mappings":""}

package/dist/layout/insert.d.ts

@@ -0,0 +1,34 @@
+import { LayoutDocument } from './types';
+export type InsertPosition = "before" | "after";
+/**
+ * Default height (in row units) for a freshly added block. `1` row (= rowUnit,
+ * 40px by default) is too short for the layout-mode skeleton's icon + name +
+ * lines and clips the label, so new blocks start a few rows tall. The merchant
+ * can still resize down in layout mode.
+ */
+export declare const DEFAULT_NEW_BLOCK_HEIGHT = 4;
+/**
+ * Insert a rect for `blockId` adjacent to `targetId` in EVERY stored breakpoint
+ * of `doc`, so a block added via the editor's add buttons lands directly
+ * above/below the block it was added relative to — not at the end of the grid —
+ * in each viewport (desktop and an independent `layouts.mobile` alike).
+ *
+ * Within each breakpoint the new block inherits that breakpoint's target column
+ * (`c`) and width (`w`), so it appears in the same lane the user added it from
+ * (full-width when the target is full-width; the single mobile lane on a cols:1
+ * breakpoint). Every block at or below the insertion row is shifted down by the
+ * new block's height so reading order is preserved regardless of GridStack's
+ * compaction. Because each breakpoint uses its own target rect, the desktop and
+ * mobile orders stay independent.
+ *
+ * Returns a NEW document; the input is never mutated. Breakpoints whose layout
+ * doesn't contain the target (not reconciled yet, or derived-on-demand) are
+ * skipped; if no breakpoint contains it the document is returned unchanged and
+ * `reconcileLayout` falls back to its default end-of-grid placement.
+ */
+export declare function insertRectRelative(doc: LayoutDocument, args: {
+    blockId: string;
+    targetId: string;
+    position: InsertPosition;
+}): LayoutDocument;
+//# sourceMappingURL=insert.d.ts.map

package/dist/layout/insert.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"insert.d.ts","sourceRoot":"","sources":["../../src/layout/insert.ts"],"names":[],"mappings":"AACA,OAAO,EAAgB,KAAK,cAAc,EAAE,MAAM,SAAS,CAAC;AAE5D,MAAM,MAAM,cAAc,GAAG,QAAQ,GAAG,OAAO,CAAC;AAEhD;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB,IAAI,CAAC;AAE1C;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,kBAAkB,CAChC,GAAG,EAAE,cAAc,EACnB,IAAI,EAAE;IACJ,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,cAAc,CAAC;CAC1B,GACA,cAAc,CAgChB"}

package/dist/layout/insert.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=insert.test.d.ts.map

package/dist/layout/insert.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"insert.test.d.ts","sourceRoot":"","sources":["../../src/layout/insert.test.ts"],"names":[],"mappings":""}

package/dist/layout/override.d.ts

@@ -0,0 +1,10 @@
+import { LayoutDocument } from './types';
+/**
+ * Couple a non-base breakpoint back to desktop: drop its stored layout so it
+ * follows the base breakpoint again. All-or-nothing.
+ *
+ * No-op when the breakpoint is the base (never delete the authored layout) or
+ * when nothing is stored for it. Never mutates the input document.
+ */
+export declare function resetBreakpoint(doc: LayoutDocument, breakpointId: string): LayoutDocument;
+//# sourceMappingURL=override.d.ts.map

package/dist/layout/override.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"override.d.ts","sourceRoot":"","sources":["../../src/layout/override.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE9C;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC7B,GAAG,EAAE,cAAc,EACnB,YAAY,EAAE,MAAM,GACnB,cAAc,CAQhB"}

package/dist/layout/override.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=override.test.d.ts.map

package/dist/layout/override.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"override.test.d.ts","sourceRoot":"","sources":["../../src/layout/override.test.ts"],"names":[],"mappings":""}

package/dist/layout/project-css.d.ts

@@ -0,0 +1,6 @@
+import { LayoutDocument } from './types';
+export declare function projectToCss(doc: LayoutDocument, opts: {
+    scope: string;
+    domOrder?: string[];
+}): string;
+//# sourceMappingURL=project-css.d.ts.map

package/dist/layout/project-css.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-css.d.ts","sourceRoot":"","sources":["../../src/layout/project-css.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAwB,cAAc,EAAuB,MAAM,SAAS,CAAC;AAwOzF,wBAAgB,YAAY,CAC1B,GAAG,EAAE,cAAc,EACnB,IAAI,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;CAAE,GAC3C,MAAM,CAqBR"}

package/dist/layout/project-css.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=project-css.test.d.ts.map

package/dist/layout/project-css.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-css.test.d.ts","sourceRoot":"","sources":["../../src/layout/project-css.test.ts"],"names":[],"mappings":""}

package/dist/layout/project-gridstack.d.ts

@@ -0,0 +1,50 @@
+import { LayoutDocument } from './types';
+export { MAX_BLOCKS_PER_ROW } from './types';
+/**
+ * Minimum height (in row units) the merchant may resize a block to in layout
+ * mode. Below this the layout-mode skeleton's icon + name label gets clipped
+ * and the block becomes unidentifiable, so we floor the resize handle here
+ * (enforced via GridStack's per-widget `minH`).
+ */
+export declare const MIN_BLOCK_ROWS = 2;
+/**
+ * Minimum width (in CSS px) the merchant may resize a block to in layout mode.
+ * Sized so a block can shrink to a third of the grid (≈4 of 12 columns) at
+ * realistic canvas widths, letting three blocks sit alongside each other — the
+ * previous 320px "mobile block" floor forced blocks to ~half the grid, capping
+ * a row at two. Columns are a fraction of the grid width, so this is converted
+ * to a per-widget `minW` (column count) by the adapter, which is the only place
+ * that knows the live pixel width.
+ */
+export declare const MIN_BLOCK_PX = 200;
+export type GridStackWidgetProjection = {
+    id: string;
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    minH: number;
+    /** True when the block already fills the free span of its row band. */
+    filled: boolean;
+};
+export type GridStackProjection = {
+    options: {
+        column: number;
+        cellHeight: number;
+        margin: number;
+        float: boolean;
+        sizeToContent: boolean;
+    };
+    widgets: GridStackWidgetProjection[];
+};
+/**
+ * Resolve which breakpoint a container of `containerWidthPx` renders, mirroring
+ * the CSS `@container (max-width:N)` cascade in `project-css.ts`: start at the
+ * base (widest) breakpoint and let each narrower breakpoint whose `maxWidth`
+ * query matches override it (document order = widest→narrowest, so the last
+ * match — the narrowest applicable — wins). Returns the base id when the width
+ * can't be measured (0 / jsdom), so layout mode defaults to desktop.
+ */
+export declare function resolveActiveBreakpoint(doc: LayoutDocument, containerWidthPx: number): string;
+export declare function projectToGridStack(doc: LayoutDocument, breakpointId: string): GridStackProjection;
+//# sourceMappingURL=project-gridstack.d.ts.map

package/dist/layout/project-gridstack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-gridstack.d.ts","sourceRoot":"","sources":["../../src/layout/project-gridstack.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE9C,OAAO,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAE7C;;;;;GAKG;AACH,eAAO,MAAM,cAAc,IAAI,CAAC;AAEhC;;;;;;;;GAQG;AACH,eAAO,MAAM,YAAY,MAAM,CAAC;AAEhC,MAAM,MAAM,yBAAyB,GAAG;IACtC,EAAE,EAAE,MAAM,CAAC;IACX,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,IAAI,EAAE,MAAM,CAAC;IACb,uEAAuE;IACvE,MAAM,EAAE,OAAO,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,OAAO,EAAE;QACP,MAAM,EAAE,MAAM,CAAC;QACf,UAAU,EAAE,MAAM,CAAC;QACnB,MAAM,EAAE,MAAM,CAAC;QACf,KAAK,EAAE,OAAO,CAAC;QACf,aAAa,EAAE,OAAO,CAAC;KACxB,CAAC;IACF,OAAO,EAAE,yBAAyB,EAAE,CAAC;CACtC,CAAC;AAEF;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CACrC,GAAG,EAAE,cAAc,EACnB,gBAAgB,EAAE,MAAM,GACvB,MAAM,CAQR;AAED,wBAAgB,kBAAkB,CAChC,GAAG,EAAE,cAAc,EACnB,YAAY,EAAE,MAAM,GACnB,mBAAmB,CAgCrB"}

package/dist/layout/project-gridstack.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=project-gridstack.test.d.ts.map

package/dist/layout/project-gridstack.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-gridstack.test.d.ts","sourceRoot":"","sources":["../../src/layout/project-gridstack.test.ts"],"names":[],"mappings":""}

package/dist/layout/reconcile.d.ts

@@ -0,0 +1,23 @@
+import { LayoutDocument } from './types';
+export declare function createDefaultLayoutDocument(blockIds: string[]): LayoutDocument;
+export declare function reconcileLayout(doc: LayoutDocument | null | undefined, blockIds: string[]): LayoutDocument;
+/**
+ * Compact the base (authored) breakpoint of a layout document with
+ * `float:false` gravity (see `compactItems`). Used after mutations that can
+ * leave the settled CSS-grid view out of sync with the GridStack model — most
+ * notably deleting a block (which otherwise leaves a vertical gap) or stretching
+ * one to full width (which otherwise overlays its row-mates). Runs on every
+ * stored breakpoint so an independent `layouts.mobile` compacts too; absent
+ * (derived) breakpoints are untouched.
+ */
+export declare function compactLayoutDocument(doc: LayoutDocument | null | undefined): LayoutDocument | null | undefined;
+/**
+ * Re-apply sticky `fill` expansion to the base (authored) breakpoint of a layout
+ * document (see `applyFillExpansion`). Mutations routed through the block tree
+ * (e.g. deleting or adding a block) reconcile + compact the layout but do NOT go
+ * through the grid engine's command pipeline, so without this a fill block never
+ * reclaims the columns a deleted row-mate vacates. Kept document-level to mirror
+ * `compactLayoutDocument` and run right after it, across every stored breakpoint.
+ */
+export declare function expandFillLayoutDocument(doc: LayoutDocument | null | undefined): LayoutDocument | null | undefined;
+//# sourceMappingURL=reconcile.d.ts.map

package/dist/layout/reconcile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reconcile.d.ts","sourceRoot":"","sources":["../../src/layout/reconcile.ts"],"names":[],"mappings":"AACA,OAAO,EAKL,KAAK,cAAc,EAEpB,MAAM,SAAS,CAAC;AAEjB,wBAAgB,2BAA2B,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,cAAc,CAa9E;AAmCD,wBAAgB,eAAe,CAC7B,GAAG,EAAE,cAAc,GAAG,IAAI,GAAG,SAAS,EACtC,QAAQ,EAAE,MAAM,EAAE,GACjB,cAAc,CA0ChB;AAED;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CACnC,GAAG,EAAE,cAAc,GAAG,IAAI,GAAG,SAAS,GACrC,cAAc,GAAG,IAAI,GAAG,SAAS,CAYnC;AAED;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CACtC,GAAG,EAAE,cAAc,GAAG,IAAI,GAAG,SAAS,GACrC,cAAc,GAAG,IAAI,GAAG,SAAS,CAYnC"}

package/dist/layout/reconcile.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=reconcile.test.d.ts.map

package/dist/layout/reconcile.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reconcile.test.d.ts","sourceRoot":"","sources":["../../src/layout/reconcile.test.ts"],"names":[],"mappings":""}