@n-uf/placement 26.11.8 → 26.11.10

package/CHANGELOG.md

@@ -3,6 +3,61 @@
 Versions are calendar versions, `YY.M.R` (year, month of the release, counter within the month), shared with
 `@n-uf/motion`: both packages carry the same version, and a release bumps both.
 
+## 26.11.10
+
+- `@n-uf/placement/panels`, bands and reserved room (all opt-in; a state and options without them lay out as before,
+  and the store stays v1):
+  - Bands: a top and a bottom dock (`options.bands`, `{ top?, bottom? }`, each `{ mode: "reserved" | "overlay",
+    span: "between" | "full" }`). Its panels sit side by side and share its width (`kind` `"band"`, `edge`, `index`);
+    a stored height clamped to `PanelDef.band` (default `BAND_SIZE`, min 120, max 480, natural 200). It folds as a
+    whole, to one bar. `layout.bands` (`PlacedBand`). New: `Edge`, `EDGES`, `Place`, `Band`, `BandOption`,
+    `PanelsState.bands`, `PanelsStart.top` / `bottom`, `dockBand`, `resizeBand`, `bandSize`, `bandHeight`;
+    `open(state, id, { edge, height? })`; `Where` and `PanelPlace` gain a `band` kind; `PanelDef.sides` may name
+    edges.
+  - Height give-way for bands: `options.pagesMinHeight` (default 240). Reserved bands shrink, then fold to a bar,
+    unkept before kept, policy order, bottom first on a tie, until the pages keep the min; then the overlay bands,
+    together, until they leave the min of the pages uncovered. Notes `band-shrunk`, `band-folded`, `kept-folded` with
+    `edge`; `pages-short` when the pages' rect is still under the min (overlay bands never cause it); `band-off` for a
+    band on an edge the options don't enable.
+  - Reserved room: `options.reserve` (`{ top?, right?, bottom?, left? }`) keeps px clear along the pages' edges for an
+    app's toolbar; `layout.reserved` has the rects. `pagesMin` and `pagesMinHeight` count after it. An overlay band
+    lies next to the reserve on its edge, on the pages' side, never over it.
+  - Targets `band:<edge>:<i>` and `band:<edge>` (an empty enabled edge). The stored form carries `bands` (an optional
+    v1 field).
+  - Typing: `PanelKind`, `PanelPlace`, `Where` and `PanelsNote` gain members, and `@n-uf/placement/desk`'s `PresetId`
+    gains `"docksFull"` (so `PRESETS` has a fourth key), so an exhaustive `switch` over them, or a `Record` keyed by
+    `PresetId`, in a consumer needs the new cases.
+- `@n-uf/placement/desk`: `docks` and `dockTear` get a bottom band (reserved, between the columns); a new preset
+  `docksFull` (the bottom band full width). `DeskHint.bottom` starts the band; else the last def whose `sides` names
+  `"bottom"`. `navigator` has no band. Because the band is enabled, `docks` and `dockTear` now always offer a
+  `band:bottom` drop strip along the pages' bottom, even when the band is empty (a drop there used to be a float in
+  `dockTear`, and no drop in `docks`).
+- Known limit: with `pagesMinHeight` below about 100 px on a very short stage, a column can be shorter than its title
+  bars, which then run past it (column bars were always a fixed `options.bar` tall). Keep the default 240, or at least
+  a few bars' height, when bands are on.
+
+## 26.11.9
+
+- `@n-uf/placement/panels`:
+  - Tabs: `Column.show` (`"stack"`, the default, or `"tabs"`) and `Column.active`. A tabbed column draws a strip
+    `options.tabs` tall (new chrome size, default 28; `PlacedColumn.strip`); its active panel takes the rest and the
+    others are `hidden`, each with its `tab` rect in the strip. It folds as a whole: its active panel folded shows only
+    the strip, every panel folded goes to the rail (or rides). `showTabs(state, side, index, on)`, `activate(state, id)`
+    (a use). A drop `into` a tabbed column adds a tab at the end and shows it, and so does `open` on a panel in one; a
+    panel that leaves takes its `active` mark with it. With no `active` (or one that isn't there), the column shows its
+    first panel that isn't closed.
+  - Height give-way, opt-in: `PanelDef.height` (`{ min, natural }`). In a stack column where an open section has one,
+    sections get their natural heights and the last open one the rest (never under its min); sections without one
+    share what is left, never under a bar's height. The others' natural heights give way toward their mins first;
+    still short of room, open sections fold to bars in give-way policy order (kept last, never the last open one, never
+    one whose min is no more than a bar), note `section-folded`. It never writes `folded`. Columns without `height`
+    defs are unchanged.
+  - The stored form carries a column's `show` and `active` (optional v1 fields); an `active` that isn't in its column
+    is dropped as `"column.active:<id>"`, an unknown `show` as `"column.show"`.
+- New entry `@n-uf/placement/desk`: presets as data on `./panels` (`docks`, `dockTear`, `navigator`; `PRESETS`,
+  `presetLayout`, `presetTargets`, `presetDrop`, `presetInput`). It imports only `./panels`' public index (a guard test
+  holds it to that) and carries no titles, words or toolbar wiring. `./dock` is unchanged.
+
 ## 26.11.8
 
 - `@n-uf/placement/panels`:

