@juo/blocks 1.15.0 → 2.0.0-alpha.1

package/dist/css-runtime-B7tZrBIp.js

@@ -0,0 +1,749 @@
+import { e as createContext, f as d, E, r, g as createBlockInstanceFromObject, h as createBlockInstance, j as getDefinedBlocks, k as serializeBlocks, l as setLayoutSystemEnabled, o as onRegisterBlock } from "./block-BjJztStr.js";
+import { reportBlockError } from "./observability.js";
+const DEFAULT_GLOBAL_STYLES = {
+  volume: "comfort",
+  style: "ghost",
+  corners: "round",
+  buttonCorners: "round",
+  thumbnailCorners: "circle",
+  theme: "preset",
+  themeType: "neutral",
+  colors: {
+    accent: "#000000",
+    secondary: "#000000",
+    tint: "#111111",
+    callout: "#F5F5F5",
+    success: "#287a25",
+    error: "#a93c3c",
+    information: "#0075a3",
+    warning: "#8a5e00",
+    background: "#FFFFFF"
+  }
+};
+const ThemeStateContext = createContext("theme-state");
+function normalizeLocale(locale) {
+  return locale.trim().toLowerCase().split("-")[0] || "en";
+}
+function toStringRecord$1(input) {
+  if (input == null) return {};
+  return Object.fromEntries(
+    Object.entries(input).filter(([, value]) => typeof value === "string")
+  );
+}
+function parseBlockLocaleFile(file) {
+  if (file == null) {
+    return { defaults: {}, modes: {} };
+  }
+  const entries = Object.entries(file).filter(
+    ([key, value]) => key !== "overrides" && typeof value === "string"
+  );
+  const topLevel = Object.fromEntries(entries);
+  const overrides = toStringRecord$1(file.overrides);
+  return {
+    defaults: { ...topLevel, ...overrides },
+    modes: {
+      ...Object.fromEntries(
+        Object.keys(topLevel).map((key) => [key, "default"])
+      ),
+      ...Object.fromEntries(
+        Object.keys(overrides).map((key) => [key, "override"])
+      )
+    }
+  };
+}
+function indexOverrides(overrides) {
+  const indexed = {
+    theme: {},
+    blocks: {}
+  };
+  for (const item of overrides) {
+    if (item.scope.kind === "theme") {
+      indexed.theme[item.key] = item.value;
+      continue;
+    }
+    if (indexed.blocks[item.scope.blockId] == null) {
+      indexed.blocks[item.scope.blockId] = {};
+    }
+    indexed.blocks[item.scope.blockId][item.key] = item.value;
+  }
+  return indexed;
+}
+function createThemeState(deps) {
+  var _a;
+  const surfaces = {
+    page: {
+      blocks: d([]),
+      layout: d(null)
+    },
+    overlay: {
+      blocks: d([]),
+      layout: d(null)
+    }
+  };
+  const locale = d("en");
+  const catalogs = d(null);
+  const globalStyles = d(
+    deps.initialGlobalStyles ?? DEFAULT_GLOBAL_STYLES
+  );
+  function setGlobalStyles(styles) {
+    globalStyles.value = styles;
+  }
+  function setInstanceTranslationOverride(blockId, key, value) {
+    const current = catalogs.value;
+    if (current == null) return;
+    catalogs.value = {
+      ...current,
+      blocks: {
+        ...current.blocks,
+        overrides: {
+          ...current.blocks.overrides,
+          [blockId]: { ...current.blocks.overrides[blockId], [key]: value }
+        }
+      }
+    };
+  }
+  E(() => {
+    setLayoutSystemEnabled(globalStyles.value.layoutEngine === "grid-v1");
+  });
+  async function collectBlockDefaults(loc) {
+    const nextDefaults = {};
+    const nextModes = {};
+    for (const block of getDefinedBlocks()) {
+      if (block.locales == null) continue;
+      let file = null;
+      try {
+        file = await block.locales.load(loc);
+      } catch {
+        file = null;
+      }
+      const parsed = parseBlockLocaleFile(file);
+      nextDefaults[block.name] = parsed.defaults;
+      nextModes[block.name] = parsed.modes;
+    }
+    return { defaults: nextDefaults, modes: nextModes };
+  }
+  async function setLocale(nextLocaleRaw) {
+    var _a2;
+    const nextLocale = normalizeLocale(nextLocaleRaw);
+    const [blockData, loadedOverrides] = await Promise.all([
+      collectBlockDefaults(nextLocale),
+      ((_a2 = deps.translations) == null ? void 0 : _a2.resolveTranslations(nextLocale).catch(() => [])) ?? Promise.resolve([])
+    ]);
+    const overrides = loadedOverrides.filter(
+      (item) => normalizeLocale(item.locale) === nextLocale
+    );
+    const indexed = indexOverrides(overrides);
+    catalogs.value = {
+      theme: {
+        defaults: {},
+        overrides: indexed.theme
+      },
+      blocks: {
+        defaults: blockData.defaults,
+        modes: blockData.modes,
+        overrides: indexed.blocks
+      }
+    };
+    locale.value = nextLocale;
+  }
+  async function resolve(surface, path, params) {
+    var _a2, _b, _c, _d, _e, _f, _g, _h;
+    r(() => {
+      surfaces[surface].blocks.value = [];
+      surfaces[surface].layout.value = null;
+    });
+    const stored = await deps.resolve(surface, path);
+    if (stored != null) {
+      const instances = stored.blocks.flatMap((block) => {
+        try {
+          return [createBlockInstanceFromObject(block)];
+        } catch (error) {
+          reportBlockError(error, {
+            site: "theme-state.resolve.hydrate",
+            extra: {
+              surface,
+              path,
+              blockType: typeof (block == null ? void 0 : block.type) === "string" ? block.type : "(unknown)"
+            }
+          });
+          return [];
+        }
+      });
+      if (surface === "overlay") {
+        for (const instance of instances) {
+          if (typeof instance.type !== "string" || !instance.type.startsWith("overlay:")) {
+            continue;
+          }
+          try {
+            const canonical = createBlockInstance(instance.type);
+            instance.props = {
+              ...instance.props ?? {},
+              layout: (_a2 = canonical.props) == null ? void 0 : _a2.layout,
+              canAbort: (_b = canonical.props) == null ? void 0 : _b.canAbort
+            };
+          } catch (error) {
+            reportBlockError(error, {
+              site: "theme-state.resolve.overlay-layout",
+              extra: { surface, path, blockType: instance.type }
+            });
+          }
+        }
+      }
+      if (params != null) {
+        for (const instance of instances) {
+          const content = (_c = instance.slots) == null ? void 0 : _c.content;
+          const child = Array.isArray(content) ? content[0] : void 0;
+          if (child != null) {
+            child.props = { ...child.props ?? {}, ...params };
+          }
+        }
+      }
+      r(() => {
+        surfaces[surface].blocks.value = instances;
+        surfaces[surface].layout.value = stored.layout ?? null;
+      });
+      return stored;
+    }
+    const blockToUse = surface === "page" ? (_e = (_d = deps.routerService) == null ? void 0 : _d.getPages().find((p) => p.path === path)) == null ? void 0 : _e.block : (_f = getDefinedBlocks().find((b) => b.name === path)) == null ? void 0 : _f.name;
+    if (blockToUse != null) {
+      const instance = createBlockInstance(blockToUse);
+      if (params != null) {
+        const content = (_g = instance.slots) == null ? void 0 : _g.content;
+        const child = Array.isArray(content) ? content[0] : void 0;
+        if (child != null) {
+          child.props = { ...child.props ?? {}, ...params };
+        }
+      }
+      surfaces[surface].blocks.value = [instance];
+      const serialized = serializeBlocks([instance]);
+      (_h = deps.upsertState) == null ? void 0 : _h.call(deps, surface, path, serialized);
+      return { blocks: serialized };
+    }
+    return { blocks: [] };
+  }
+  onRegisterBlock(async (_, block) => {
+    if (block.locales == null || catalogs.value == null) return;
+    const localeAtLoadStart = locale.value;
+    let file = null;
+    try {
+      file = await block.locales.load(localeAtLoadStart);
+    } catch {
+      file = null;
+    }
+    if (catalogs.value == null || locale.value !== localeAtLoadStart) return;
+    const parsed = parseBlockLocaleFile(file);
+    const current = catalogs.value;
+    catalogs.value = {
+      ...current,
+      blocks: {
+        ...current.blocks,
+        defaults: {
+          ...current.blocks.defaults,
+          [block.name]: parsed.defaults
+        },
+        modes: {
+          ...current.blocks.modes,
+          [block.name]: parsed.modes
+        }
+      }
+    };
+  });
+  (_a = deps.routerService) == null ? void 0 : _a.subscribe(({ path }) => {
+    resolve("page", path);
+  });
+  return {
+    page: surfaces.page,
+    overlay: surfaces.overlay,
+    locales: { locale, catalogs, setLocale },
+    globalStyles,
+    setGlobalStyles,
+    setInstanceTranslationOverride,
+    resolve
+  };
+}
+const TranslationContext = createContext("translation");
+function toStringRecord(input) {
+  if (input == null) return {};
+  return Object.fromEntries(
+    Object.entries(input).filter(([, value]) => typeof value === "string")
+  );
+}
+function createTranslationService(locales, options = {}) {
+  const loadedThemeDefaults = d({});
+  if (options.loadDefaultTranslations) {
+    let loadVersion = 0;
+    E(() => {
+      const locale = locales.locale.value;
+      const currentVersion = ++loadVersion;
+      void options.loadDefaultTranslations(locale).then((result) => toStringRecord(result)).catch(() => ({})).then((result) => {
+        if (currentVersion !== loadVersion) return;
+        loadedThemeDefaults.value = result;
+      });
+    });
+  }
+  return {
+    locale: locales.locale,
+    resolve(blockType, blockId, key) {
+      var _a, _b, _c;
+      const data = locales.catalogs.value;
+      const themeDefault = loadedThemeDefaults.value[key] ?? (data == null ? void 0 : data.theme.defaults[key]);
+      if (data == null) {
+        return themeDefault ?? key;
+      }
+      if (blockId && ((_a = data.blocks.overrides[blockId]) == null ? void 0 : _a[key]) !== void 0) {
+        return data.blocks.overrides[blockId][key];
+      }
+      const blockDefault = blockType != null ? (_b = data.blocks.defaults[blockType]) == null ? void 0 : _b[key] : void 0;
+      const mode = (blockType != null ? (_c = data.blocks.modes[blockType]) == null ? void 0 : _c[key] : void 0) ?? "override";
+      if (blockDefault !== void 0 && mode === "override") {
+        return blockDefault;
+      }
+      if (data.theme.overrides[key] !== void 0) {
+        return data.theme.overrides[key];
+      }
+      if (themeDefault !== void 0) {
+        return themeDefault;
+      }
+      if (blockDefault !== void 0) {
+        return blockDefault;
+      }
+      return key;
+    }
+  };
+}
+const GRID_V1_ENGINE_ID = "grid-v1";
+const PAGE_ROOT_SLOT = "content";
+const DEFAULT_GRID = { cols: 12, gap: 16, rowUnit: 40 };
+const MAX_BLOCKS_PER_ROW = 3;
+const DEFAULT_BREAKPOINTS = [
+  { id: "desktop", cols: 12 },
+  { id: "mobile", cols: 1, query: { maxWidth: 600 } }
+];
+function sharesRowBand$1(a, b) {
+  return a.r < b.r + b.h && a.r + a.h > b.r;
+}
+function minFillCols(cols) {
+  return Math.max(1, Math.ceil(Math.max(1, cols) / MAX_BLOCKS_PER_ROW));
+}
+function clampRect(rect, cols) {
+  const w = Math.max(1, Math.min(rect.w, cols));
+  const c = Math.max(0, Math.min(rect.c, cols - w));
+  const h = Math.max(1, rect.h);
+  const r2 = Math.max(0, rect.r);
+  return { ...rect, c, r: r2, w, h };
+}
+function rectsOverlap(a, b) {
+  return a.c < b.c + b.w && a.c + a.w > b.c && a.r < b.r + b.h && a.r + a.h > b.r;
+}
+function readingOrder(items) {
+  return Object.keys(items).sort((idA, idB) => {
+    const a = items[idA];
+    const b = items[idB];
+    if (a.r !== b.r) return a.r - b.r;
+    return a.c - b.c;
+  });
+}
+function compactItems(items, cols) {
+  const columnBottoms = new Array(Math.max(1, cols)).fill(0);
+  const compacted = {};
+  for (const id of readingOrder(items)) {
+    const rect = clampRect(items[id], cols);
+    let top = 0;
+    for (let c = rect.c; c < rect.c + rect.w; c++) {
+      top = Math.max(top, columnBottoms[c] ?? 0);
+    }
+    compacted[id] = { ...rect, r: top };
+    for (let c = rect.c; c < rect.c + rect.w; c++) {
+      columnBottoms[c] = top + rect.h;
+    }
+  }
+  return compacted;
+}
+function rowBandBounds(items, target, cols, excludeId) {
+  let left = 0;
+  let right = Math.max(1, cols);
+  for (const [id, rect] of Object.entries(items)) {
+    if (id === excludeId) continue;
+    const sharesRow = rect.r < target.r + target.h && rect.r + rect.h > target.r;
+    if (!sharesRow) continue;
+    const rectRight = rect.c + rect.w;
+    if (rectRight <= target.c) {
+      left = Math.max(left, rectRight);
+    } else if (rect.c >= target.c + target.w) {
+      right = Math.min(right, rect.c);
+    }
+  }
+  return { left, right };
+}
+function fillSegmentBounds(target, nonFill, cols) {
+  let left = 0;
+  let right = Math.max(1, cols);
+  for (const rect of nonFill) {
+    if (!sharesRowBand$1(rect, target)) continue;
+    const rectRight = rect.c + rect.w;
+    if (rectRight <= target.c) {
+      left = Math.max(left, rectRight);
+    } else if (rect.c >= target.c) {
+      right = Math.min(right, rect.c);
+    } else {
+      left = Math.max(left, rectRight);
+    }
+  }
+  return { left, right: Math.max(left, right) };
+}
+function applyFillExpansion(items, cols) {
+  const next = {};
+  for (const id of readingOrder(items)) {
+    next[id] = items[id];
+  }
+  const fillIds = readingOrder(next).filter((id) => next[id].fill === true);
+  if (fillIds.length === 0) return next;
+  const nonFill = Object.values(next).filter((rect) => rect.fill !== true);
+  const groups = [];
+  for (const id of fillIds) {
+    const rect = next[id];
+    const seg = fillSegmentBounds(rect, nonFill, cols);
+    const group = groups.find(
+      (g) => g.left === seg.left && g.right === seg.right && g.members.some((memberId) => sharesRowBand$1(next[memberId], rect))
+    );
+    if (group) group.members.push(id);
+    else groups.push({ left: seg.left, right: seg.right, members: [id] });
+  }
+  const minCols = minFillCols(cols);
+  const overflow = [];
+  for (const group of groups) {
+    const span = Math.max(1, group.right - group.left);
+    const fit = Math.min(group.members.length, Math.floor(span / minCols));
+    if (fit <= 0) {
+      overflow.push(...group.members);
+      continue;
+    }
+    const staying = group.members.slice(0, fit);
+    overflow.push(...group.members.slice(fit));
+    const base = Math.floor(span / fit);
+    const remainder = span - base * fit;
+    let pos = group.left;
+    staying.forEach((id, index) => {
+      const w = base + (index < remainder ? 1 : 0);
+      next[id] = { ...next[id], c: pos, w: Math.max(1, w) };
+      pos += w;
+    });
+  }
+  if (overflow.length === 0) return next;
+  for (const id of overflow) {
+    const rect = next[id];
+    let bandBottom = rect.r;
+    for (const [otherId, other] of Object.entries(next)) {
+      if (otherId === id || overflow.includes(otherId)) continue;
+      if (sharesRowBand$1(other, rect)) {
+        bandBottom = Math.max(bandBottom, other.r + other.h);
+      }
+    }
+    next[id] = { ...next[id], c: 0, r: bandBottom, w: cols };
+  }
+  return compactItems(next, cols);
+}
+function findFreeRect(items, size, cols) {
+  const w = Math.max(1, Math.min(size.w, cols));
+  const h = Math.max(1, size.h);
+  const existing = Object.values(items);
+  for (let r2 = 0; ; r2++) {
+    for (let c = 0; c <= cols - w; c++) {
+      const candidate = { c, r: r2, w, h };
+      if (!existing.some((rect) => rectsOverlap(candidate, rect))) {
+        return candidate;
+      }
+    }
+  }
+}
+function deriveLayout(base, target) {
+  const cols = target.cols;
+  const items = {};
+  let r2 = 0;
+  for (const id of readingOrder(base.items)) {
+    const h = Math.max(1, base.items[id].h);
+    items[id] = clampRect({ c: 0, r: r2, w: cols, h }, cols);
+    r2 += h;
+  }
+  return { grid: { ...base.grid, cols }, items };
+}
+function resolveLayout(doc, breakpointId) {
+  var _a;
+  const present = doc.layouts[breakpointId];
+  if (present) return present;
+  const baseId = (_a = doc.breakpoints[0]) == null ? void 0 : _a.id;
+  const baseLayout = baseId ? doc.layouts[baseId] : void 0;
+  const target = doc.breakpoints.find((b) => b.id === breakpointId);
+  if (!baseLayout || !target) {
+    return { grid: { ...DEFAULT_GRID, cols: (target == null ? void 0 : target.cols) ?? 1 }, items: {} };
+  }
+  return deriveLayout(baseLayout, target);
+}
+function classifyRowDividers(items, blockIds) {
+  const leaderBlockIds = /* @__PURE__ */ new Set();
+  const rowBlockIds = /* @__PURE__ */ new Set();
+  const placed = blockIds.filter((id) => items[id] != null);
+  if (placed.length === 0) return { leaderBlockIds, rowBlockIds };
+  const rects = placed.map((id) => items[id]);
+  const minRow = Math.min(...rects.map((rect) => rect.r));
+  const boundaryIsCrossed = (boundary) => rects.some((rect) => rect.r < boundary && rect.r + rect.h > boundary);
+  const ordered = [...placed].sort((a, b) => {
+    const ra = items[a];
+    const rb = items[b];
+    return ra.r - rb.r || ra.c - rb.c;
+  });
+  let lastLeaderRow = null;
+  for (const id of ordered) {
+    const { r: r2 } = items[id];
+    if (r2 <= minRow || boundaryIsCrossed(r2)) continue;
+    rowBlockIds.add(id);
+    if (r2 !== lastLeaderRow) {
+      leaderBlockIds.add(id);
+      lastLeaderRow = r2;
+    }
+  }
+  return { leaderBlockIds, rowBlockIds };
+}
+function containerRule(scope, grid) {
+  return `${scope}{display:grid;grid-template-columns:repeat(${grid.cols},minmax(0,1fr));--juo-layout-cols:${grid.cols};--juo-layout-gap:var(--juo-layout-spacing,${grid.gap}px);column-gap:var(--juo-layout-gap);row-gap:0;margin-block-end:calc(-1 * var(--juo-layout-gap));}`;
+}
+function baseSpacingRule(scope) {
+  return `${scope} > [data-block-id]{margin-block-end:var(--juo-layout-gap);}`;
+}
+function collapseRule(scope) {
+  return `${scope} > [data-empty],${scope} > :has(> [data-empty]){margin-block-end:0;}`;
+}
+function itemRule(scope, blockId, rect, divider) {
+  return `${scope} > [data-block-id="${blockId}"]{grid-column:${rect.c + 1}/span ${rect.w};grid-row:${rect.r + 1}/span ${rect.h};--juo-layout-c:${rect.c};--juo-divider-row:${divider.row ? 1 : 0};--juo-divider-line:${divider.line ? 1 : 0};}`;
+}
+function breakpointCss(scope, layout, domOrder) {
+  const { leaderBlockIds, rowBlockIds } = classifyRowDividers(
+    layout.items,
+    domOrder
+  );
+  const rules = [containerRule(scope, layout.grid)];
+  for (const blockId of Object.keys(layout.items)) {
+    rules.push(
+      itemRule(scope, blockId, layout.items[blockId], {
+        row: rowBlockIds.has(blockId),
+        line: leaderBlockIds.has(blockId)
+      })
+    );
+  }
+  return rules.join("");
+}
+function sharesRowBand(a, b) {
+  return a.r < b.r + b.h && a.r + a.h > b.r;
+}
+function nonEmptySubsets(ids) {
+  const out = [];
+  for (let mask = 1; mask < 1 << ids.length; mask++) {
+    const subset = [];
+    for (let i = 0; i < ids.length; i++) {
+      if (mask & 1 << i) subset.push(ids[i]);
+    }
+    out.push(subset);
+  }
+  return out;
+}
+function reclaimSelector(scope, fillId, emptyMates, domIndex) {
+  const fillIdx = domIndex.get(fillId) ?? 0;
+  const byDom = (a, b) => (domIndex.get(a) ?? 0) - (domIndex.get(b) ?? 0);
+  const before = emptyMates.filter((id) => (domIndex.get(id) ?? 0) < fillIdx).sort(byDom);
+  const after = emptyMates.filter((id) => (domIndex.get(id) ?? 0) > fillIdx).sort(byDom);
+  const emptyBefore = (id) => `[data-block-id="${id}"]:is([data-empty],:has(> [data-empty]))`;
+  const emptyAfterHas = (id) => `~ [data-block-id="${id}"][data-empty],~ [data-block-id="${id}"] > [data-empty]`;
+  let sel = "";
+  for (const id of before) sel += `${emptyBefore(id)} ~ `;
+  sel += `[data-block-id="${fillId}"]`;
+  for (const id of after) sel += `:has(${emptyAfterHas(id)})`;
+  return `${scope} > ${sel}`;
+}
+function reclaimCss(scope, layout, domOrder) {
+  const items = layout.items;
+  const cols = layout.grid.cols;
+  const domIndex = new Map(domOrder.map((id, index) => [id, index]));
+  const rules = [];
+  for (const [fillId, fillRect] of Object.entries(items)) {
+    if (fillRect.fill !== true) continue;
+    const mateIds = Object.entries(items).filter(([id, rect]) => id !== fillId && sharesRowBand(rect, fillRect)).map(([id]) => id);
+    if (mateIds.length === 0 || mateIds.length > 4) continue;
+    for (const emptyMates of nonEmptySubsets(mateIds)) {
+      const remaining = {};
+      for (const [id, rect] of Object.entries(items)) {
+        if (id === fillId || emptyMates.includes(id)) continue;
+        remaining[id] = rect;
+      }
+      const { left, right } = rowBandBounds(remaining, fillRect, cols);
+      if (left >= fillRect.c && right <= fillRect.c + fillRect.w) continue;
+      const selector = reclaimSelector(scope, fillId, emptyMates, domIndex);
+      rules.push(
+        `${selector}{grid-column:${left + 1}/span ${Math.max(1, right - left)};--juo-layout-c:${left};}`
+      );
+    }
+  }
+  return rules.join("");
+}
+function projectToCss(doc, opts) {
+  const base = doc.breakpoints[0];
+  if (!base) return "";
+  const baseLayout = resolveLayout(doc, base.id);
+  const domOrder = opts.domOrder ?? Object.keys(baseLayout.items);
+  const parts = [
+    breakpointCss(opts.scope, baseLayout, domOrder),
+    baseSpacingRule(opts.scope),
+    collapseRule(opts.scope),
+    reclaimCss(opts.scope, baseLayout, domOrder)
+  ];
+  for (const bp of doc.breakpoints.slice(1)) {
+    if (!bp.query) continue;
+    parts.push(
+      `@container (max-width:${bp.query.maxWidth}px){` + breakpointCss(opts.scope, resolveLayout(doc, bp.id), domOrder) + `}`
+    );
+  }
+  return parts.join("");
+}
+function createDefaultLayoutDocument(blockIds) {
+  const items = {};
+  blockIds.forEach((id, index) => {
+    items[id] = { c: 0, r: index, w: DEFAULT_GRID.cols, h: 1 };
+  });
+  return {
+    version: 1,
+    engine: GRID_V1_ENGINE_ID,
+    breakpoints: structuredClone([...DEFAULT_BREAKPOINTS]),
+    layouts: {
+      [DEFAULT_BREAKPOINTS[0].id]: { grid: { ...DEFAULT_GRID }, items }
+    }
+  };
+}
+function colsForBreakpoint(doc, breakpointId, layout) {
+  var _a;
+  return ((_a = doc.breakpoints.find((b) => b.id === breakpointId)) == null ? void 0 : _a.cols) ?? layout.grid.cols;
+}
+function reconcileBreakpointLayout(layout, blockIds, cols) {
+  const known = new Set(blockIds);
+  for (const id of Object.keys(layout.items)) {
+    if (!known.has(id)) delete layout.items[id];
+  }
+  for (const id of blockIds) {
+    if (!layout.items[id]) {
+      layout.items[id] = findFreeRect(layout.items, { w: cols, h: 1 }, cols);
+    }
+  }
+}
+function reconcileLayout(doc, blockIds) {
+  var _a;
+  if (!doc) return createDefaultLayoutDocument(blockIds);
+  const next = structuredClone(doc);
+  const baseId = (_a = next.breakpoints[0]) == null ? void 0 : _a.id;
+  if (!baseId) return createDefaultLayoutDocument(blockIds);
+  for (const def of DEFAULT_BREAKPOINTS) {
+    if (!next.breakpoints.some((b) => b.id === def.id)) {
+      next.breakpoints.push(structuredClone(def));
+    }
+  }
+  next.layouts[baseId] = next.layouts[baseId] ?? {
+    grid: { ...DEFAULT_GRID },
+    items: {}
+  };
+  for (const breakpointId of Object.keys(next.layouts)) {
+    const layout = next.layouts[breakpointId];
+    if (!layout) continue;
+    reconcileBreakpointLayout(
+      layout,
+      blockIds,
+      colsForBreakpoint(next, breakpointId, layout)
+    );
+  }
+  return next;
+}
+function compactLayoutDocument(doc) {
+  if (!doc) return doc;
+  const next = structuredClone(doc);
+  for (const breakpointId of Object.keys(next.layouts)) {
+    const layout = next.layouts[breakpointId];
+    if (!layout) continue;
+    layout.items = compactItems(
+      layout.items,
+      colsForBreakpoint(next, breakpointId, layout)
+    );
+  }
+  return next;
+}
+function expandFillLayoutDocument(doc) {
+  if (!doc) return doc;
+  const next = structuredClone(doc);
+  for (const breakpointId of Object.keys(next.layouts)) {
+    const layout = next.layouts[breakpointId];
+    if (!layout) continue;
+    layout.items = applyFillExpansion(
+      layout.items,
+      colsForBreakpoint(next, breakpointId, layout)
+    );
+  }
+  return next;
+}
+const LAYOUT_SCOPE_ATTR = "data-juo-layout";
+function layoutScopeSelector(scopeId) {
+  return `[${LAYOUT_SCOPE_ATTR}="${scopeId}"]`;
+}
+function buildLayoutCss(layout, blockIds, scopeId) {
+  const reconciled = reconcileLayout(layout, blockIds);
+  return projectToCss(reconciled, {
+    scope: layoutScopeSelector(scopeId),
+    domOrder: blockIds
+  });
+}
+function buildGridLayout(layout, blockIds, scopeId) {
+  var _a, _b;
+  const scope = layoutScopeSelector(scopeId);
+  const reconciled = reconcileLayout(layout, blockIds);
+  const baseId = (_a = reconciled.breakpoints[0]) == null ? void 0 : _a.id;
+  const layoutItems = (baseId != null ? (_b = reconciled.layouts[baseId]) == null ? void 0 : _b.items : null) ?? {};
+  const { leaderBlockIds, rowBlockIds } = classifyRowDividers(
+    layoutItems,
+    blockIds
+  );
+  const fullWidthBlockIds = /* @__PURE__ */ new Set();
+  for (const [id, rect] of Object.entries(layoutItems)) {
+    if (rect.fill === true) fullWidthBlockIds.add(id);
+  }
+  return {
+    css: projectToCss(reconciled, { scope, domOrder: blockIds }),
+    dividerBlockIds: leaderBlockIds,
+    dividerRowBlockIds: rowBlockIds,
+    fullWidthBlockIds
+  };
+}
+export {
+  DEFAULT_GRID as D,
+  GRID_V1_ENGINE_ID as G,
+  LAYOUT_SCOPE_ATTR as L,
+  MAX_BLOCKS_PER_ROW as M,
+  PAGE_ROOT_SLOT as P,
+  TranslationContext as T,
+  ThemeStateContext as a,
+  buildGridLayout as b,
+  reconcileLayout as c,
+  clampRect as d,
+  applyFillExpansion as e,
+  compactItems as f,
+  findFreeRect as g,
+  DEFAULT_BREAKPOINTS as h,
+  DEFAULT_GLOBAL_STYLES as i,
+  buildLayoutCss as j,
+  classifyRowDividers as k,
+  compactLayoutDocument as l,
+  createDefaultLayoutDocument as m,
+  createThemeState as n,
+  createTranslationService as o,
+  deriveLayout as p,
+  expandFillLayoutDocument as q,
+  resolveLayout as r,
+  indexOverrides as s,
+  layoutScopeSelector as t,
+  projectToCss as u,
+  readingOrder as v,
+  rectsOverlap as w
+};