@richardmcquiston01/dashboard-widgets-toolkit 0.9.0 → 0.10.0

package/dist/core.cjs

@@ -634,21 +634,44 @@ function fillColumnSpans(items, columns, largeSpan = 2) {
 function fillWidthSpans(items) {
   return placeAndFill(items, WIDTH_COLUMNS, itemWidth);
 }
+function placeRows(items) {
+  return placeAndFillRows(items, WIDTH_COLUMNS, itemWidth).rows;
+}
+function fitCount(items, maxRows) {
+  const rows = placeRows(items);
+  let count = 0;
+  for (const row of rows.slice(0, Math.max(0, Math.floor(maxRows)))) {
+    count += row.keys.length;
+  }
+  return count;
+}
 function placeAndFill(items, columns, spanOf) {
+  return placeAndFillRows(items, columns, spanOf).spans;
+}
+function placeAndFillRows(items, columns, spanOf) {
   const trackCount = Math.max(1, Math.floor(columns));
   const spans = /* @__PURE__ */ new Map();
+  const rows = [];
   let row = [];
   let used = 0;
   function closeRow() {
+    if (row.length === 0) return;
     const fillers = row.filter(({ item }) => fillsWidth(item.fill));
     const leftover = trackCount - used;
+    const finalSpans = /* @__PURE__ */ new Map();
     if (fillers.length > 0) {
       const share = Math.floor(leftover / fillers.length);
       const remainder = leftover % fillers.length;
       fillers.forEach(({ item, span }, index) => {
-        spans.set(item.key, span + share + (index < remainder ? 1 : 0));
+        const grown = span + share + (index < remainder ? 1 : 0);
+        spans.set(item.key, grown);
+        finalSpans.set(item.key, grown);
       });
     }
+    rows.push({
+      keys: row.map(({ item }) => item.key),
+      spans: row.map(({ item, span }) => finalSpans.get(item.key) ?? span)
+    });
     row = [];
     used = 0;
   }
@@ -659,10 +682,13 @@ function placeAndFill(items, columns, spanOf) {
     used += span;
   }
   closeRow();
-  return spans;
+  return { spans, rows };
 }
 
 // src/core/layout.ts
+var MAX_PAGE_TITLE_LENGTH = 30;
+var MAX_PARSED_PAGES = 50;
+var MAX_PAGE_ROWS = 20;
 var EMPTY_LAYOUT = Object.freeze({
   order: Object.freeze([]),
   hidden: Object.freeze([]),
@@ -692,16 +718,66 @@ function parseLayout(raw) {
   const order = uniqueStrings(record["order"]);
   const hidden = uniqueStrings(record["hidden"]);
   const minimized = uniqueStrings(record["minimized"]);
+  const pages = parsePages(record["pages"]);
+  if (pages.length > 0) {
+    return {
+      order: EMPTY_LAYOUT.order,
+      hidden: EMPTY_LAYOUT.hidden,
+      minimized: EMPTY_LAYOUT.minimized,
+      pages
+    };
+  }
   if (order.length === 0 && hidden.length === 0 && minimized.length === 0) {
     return EMPTY_LAYOUT;
   }
   return { order, hidden, minimized };
 }
+function parsePages(value) {
+  if (!Array.isArray(value)) return [];
+  const pages = [];
+  const keys = /* @__PURE__ */ new Set();
+  for (const entry of value.slice(0, MAX_PARSED_PAGES)) {
+    if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
+      continue;
+    }
+    const record = entry;
+    const key = record["key"];
+    if (typeof key !== "string" || key === "" || keys.has(key)) continue;
+    keys.add(key);
+    const rawTitle = record["title"];
+    const title = typeof rawTitle === "string" && rawTitle.trim() !== "" ? rawTitle.trim().slice(0, MAX_PAGE_TITLE_LENGTH) : `Page ${pages.length + 1}`;
+    const maxRows = record["maxRows"];
+    const held = /* @__PURE__ */ new Set();
+    for (const earlier of pages) {
+      for (const k of [...earlier.order, ...earlier.hidden]) held.add(k);
+    }
+    const keep = (list) => uniqueStrings(list).filter((k) => !held.has(k));
+    pages.push({
+      key,
+      title,
+      order: keep(record["order"]),
+      hidden: keep(record["hidden"]),
+      minimized: keep(record["minimized"]),
+      ...typeof maxRows === "number" && Number.isInteger(maxRows) && maxRows >= 1 && maxRows <= MAX_PAGE_ROWS ? { maxRows } : {}
+    });
+  }
+  return pages;
+}
 function serializeLayout(layout) {
   return JSON.stringify({
     order: [...layout.order],
     hidden: [...layout.hidden],
-    minimized: [...layout.minimized]
+    minimized: [...layout.minimized],
+    ...layout.pages === void 0 || layout.pages.length === 0 ? {} : {
+      pages: layout.pages.map((page) => ({
+        key: page.key,
+        title: page.title,
+        order: [...page.order],
+        hidden: [...page.hidden],
+        minimized: [...page.minimized],
+        ...page.maxRows === void 0 ? {} : { maxRows: page.maxRows }
+      }))
+    }
   });
 }
 function bySortOrder(items) {
@@ -824,13 +900,28 @@ function toggleMinimized(layout, key) {
 }
 function pruneLayout(definitions, layout) {
   const known = new Set(definitions.map((d) => d.key));
-  const keep = (keys) => keys.filter((k) => known.has(k));
-  const next = {
-    order: keep(layout.order),
-    hidden: keep(layout.hidden),
-    minimized: keep(layout.minimized)
+  const keep = (keys) => keys.every((k) => known.has(k)) ? keys : keys.filter((k) => known.has(k));
+  return mapLayoutLists(layout, (lists) => ({
+    order: keep(lists.order),
+    hidden: keep(lists.hidden),
+    minimized: keep(lists.minimized)
+  }));
+}
+function mapLayoutLists(layout, change) {
+  const top = change(layout);
+  const pages = layout.pages?.map((page) => {
+    const next = change(page);
+    return next.order === page.order && next.hidden === page.hidden && next.minimized === page.minimized ? page : { ...page, ...next };
+  });
+  const pagesChanged = pages !== void 0 && pages.some((page, i) => page !== layout.pages?.[i]);
+  if (top.order === layout.order && top.hidden === layout.hidden && top.minimized === layout.minimized && !pagesChanged) {
+    return layout;
+  }
+  return {
+    ...layout,
+    ...top,
+    ...pages === void 0 ? {} : { pages }
   };
-  return next.order.length === layout.order.length && next.hidden.length === layout.hidden.length && next.minimized.length === layout.minimized.length ? layout : next;
 }
 function enforceLocks(definitions, layout, options = {}) {
   if (options.overrideLocks === true) return layout;
@@ -843,11 +934,12 @@ function enforceLocks(definitions, layout, options = {}) {
     if (lock.hide) noHide.add(definition.key);
     if (lock.minimize) noMinimize.add(definition.key);
   }
-  const without = (keys, drop) => keys.some((key) => drop.has(key)) ? keys.filter((key) => !drop.has(key)) : keys;
-  const order = without(layout.order, noMove);
-  const hidden = without(layout.hidden, noHide);
-  const minimized = without(layout.minimized, noMinimize);
-  return order === layout.order && hidden === layout.hidden && minimized === layout.minimized ? layout : { ...layout, order, hidden, minimized };
+  const without2 = (keys, drop) => keys.some((key) => drop.has(key)) ? keys.filter((key) => !drop.has(key)) : keys;
+  return mapLayoutLists(layout, (lists) => ({
+    order: without2(lists.order, noMove),
+    hidden: without2(lists.hidden, noHide),
+    minimized: without2(lists.minimized, noMinimize)
+  }));
 }
 
 // src/core/validate.ts
@@ -1212,6 +1304,13 @@ function validateWidgetDefinition(value) {
   checkDetailOption(value["detail"], problems);
   checkTableControlsOption(value["tableControls"], value["kind"], problems);
   checkLockedOption(value["locked"], problems);
+  if (value["page"] !== void 0) {
+    if (typeof value["page"] !== "string" || value["page"].trim() === "") {
+      problems.push(
+        `page must be a non-empty page key or title, got ${describeType2(value["page"])}.`
+      );
+    }
+  }
   if (value["fill"] !== void 0) {
     requireOneOf(value, "fill", WIDGET_FILLS, "", problems);
   }
@@ -1465,6 +1564,475 @@ function createWidgetLoader(options) {
   };
 }
 
+// src/core/pages.ts
+var DEFAULT_PAGE_KEY = "default";
+var DEFAULT_PAGE_ROWS = 4;
+function rowsAllowed(page, options) {
+  const rows = page.maxRows ?? options.maxRows ?? DEFAULT_PAGE_ROWS;
+  return Math.max(1, Math.min(MAX_PAGE_ROWS, Math.floor(rows)));
+}
+function hasPages(layout) {
+  return layout.pages !== void 0 && layout.pages.length > 0;
+}
+function pageList(layout) {
+  if (layout.pages !== void 0 && layout.pages.length > 0) {
+    return layout.pages;
+  }
+  return [
+    {
+      key: DEFAULT_PAGE_KEY,
+      title: "Page 1",
+      order: layout.order,
+      hidden: layout.hidden,
+      minimized: layout.minimized
+    }
+  ];
+}
+function withExplicitPages(layout) {
+  if (hasPages(layout)) return layout;
+  return {
+    ...layout,
+    order: [],
+    hidden: [],
+    minimized: [],
+    pages: pageList(layout)
+  };
+}
+function sameKeys(a, b) {
+  return a === b || a.length === b.length && a.every((k, i) => k === b[i]);
+}
+function pageLayout(layout, pageKey) {
+  if (!hasPages(layout))
+    return pageKey === DEFAULT_PAGE_KEY ? layout : void 0;
+  const page = layout.pages?.find(
+    (p) => p.key === pageKey
+  );
+  if (page === void 0) return void 0;
+  const { pages, ...rest } = layout;
+  return {
+    ...rest,
+    order: page.order,
+    hidden: page.hidden,
+    minimized: page.minimized
+  };
+}
+function withPageLayout(layout, pageKey, next) {
+  const current = pageLayout(layout, pageKey);
+  if (current === void 0 || sameKeys(current.order, next.order) && sameKeys(current.hidden, next.hidden) && sameKeys(current.minimized, next.minimized)) {
+    return layout;
+  }
+  if (!hasPages(layout)) {
+    return {
+      ...layout,
+      order: next.order,
+      hidden: next.hidden,
+      minimized: next.minimized
+    };
+  }
+  return {
+    ...layout,
+    pages: (layout.pages ?? []).map(
+      (page) => page.key === pageKey ? {
+        ...page,
+        order: next.order,
+        hidden: next.hidden,
+        minimized: next.minimized
+      } : page
+    )
+  };
+}
+function normalizedTitle(title) {
+  return title.trim().normalize("NFKC").toLowerCase();
+}
+function resolvePageKey(layout, reference) {
+  if (reference === void 0 || reference === "") return void 0;
+  const pages = pageList(layout);
+  const byKey = pages.find((p) => p.key === reference);
+  if (byKey !== void 0) return byKey.key;
+  const wanted = normalizedTitle(reference);
+  return pages.find((p) => normalizedTitle(p.title) === wanted)?.key;
+}
+function homePageKey(layout, item) {
+  return resolvePageKey(layout, item.page) ?? pageList(layout)[0].key;
+}
+function assignPages(definitions, layout) {
+  const pages = pageList(layout);
+  const assigned = new Map(pages.map((p) => [p.key, []]));
+  for (const definition of definitions) {
+    let pageKey;
+    if (!resolveWidgetLock(definition).move) {
+      pageKey = pages.find(
+        (p) => p.order.includes(definition.key) || p.hidden.includes(definition.key)
+      )?.key;
+    }
+    assigned.get(pageKey ?? homePageKey(layout, definition))?.push(definition);
+  }
+  return assigned;
+}
+function pageOf(definitions, layout, key) {
+  for (const [pageKey, widgets] of assignPages(definitions, layout)) {
+    if (widgets.some((w) => w.key === key)) return pageKey;
+  }
+  return void 0;
+}
+function pageWidgets(definitions, layout, pageKey) {
+  const onPage = assignPages(definitions, layout).get(pageKey) ?? [];
+  const view = pageLayout(layout, pageKey);
+  return view === void 0 ? [] : visibleWidgets(onPage, view);
+}
+function pageRoom(definitions, layout, pageKey, options = {}) {
+  const page = pageList(layout).find(
+    (p) => p.key === pageKey
+  );
+  if (page === void 0) return void 0;
+  const maxRows = rowsAllowed(page, options);
+  const rowsUsed = placeRows(
+    pageWidgets(definitions, layout, pageKey)
+  ).length;
+  return { maxRows, rowsUsed, rowsFree: Math.max(0, maxRows - rowsUsed) };
+}
+function describePage(page) {
+  return `Page "${page.title}"`;
+}
+function titleOf(item) {
+  return item.title ?? item.key;
+}
+function checkTitle(layout, title, exceptKey) {
+  const trimmed = title.trim();
+  if (trimmed === "") return err("A page title must not be empty.");
+  if (trimmed.length > MAX_PAGE_TITLE_LENGTH) {
+    return err(
+      `Page title "${trimmed}" is ${trimmed.length} characters; the most is ${MAX_PAGE_TITLE_LENGTH}.`
+    );
+  }
+  const wanted = normalizedTitle(trimmed);
+  const clash = pageList(layout).find(
+    (p) => p.key !== exceptKey && normalizedTitle(p.title) === wanted
+  );
+  if (clash !== void 0) {
+    return err(`Another page is already called "${clash.title}".`);
+  }
+  return ok(trimmed);
+}
+function nextPageKey(layout) {
+  const keys = new Set(pageList(layout).map((p) => p.key));
+  let n = 1;
+  while (keys.has(`page-${n}`)) n += 1;
+  return `page-${n}`;
+}
+function nextPageTitle(layout) {
+  const used = new Set(
+    pageList(layout).map((p) => normalizedTitle(p.title))
+  );
+  let n = pageList(layout).length + 1;
+  while (used.has(normalizedTitle(`Page ${n}`))) n += 1;
+  return `Page ${n}`;
+}
+function addPage(layout, options = {}) {
+  if (pageList(layout).length >= MAX_PARSED_PAGES) {
+    return err(
+      `The layout already has ${MAX_PARSED_PAGES} pages, the most it can keep.`
+    );
+  }
+  const key = options.key ?? nextPageKey(layout);
+  if (pageList(layout).some((p) => p.key === key)) {
+    return err(`A page with the key "${key}" already exists.`);
+  }
+  const title = checkTitle(
+    layout,
+    options.title ?? nextPageTitle(layout)
+  );
+  if (!title.ok) return title;
+  const base = withExplicitPages(layout);
+  const page = {
+    key,
+    title: title.value,
+    order: [],
+    hidden: [],
+    minimized: []
+  };
+  return ok({ ...base, pages: [...base.pages ?? [], page] });
+}
+function renamePage(layout, pageKey, title) {
+  const page = pageList(layout).find(
+    (p) => p.key === pageKey
+  );
+  if (page === void 0) return err(`Page "${pageKey}" doesn't exist.`);
+  const checked = checkTitle(layout, title, pageKey);
+  if (!checked.ok) return checked;
+  if (checked.value === page.title) return ok(layout);
+  const base = withExplicitPages(layout);
+  return ok({
+    ...base,
+    pages: (base.pages ?? []).map(
+      (p) => p.key === pageKey ? { ...p, title: checked.value } : p
+    )
+  });
+}
+function movePage(layout, pageKey, offset) {
+  const pages = layout.pages ?? [];
+  const from = pages.findIndex((p) => p.key === pageKey);
+  if (from === -1) return layout;
+  const to = Math.max(
+    0,
+    Math.min(pages.length - 1, from + Math.trunc(offset))
+  );
+  if (to === from) return layout;
+  const next = [...pages];
+  const [moved] = next.splice(from, 1);
+  next.splice(to, 0, moved);
+  return { ...layout, pages: next };
+}
+function overflowing(definitions, layout, options) {
+  return pageList(layout).find(
+    (page) => placeRows(pageWidgets(definitions, layout, page.key)).length > rowsAllowed(page, options)
+  );
+}
+function removePage(definitions, layout, pageKey, options = {}) {
+  const pages = pageList(layout);
+  const index = pages.findIndex((p) => p.key === pageKey);
+  const page = pages[index];
+  if (page === void 0) return err(`Page "${pageKey}" doesn't exist.`);
+  if (pages.length === 1) {
+    return err(
+      `${describePage(page)} is the only page, so it can't be removed.`
+    );
+  }
+  const target = pages[index > 0 ? index - 1 : 1];
+  const merged = {
+    ...layout,
+    pages: pages.filter((p) => p.key !== pageKey).map(
+      (p) => p.key === target.key ? {
+        ...p,
+        order: index > 0 ? [...p.order, ...page.order] : [...page.order, ...p.order],
+        hidden: [...p.hidden, ...page.hidden],
+        minimized: [...p.minimized, ...page.minimized]
+      } : p
+    )
+  };
+  const full = overflowing(
+    definitions,
+    merged,
+    options
+  );
+  if (full !== void 0) {
+    return err(
+      `${describePage(page)} has widgets that don't fit on the other pages (${describePage(full)} would need more than ${rowsAllowed(full, options)} rows). Move or hide some first.`
+    );
+  }
+  return ok(merged);
+}
+function without(keys, key) {
+  return keys.includes(key) ? keys.filter((k) => k !== key) : keys;
+}
+function moveWidgetToPage(definitions, layout, widgetKey, targetKey, options = {}) {
+  const widget = definitions.find((d) => d.key === widgetKey);
+  if (widget === void 0) {
+    return err(
+      `Widget "${widgetKey}" isn't one of the widgets, so it can't be moved to a page.`
+    );
+  }
+  const pages = pageList(layout);
+  const target = pages.find((p) => p.key === targetKey);
+  if (target === void 0) return err(`Page "${targetKey}" doesn't exist.`);
+  const sourceKey = pageOf(definitions, layout, widgetKey);
+  if (sourceKey === targetKey) return ok(layout);
+  if (resolveWidgetLock(widget).move) {
+    return err(
+      `Widget "${titleOf(widget)}" is locked against moving, so it can't be moved to ${describePage(target)}.`
+    );
+  }
+  const base = withExplicitPages(layout);
+  const source = (base.pages ?? []).find(
+    (p) => p.key === sourceKey
+  );
+  const hidden = source.hidden.includes(widgetKey);
+  const minimized = source.minimized.includes(widgetKey);
+  const targetOrder = pageWidgets(
+    definitions,
+    base,
+    targetKey
+  ).map((d) => d.key);
+  const moved = {
+    ...base,
+    pages: (base.pages ?? []).map((p) => {
+      if (p.key === sourceKey) {
+        return {
+          ...p,
+          order: without(p.order, widgetKey),
+          hidden: without(p.hidden, widgetKey),
+          minimized: without(p.minimized, widgetKey)
+        };
+      }
+      if (p.key === targetKey) {
+        return {
+          ...p,
+          order: hidden ? p.order : [...targetOrder, widgetKey],
+          hidden: hidden ? [...p.hidden, widgetKey] : p.hidden,
+          minimized: minimized ? [...p.minimized, widgetKey] : p.minimized
+        };
+      }
+      return p;
+    })
+  };
+  if (!hidden) {
+    const allowed = rowsAllowed(target, options);
+    const needed = placeRows(
+      pageWidgets(definitions, moved, targetKey)
+    ).length;
+    if (needed > allowed) {
+      return err(
+        `${describePage(target)} has no room for "${titleOf(widget)}": it would need row ${needed}, and the page allows ${allowed}.`
+      );
+    }
+  }
+  return ok(moved);
+}
+function withoutLockField(definition) {
+  if (definition.locked === void 0) return definition;
+  const copy = { ...definition };
+  delete copy.locked;
+  return copy;
+}
+function uniqueTitle(taken, title, index) {
+  let base = title.trim().slice(0, MAX_PAGE_TITLE_LENGTH);
+  if (base === "") base = `Page ${index + 1}`;
+  let candidate = base;
+  let n = 1;
+  while (taken.has(normalizedTitle(candidate))) {
+    const suffix = ` (#${n})`;
+    candidate = `${base.slice(0, MAX_PAGE_TITLE_LENGTH - suffix.length)}${suffix}`;
+    n += 1;
+  }
+  taken.add(normalizedTitle(candidate));
+  return candidate;
+}
+function samePages(a, b) {
+  return a.length === b.length && a.every((p, i) => {
+    const q = b[i];
+    return p.key === q.key && p.title === q.title && p.maxRows === q.maxRows && sameKeys(p.order, q.order) && sameKeys(p.hidden, q.hidden) && sameKeys(p.minimized, q.minimized);
+  });
+}
+function normalizeLayout(definitions, layout, options = {}) {
+  const known = pruneLayout(definitions, layout);
+  const locked = enforceLocks(definitions, known, options);
+  if (!hasPages(locked)) return locked === layout ? layout : locked;
+  const defs = options.overrideLocks === true ? definitions.map(withoutLockField) : definitions;
+  const taken = /* @__PURE__ */ new Set();
+  const seenKeys = /* @__PURE__ */ new Set();
+  const held = /* @__PURE__ */ new Set();
+  let pages = [];
+  (locked.pages ?? []).forEach((page, index) => {
+    if (seenKeys.has(page.key)) return;
+    seenKeys.add(page.key);
+    const keep = (list) => [
+      ...new Set(list.filter((k) => !held.has(k)))
+    ];
+    const next = {
+      ...page,
+      title: uniqueTitle(taken, page.title, index),
+      order: keep(page.order),
+      hidden: keep(page.hidden),
+      minimized: keep(page.minimized)
+    };
+    for (const k of [...next.order, ...next.hidden]) held.add(k);
+    pages.push(next);
+  });
+  const work = () => ({ ...locked, pages });
+  const pinned = defs.filter((d) => resolveWidgetLock(d).move);
+  for (const widget of pinned) {
+    const home = homePageKey(work(), widget);
+    const keysHere = (p, list) => p.key !== home && p[list].includes(widget.key);
+    const wasHidden = pages.some((p) => keysHere(p, "hidden"));
+    const wasMinimized = pages.some((p) => keysHere(p, "minimized"));
+    if (!wasHidden && !wasMinimized) continue;
+    pages = pages.map((p) => {
+      let next = p;
+      if (keysHere(p, "hidden")) {
+        next = { ...next, hidden: without(next.hidden, widget.key) };
+      }
+      if (keysHere(p, "minimized")) {
+        next = { ...next, minimized: without(next.minimized, widget.key) };
+      }
+      if (p.key === home) {
+        next = {
+          ...next,
+          hidden: wasHidden && !next.hidden.includes(widget.key) ? [...next.hidden, widget.key] : next.hidden,
+          minimized: wasMinimized && !next.minimized.includes(widget.key) ? [...next.minimized, widget.key] : next.minimized
+        };
+      }
+      return next;
+    });
+  }
+  const placedKeys = /* @__PURE__ */ new Set();
+  for (const p of pages) {
+    for (const k of [...p.order, ...p.hidden]) placedKeys.add(k);
+  }
+  const pinnedKeys = new Set(pinned.map((d) => d.key));
+  const unplaced = defs.filter((d) => !placedKeys.has(d.key) && !pinnedKeys.has(d.key)).map((definition, index) => ({ definition, index })).sort(
+    (a, b) => (a.definition.sortOrder ?? 0) - (b.definition.sortOrder ?? 0) || a.index - b.index
+  ).map(({ definition }) => definition);
+  for (const widget of unplaced) {
+    const home = homePageKey(work(), widget);
+    pages = pages.map(
+      (p) => p.key === home ? { ...p, order: [...p.order, widget.key] } : p
+    );
+  }
+  for (let i = 0; i < pages.length; i += 1) {
+    const page = pages[i];
+    const shown = pageWidgets(defs, work(), page.key);
+    const fits = fitCount(shown, rowsAllowed(page, options));
+    if (fits >= shown.length) continue;
+    const moving = shown.slice(fits).filter((d) => !pinnedKeys.has(d.key)).map((d) => d.key);
+    if (moving.length === 0) continue;
+    const moveSet = new Set(moving);
+    const movedMinimized = page.minimized.filter(
+      (k) => moveSet.has(k)
+    );
+    pages = pages.map(
+      (p) => p.key === page.key ? {
+        ...p,
+        order: p.order.filter((k) => !moveSet.has(k)),
+        minimized: p.minimized.filter((k) => !moveSet.has(k))
+      } : p
+    );
+    let placed = false;
+    for (let j = i + 1; j < pages.length && !placed; j += 1) {
+      const candidate = pages[j];
+      const trial = pages.map(
+        (p) => p.key === candidate.key ? {
+          ...p,
+          order: [...moving, ...p.order],
+          minimized: [...p.minimized, ...movedMinimized]
+        } : p
+      );
+      const items = pageWidgets(
+        defs,
+        { ...locked, pages: trial },
+        candidate.key
+      );
+      if (placeRows(items).length <= rowsAllowed(candidate, options)) {
+        pages = trial;
+        placed = true;
+      }
+    }
+    if (!placed) {
+      const key = nextPageKey(work());
+      const title = uniqueTitle(
+        new Set(pages.map((p) => normalizedTitle(p.title))),
+        `Page ${pages.length + 1}`,
+        pages.length
+      );
+      pages = [
+        ...pages,
+        { key, title, order: moving, hidden: [], minimized: movedMinimized }
+      ];
+    }
+  }
+  const result = work();
+  return samePages(layout.pages ?? [], pages) && sameKeys(layout.order, result.order) ? layout : result;
+}
+
 // src/core/scale.ts
 function niceStep(value) {
   if (!(value > 0) || !Number.isFinite(value)) return 1;
@@ -1499,10 +2067,15 @@ exports.DEFAULT_COMPARISON_LABEL = DEFAULT_COMPARISON_LABEL;
 exports.DEFAULT_CURRENCY = DEFAULT_CURRENCY;
 exports.DEFAULT_DETAIL_PAGE_SIZE = DEFAULT_DETAIL_PAGE_SIZE;
 exports.DEFAULT_EMPTY_TEXT = DEFAULT_EMPTY_TEXT;
+exports.DEFAULT_PAGE_KEY = DEFAULT_PAGE_KEY;
+exports.DEFAULT_PAGE_ROWS = DEFAULT_PAGE_ROWS;
 exports.DETAIL_MODES = DETAIL_MODES;
 exports.EMPTY_LAYOUT = EMPTY_LAYOUT;
 exports.MAX_DETAIL_PAGE_SIZE = MAX_DETAIL_PAGE_SIZE;
 exports.MAX_GRAPH_SERIES = MAX_GRAPH_SERIES;
+exports.MAX_PAGE_ROWS = MAX_PAGE_ROWS;
+exports.MAX_PAGE_TITLE_LENGTH = MAX_PAGE_TITLE_LENGTH;
+exports.MAX_PARSED_PAGES = MAX_PARSED_PAGES;
 exports.MAX_REPORTED_PROBLEMS = MAX_REPORTED_PROBLEMS;
 exports.MAX_WIDGET_WIDTH = MAX_WIDGET_WIDTH;
 exports.MIN_WIDGET_WIDTH = MIN_WIDGET_WIDTH;
@@ -1511,6 +2084,8 @@ exports.WIDGET_FILLS = WIDGET_FILLS;
 exports.WIDGET_KINDS = WIDGET_KINDS;
 exports.WIDGET_SIZES = WIDGET_SIZES;
 exports.WIDTH_COLUMNS = WIDTH_COLUMNS;
+exports.addPage = addPage;
+exports.assignPages = assignPages;
 exports.baseColumnSpan = baseColumnSpan;
 exports.cacheKeyFor = cacheKeyFor;
 exports.createWidgetLoader = createWidgetLoader;
@@ -1527,10 +2102,12 @@ exports.fillColumnSpans = fillColumnSpans;
 exports.fillWidthSpans = fillWidthSpans;
 exports.fillsHeight = fillsHeight;
 exports.fillsWidth = fillsWidth;
+exports.fitCount = fitCount;
 exports.formatCount = formatCount;
 exports.formatPercentChange = formatPercentChange;
 exports.formatValue = formatValue;
 exports.fromLegacyDefinition = fromLegacyDefinition;
+exports.hasPages = hasPages;
 exports.hiddenWidgets = hiddenWidgets;
 exports.hideWidget = hideWidget;
 exports.isHidden = isHidden;
@@ -1546,19 +2123,32 @@ exports.kpiDelta = kpiDelta;
 exports.labelStride = labelStride;
 exports.loadingWidgets = loadingWidgets;
 exports.minimizeWidget = minimizeWidget;
+exports.movePage = movePage;
 exports.moveWidget = moveWidget;
 exports.moveWidgetBy = moveWidgetBy;
 exports.moveWidgetDown = moveWidgetDown;
+exports.moveWidgetToPage = moveWidgetToPage;
 exports.moveWidgetUp = moveWidgetUp;
+exports.nextPageKey = nextPageKey;
 exports.niceDomain = niceDomain;
 exports.niceStep = niceStep;
+exports.normalizeLayout = normalizeLayout;
 exports.ok = ok;
+exports.pageLayout = pageLayout;
+exports.pageList = pageList;
+exports.pageOf = pageOf;
+exports.pageRoom = pageRoom;
+exports.pageWidgets = pageWidgets;
 exports.parseDetailQuery = parseDetailQuery;
 exports.parseLayout = parseLayout;
 exports.percentChange = percentChange;
+exports.placeRows = placeRows;
 exports.pruneLayout = pruneLayout;
 exports.queryRows = queryRows;
+exports.removePage = removePage;
+exports.renamePage = renamePage;
 exports.resolveDetailOptions = resolveDetailOptions;
+exports.resolvePageKey = resolvePageKey;
 exports.resolvePayload = resolvePayload;
 exports.resolveTableControls = resolveTableControls;
 exports.resolveWidget = resolveWidget;
@@ -1581,5 +2171,6 @@ exports.validateWidgetDefinition = validateWidgetDefinition;
 exports.visibleWidgets = visibleWidgets;
 exports.widgetsFor = widgetsFor;
 exports.widthForSize = widthForSize;
+exports.withPageLayout = withPageLayout;
 //# sourceMappingURL=core.cjs.map
 //# sourceMappingURL=core.cjs.map