package/README.md

@@ -34,9 +34,11 @@ without importing each other: a target list from `@n-uf/placement/targets` is ex
 - **`/targets`**: drop targets (`{ id, priority, hit, slot?, label?, free? }`) for the desk's constructions,
   toolbar hosts (each with its `slot`, and `allows` to leave out places a group may not take) and pane zones; and
   `keyboardStops`, one ordered list of places for the arrow keys and a "Move to" menu.
-- **`/panels`**: tool panels with string ids: full-height columns per side, each with its own width; folding to a
-  title bar or a rail; give-way by age when the pages run out of room; resizable floats, some pinned to the view;
-  their drop targets; and a stored form.
+- **`/panels`**: tool panels with string ids: full-height columns per side, each with its own width, shown as a
+  stack of sections or as tabs; folding to a title bar or a rail; give-way by age when the pages run out of room (and,
+  opt-in, when a column runs out of height); resizable floats, some pinned to the view; their drop targets; and a
+  stored form.
+- **`/desk`**: desk presets (`docks`, `dockTear`, `navigator`) as data on `/panels`: options and a start state.
 
 Rendering stays in the app: it draws the rects, measures its groups, and feeds pointer samples to a drag intent.
 
@@ -210,9 +212,96 @@ gain its room), and its stored place and width are untouched, so unfolding puts
 every column on a side is folded does the side show its rail. Give-way's folds (`column-folded`, `kept-folded`) go to
 the rail in both modes.
 
+**Tabs**: a column with `show: "tabs"` shows one panel at a time, its `active` one (default, or when `active` isn't
+one of them: the first panel in the column that isn't closed), under a strip
+`options.tabs` tall (default 28). The strip is `PlacedColumn.strip`, and each panel's `tab` is its header's rect in it
+(panel order, equal widths); the others are `hidden`. A tabbed column folds as a whole: with its active panel in
+`folded` it shows only its strip (the active panel is a `"bar"` there); with every panel folded it goes to the rail,
+or rides, as a stack column does. `showTabs(state, side, index, on)` switches a column; `activate(state, id)` shows a
+tab and counts as a use. A drop `into` a tabbed column adds a tab at the end and shows it, and `open` on a panel in a
+tabbed column shows its tab too.
+
+**Section heights** (opt-in): a `PanelDef.height` (`{ min, natural }`) gives a section of a stack column its natural
+height; the column's last open section takes the rest, never under its min, and sections without one share what is
+left equally, never under a bar's height (`options.bar`). The others' natural heights give way toward their mins
+first. When the open sections' mins and the bars still don't fit, open sections fold to bars by the give-way policy
+(kept last, never the last open one, and never one whose min is no more than a bar, since folding it gains nothing),
+each with a `section-folded` note; that never writes `folded`, so a taller stage unfolds them. Columns without
+`height` defs lay out as before.
+
 **Changes** are pure: `open`, `close`, `focus`, `toggleFold`, `keep`, `dock(state, id, side, index, { into?, width? })`,
 `float`, `pin(state, id, on, view?, shown?)` (pass the layout's rect as `shown` so a clamped float pins where it
-shows), `resizeColumn`, `resizeFloat`.
+shows), `resizeColumn`, `resizeFloat`, `showTabs`, `activate`, and for bands `dockBand`, `resizeBand`.
+
+### Bands
+
+A band is a horizontal dock along the stage's top or bottom edge (opt-in: `options.bands`, default none). Its panels
+sit side by side, left to right, and share its width equally; it has one stored height, clamped to its panels' limits
+(`PanelDef.band`, default `BAND_SIZE`: min 120, max 480, natural 200; the largest min and the smallest max win, as a
+column's width does). Each enabled edge says how its band lies:
+
+- `mode: "reserved"` shortens the pages; `"overlay"` lies over the pages' upper or lower part (layer 5, over columns'
+  layer 0 and under floats) and leaves the pages' rect as it is.
+- `span: "full"` takes its height from the stage first, across the whole width, and the columns and rails stand on it
+  (or hang from it); `"between"` runs between the innermost open column (or rail) on each side.
+
+A band's open panels are `kind` `"band"` (with `edge` and `index`); `layout.bands` has each band as laid out
+(`PlacedBand`: `rect`, `height`, `min`, `max`, `folded`, `shrunk`, `kept`, `mode`, `span`, `panels`). It folds as a
+whole: `toggleFold` on any of its panels folds or unfolds them all, and a folded band is one bar, `options.bar` tall,
+each panel a `"bar"` side by side. `keep` works on band panels.
+
+**Height give-way**: when the pages would be shorter than `pagesMinHeight` (default 240; counted after the top and
+bottom reserves), reserved bands shrink toward their min, then fold to a bar, unkept before kept, in the give-way
+policy's order, bottom before top on a tie (`band-shrunk`, `band-folded`, or `kept-folded` with `edge`); they leave the
+pages room for the overlay bands' bars at least. Then the overlay bands give way the same way, together, until they leave
+`pagesMinHeight` of the pages uncovered, so a top and a bottom one never meet. Give-way never writes `folded`, so a
+taller stage brings a band back. If the pages' rect is still under the min: `pages-short` (overlay bands don't change
+the pages' rect, so they never cause it; how far one covers the pages is its own `band-shrunk` or `band-folded`).
+Columns never give way by height to a band.
+
+`dockBand(state, id, edge, index, defs?)` puts a panel into a band (0 the leftmost, past the end the rightmost; a new
+band takes the panel's natural band height); `open(state, id, { edge, height? })` puts a panel placed nowhere at a
+band's right end; `liftPanel`, `dock` and `float` take a panel out, and an emptied band goes from the state.
+`createPanels` takes `top` and `bottom` (the clock counts left, right, top, bottom, floats). A band in the state on an
+edge the options don't enable is left out of `items` (`band-off`). A def's `sides` may name edges: without `sides` a
+panel may go to every enabled edge; with them, only where they say. The drop targets add `band:<edge>:<i>` (the slots
+at a band's ends and between its panels, the band split at its panels' middles) and, on an empty enabled edge,
+`band:<edge>` (a strip `2 × bar` tall along it inside the pages); a drop's `slot` is the panel's share of the band.
+
+```ts
+import { createPanels, layoutPanels, panelTargets, type PanelDef } from "@n-uf/placement/panels";
+
+const defs: PanelDef[] = [
+  { id: "files", width: { min: 180, natural: 220, max: 360 } },
+  { id: "history", width: { min: 200, natural: 240, max: 360 }, band: { min: 100, max: 400, natural: 180 } },
+];
+const state = createPanels(defs, { left: [["files"]], bottom: ["history"] });
+const options = { bands: { bottom: { mode: "reserved", span: "between" } } } as const;
+const tall = layoutPanels(defs, state, { width: 1200, height: 700 }, options);
+console.log(tall.bands.bottom!.rect, tall.pages); // { x: 220, y: 520, width: 980, height: 180 } { x: 220, y: 0, width: 980, height: 520 }
+const short = layoutPanels(defs, state, { width: 1200, height: 300 }, options);
+console.log(short.notes.map((n) => n.code), short.items.get("history")!.kind); // [ 'band-folded' ] bar
+const targets = panelTargets({ defs, state, id: "files", stage: { width: 1200, height: 700 }, options });
+console.log(targets.filter((t) => t.place.kind === "band").map((t) => t.id)); // [ 'band:bottom:0', 'band:bottom:1' ]
+```
+
+### Reserved room
+
+`options.reserve` (`{ top?, right?, bottom?, left? }`, px, default none) keeps room clear along the pages' edges for a
+toolbar the app draws; `./toolbar` stays the toolbar's model, and placement neither draws nor names it. The reserve
+comes off the pages' area after the columns and bands: `layout.reserved.top` is the pages' full width and `reserve.top`
+tall at their top (bottom likewise), and the left and right reserves are as tall as what the top and bottom reserves
+(and overlay bands) leave. `pagesMin` counts after the left and right reserves, `pagesMinHeight` after the top and
+bottom ones; a reserve never shrinks or folds. An overlay band lies next to the reserve on its edge, on the pages' side, never over it.
+
+```ts
+// The defs and state above; without band options the band is off (a `band-off` note).
+const l = layoutPanels(defs, state, { width: 1200, height: 700 }, { reserve: { top: 40 } });
+console.log(l.reserved.top, l.pages); // { x: 220, y: 0, width: 980, height: 40 } { x: 220, y: 40, width: 980, height: 660 }
+```
+
+Without band options, no `bands` in the state and no reserve, every layout, target and note is what it was before
+bands.
 
 **Drop targets**: `panelTargets({ defs, state, id, stage, options?, allows? })` gives `column:<side>:<i>` (a new
 column as wide as the panel's own width), `into:<side>:<i>` (stack into a column), `rail:<side>` (dock folded) and
@@ -243,17 +332,64 @@ console.log(stops.map((s) => (s.home ? "home" : s.id))); // [ 'rail:left', 'colu
 parsed data back and never throws. Anything but an object of version 1 is `{ ok: false, error }`; inside one, unknown
 or repeated ids and malformed entries are dropped and listed in `dropped`, and widths and float sizes are clamped to
 the defs. Version 1 only gains optional fields: a field this reader doesn't know is skipped and listed in `dropped`
-too (`"theme"`, `"sides.bottom"`, `"column.<field>"`, `"float.<field>"`, `"clock.<id>"`). The note codes
-(`PanelsNoteCode`):
+too (`"theme"`, `"sides.bottom"`, `"column.<field>"`, `"float.<field>"`, `"clock.<id>"`). A column's `show` and
+`active` are carried; an `active` that isn't one of the column's panels is dropped as `"column.active:<id>"`. `bands`
+is carried too, only when the state has one: an unknown edge is dropped as `"bands.<key>"`, a band without a panels
+list or a numeric height (or whose panels are all dropped) as `"bands.<edge>"`, an unknown field in one as
+`"band.<field>"`, and heights are clamped to the defs. The note codes (`PanelsNoteCode`):
 
 | Code | Says | Also |
 |---|---|---|
 | `column-shrunk` | a column narrowed toward its minimum | `side`, `column`, `items`, `from`, `to` |
 | `column-folded` | a column folded to its side's rail | `side`, `column`, `items` |
 | `kept-folded` | a kept column folded: the pages needed the room | `side`, `column`, `items` |
+| `section-folded` | a section of a stack column folded to a bar: the column was short | `side`, `column`, `items` |
 | `pages-under-min` | the pages are under `pagesMin` with every column folded | `width`, `min` |
 | `float-resized` | a float shrank to fit the view | `items` |
 | `float-clamped` | a float moved to stay in the view | `items` |
+| `band-shrunk` | a band lowered toward its min: the pages needed the height | `edge`, `items`, `from`, `to` |
+| `band-folded` | a band folded to a bar: the pages needed the height | `edge`, `items` |
+| `kept-folded` | (on a band) a kept band folded, last | `edge`, `items` |
+| `band-off` | a band on an edge the options don't enable: its panels aren't laid out | `edge`, `items` |
+| `pages-short` | the pages' rect is under `pagesMinHeight` with every reserved band folded (or by the reserves alone) | `height`, `min` |
+
+## Desk presets
+
+`@n-uf/placement/desk` holds desk presets as data on `./panels`: each is panels options and a start state. It imports
+only the panels entry, carries no titles or words and wires no toolbar; the app names the presets and draws them.
+
+| Preset | Columns, bands and floats |
+|---|---|
+| `docks` | one stack column per side, sections at their natural heights when the defs give `height`, folding to the rail; a bottom band between the columns (reserved), folding to a bar on a short stage; no floats |
+| `docksFull` | as `docks`, with the bottom band full width: the columns stand on it |
+| `dockTear` | as `docks` (with its bottom band), and panels may float (tear-off and dock-back); one panel floats at the start |
+| `navigator` | a tabbed column on the left, a stack column on the right; no band, no floats |
+
+The bottom band starts with the hint's `bottom` panels (`start(defs, { bottom: [...] })`), else with the last def whose
+`sides` names `"bottom"`; a def without `sides` may be dropped into the band but doesn't start there. `presetTargets`
+and `presetDrop` include the band's targets.
+
+```ts
+import { PRESETS, presetLayout, presetTargets } from "@n-uf/placement/desk";
+import type { PanelDef } from "@n-uf/placement/panels";
+
+const defs: PanelDef[] = [
+  { id: "files", width: { min: 200, natural: 240, max: 360 }, height: { min: 80, natural: 160 } },
+  { id: "outline", width: { min: 200, natural: 240, max: 360 }, height: { min: 80, natural: 200 } },
+  { id: "history", width: { min: 200, natural: 240, max: 360 } },
+];
+const nav = PRESETS.navigator;
+const state = nav.start(defs, { left: ["files", "outline"] });
+const layout = presetLayout(nav, defs, state, { width: 1200, height: 600 });
+console.log(layout.columns[0]!.strip, layout.items.get("outline")!.hidden); // { x: 0, y: 0, width: 240, height: 28 } true
+const targets = presetTargets(nav, { defs, state, id: "history", stage: { width: 1200, height: 600 } });
+console.log(targets.some((t) => t.id === "float")); // false
+```
+
+`presetLayout(preset, defs, state, stage, options?)` is `layoutPanels` with the preset's options under the caller's;
+`presetTargets(preset, input)` and `presetDrop(preset, input, target, point, grab)` are `panelTargets` and `panelDrop`
+the same way, offering only the places the preset allows (`presetInput` gives that input). `./dock` stays as it is for
+now.
 
 ## Pane zones
 

package/dist/chunk-7R5H2ABL.js

@@ -0,0 +1,172 @@
+import {
+  EDGES,
+  SIDES,
+  bandSize,
+  defOf,
+  floatSize
+} from "./chunk-PJD5HKYX.js";
+
+// src/panels/store.ts
+function storePanels(state) {
+  const column = (c) => ({
+    panels: [...c.panels],
+    width: c.width,
+    ...c.show === "tabs" ? { show: "tabs" } : {},
+    ...c.active !== void 0 ? { active: c.active } : {}
+  });
+  const sides = Object.fromEntries(SIDES.map((s) => [s, state.sides[s].map(column)]));
+  const bands = {};
+  for (const e of EDGES) {
+    const b = state.bands?.[e];
+    if (b) bands[e] = { panels: [...b.panels], height: b.height };
+  }
+  return {
+    v: 1,
+    sides,
+    ...EDGES.some((e) => bands[e]) ? { bands } : {},
+    floats: state.floats.map((f) => ({ id: f.id, rect: { x: f.rect.x, y: f.rect.y, width: f.rect.width, height: f.rect.height }, pinned: !!f.pinned })),
+    folded: [...state.folded],
+    kept: [...state.kept],
+    closed: [...state.closed],
+    clock: Object.fromEntries(Object.entries(state.clock).map(([k, c]) => [k, { opened: c.opened, used: c.used }]))
+  };
+}
+var isObject = (x) => typeof x === "object" && x !== null && !Array.isArray(x);
+var finite = (x) => typeof x === "number" && Number.isFinite(x);
+function readPanels(data, defs) {
+  try {
+    return read(data, defs);
+  } catch (e) {
+    return { ok: false, error: `unreadable: ${e instanceof Error ? e.message : typeof e}` };
+  }
+}
+function read(data, defs) {
+  if (!isObject(data)) return { ok: false, error: "not an object" };
+  if (data.v !== 1) return { ok: false, error: `unknown version ${typeof data.v === "number" || typeof data.v === "string" ? String(data.v) : typeof data.v} (this reads version 1)` };
+  if (!isObject(data.sides)) return { ok: false, error: "sides is missing" };
+  const dropped = [];
+  const drop = (what) => {
+    if (!dropped.includes(what)) dropped.push(what);
+  };
+  const seen = /* @__PURE__ */ new Set();
+  const take = (x) => {
+    if (typeof x !== "string") {
+      drop(`a ${typeof x} where an id goes`);
+      return null;
+    }
+    if (defs && !defOf(defs, x) || seen.has(x)) {
+      drop(x);
+      return null;
+    }
+    seen.add(x);
+    return x;
+  };
+  const extra = (o, known, prefix) => {
+    for (const k of Object.keys(o)) if (!known.includes(k)) drop(`${prefix}${k}`);
+  };
+  extra(data, ["v", "sides", "bands", "floats", "folded", "kept", "closed", "clock"], "");
+  extra(data.sides, SIDES, "sides.");
+  const sides = { left: [], right: [] };
+  for (const side of SIDES) {
+    const cols = data.sides[side];
+    if (cols === void 0) continue;
+    if (!Array.isArray(cols)) {
+      drop(`sides.${side}`);
+      continue;
+    }
+    for (const c of cols) {
+      if (!isObject(c) || !Array.isArray(c.panels)) {
+        drop(`a column on the ${side}`);
+        continue;
+      }
+      extra(c, ["panels", "width", "show", "active"], "column.");
+      const panels = c.panels.map(take).filter((x) => x !== null);
+      if (panels.length === 0) continue;
+      const ds = defs ? panels.map((id) => defOf(defs, id)) : [];
+      const lo = Math.max(0, ...ds.map((d) => d.width.min));
+      const hi = Math.max(lo, Math.min(...ds.map((d) => d.width.max)));
+      const natural = ds.length ? Math.max(...ds.map((d) => d.width.natural)) : 0;
+      const width = finite(c.width) ? c.width : natural;
+      if (c.show !== void 0 && c.show !== "tabs" && c.show !== "stack") drop("column.show");
+      if (c.active !== void 0 && !(typeof c.active === "string" && panels.includes(c.active))) drop(`column.active:${typeof c.active === "string" ? c.active : typeof c.active}`);
+      const tabs = c.show === "tabs" ? { show: "tabs" } : {};
+      const active = typeof c.active === "string" && panels.includes(c.active) ? { active: c.active } : {};
+      sides[side].push({ panels, width: defs ? Math.min(Math.max(width, lo), hi) : Math.max(0, width), ...tabs, ...active });
+    }
+  }
+  const bands = {};
+  if (data.bands !== void 0) {
+    if (!isObject(data.bands)) drop("bands");
+    else {
+      extra(data.bands, EDGES, "bands.");
+      for (const e of EDGES) {
+        const b = data.bands[e];
+        if (b === void 0) continue;
+        if (!isObject(b) || !Array.isArray(b.panels) || !finite(b.height)) {
+          drop(`bands.${e}`);
+          continue;
+        }
+        extra(b, ["panels", "height"], "band.");
+        const panels = b.panels.map(take).filter((x) => x !== null);
+        if (panels.length === 0) {
+          drop(`bands.${e}`);
+          continue;
+        }
+        const ds = defs ? panels.map((id) => bandSize(defOf(defs, id))) : [];
+        const lo = Math.max(0, ...ds.map((d) => d.min));
+        const hi = Math.max(lo, Math.min(...ds.map((d) => d.max)));
+        bands[e] = { panels, height: defs ? Math.min(Math.max(b.height, lo), hi) : Math.max(0, b.height) };
+      }
+    }
+  }
+  const floats = [];
+  for (const f of Array.isArray(data.floats) ? data.floats : []) {
+    const r = isObject(f) ? f.rect : void 0;
+    if (!isObject(f) || !isObject(r) || !finite(r.x) || !finite(r.y) || !finite(r.width) || !finite(r.height)) {
+      drop(isObject(f) && typeof f.id === "string" ? f.id : "a float");
+      continue;
+    }
+    extra(f, ["id", "rect", "pinned"], "float.");
+    const id = take(f.id);
+    if (id === null) continue;
+    const min = defs ? floatSize(defOf(defs, id)).min : { width: 0, height: 0 };
+    floats.push({ id, rect: { x: r.x, y: r.y, width: Math.max(min.width, r.width), height: Math.max(min.height, r.height) }, ...f.pinned === true ? { pinned: true } : {} });
+  }
+  if (data.floats !== void 0 && !Array.isArray(data.floats)) drop("floats");
+  const placed = (key) => {
+    const x = data[key];
+    if (x === void 0) return [];
+    if (!Array.isArray(x)) {
+      drop(key);
+      return [];
+    }
+    const out = [];
+    for (const id of x) {
+      if (typeof id === "string" && seen.has(id)) {
+        if (!out.includes(id)) out.push(id);
+      } else drop(typeof id === "string" ? id : `a ${typeof id} in ${key}`);
+    }
+    return out;
+  };
+  const floating = new Set(floats.map((f) => f.id));
+  const kept = placed("kept").filter((id) => {
+    if (floating.has(id)) drop(id);
+    return !floating.has(id);
+  });
+  const clock = {};
+  if (isObject(data.clock)) {
+    for (const id of Object.keys(data.clock)) if (!seen.has(id)) drop(`clock.${id}`);
+    for (const id of seen) {
+      const c = data.clock[id];
+      clock[id] = isObject(c) && finite(c.opened) && finite(c.used) ? { opened: c.opened, used: c.used } : { opened: 0, used: 0 };
+    }
+  }
+  const state = { sides, floats, folded: placed("folded"), kept, closed: placed("closed"), clock };
+  return { ok: true, state: EDGES.some((e) => bands[e]) ? { ...state, bands } : state, dropped };
+}
+
+export {
+  storePanels,
+  readPanels
+};
+//# sourceMappingURL=chunk-7R5H2ABL.js.map

package/dist/chunk-7R5H2ABL.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/panels/store.ts"],"sourcesContent":["/**\n * The panels' stored form: `storePanels(state)` gives plain JSON-safe data (`{ v: 1, … }`); `readPanels(data, defs?)`\n * reads parsed data back and never throws. As with the toolbar's `readArrangement`: anything but an object of\n * version 1 is `{ ok: false, error }`. Inside one, it is lenient: an unknown id (with `defs`), a repeated one or a\n * malformed entry is dropped and listed in `dropped`; widths and float sizes are clamped to the defs. A panel the\n * consumer has but the stored state lacks is no error: the consumer places it (`open` with a place, say).\n *\n * Version 1 only gains optional fields. A field this reader doesn't know (a newer writer's, say) is no error either:\n * it is skipped and reported in `dropped` (`\"<field>\"` at the top, `\"sides.<key>\"`, `\"column.<field>\"`,\n * `\"float.<field>\"`; a clock entry for a panel that isn't placed as `\"clock.<id>\"`), so a consumer can tell that\n * something was left out. A column's `show` (\"tabs\") and `active` are such optional fields: an unknown `show` is\n * dropped as `\"column.show\"`, an `active` that isn't one of the column's panels as `\"column.active:<id>\"`.\n *\n * `bands` (26.11.10) is such an optional field too: `{ top?, bottom? }`, each `{ panels, height }`. An unknown edge is\n * dropped as `\"bands.<key>\"`, a band that isn't an object with a panels list and a numeric height (or whose panels are\n * all dropped) as `\"bands.<edge>\"`, an unknown field in one as `\"band.<field>\"`. Heights are clamped to the defs.\n */\nimport type { Rect } from \"../geometry\";\nimport { EDGES, SIDES, bandSize, defOf, floatSize, type Band, type Clock, type Column, type Edge, type FloatAt, type PanelDef, type PanelsState, type Side } from \"./model\";\n\nexport interface StoredPanels {\n  readonly v: 1;\n  /** A column's `show` and `active` only when it is tabbed / has one (optional fields of v1). */\n  readonly sides: Record<Side, { panels: string[]; width: number; show?: \"tabs\"; active?: string }[]>;\n  /** The bands, only when the state has one (an optional field of v1). */\n  readonly bands?: Partial<Record<Edge, { panels: string[]; height: number }>>;\n  readonly floats: { id: string; rect: Rect; pinned: boolean }[];\n  readonly folded: string[];\n  readonly kept: string[];\n  readonly closed: string[];\n  readonly clock: Record<string, Clock>;\n}\n\nexport type PanelsRead = { readonly ok: true; readonly state: PanelsState; readonly dropped: readonly string[] } | { readonly ok: false; readonly error: string };\n\nexport function storePanels(state: PanelsState): StoredPanels {\n  const column = (c: Column): StoredPanels[\"sides\"][\"left\"][number] => ({\n    panels: [...c.panels],\n    width: c.width,\n    ...(c.show === \"tabs\" ? { show: \"tabs\" as const } : {}),\n    ...(c.active !== undefined ? { active: c.active } : {}),\n  });\n  const sides = Object.fromEntries(SIDES.map((s) => [s, state.sides[s].map(column)])) as StoredPanels[\"sides\"];\n  const bands: NonNullable<StoredPanels[\"bands\"]> = {};\n  for (const e of EDGES) {\n    const b = state.bands?.[e];\n    if (b) bands[e] = { panels: [...b.panels], height: b.height };\n  }\n  return {\n    v: 1,\n    sides,\n    ...(EDGES.some((e) => bands[e]) ? { bands } : {}),\n    floats: state.floats.map((f) => ({ id: f.id, rect: { x: f.rect.x, y: f.rect.y, width: f.rect.width, height: f.rect.height }, pinned: !!f.pinned })),\n    folded: [...state.folded],\n    kept: [...state.kept],\n    closed: [...state.closed],\n    clock: Object.fromEntries(Object.entries(state.clock).map(([k, c]) => [k, { opened: c.opened, used: c.used }])),\n  };\n}\n\nconst isObject = (x: unknown): x is Record<string, unknown> => typeof x === \"object\" && x !== null && !Array.isArray(x);\nconst finite = (x: unknown): x is number => typeof x === \"number\" && Number.isFinite(x);\n\nexport function readPanels(data: unknown, defs?: readonly PanelDef[]): PanelsRead {\n  try {\n    return read(data, defs);\n  } catch (e) {\n    // A getter that throws, a proxy: still no throw.\n    return { ok: false, error: `unreadable: ${e instanceof Error ? e.message : typeof e}` };\n  }\n}\n\nfunction read(data: unknown, defs?: readonly PanelDef[]): PanelsRead {\n  if (!isObject(data)) return { ok: false, error: \"not an object\" };\n  // Named without serialising it: a BigInt or a circular value must not throw.\n  if (data.v !== 1) return { ok: false, error: `unknown version ${typeof data.v === \"number\" || typeof data.v === \"string\" ? String(data.v) : typeof data.v} (this reads version 1)` };\n  if (!isObject(data.sides)) return { ok: false, error: \"sides is missing\" };\n  const dropped: string[] = [];\n  const drop = (what: string): void => {\n    if (!dropped.includes(what)) dropped.push(what);\n  };\n  const seen = new Set<string>();\n  // An id the consumer has, not placed yet.\n  const take = (x: unknown): string | null => {\n    if (typeof x !== \"string\") {\n      drop(`a ${typeof x} where an id goes`);\n      return null;\n    }\n    if ((defs && !defOf(defs, x)) || seen.has(x)) {\n      drop(x);\n      return null;\n    }\n    seen.add(x);\n    return x;\n  };\n  // Fields this version doesn't know: skipped, and reported.\n  const extra = (o: Record<string, unknown>, known: readonly string[], prefix: string): void => {\n    for (const k of Object.keys(o)) if (!known.includes(k)) drop(`${prefix}${k}`);\n  };\n  extra(data, [\"v\", \"sides\", \"bands\", \"floats\", \"folded\", \"kept\", \"closed\", \"clock\"], \"\");\n  extra(data.sides, SIDES, \"sides.\");\n  const sides = { left: [] as Column[], right: [] as Column[] };\n  for (const side of SIDES) {\n    const cols = data.sides[side];\n    if (cols === undefined) continue;\n    if (!Array.isArray(cols)) {\n      drop(`sides.${side}`);\n      continue;\n    }\n    for (const c of cols as unknown[]) {\n      if (!isObject(c) || !Array.isArray(c.panels)) {\n        drop(`a column on the ${side}`);\n        continue;\n      }\n      extra(c, [\"panels\", \"width\", \"show\", \"active\"], \"column.\");\n      const panels = (c.panels as unknown[]).map(take).filter((x): x is string => x !== null);\n      if (panels.length === 0) continue;\n      const ds = defs ? panels.map((id) => defOf(defs, id)!) : [];\n      const lo = Math.max(0, ...ds.map((d) => d.width.min));\n      const hi = Math.max(lo, Math.min(...ds.map((d) => d.width.max)));\n      const natural = ds.length ? Math.max(...ds.map((d) => d.width.natural)) : 0;\n      const width = finite(c.width) ? c.width : natural;\n      // `show`: \"tabs\" or \"stack\" (a stack is the default, so not kept); `active`: a panel of this column.\n      if (c.show !== undefined && c.show !== \"tabs\" && c.show !== \"stack\") drop(\"column.show\");\n      if (c.active !== undefined && !(typeof c.active === \"string\" && panels.includes(c.active))) drop(`column.active:${typeof c.active === \"string\" ? c.active : typeof c.active}`);\n      const tabs = c.show === \"tabs\" ? { show: \"tabs\" as const } : {};\n      const active = typeof c.active === \"string\" && panels.includes(c.active) ? { active: c.active } : {};\n      sides[side].push({ panels, width: defs ? Math.min(Math.max(width, lo), hi) : Math.max(0, width), ...tabs, ...active });\n    }\n  }\n  const bands: Partial<Record<Edge, Band>> = {};\n  if (data.bands !== undefined) {\n    if (!isObject(data.bands)) drop(\"bands\");\n    else {\n      extra(data.bands, EDGES, \"bands.\");\n      for (const e of EDGES) {\n        const b = data.bands[e];\n        if (b === undefined) continue;\n        if (!isObject(b) || !Array.isArray(b.panels) || !finite(b.height)) {\n          drop(`bands.${e}`);\n          continue;\n        }\n        extra(b, [\"panels\", \"height\"], \"band.\");\n        const panels = (b.panels as unknown[]).map(take).filter((x): x is string => x !== null);\n        if (panels.length === 0) {\n          drop(`bands.${e}`);\n          continue;\n        }\n        const ds = defs ? panels.map((id) => bandSize(defOf(defs, id))) : [];\n        const lo = Math.max(0, ...ds.map((d) => d.min));\n        const hi = Math.max(lo, Math.min(...ds.map((d) => d.max)));\n        bands[e] = { panels, height: defs ? Math.min(Math.max(b.height, lo), hi) : Math.max(0, b.height) };\n      }\n    }\n  }\n  const floats: FloatAt[] = [];\n  for (const f of Array.isArray(data.floats) ? (data.floats as unknown[]) : []) {\n    const r = isObject(f) ? f.rect : undefined;\n    if (!isObject(f) || !isObject(r) || !finite(r.x) || !finite(r.y) || !finite(r.width) || !finite(r.height)) {\n      drop(isObject(f) && typeof f.id === \"string\" ? f.id : \"a float\");\n      continue;\n    }\n    extra(f, [\"id\", \"rect\", \"pinned\"], \"float.\");\n    const id = take(f.id);\n    if (id === null) continue;\n    const min = defs ? floatSize(defOf(defs, id)).min : { width: 0, height: 0 };\n    floats.push({ id, rect: { x: r.x, y: r.y, width: Math.max(min.width, r.width), height: Math.max(min.height, r.height) }, ...(f.pinned === true ? { pinned: true } : {}) });\n  }\n  if (data.floats !== undefined && !Array.isArray(data.floats)) drop(\"floats\");\n  // The lists keep only ids that are placed (a closed panel keeps its place).\n  const placed = (key: \"folded\" | \"kept\" | \"closed\"): string[] => {\n    const x = data[key];\n    if (x === undefined) return [];\n    if (!Array.isArray(x)) {\n      drop(key);\n      return [];\n    }\n    const out: string[] = [];\n    for (const id of x as unknown[]) {\n      if (typeof id === \"string\" && seen.has(id)) {\n        if (!out.includes(id)) out.push(id);\n      } else drop(typeof id === \"string\" ? id : `a ${typeof id} in ${key}`);\n    }\n    return out;\n  };\n  const floating = new Set(floats.map((f) => f.id));\n  // Only a docked panel is kept open.\n  const kept = placed(\"kept\").filter((id) => {\n    if (floating.has(id)) drop(id);\n    return !floating.has(id);\n  });\n  const clock: Record<string, Clock> = {};\n  if (isObject(data.clock)) {\n    for (const id of Object.keys(data.clock)) if (!seen.has(id)) drop(`clock.${id}`);\n    for (const id of seen) {\n      const c = data.clock[id];\n      clock[id] = isObject(c) && finite(c.opened) && finite(c.used) ? { opened: c.opened, used: c.used } : { opened: 0, used: 0 };\n    }\n  }\n  const state: PanelsState = { sides, floats, folded: placed(\"folded\"), kept, closed: placed(\"closed\"), clock };\n  return { ok: true, state: EDGES.some((e) => bands[e]) ? { ...state, bands } : state, dropped };\n}\n"],"mappings":"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","names":[]}