@50arms/ui 0.0.0-stage → 35.1.0

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/lib/attention.js

@@ -0,0 +1,75 @@
+const u = ["glow", "pulse", "ripple", "beacon", "ring", "shimmer", "bounce", "wiggle"], a = ["bounce", "wiggle"];
+function R(n) {
+  const e = typeof n == "string" ? [n] : [...n];
+  if (e.length === 0) throw new RangeError("Attention: `effect` must name at least one effect, got an empty list");
+  for (const t of e)
+    if (!u.includes(t)) throw new RangeError(`Attention: unknown effect "${t}"`);
+  const o = u.filter((t) => e.includes(t)), s = o.filter((t) => a.includes(t));
+  return s.length > 1 ? { effects: o.filter((t) => !a.includes(t)), conflict: s } : { effects: o, conflict: null };
+}
+const m = ["beacon", "shimmer", "bounce", "wiggle"];
+function g(n) {
+  return m.includes(n);
+}
+const w = {
+  ripple: { slow: 6e3, normal: 4e3, fast: 2400 },
+  pulse: { slow: 4400, normal: 3e3, fast: 2e3 },
+  glow: { slow: 4400, normal: 3e3, fast: 2e3 },
+  ring: { slow: 6400, normal: 3800, fast: 2200 }
+}, M = { slow: 7e3, normal: 4500, fast: 2800 };
+function p(n, e, o) {
+  return g(n) ? o !== void 0 ? { cycleMs: i(o, "interval") } : typeof e == "number" ? { cycleMs: i(e, "speed") } : { cycleMs: M[e] } : typeof e == "number" ? { cycleMs: i(e, "speed") } : { cycleMs: w[n][e] };
+}
+function i(n, e) {
+  if (!Number.isFinite(n) || n <= 0)
+    throw new RangeError(`Attention: \`${e}\` must be a positive number of milliseconds, got ${n}`);
+  return n;
+}
+const f = { subtle: 0.75, medium: 1, strong: 1.25 };
+function h(n, e, o) {
+  const s = Math.min(n, e);
+  if (!(s > 0)) return null;
+  const t = c(s * 0.9, 18, 42) * f[o], l = c(s * 0.28, 6, 12) * f[o];
+  return {
+    reachPx: r(t),
+    diagonal: r(Math.hypot(n, e)),
+    reachX: r(1 + t / n),
+    reachY: r(1 + t / e),
+    swellX: r(1 + l / n),
+    swellY: r(1 + l / e),
+    /* A turn that is right for an icon is a swinging door on a card: the angle
+       shrinks as the thing gets longer, so the corners sweep about the same
+       distance whatever is wrapped. */
+    tilt: r(c(432 / Math.max(n, e), 1.5, 9))
+  };
+}
+const E = [
+  [1, 0.62, 0.84],
+  [0.7, 0.95, 0.55],
+  [0.9, 0.66, 1],
+  [0.58, 1, 0.76],
+  [0.84, 0.72, 0.94]
+], b = E.length;
+function y(n) {
+  if (!Number.isFinite(n)) throw new RangeError(`Attention: \`rings\` must be a number, got ${n}`);
+  return Math.min(b, Math.max(1, Math.round(n)));
+}
+function c(n, e, o) {
+  return Math.min(o, Math.max(e, n));
+}
+function r(n) {
+  return Math.round(n * 1e3) / 1e3;
+}
+export {
+  u as EFFECT_ORDER,
+  b as MAX_RINGS,
+  a as MOTION_EFFECTS,
+  m as PERIODIC_EFFECTS,
+  E as WAVE_REACH,
+  y as clampRings,
+  g as isPeriodic,
+  R as resolveEffects,
+  h as resolveReach,
+  p as resolveTiming
+};
+//# sourceMappingURL=attention.js.map

package/dist/lib/attention.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"attention.js","sources":["../../src/lib/attention.ts"],"sourcesContent":["/* ============================================================================\n   ATTENTION — the pure half: which timings, which sizes, which radii.\n\n   `Attention` draws everything with CSS, so the only decisions left for script\n   are numbers: how long one cycle takes, how far a wave reaches for the size of\n   the thing it surrounds, and how the ring radii vary. They live here, free of\n   React and the DOM, so a test can pin them without rendering anything.\n   ========================================================================= */\n\nexport type AttentionEffect =\n  | \"ripple\"\n  | \"pulse\"\n  | \"glow\"\n  | \"ring\"\n  | \"beacon\"\n  | \"shimmer\"\n  | \"bounce\"\n  | \"wiggle\";\n\nexport type AttentionSpeed = \"slow\" | \"normal\" | \"fast\" | number;\n\nexport type AttentionIntensity = \"subtle\" | \"medium\" | \"strong\";\n\n/* ----------------------------------------------------------------------------\n   COMBINING EFFECTS (DX-4504). `effect` takes one effect or several. Every\n   effect but two draws a layer of its own, and layers stack in ONE defined\n   order whatever order they were asked for in, so `[\"glow\", \"ripple\"]` and\n   `[\"ripple\", \"glow\"]` are the same picture. Bottom to top: the glow halo, the\n   pulse, the ripple circles, the beacon ping and the ring's arc behind the\n   control; the shimmer's glint over it.\n\n   `bounce` and `wiggle` draw no layer: they move the control itself (the\n   wrapper, so every layer moves with it, a glint included). A control cannot\n   hop and shake at once, so asking for both is refused: a type error for a\n   literal list, and at runtime a console error naming the conflict and neither\n   of them drawn. Never one picked silently.\n   -------------------------------------------------------------------------- */\n\n/** Bottom to top. The two that move the control come last: they are not layers, so they have no place in the stack. */\nexport const EFFECT_ORDER: readonly AttentionEffect[] = [\"glow\", \"pulse\", \"ripple\", \"beacon\", \"ring\", \"shimmer\", \"bounce\", \"wiggle\"];\n\n/** The effects that move the control itself, of which a wrapper can run one. */\nexport const MOTION_EFFECTS: readonly AttentionEffect[] = [\"bounce\", \"wiggle\"];\n\n/** One effect, or several to combine. */\nexport type AttentionEffects = AttentionEffect | readonly AttentionEffect[];\n\n/** What a literal list naming both `bounce` and `wiggle` becomes: an object whose one key is the reason, so the type error says it. */\nexport type AttentionEffectConflict = {\n  \"Attention: bounce and wiggle both move the control itself, so they cannot be combined; pick one\": never;\n};\n\n/**\n * `E` itself, unless it is a literal list naming both `bounce` and `wiggle`. A list whose contents are only known\n * at runtime (`AttentionEffect[]`) passes here and is checked by `resolveEffects`.\n */\nexport type ValidAttentionEffects<E> = E extends readonly AttentionEffect[]\n  ? number extends E[\"length\"]\n    ? E\n    : \"bounce\" extends E[number]\n      ? \"wiggle\" extends E[number]\n        ? AttentionEffectConflict\n        : E\n      : E\n  : E;\n\nexport interface ResolvedEffects {\n  /** The effects to draw, de-duplicated, in stacking order. */\n  effects: AttentionEffect[];\n  /** The motion effects that were asked for together and so are not drawn; `null` when there is no conflict. */\n  conflict: AttentionEffect[] | null;\n}\n\nexport function resolveEffects(effect: AttentionEffects): ResolvedEffects {\n  const asked = typeof effect === \"string\" ? [effect] : [...effect];\n  if (asked.length === 0) throw new RangeError(\"Attention: `effect` must name at least one effect, got an empty list\");\n  for (const one of asked) {\n    if (!EFFECT_ORDER.includes(one)) throw new RangeError(`Attention: unknown effect \"${one}\"`);\n  }\n  const unique = EFFECT_ORDER.filter((one) => asked.includes(one));\n  const motions = unique.filter((one) => MOTION_EFFECTS.includes(one));\n  if (motions.length > 1) {\n    return { effects: unique.filter((one) => !MOTION_EFFECTS.includes(one)), conflict: motions };\n  }\n  return { effects: unique, conflict: null };\n}\n\n/** Effects that rest between bursts. Their cycle is the gap between two bursts. */\nexport const PERIODIC_EFFECTS: readonly AttentionEffect[] = [\"beacon\", \"shimmer\", \"bounce\", \"wiggle\"];\n\nexport function isPeriodic(effect: AttentionEffect): boolean {\n  return PERIODIC_EFFECTS.includes(effect);\n}\n\n/* The slowest preset is genuinely slow. A click ripple takes ~0.6s; the\n   attention ripple takes ten times that to cross its distance, so it reads as\n   something breathing rather than something that was just pressed.\n\n   `ripple` is the time ONE wave takes to expand and fade. With three rings the\n   staggering is that time divided by three, so `normal` starts a new wave every\n   ~1.3s and `slow` every 2s: always two or three in flight, never a rhythm\n   fast enough to read as a loading indicator. */\nconst CONTINUOUS_MS: Record<\"ripple\" | \"pulse\" | \"glow\" | \"ring\", Record<\"slow\" | \"normal\" | \"fast\", number>> = {\n  ripple: { slow: 6000, normal: 4000, fast: 2400 },\n  pulse: { slow: 4400, normal: 3000, fast: 2000 },\n  glow: { slow: 4400, normal: 3000, fast: 2000 },\n  ring: { slow: 6400, normal: 3800, fast: 2200 },\n};\n\n/* The gap between the START of one burst and the start of the next. The burst\n   itself takes a fixed share of it (set in attention.css), so the rest between\n   bursts is whatever is left. */\nconst PERIODIC_MS: Record<\"slow\" | \"normal\" | \"fast\", number> = { slow: 7000, normal: 4500, fast: 2800 };\n\nexport interface AttentionTiming {\n  /** The effect's own cycle, in ms: one wave for `ripple`, one breath for `pulse`/`glow`, one turn for `ring`, the whole period for the periodic effects. */\n  cycleMs: number;\n}\n\n/**\n * How long one cycle of `effect` takes.\n *\n * `interval` only means something to the periodic effects (it IS their cycle);\n * a continuous effect has no rest to size, so it ignores it, and `Attention`\n * warns once in development rather than ignoring it in silence.\n */\nexport function resolveTiming(\n  effect: AttentionEffect,\n  speed: AttentionSpeed,\n  interval?: number,\n): AttentionTiming {\n  if (isPeriodic(effect)) {\n    if (interval !== undefined) return { cycleMs: positive(interval, \"interval\") };\n    if (typeof speed === \"number\") return { cycleMs: positive(speed, \"speed\") };\n    return { cycleMs: PERIODIC_MS[speed] };\n  }\n  if (typeof speed === \"number\") return { cycleMs: positive(speed, \"speed\") };\n  return { cycleMs: CONTINUOUS_MS[effect as keyof typeof CONTINUOUS_MS][speed] };\n}\n\nfunction positive(value: number, name: string): number {\n  if (!Number.isFinite(value) || value <= 0) {\n    throw new RangeError(`Attention: \\`${name}\\` must be a positive number of milliseconds, got ${value}`);\n  }\n  return value;\n}\n\n/* Waves are sized from the thing they surround, and in PIXELS, not as a ratio.\n   A fixed scale factor would make a 32px icon button send a 60px ring and a\n   400px card a 760px one, which is the card swallowing its neighbours. The\n   reach is a distance, capped; the two scale factors are derived from it so a\n   wave spreads the SAME distance on every side — a pill gets a pill-shaped\n   wave that is the same few pixels bigger all round, not one stretched to\n   twice its length. */\nconst REACH_FACTOR: Record<AttentionIntensity, number> = { subtle: 0.75, medium: 1, strong: 1.25 };\n\nexport interface AttentionReach {\n  /** How far past the box's edge a wave that is not contained reaches, in px (`ripple` with `contain={false}`). */\n  reachPx: number;\n  /** The box's diagonal in px: the diameter a contained ripple circle needs to cover every corner. */\n  diagonal: number;\n  /** Scale the `beacon` ping grows to, across and down. */\n  reachX: number;\n  reachY: number;\n  /** Scale the `pulse` breath swells to, across and down. */\n  swellX: number;\n  swellY: number;\n  /** How far `wiggle` turns, in degrees. */\n  tilt: number;\n}\n\n/**\n * The scale factors for a box of the given size. The shorter side decides how\n * far a wave spreads, so a long thin control does not send a wave across the page.\n */\nexport function resolveReach(width: number, height: number, intensity: AttentionIntensity): AttentionReach | null {\n  const side = Math.min(width, height);\n  if (!(side > 0)) return null;\n  const reachPx = clamp(side * 0.9, 18, 42) * REACH_FACTOR[intensity];\n  const swellPx = clamp(side * 0.28, 6, 12) * REACH_FACTOR[intensity];\n  return {\n    reachPx: round(reachPx),\n    diagonal: round(Math.hypot(width, height)),\n    reachX: round(1 + reachPx / width),\n    reachY: round(1 + reachPx / height),\n    swellX: round(1 + swellPx / width),\n    swellY: round(1 + swellPx / height),\n    /* A turn that is right for an icon is a swinging door on a card: the angle\n       shrinks as the thing gets longer, so the corners sweep about the same\n       distance whatever is wrapped. */\n    tilt: round(clamp((9 * 48) / Math.max(width, height), 1.5, 9)),\n  };\n}\n\n/* How far each ring of a ripple reaches, as a share of its full reach, for its\n   first three waves. Every ring has its own sequence, so no two rings are ever\n   at the same radius at the same moment and the radius keeps changing: the\n   waves are different sizes, not copies of one. Five rows is the most rings.\n\n   A contained circle's full reach is the box's diagonal (so the biggest covers\n   every corner and the smallest fades out just inside the edge of a circle); a\n   spilling one's is the box plus `reachPx` on every side. */\nexport const WAVE_REACH: readonly (readonly [number, number, number])[] = [\n  [1, 0.62, 0.84],\n  [0.7, 0.95, 0.55],\n  [0.9, 0.66, 1],\n  [0.58, 1, 0.76],\n  [0.84, 0.72, 0.94],\n];\n\nexport const MAX_RINGS = WAVE_REACH.length;\n\nexport function clampRings(rings: number): number {\n  if (!Number.isFinite(rings)) throw new RangeError(`Attention: \\`rings\\` must be a number, got ${rings}`);\n  return Math.min(MAX_RINGS, Math.max(1, Math.round(rings)));\n}\n\nfunction clamp(value: number, min: number, max: number): number {\n  return Math.min(max, Math.max(min, value));\n}\n\nfunction round(value: number): number {\n  return Math.round(value * 1000) / 1000;\n}\n"],"names":["EFFECT_ORDER","MOTION_EFFECTS","resolveEffects","effect","asked","one","unique","motions","PERIODIC_EFFECTS","isPeriodic","CONTINUOUS_MS","PERIODIC_MS","resolveTiming","speed","interval","positive","value","name","REACH_FACTOR","resolveReach","width","height","intensity","side","reachPx","clamp","swellPx","round","WAVE_REACH","MAX_RINGS","clampRings","rings","min","max"],"mappings":"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"}

package/dist/lib/board/anchor.js

@@ -0,0 +1,14 @@
+function i(o, r, n) {
+  if (r.to.lane) return { lane: !0 };
+  if (r.to.edge !== void 0) return { edge: r.to.edge };
+  const t = o.filter((d) => n(d) !== r.itemId), { index: e } = r.to;
+  if (!Number.isInteger(e) || e < 0 || e > t.length)
+    throw new Error(
+      `moveAnchor: to.index ${e} is outside the destination's ${t.length} loaded card(s) (the moved card excluded), so no neighbour can be named for "${r.itemId}".`
+    );
+  return e < t.length ? { beforeId: n(t[e]) } : e > 0 ? { afterId: n(t[e - 1]) } : {};
+}
+export {
+  i as moveAnchor
+};
+//# sourceMappingURL=anchor.js.map

package/dist/lib/board/anchor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"anchor.js","sources":["../../../src/lib/board/anchor.ts"],"sourcesContent":["/**\n * ==== MOVE ANCHOR ====\n *\n * What a server needs to place a card the board moved, when the board holds\n * only a window of the column (DX-4540). A drop knows exactly one thing about\n * where it landed: which LOADED neighbours it is between. It never knows the\n * card's position in the whole column, and a client that tries to compute one\n * from `to.index` is wrong the moment the window does not start at the top.\n * So the request names the neighbours, and the server finds the place.\n *\n * `to.index` counts the destination's LOADED cards with the moved card already\n * removed (the board's one index rule), so the card lands before\n * `rest[to.index]`, where `rest` is the destination's loaded cards without the\n * moved one. ONE neighbour is named, because a server places a card relative to\n * one: the card it lands directly above (`beforeId`) whenever there is one, and\n * only at the end of the loaded run, where nothing is below, the card it lands\n * directly below (`afterId`). An empty destination names nothing.\n *\n * A LANE MOVE IS ITS OWN ANSWER (DX-4583). It carries no position, so there is\n * no neighbour to anchor to, and `{ lane: true }` says so: the server changes\n * the card's lane and keeps its own rank. That is not the empty anchor, which\n * says \"the destination has no cards, so this is the first\".\n *\n * AN EDGE INTENT TRUMPS THE NEIGHBOURS. \"Move to top\" in a window that starts\n * at card 221 means the top of the column, which no loaded neighbour can say,\n * so the anchor carries the edge and no ids.\n */\n\nimport type { BoardEdge, BoardItemId, BoardMove } from \"./types\";\n\n/**\n * EXACTLY ONE field is set — a server's lane-move takes one — or none for an\n * empty destination:\n *   beforeId  the moved card lands directly above this loaded card\n *   afterId   it lands directly below this one: only when it lands after the last\n *             loaded card, where nothing is below to name\n *   edge      it goes to the very top or bottom of the whole column\n *   lane      a lane move: no position at all, the card keeps its rank\n * None is set for an empty destination.\n */\nexport type MoveAnchor =\n  | { beforeId: BoardItemId; afterId?: never; edge?: never; lane?: never }\n  | { afterId: BoardItemId; beforeId?: never; edge?: never; lane?: never }\n  | { edge: BoardEdge; beforeId?: never; afterId?: never; lane?: never }\n  | { lane: true; beforeId?: never; afterId?: never; edge?: never }\n  | { beforeId?: never; afterId?: never; edge?: never; lane?: never };\n\n/**\n * @param destinationItems the destination column's LOADED cards (the moved card\n *   may be among them, for a same-column move).\n */\nexport function moveAnchor<T>(\n  destinationItems: readonly T[],\n  move: BoardMove,\n  getId: (item: T) => BoardItemId,\n): MoveAnchor {\n  if (move.to.lane) return { lane: true };\n  if (move.to.edge !== undefined) return { edge: move.to.edge };\n\n  const rest = destinationItems.filter((item) => getId(item) !== move.itemId);\n  const { index } = move.to;\n  if (!Number.isInteger(index) || index < 0 || index > rest.length) {\n    throw new Error(\n      `moveAnchor: to.index ${index} is outside the destination's ${rest.length} loaded card(s) ` +\n        `(the moved card excluded), so no neighbour can be named for \"${move.itemId}\".`,\n    );\n  }\n  if (index < rest.length) return { beforeId: getId(rest[index]) };\n  if (index > 0) return { afterId: getId(rest[index - 1]) };\n  return {};\n}\n"],"names":["moveAnchor","destinationItems","move","getId","rest","item","index"],"mappings":"AAmDO,SAASA,EACdC,GACAC,GACAC,GACY;AACZ,MAAID,EAAK,GAAG,KAAM,QAAO,EAAE,MAAM,GAAA;AACjC,MAAIA,EAAK,GAAG,SAAS,eAAkB,EAAE,MAAMA,EAAK,GAAG,KAAA;AAEvD,QAAME,IAAOH,EAAiB,OAAO,CAACI,MAASF,EAAME,CAAI,MAAMH,EAAK,MAAM,GACpE,EAAE,OAAAI,MAAUJ,EAAK;AACvB,MAAI,CAAC,OAAO,UAAUI,CAAK,KAAKA,IAAQ,KAAKA,IAAQF,EAAK;AACxD,UAAM,IAAI;AAAA,MACR,wBAAwBE,CAAK,iCAAiCF,EAAK,MAAM,gFACPF,EAAK,MAAM;AAAA,IAAA;AAGjF,SAAII,IAAQF,EAAK,SAAe,EAAE,UAAUD,EAAMC,EAAKE,CAAK,CAAC,EAAA,IACzDA,IAAQ,IAAU,EAAE,SAASH,EAAMC,EAAKE,IAAQ,CAAC,CAAC,EAAA,IAC/C,CAAA;AACT;"}

package/dist/lib/board/model.js

@@ -0,0 +1,41 @@
+import { columnLength as u, positionInColumn as m } from "./position.js";
+function g(l, r, s) {
+  const i = /* @__PURE__ */ new Map();
+  for (const t of r) i.set(t.id, []);
+  const e = [];
+  for (const t of l) {
+    const o = s.getColumnId(t), n = i.get(o);
+    if (n) {
+      n.push(t);
+      continue;
+    }
+    e.push(t);
+  }
+  if (e.length > 0) {
+    const t = e.slice(0, 5).map((n) => String(s.getId(n))), o = e.length - t.length;
+    console.warn(
+      `[danxbot] board: ${e.length} item(s) reference a columnId matching no declared column — routed to \`unassigned\` rather than dropped: ${t.join(", ")}${o > 0 ? `, +${o} more` : ""}`
+    );
+  }
+  return { columns: r.map((t) => {
+    const o = i.get(t.id) ?? [], n = t.total === null, c = u(t, o.length);
+    return {
+      id: t.id,
+      label: t.label,
+      items: o,
+      count: c,
+      counting: n,
+      offset: m(t, 0),
+      wipLimit: t.wipLimit,
+      reorderLocked: t.reorderLocked,
+      reorderLabels: t.reorderLabels,
+      /* `wipLimit` undefined => always false, per the field's own doc on
+         `BoardColumnModel` — a column with no limit cannot be over one. */
+      overWip: t.wipLimit !== void 0 && !n && c > t.wipLimit
+    };
+  }), unassigned: e };
+}
+export {
+  g as buildBoardModel
+};
+//# sourceMappingURL=model.js.map

package/dist/lib/board/model.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"model.js","sources":["../../../src/lib/board/model.ts"],"sourcesContent":["/**\r\n * ==== BOARD MODEL ====\r\n *\r\n * Pure derivation: `items` + column defs + accessors -> one `BoardColumnModel`\r\n * per declared column, ready to render. No React, no mutation, no I/O other\r\n * than the diagnostic `console.warn` below — the same inputs always produce\r\n * the same output, which is what makes this testable without a browser and\r\n * safe to call on every render (`use-board.ts` wraps it in a `useMemo`, it\r\n * does not need to defend itself).\r\n *\r\n * WHY AN ITEM THAT MATCHES NO COLUMN IS NEVER DROPPED. GitHub Projects has a\r\n * live, cited bug (RES-GAME / tracker) where grouping by parent silently\r\n * drops sub-issues that carry a valid link — the item is real, the grouping\r\n * key is merely stale, and the user has no way to discover the card still\r\n * exists. A board built the same way inherits the identical bug the moment a\r\n * column is renamed or retired out from under live data, which is routine\r\n * here (a status gets retired, a card's derived status hasn't caught up to a\r\n * board's `columns` prop yet, a consumer passes a filtered `columns` list).\r\n * So an item whose `getColumnId` names no declared column is never\r\n * discarded — it is routed into `unassigned`, a structurally present field\r\n * of the model rather than a side channel a caller has to remember to check.\r\n * Every item that goes in comes out somewhere: either inside exactly one\r\n * `columns[].items`, or inside `unassigned`. That invariant is asserted by\r\n * the \"floor\" test in board-core.test.ts, so a future edit that starts\r\n * quietly filtering can't pass silently either.\r\n *\r\n * A single summarising `console.warn` also fires when any item orphans,\r\n * matching the `[danxbot] …` prefix `ErrorBoundary.tsx` already uses (and\r\n * unguarded, as that one is — this library has no dev-only convention). It is\r\n * a diagnostic ONLY, never the sole signal, since a console message is easy to\r\n * miss and impossible to act on from inside a pure function. The `data` itself\r\n * is what must never be lost; the warning just makes the gap visible before a\r\n * consumer has built an \"Unsorted\" affordance for `unassigned`.\r\n */\r\n\r\nimport { columnLength, positionInColumn } from \"./position\";\r\nimport type {\r\n  BoardAccessors,\r\n  BoardColumnDef,\r\n  BoardColumnId,\r\n  BoardColumnModel,\r\n} from \"./types\";\r\n\r\n/** The full derivation result. See the file header for why `unassigned` exists. */\r\nexport interface BoardModel<T> {\r\n  /** One entry per declared column, in the SAME order as the `columns` input. */\r\n  columns: readonly BoardColumnModel<T>[];\r\n  /** Items whose `getColumnId` matched no entry in `columns`. Never dropped. */\r\n  unassigned: readonly T[];\r\n}\r\n\r\nexport function buildBoardModel<T>(\r\n  items: readonly T[],\r\n  columns: readonly BoardColumnDef[],\r\n  accessors: BoardAccessors<T>,\r\n): BoardModel<T> {\r\n  /* Seeded from `columns` up front — including columns with zero items — so\r\n     an empty column still renders its header rather than vanishing from the\r\n     model entirely. A `Map` rather than a plain object because `BoardColumnId`\r\n     is a consumer-supplied string with no guarantee against prototype-pollution\r\n     keys like \"constructor\". */\r\n  const buckets = new Map<BoardColumnId, T[]>();\r\n  for (const def of columns) buckets.set(def.id, []);\r\n\r\n  const unassigned: T[] = [];\r\n  for (const item of items) {\r\n    const columnId = accessors.getColumnId(item);\r\n    const bucket = buckets.get(columnId);\r\n    if (bucket) {\r\n      bucket.push(item);\r\n      continue;\r\n    }\r\n    unassigned.push(item);\r\n  }\r\n\r\n  /* ONE WARNING PER CALL, NOT ONE PER ITEM. The orphan case is not rare-and-\r\n     isolated: retire a column out from under live data and EVERY card in it\r\n     orphans at once, so a per-item warning emits hundreds of lines on every\r\n     recompute of an unchanged board. That floods the console and buries the\r\n     messages around it — the same alert-fatigue failure this project's own\r\n     research documents for the UI, aimed at the developer instead. A bounded\r\n     summary says the identical thing and stays readable, so it keeps being\r\n     read. Ids are capped for the same reason; `unassigned` carries the\r\n     complete set for anyone who needs it. */\r\n  if (unassigned.length > 0) {\r\n    const shown = unassigned.slice(0, 5).map((item) => String(accessors.getId(item)));\r\n    const rest = unassigned.length - shown.length;\r\n    console.warn(\r\n      `[danxbot] board: ${unassigned.length} item(s) reference a columnId matching ` +\r\n        `no declared column — routed to \\`unassigned\\` rather than dropped: ` +\r\n        `${shown.join(\", \")}${rest > 0 ? `, +${rest} more` : \"\"}`,\r\n    );\r\n  }\r\n\r\n  const result: BoardColumnModel<T>[] = columns.map((def) => {\r\n    const columnItems = buckets.get(def.id) ?? [];\r\n    /* DX-4540: THE ONE PLACE A COLUMN'S LENGTH AND ITS WIP VERDICT ARE\r\n       DECIDED. A windowed column holds a few pages of a long list, so its\r\n       length is the `total` the consumer reports, not what is loaded; `null` is\r\n       a length still being read, which is neither empty nor over a limit. */\r\n    const counting = def.total === null;\r\n    const count = columnLength(def, columnItems.length);\r\n    return {\r\n      id: def.id,\r\n      label: def.label,\r\n      items: columnItems,\r\n      count,\r\n      counting,\r\n      offset: positionInColumn(def, 0),\r\n      wipLimit: def.wipLimit,\r\n      reorderLocked: def.reorderLocked,\r\n      reorderLabels: def.reorderLabels,\r\n      /* `wipLimit` undefined => always false, per the field's own doc on\r\n         `BoardColumnModel` — a column with no limit cannot be over one. */\r\n      overWip: def.wipLimit !== undefined && !counting && count > def.wipLimit,\r\n    };\r\n  });\r\n\r\n  return { columns: result, unassigned };\r\n}\r\n"],"names":["buildBoardModel","items","columns","accessors","buckets","def","unassigned","item","columnId","bucket","shown","rest","columnItems","counting","count","columnLength","positionInColumn"],"mappings":";AAmDO,SAASA,EACdC,GACAC,GACAC,GACe;AAMf,QAAMC,wBAAc,IAAA;AACpB,aAAWC,KAAOH,EAAS,CAAAE,EAAQ,IAAIC,EAAI,IAAI,EAAE;AAEjD,QAAMC,IAAkB,CAAA;AACxB,aAAWC,KAAQN,GAAO;AACxB,UAAMO,IAAWL,EAAU,YAAYI,CAAI,GACrCE,IAASL,EAAQ,IAAII,CAAQ;AACnC,QAAIC,GAAQ;AACV,MAAAA,EAAO,KAAKF,CAAI;AAChB;AAAA,IACF;AACA,IAAAD,EAAW,KAAKC,CAAI;AAAA,EACtB;AAWA,MAAID,EAAW,SAAS,GAAG;AACzB,UAAMI,IAAQJ,EAAW,MAAM,GAAG,CAAC,EAAE,IAAI,CAACC,MAAS,OAAOJ,EAAU,MAAMI,CAAI,CAAC,CAAC,GAC1EI,IAAOL,EAAW,SAASI,EAAM;AACvC,YAAQ;AAAA,MACN,oBAAoBJ,EAAW,MAAM,6GAEhCI,EAAM,KAAK,IAAI,CAAC,GAAGC,IAAO,IAAI,MAAMA,CAAI,UAAU,EAAE;AAAA,IAAA;AAAA,EAE7D;AA0BA,SAAO,EAAE,SAxB6BT,EAAQ,IAAI,CAACG,MAAQ;AACzD,UAAMO,IAAcR,EAAQ,IAAIC,EAAI,EAAE,KAAK,CAAA,GAKrCQ,IAAWR,EAAI,UAAU,MACzBS,IAAQC,EAAaV,GAAKO,EAAY,MAAM;AAClD,WAAO;AAAA,MACL,IAAIP,EAAI;AAAA,MACR,OAAOA,EAAI;AAAA,MACX,OAAOO;AAAA,MACP,OAAAE;AAAA,MACA,UAAAD;AAAA,MACA,QAAQG,EAAiBX,GAAK,CAAC;AAAA,MAC/B,UAAUA,EAAI;AAAA,MACd,eAAeA,EAAI;AAAA,MACnB,eAAeA,EAAI;AAAA;AAAA;AAAA,MAGnB,SAASA,EAAI,aAAa,UAAa,CAACQ,KAAYC,IAAQT,EAAI;AAAA,IAAA;AAAA,EAEpE,CAAC,GAEyB,YAAAC,EAAA;AAC5B;"}

package/dist/lib/board/move.js

@@ -0,0 +1,161 @@
+import { positionInColumn as y, columnLength as B } from "./position.js";
+import { applyMove as E, isNoOp as $ } from "../dnd/geometry.js";
+function b(l, n, c) {
+  const { from: m, to: r } = l;
+  if (m.columnId !== r.columnId) return !1;
+  if (r.lane) return !0;
+  if (r.edge === void 0)
+    return $(
+      { container: m.columnId, index: m.index },
+      { container: r.columnId, index: r.index }
+    );
+  const i = y(n, m.index);
+  return r.edge === "top" ? i === 0 : i === B(n, c) - 1;
+}
+function N(l, n) {
+  const { items: c, columns: m, accessors: r, validateMove: i } = l;
+  if (n.moves.length === 0)
+    return { verdict: { ok: !0 }, commit: [] };
+  if (n.moves.length > 1 && n.source !== "bulk")
+    throw new Error(`resolveMove: a request with ${n.moves.length} moves must use source "bulk", got "${n.source}"`);
+  const a = new Set(m.map((o) => o.id)), I = new Map(c.map((o) => [r.getId(o), o])), u = /* @__PURE__ */ new Map();
+  for (const o of c) {
+    const g = r.getColumnId(o);
+    u.set(g, (u.get(g) ?? 0) + 1);
+  }
+  const e = new Map(m.map((o) => [o.id, o])), t = (o) => b(o, e.get(o.from.columnId), u.get(o.from.columnId) ?? 0), s = /* @__PURE__ */ new Map();
+  for (const o of n.moves)
+    t(o) || s.set(
+      o.from.columnId,
+      (s.get(o.from.columnId) ?? 0) + 1
+    );
+  const d = /* @__PURE__ */ new Set();
+  for (const o of n.moves) {
+    if (d.has(o.itemId))
+      throw new Error(`resolveMove: item "${o.itemId}" appears more than once in the same move request`);
+    d.add(o.itemId);
+    const g = I.get(o.itemId);
+    if (!g)
+      return { verdict: { ok: !1, reason: { code: "unknownItem", itemId: o.itemId } }, commit: [] };
+    for (const x of [o.from.columnId, o.to.columnId])
+      if (!a.has(x))
+        return { verdict: { ok: !1, reason: { code: "unknownColumn", columnId: x } }, commit: [] };
+    const p = r.getColumnId(g);
+    if (p !== o.from.columnId)
+      return {
+        verdict: {
+          ok: !1,
+          reason: {
+            code: "wrongColumn",
+            itemId: o.itemId,
+            actualColumnId: p,
+            claimedColumnId: o.from.columnId
+          }
+        },
+        commit: []
+      };
+    if (!Number.isInteger(o.from.index) || o.from.index < 0)
+      throw new Error(`resolveMove: item "${o.itemId}" has an invalid from.index`);
+    const v = u.get(o.from.columnId) ?? 0;
+    if (o.from.index >= v)
+      return {
+        verdict: {
+          ok: !1,
+          reason: {
+            code: "fromIndexPastEnd",
+            itemId: o.itemId,
+            index: o.from.index,
+            columnId: o.from.columnId,
+            count: v
+          }
+        },
+        commit: []
+      };
+    if (o.to.lane) continue;
+    if (!Number.isInteger(o.to.index) || o.to.index < 0)
+      throw new Error(`resolveMove: item "${o.itemId}" has an invalid to.index`);
+    const h = e.get(o.from.columnId)?.reorderLocked;
+    if (h !== void 0 && o.from.columnId === o.to.columnId && !t(o))
+      return { verdict: { ok: !1, reason: { code: "consumer", message: h } }, commit: [] };
+    const k = u.get(o.to.columnId) ?? 0, C = s.get(o.to.columnId) ?? 0, w = k - C;
+    if (o.to.index > w)
+      return {
+        verdict: {
+          ok: !1,
+          reason: {
+            code: "toIndexPastEnd",
+            itemId: o.itemId,
+            index: o.to.index,
+            columnId: o.to.columnId,
+            max: w
+          }
+        },
+        commit: []
+      };
+  }
+  if (i) {
+    const o = i(n);
+    if (!o.ok)
+      return { verdict: { ok: !1, reason: { code: "consumer", message: o.reason } }, commit: [] };
+  }
+  const f = n.moves.filter((o) => !t(o));
+  return { verdict: { ok: !0 }, commit: f };
+}
+function F(l, n, c) {
+  if (c.length === 0) return l.slice();
+  const m = c[0];
+  if (c.length === 1 && m.from.columnId === m.to.columnId && !m.to.lane) {
+    const e = m.from.columnId, t = /* @__PURE__ */ new Map();
+    for (const d of l) {
+      const f = n.getColumnId(d), o = t.get(f);
+      o ? o.push(d) : t.set(f, [d]);
+    }
+    const s = t.get(e) ?? [];
+    return t.set(e, E(s, m.from.index, m.to.index)), M(l, n, t);
+  }
+  const r = new Map(l.map((e) => [n.getId(e), e]));
+  for (const e of c) {
+    if (!e.to.lane) continue;
+    const t = r.get(e.itemId);
+    if (t !== void 0 && n.getColumnId(t) !== e.to.columnId)
+      throw new Error(
+        `applyBoardMoves: "${e.itemId}" moves to lane "${e.to.columnId}" but its own lane is still "${n.getColumnId(t)}"; write the lane on the item before applying a lane move.`
+      );
+  }
+  const i = c.filter((e) => !e.to.lane), a = new Set(i.map((e) => e.itemId)), I = /* @__PURE__ */ new Map();
+  for (const e of l) {
+    const t = n.getColumnId(e);
+    if (a.has(n.getId(e))) continue;
+    const s = I.get(t);
+    s ? s.push(e) : I.set(t, [e]);
+  }
+  const u = /* @__PURE__ */ new Map();
+  i.forEach((e, t) => {
+    const s = u.get(e.to.columnId), d = { move: e, requestOrder: t };
+    s ? s.push(d) : u.set(e.to.columnId, [d]);
+  });
+  for (const [e, t] of u) {
+    t.sort((d, f) => d.move.to.index - f.move.to.index || d.requestOrder - f.requestOrder);
+    const s = I.get(e) ?? [];
+    t.forEach(({ move: d }, f) => {
+      const o = r.get(d.itemId);
+      o && s.splice(d.to.index + f, 0, o);
+    }), I.set(e, s);
+  }
+  return M(l, n, I);
+}
+function M(l, n, c) {
+  const m = [], r = /* @__PURE__ */ new Set();
+  for (const i of l) {
+    const a = n.getColumnId(i);
+    c.has(a) && !r.has(a) && (r.add(a), m.push(a));
+  }
+  for (const i of c.keys())
+    r.has(i) || (r.add(i), m.push(i));
+  return m.flatMap((i) => c.get(i) ?? []);
+}
+export {
+  F as applyBoardMoves,
+  N as resolveMove
+};
+//# sourceMappingURL=move.js.map

package/dist/lib/board/move.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"move.js","sources":["../../../src/lib/board/move.ts"],"sourcesContent":["/**\n * ==== MOVE ====\n *\n * The one validated pipeline every `BoardMoveRequest` passes through, no\n * matter which of the four `BoardMoveSource` values produced it. `types.ts`\n * names this the load-bearing rule: pointer drag, keyboard, the mandatory\n * \"Move to…\" menu (WCAG 2.5.7) and bulk selection all construct a request\n * and call the SAME function here. A per-source branch that skips a step is\n * exactly how the accessible paths rot — the drag path gets exercised daily\n * and the menu path silently stops agreeing with it, taking the 2.5.7\n * alternative down with it and nobody notices until an audit.\n *\n * TWO RESPONSIBILITIES, DELIBERATELY SEPARATE FUNCTIONS:\n *\n *   `resolveMove` decides WHETHER a request may commit. It is the only thing\n *   `use-board.ts`'s `requestMove` calls, and it never touches `T[]` — it\n *   returns a verdict plus the subset of moves worth writing.\n *\n *   `applyBoardMoves` decides WHAT the resulting `items` array looks like,\n *   given moves already known to be valid (typically `resolveMove(...).commit`).\n *   It does no validation of its own — that would duplicate `resolveMove` — and\n *   it is exported separately because `onMove` on `UseBoardOptions` returns\n *   `void`: this module hands the consumer a verdict, not a next state, so a\n *   consumer's own `onMove` needs a correct way to turn \"these moves are real\"\n *   into \"here is my next `items` array.\" Without it, every consumer either\n *   re-derives the exact index arithmetic `applyMove` exists to remove, or\n *   worse, folds it over a bulk request and gets the trap below.\n *\n * WHY `resolveMove` DOES ITS OWN STRUCTURAL CHECKS BEFORE EVER CALLING THE\n * CALLER'S `validateMove`. `validateMove` is optional and, per `types.ts`,\n * \"Absent means every move is allowed\" — so nothing upstream is guaranteed to\n * have checked that `itemId` names a real item or that a `columnId` names a\n * declared column. A malformed request must never reach a consumer's domain\n * rule carrying numbers that don't correspond to reality, and a consumer's\n * `validateMove` should never have to re-derive checks this module can prove\n * from its own inputs for free. So structural validity runs FIRST, always on,\n * not configurable — before `validateMove`, before no-op filtering.\n *\n * WHY NO-OP FILTERING IS PER-MOVE BUT VALIDITY IS ALL-OR-NOTHING. These are\n * different questions. Atomicity (\"did the batch survive as one unit\")\n * governs whether the request is safe to commit AT ALL — RES-GAME names this\n * exactly: \"moving five selected cards should not accept the first two and\n * reject the remaining three.\" One bad move rejects the whole batch, full\n * stop. But once a batch is known-good, a card that happens to already be\n * exactly where it is going is not an error — it is nothing to write.\n * Dropping that ONE entry from the committed set changes nothing about the\n * other four having moved correctly, and `onMove`'s own doc on\n * `UseBoardOptions` names the cost of not doing this: \"the previous board\n * wrote its ordering field on every release that landed where it started.\"\n *\n * NO-OP IS A PER-MOVE, SYNTACTIC CHECK — REUSING `isNoOp` FROM `lib/dnd`,\n * NOT A FULL SIMULATION OF FINAL POSITION. `isNoOp(from, to)` says \"same\n * column, same index\" for exactly one move, taken at face value. For a bulk\n * request whose moves interact (two items landing in the same column), a\n * move's own `{column, index}` pair can be untouched while its ABSOLUTE final\n * position shifts because a sibling move inserted ahead of it. This module\n * does not attempt to detect that: `to.index` is the caller's stated INTENT,\n * so a move that literally says \"column A index 2 to column A index 2\" is\n * declaring no intended change regardless of what its bulk-mates do, and\n * that is the same per-item promise the drag engine's own `DragEndEvent.moved`\n * makes — it never reasoned about siblings either, because a single drag\n * gesture never has any.\n *\n * THE BULK INDEX CONVENTION, AND WHY IT HAS TO BE STATED EXPLICITLY. The\n * engine's single-item convention — `to.index` counts the destination list\n * WITH THE DRAGGED ITEM ALREADY REMOVED — has no obvious generalisation to N\n * items removed from possibly-different columns at once, and `types.ts`\n * does not pick one; that is this module's decision to make and document.\n * THE RULE: every positional move's `to.index`, bulk or not, counts its destination\n * column's items with EVERY item named ANYWHERE in the same request already\n * removed — not just itself. For a single-move request that is identical to\n * the engine's own rule (nothing else is being removed). For a bulk request\n * it means a UI constructing the request reasons about one shared reference\n * frame per target column (\"insert these three selected cards starting at\n * position two among the cards that are staying put\"), not about where its\n * OTHER selected cards will land — which is the only version of \"bulk move\n * to a position\" an operator selecting five cards can sensibly form an\n * intention about in the first place.\n *\n * THE TRAP THIS CONVENTION EXISTS TO AVOID: SEQUENTIAL applyMove FOLDING\n * SILENTLY CORRUPTS A BULK REORDER. Applying move 1 then move 2 via\n * `applyMove` one at a time is NOT equivalent to applying them together,\n * because move 1's splice shifts every index move 2 was computed against —\n * and worse, if move 2's stored index is blindly reused against the\n * ALREADY-SHIFTED array (rather than re-resolved), it can silently pick up\n * the wrong item's position entirely. `applyBoardMoves` never folds moves\n * sequentially over a mutating array for this reason. Instead it resolves\n * every move against ONE shared snapshot — the residual list per column with\n * every moved item already removed — and inserts all of a column's incoming\n * items in a single deterministic pass: sorted by `to.index` ascending\n * (ties broken by the item's original position in `moves`, i.e. request\n * order), each inserted at `to.index + (insertions already made into this\n * column)`. That running offset is exactly what accounts for earlier\n * insertions shifting the positions later ones land at, computed once\n * instead of re-derived per move. A LANE MOVE (`to.lane`, DX-4583) has no\n * index, so it takes no part in this pass: it neither leaves the residual nor\n * is inserted, and the card stays where the consumer's order already holds it\n * once the consumer has written its lane. board-core.test.ts pins a concrete bulk\n * case where the naive sequential-splice answer and this one visibly differ,\n * so the property is proven rather than incidentally true.\n *\n * WHY `applyBoardMoves` CALLS THE SHARED `applyMove` FOR THE ONE CASE WHERE\n * IT APPLIES, AND HAND-SPLICES EVERYWHERE ELSE. `applyMove(list, from, to)`\n * splices ONE array — it has no way to express \"remove from list A, insert\n * into list B,\" because a cross-column move is inherently a two-list\n * operation. The design system's own `DragDropPage` demo shows this exact\n * split already: `applyMove` for the same-container branch, a manual\n * remove-then-insert for the cross-container one. This module follows the\n * identical rule for the single-move, same-column case (delegates to\n * `applyMove` outright — see the equivalence test, which proves the general\n * residual-based path used for every other case produces byte-identical\n * output to `applyMove` when it degenerates to N=1, same column). Every\n * other shape — cross-column, or any bulk request — has no single shared\n * array to splice, so it goes through the residual-and-insert pass above.\n */\n\nimport { applyMove, isNoOp } from \"../dnd\";\nimport { columnLength, positionInColumn } from \"./position\";\nimport type {\n  BoardAccessors,\n  BoardColumnDef,\n  BoardColumnId,\n  BoardItemId,\n  BoardMove,\n  BoardMoveRequest,\n  BoardMoveOutcome,\n  BoardMoveVerdict,\n} from \"./types\";\n\n/** A move that names an index: everything but a lane move. */\ntype PositionalMove = BoardMove & { to: { index: number } };\n\n/** Everything `resolveMove` reads to prove a request is structurally real. */\nexport interface ResolveMoveContext<T> {\n  items: readonly T[];\n  columns: readonly BoardColumnDef[];\n  accessors: BoardAccessors<T>;\n  /** Consulted after structural validity holds. See the file header for order. */\n  validateMove?: (request: BoardMoveRequest) => BoardMoveVerdict;\n}\n\n/**\n * A move that changes nothing. Same column and same index is one — unless the\n * move carries an edge intent (DX-4540): in a windowed column index 0 is the\n * first LOADED card, not the top of the column, so \"move to top\" of a card at\n * loaded index 0 changes something whenever the window does not start at the\n * top. An edge move is a no-op only when the card is already at that edge of\n * the WHOLE column.\n */\nfunction isNoOpMove(move: BoardMove, def: BoardColumnDef | undefined, loaded: number): boolean {\n  const { from, to } = move;\n  if (from.columnId !== to.columnId) return false;\n  /* DX-4583: a lane move into the lane the card is already in changes nothing. */\n  if (to.lane) return true;\n  if (to.edge === undefined) {\n    return isNoOp(\n      { container: from.columnId, index: from.index },\n      { container: to.columnId, index: to.index },\n    );\n  }\n  const position = positionInColumn(def, from.index);\n  return to.edge === \"top\" ? position === 0 : position === columnLength(def, loaded) - 1;\n}\n\nexport interface ResolvedMove {\n  verdict: BoardMoveOutcome;\n  /**\n   * The subset of the request's moves worth committing, in original order.\n   * Empty whenever there is nothing to write — either every move was a\n   * no-op, or `verdict.ok` is false. Only ever meaningful when `verdict.ok`.\n   */\n  commit: readonly BoardMove[];\n}\n\nexport function resolveMove<T>(\n  context: ResolveMoveContext<T>,\n  request: BoardMoveRequest,\n): ResolvedMove {\n  const { items, columns, accessors, validateMove } = context;\n\n  if (request.moves.length === 0) {\n    return { verdict: { ok: true }, commit: [] };\n  }\n\n  /* `moves.length > 1` only for `\"bulk\"` per types.ts's own doc on\n     `BoardMoveRequest` — enforced here rather than left as an unchecked\n     convention, because a caller that forgets to set `source: \"bulk\"` on a\n     multi-move request would otherwise silently bypass whatever a consumer's\n     telemetry or `validateMove` does to distinguish bulk moves from the\n     other three sources. */\n  if (request.moves.length > 1 && request.source !== \"bulk\") {\n    throw new Error(`resolveMove: a request with ${request.moves.length} moves must use source \"bulk\", got \"${request.source}\"`);\n  }\n\n  const columnIds = new Set(columns.map((c) => c.id));\n  const itemsById = new Map<BoardItemId, T>(items.map((item) => [accessors.getId(item), item]));\n\n  const countByColumn = new Map<BoardColumnId, number>();\n  for (const item of items) {\n    const columnId = accessors.getColumnId(item);\n    countByColumn.set(columnId, (countByColumn.get(columnId) ?? 0) + 1);\n  }\n\n  /* How many of THIS request's moves ACTUALLY leave a given column — the\n     count `resolveMove` subtracts from that column's total to get the\n     residual size a `to.index` is bounds-checked against. See the file\n     header's \"bulk index convention\": every move's target frame excludes\n     every item the whole request touches, not just itself.\n\n     Built from NON-NO-OP moves only. A no-op (from and to identical) never\n     actually leaves its column, so it must not shrink the residual its own\n     bulk-mates are bounds-checked against — a real bulk request routinely\n     contains a mix (e.g. \"send the checked cards to Done\" where a couple\n     are already there), and counting a no-op as \"departing\" its own column\n     would make an otherwise-valid sibling move fail bounds-checking for a\n     reason that has nothing to do with it. */\n  const defsById = new Map(columns.map((def) => [def.id, def]));\n  const noOp = (move: BoardMove) =>\n    isNoOpMove(move, defsById.get(move.from.columnId), countByColumn.get(move.from.columnId) ?? 0);\n\n  const movesSourcedFrom = new Map<BoardColumnId, number>();\n  for (const move of request.moves) {\n    if (noOp(move)) continue;\n    movesSourcedFrom.set(\n      move.from.columnId,\n      (movesSourcedFrom.get(move.from.columnId) ?? 0) + 1,\n    );\n  }\n\n  const seenItemIds = new Set<BoardItemId>();\n\n  for (const move of request.moves) {\n    if (seenItemIds.has(move.itemId)) {\n      throw new Error(`resolveMove: item \"${move.itemId}\" appears more than once in the same move request`);\n    }\n    seenItemIds.add(move.itemId);\n\n    const item = itemsById.get(move.itemId);\n    if (!item) {\n      return { verdict: { ok: false, reason: { code: \"unknownItem\", itemId: move.itemId } }, commit: [] };\n    }\n\n    /* A live update during a drag can remove a column from under the person, so this is a refusal they can\n       reach, not a caller's bug. */\n    for (const columnId of [move.from.columnId, move.to.columnId]) {\n      if (!columnIds.has(columnId)) {\n        return { verdict: { ok: false, reason: { code: \"unknownColumn\", columnId } }, commit: [] };\n      }\n    }\n\n    /* The move's OWN claim about where the item currently lives must match\n       reality. A stale or fabricated `from.columnId` is precisely the class\n       of silent corruption this whole tracker keeps naming — catching it\n       here, with a reason, beats discovering it as an orphaned item in next\n       render's `unassigned` bucket (model.ts) with no explanation attached. */\n    const actualColumnId = accessors.getColumnId(item);\n    if (actualColumnId !== move.from.columnId) {\n      return {\n        verdict: {\n          ok: false,\n          reason: {\n            code: \"wrongColumn\",\n            itemId: move.itemId,\n            actualColumnId,\n            claimedColumnId: move.from.columnId,\n          },\n        },\n        commit: [],\n      };\n    }\n\n    if (!Number.isInteger(move.from.index) || move.from.index < 0) {\n      throw new Error(`resolveMove: item \"${move.itemId}\" has an invalid from.index`);\n    }\n    const fromCount = countByColumn.get(move.from.columnId) ?? 0;\n    if (move.from.index >= fromCount) {\n      return {\n        verdict: {\n          ok: false,\n          reason: {\n            code: \"fromIndexPastEnd\",\n            itemId: move.itemId,\n            index: move.from.index,\n            columnId: move.from.columnId,\n            count: fromCount,\n          },\n        },\n        commit: [],\n      };\n    }\n\n    /* DX-4583: a lane move names no position, so there is no index to bound. */\n    if (move.to.lane) continue;\n    if (!Number.isInteger(move.to.index) || move.to.index < 0) {\n      throw new Error(`resolveMove: item \"${move.itemId}\" has an invalid to.index`);\n    }\n    /* DX-4575: a lane that turned reordering off still sends and receives\n       cards; only a move that stays inside it is refused, with the lane's own\n       sentence as the reason. Judged on the move's intent, so an edge move\n       (menu) and a drag to a new index are refused alike, but a release that\n       lands where it started is still the no-op it always was. */\n    const lockedMessage = defsById.get(move.from.columnId)?.reorderLocked;\n    if (lockedMessage !== undefined && move.from.columnId === move.to.columnId && !noOp(move)) {\n      return { verdict: { ok: false, reason: { code: \"consumer\", message: lockedMessage } }, commit: [] };\n    }\n\n    const toCount = countByColumn.get(move.to.columnId) ?? 0;\n    const removedFromTarget = movesSourcedFrom.get(move.to.columnId) ?? 0;\n    const maxToIndex = toCount - removedFromTarget;\n    if (move.to.index > maxToIndex) {\n      return {\n        verdict: {\n          ok: false,\n          reason: {\n            code: \"toIndexPastEnd\",\n            itemId: move.itemId,\n            index: move.to.index,\n            columnId: move.to.columnId,\n            max: maxToIndex,\n          },\n        },\n        commit: [],\n      };\n    }\n  }\n\n  if (validateMove) {\n    const verdict = validateMove(request);\n    if (!verdict.ok) {\n      return { verdict: { ok: false, reason: { code: \"consumer\", message: verdict.reason } }, commit: [] };\n    }\n  }\n\n  const commit = request.moves.filter((move) => !noOp(move));\n\n  return { verdict: { ok: true }, commit };\n}\n\n/**\n * Turn a set of already-valid moves into the consumer's next `items` array.\n * Call this with moves already proven valid — typically `resolveMove(...).commit`\n * — never with raw, unvalidated input: this function does no checking of its\n * own, on purpose, so it stays a pure array transform with no notion of\n * \"reject.\" Handles N=1 and N>1 (same-column or cross-column, mixed) with the\n * one algorithm described in the file header.\n *\n * Reorders which COLUMN each item's block appears in within the returned\n * flat array (columns are emitted in first-seen order, any brand-new target\n * column appended after); WITHIN a column, order is always exactly what the\n * moves + original relative order produce. Between-column interleaving in\n * the input `items` array is not preserved because nothing in this module's\n * contract depends on it — `BoardAccessors.getColumnId` is what determines\n * column membership on every subsequent `buildBoardModel` call, and\n * `buildBoardModel` only ever reads WITHIN-column order.\n *\n * A LANE MOVE (`to.lane`, DX-4583) CHANGES MEMBERSHIP AND NOTHING ELSE. The\n * card stays at its place in `items`, so it lands among the destination's cards\n * where the consumer's own order puts it (its priority, its sort key). The\n * consumer's lane write must already be made, because this function cannot make\n * it: a lane move whose item still reports another lane throws, since the card\n * would otherwise stay in its old lane without a sound.\n *\n * `to.edge` IS NOT APPLIED HERE. This arranges the cards it was given, and in a\n * windowed column an edge move lands OUTSIDE the cards that are loaded — at the\n * top or bottom of a list this function cannot see — so the index it would\n * splice at is only the nearest loaded position, not the place the card is\n * going. A consumer of a windowed column sends the move to its server (see\n * `moveAnchor`) and re-reads the affected pages (`invalidateAll`); it does not\n * apply an edge move locally. In a column with every card loaded the edge IS\n * the index, and this function is exactly right.\n *\n * NEVER WRITES A FIELD ON ANY ITEM — ONLY REPOSITIONS. `BoardAccessors` has\n * no setter, on purpose (the file header on `types.ts` — items are opaque),\n * so this function CANNOT change what `getColumnId` reports for a moved\n * item; every returned item is the exact same reference it was given, just\n * possibly in a different slot. For a CROSS-column move this means the\n * repositioning alone does nothing observable until the caller ALSO updates\n * the moved item's own underlying field (a `status`, a `columnId`, whatever\n * the consumer's domain calls it) — that write is the consumer's, entirely\n * outside this module, because only the consumer's own accessor knows how to\n * produce it. The usual order is: update the field(s) first, THEN call this\n * to fix array position — see board-core.test.ts's \"what it does and does\n * not mutate\" tests, which pin both halves of this split.\n */\nexport function applyBoardMoves<T>(\n  items: readonly T[],\n  accessors: BoardAccessors<T>,\n  moves: readonly BoardMove[],\n): T[] {\n  if (moves.length === 0) return items.slice();\n\n  /* The one-item, same-column case is exactly what `applyMove` computes —\n     see the file header. Delegating here both reuses the shared utility\n     directly (rather than merely reproducing its arithmetic) and gives the\n     equivalence test in board-core.test.ts something concrete to pin. */\n  const only = moves[0];\n  if (moves.length === 1 && only.from.columnId === only.to.columnId && !only.to.lane) {\n    const targetColumnId = only.from.columnId;\n    /* Every column's bucket, untouched columns included — `applyMove` only\n       ever replaces the ONE bucket it reorders below. Building every bucket\n       here (rather than just the touched one) is what stops every other\n       column's items from vanishing from the returned array. */\n    const byColumn = new Map<BoardColumnId, T[]>();\n    for (const item of items) {\n      const columnId = accessors.getColumnId(item);\n      const bucket = byColumn.get(columnId);\n      if (bucket) bucket.push(item);\n      else byColumn.set(columnId, [item]);\n    }\n    const columnItems = byColumn.get(targetColumnId) ?? [];\n    byColumn.set(targetColumnId, applyMove(columnItems, only.from.index, only.to.index));\n    return flattenByFirstSeenColumn(items, accessors, byColumn);\n  }\n\n  const itemsById = new Map(items.map((item) => [accessors.getId(item), item]));\n\n  /* A lane move (DX-4583) repositions nothing: changing the lane is the\n     consumer's own write, made before this call, and the card stays where the\n     consumer's order puts it. A card whose lane was NOT written would silently\n     stay in its old lane, so that is refused here. Only a move with an index\n     takes its card out and inserts it again. */\n  for (const move of moves) {\n    if (!move.to.lane) continue;\n    const item = itemsById.get(move.itemId);\n    if (item !== undefined && accessors.getColumnId(item) !== move.to.columnId) {\n      throw new Error(\n        `applyBoardMoves: \"${move.itemId}\" moves to lane \"${move.to.columnId}\" but its own lane is still ` +\n          `\"${accessors.getColumnId(item)}\"; write the lane on the item before applying a lane move.`,\n      );\n    }\n  }\n  const positional = moves.filter((m): m is PositionalMove => !m.to.lane);\n  const movedIds = new Set(positional.map((m) => m.itemId));\n\n  /* The residual per column: every item currently in that column MINUS every\n     item this request moves out of it (from ANY source column — including\n     ones the item is moving to, since a bulk request can move several items\n     into and out of the same column at once). Building this once up front,\n     rather than mutating a shared array as each move is \"applied,\" is what\n     makes the result independent of the order `moves` happens to list them\n     in — see the file header's bulk trap. */\n  const residualByColumn = new Map<BoardColumnId, T[]>();\n  for (const item of items) {\n    const columnId = accessors.getColumnId(item);\n    if (movedIds.has(accessors.getId(item))) continue;\n    const bucket = residualByColumn.get(columnId);\n    if (bucket) bucket.push(item);\n    else residualByColumn.set(columnId, [item]);\n  }\n\n  /* Group incoming moves by target column, sorted by `to.index` ascending\n     with a stable tie-break on original request order — the exact rule the\n     file header spells out for why insertion is a single deterministic pass\n     rather than N independent splices. */\n  const incomingByColumn = new Map<BoardColumnId, { move: PositionalMove; requestOrder: number }[]>();\n  positional.forEach((move, requestOrder) => {\n    const list = incomingByColumn.get(move.to.columnId);\n    const entry = { move, requestOrder };\n    if (list) list.push(entry);\n    else incomingByColumn.set(move.to.columnId, [entry]);\n  });\n\n  for (const [columnId, incoming] of incomingByColumn) {\n    incoming.sort((a, b) => a.move.to.index - b.move.to.index || a.requestOrder - b.requestOrder);\n    const base = residualByColumn.get(columnId) ?? [];\n    incoming.forEach(({ move }, insertedSoFar) => {\n      const item = itemsById.get(move.itemId);\n      if (!item) return; // pre-validated input; defensive only, never expected.\n      base.splice(move.to.index + insertedSoFar, 0, item);\n    });\n    residualByColumn.set(columnId, base);\n  }\n\n  return flattenByFirstSeenColumn(items, accessors, residualByColumn);\n}\n\n/** Concatenate every column's items, in the order columns first appear in\n *  `original` — see `applyBoardMoves`'s doc for why between-column\n *  interleaving is not preserved but within-column order always is. */\nfunction flattenByFirstSeenColumn<T>(\n  original: readonly T[],\n  accessors: BoardAccessors<T>,\n  byColumn: ReadonlyMap<BoardColumnId, T[]>,\n): T[] {\n  const order: BoardColumnId[] = [];\n  const seen = new Set<BoardColumnId>();\n  for (const item of original) {\n    const columnId = accessors.getColumnId(item);\n    if (byColumn.has(columnId) && !seen.has(columnId)) {\n      seen.add(columnId);\n      order.push(columnId);\n    }\n  }\n  for (const columnId of byColumn.keys()) {\n    if (!seen.has(columnId)) {\n      seen.add(columnId);\n      order.push(columnId);\n    }\n  }\n  return order.flatMap((columnId) => byColumn.get(columnId) ?? []);\n}\n"],"names":["isNoOpMove","move","def","loaded","from","to","isNoOp","position","positionInColumn","columnLength","resolveMove","context","request","items","columns","accessors","validateMove","columnIds","c","itemsById","item","countByColumn","columnId","defsById","noOp","movesSourcedFrom","seenItemIds","actualColumnId","fromCount","lockedMessage","toCount","removedFromTarget","maxToIndex","verdict","commit","applyBoardMoves","moves","only","targetColumnId","byColumn","bucket","columnItems","applyMove","flattenByFirstSeenColumn","positional","m","movedIds","residualByColumn","incomingByColumn","requestOrder","list","entry","incoming","a","b","base","insertedSoFar","original","order","seen"],"mappings":"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"}

package/dist/lib/board/position.js

@@ -0,0 +1,11 @@
+function o(t, n) {
+  return typeof t?.total == "number" ? t.total : n;
+}
+function u(t, n) {
+  return (t?.offset ?? 0) + n;
+}
+export {
+  o as columnLength,
+  u as positionInColumn
+};
+//# sourceMappingURL=position.js.map

package/dist/lib/board/position.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"position.js","sources":["../../../src/lib/board/position.ts"],"sourcesContent":["/**\n * ==== COLUMN POSITION ====\n *\n * Two facts about a column that three callers each need and must not each work\n * out for themselves (DX-4540): how long the column really is, and where in the\n * whole column a loaded card sits. A windowed column holds only a few pages of\n * a longer list, so the cards loaded are not the column.\n *\n * `buildBoardModel` decides the length once (the model's `count`); `resolveMove`\n * works from the column DEFINITIONS before any model exists and must decide\n * \"is this card already at that edge\" with the same rule; and the move menu\n * decides what to offer from a card's place in the column. All three read these.\n */\n\nimport type { BoardColumnDef } from \"./types\";\n\n/**\n * The column's length: its `total` when the definition gave a number, otherwise\n * the cards loaded (`total` absent means every card is loaded; `null` means the\n * length is still being read, so the loaded cards are all that is known).\n */\nexport function columnLength(def: Pick<BoardColumnDef, \"total\"> | undefined, loaded: number): number {\n  return typeof def?.total === \"number\" ? def.total : loaded;\n}\n\n/** The place in the whole column of the loaded card at `index`: the window's offset plus the index. */\nexport function positionInColumn(def: Pick<BoardColumnDef, \"offset\"> | undefined, index: number): number {\n  return (def?.offset ?? 0) + index;\n}\n"],"names":["columnLength","def","loaded","positionInColumn","index"],"mappings":"AAqBO,SAASA,EAAaC,GAAgDC,GAAwB;AACnG,SAAO,OAAOD,GAAK,SAAU,WAAWA,EAAI,QAAQC;AACtD;AAGO,SAASC,EAAiBF,GAAiDG,GAAuB;AACvG,UAAQH,GAAK,UAAU,KAAKG;AAC9B;"}

package/dist/lib/board/rejection.js

@@ -0,0 +1,22 @@
+import { numberFormat as e } from "../intl-cache.js";
+function i(t, u, n) {
+  const m = (d) => e(u, {}).format(d);
+  switch (n.code) {
+    case "unknownItem":
+      return t.unknownItem(String(n.itemId));
+    case "wrongColumn":
+      return t.wrongColumn(String(n.itemId), String(n.actualColumnId), String(n.claimedColumnId));
+    case "unknownColumn":
+      return t.unknownColumn(String(n.columnId));
+    case "fromIndexPastEnd":
+      return t.fromIndexPastEnd(n.count, m(n.count), String(n.itemId), m(n.index), String(n.columnId));
+    case "toIndexPastEnd":
+      return t.toIndexPastEnd(String(n.itemId), m(n.index), String(n.columnId), m(n.max));
+    case "consumer":
+      return n.message;
+  }
+}
+export {
+  i as describeMoveRejection
+};
+//# sourceMappingURL=rejection.js.map

package/dist/lib/board/rejection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rejection.js","sources":["../../../src/lib/board/rejection.ts"],"sourcesContent":["import { numberFormat } from \"../intl-cache\";\nimport type { UiStrings } from \"../i18n\";\nimport type { BoardMoveRejection } from \"./types\";\n\n/**\n * DX-4740: the sentence a person reads for a refused move. The core answers with values\n * (`BoardMoveRejection`); the provider's `moveRejected` strings word them. A consumer's own\n * sentence passes through untouched.\n */\nexport function describeMoveRejection(\n  strings: UiStrings[\"moveRejected\"],\n  locale: string,\n  reason: BoardMoveRejection,\n): string {\n  const n = (value: number) => numberFormat(locale, {}).format(value);\n  switch (reason.code) {\n    case \"unknownItem\":\n      return strings.unknownItem(String(reason.itemId));\n    case \"wrongColumn\":\n      return strings.wrongColumn(String(reason.itemId), String(reason.actualColumnId), String(reason.claimedColumnId));\n    case \"unknownColumn\":\n      return strings.unknownColumn(String(reason.columnId));\n    case \"fromIndexPastEnd\":\n      return strings.fromIndexPastEnd(reason.count, n(reason.count), String(reason.itemId), n(reason.index), String(reason.columnId));\n    case \"toIndexPastEnd\":\n      return strings.toIndexPastEnd(String(reason.itemId), n(reason.index), String(reason.columnId), n(reason.max));\n    case \"consumer\":\n      return reason.message;\n  }\n}\n"],"names":["describeMoveRejection","strings","locale","reason","n","value","numberFormat"],"mappings":";AASO,SAASA,EACdC,GACAC,GACAC,GACQ;AACR,QAAMC,IAAI,CAACC,MAAkBC,EAAaJ,GAAQ,EAAE,EAAE,OAAOG,CAAK;AAClE,UAAQF,EAAO,MAAA;AAAA,IACb,KAAK;AACH,aAAOF,EAAQ,YAAY,OAAOE,EAAO,MAAM,CAAC;AAAA,IAClD,KAAK;AACH,aAAOF,EAAQ,YAAY,OAAOE,EAAO,MAAM,GAAG,OAAOA,EAAO,cAAc,GAAG,OAAOA,EAAO,eAAe,CAAC;AAAA,IACjH,KAAK;AACH,aAAOF,EAAQ,cAAc,OAAOE,EAAO,QAAQ,CAAC;AAAA,IACtD,KAAK;AACH,aAAOF,EAAQ,iBAAiBE,EAAO,OAAOC,EAAED,EAAO,KAAK,GAAG,OAAOA,EAAO,MAAM,GAAGC,EAAED,EAAO,KAAK,GAAG,OAAOA,EAAO,QAAQ,CAAC;AAAA,IAChI,KAAK;AACH,aAAOF,EAAQ,eAAe,OAAOE,EAAO,MAAM,GAAGC,EAAED,EAAO,KAAK,GAAG,OAAOA,EAAO,QAAQ,GAAGC,EAAED,EAAO,GAAG,CAAC;AAAA,IAC9G,KAAK;AACH,aAAOA,EAAO;AAAA,EAAA;AAEpB;"}

package/dist/lib/board/use-board.js

@@ -0,0 +1,43 @@
+import { useMemo as p, useCallback as l } from "react";
+import { buildBoardModel as C } from "./model.js";
+import { resolveMove as E } from "./move.js";
+const b = [];
+function I(a) {
+  const { items: n, columns: c, accessors: r, validateMove: i, onMove: m, selection: u } = a, d = p(
+    () => C(n, c, r),
+    [n, c, r]
+  ), v = l(
+    (t) => {
+      const s = E({ items: n, columns: c, accessors: r, validateMove: i }, t);
+      return s.verdict.ok && s.commit.length > 0 && m({ moves: s.commit, source: t.source }), s.verdict;
+    },
+    [n, c, r, i, m]
+  ), e = u?.selected, o = u?.onChange, f = e ?? b, g = l(
+    (t) => {
+      o?.(t);
+    },
+    [o]
+  ), M = l(
+    (t) => {
+      if (!o || !e) return;
+      const s = e.includes(t) ? e.filter((h) => h !== t) : [...e, t];
+      o(s);
+    },
+    [e, o]
+  ), S = l(() => {
+    !o || !e || e.length === 0 || o([]);
+  }, [e, o]);
+  return {
+    columns: d.columns,
+    unassigned: d.unassigned,
+    selected: f,
+    toggleSelected: M,
+    setSelected: g,
+    clearSelection: S,
+    requestMove: v
+  };
+}
+export {
+  I as useBoard
+};
+//# sourceMappingURL=use-board.js.map

package/dist/lib/board/use-board.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-board.js","sources":["../../../src/lib/board/use-board.ts"],"sourcesContent":["/**\n * ==== USE BOARD ====\n *\n * The React binding over the two pure modules. Deliberately thin: every claim\n * this hook makes has already been proven in model.ts and move.ts without a\n * browser, so the only thing left for React-specific code to get wrong is\n * memoisation and the selection wiring — logic that lived INSIDE a hook\n * instead of a pure function would be logic no test in board-core.test.ts\n * could reach without mounting a component. `renderHook` here exists only to\n * prove the composition wires up, not to re-prove validation or bulk\n * atomicity, which are already pinned in the pure-module tests.\n *\n * `requestMove` IS THE SINGLE FUNNEL. Pointer drag's `onDragEnd`, a keyboard\n * handler, the mandatory \"Move to…\" menu (WCAG 2.5.7 — see `types.ts`), and a\n * bulk-selection action all construct a `BoardMoveRequest` and call this ONE\n * function. It never mutates `items` itself — `UseBoardOptions.onMove` returns\n * `void` by contract, so the actual next `items` array is the CONSUMER's to\n * produce, typically via `applyBoardMoves` from `./move`. `requestMove` only\n * decides whether that consumer callback fires at all, and returns the verdict\n * synchronously so the caller (e.g. the menu) can show a rejection reason\n * immediately rather than guessing from a UI that just didn't change.\n *\n * SELECTION IS FULLY CONTROLLED, NOT A SECOND SOURCE OF TRUTH. `selection` on\n * `UseBoardOptions` supplies BOTH `selected` and `onChange` — this hook never\n * keeps its own copy of which ids are selected, for the same reason `items`\n * is never copied: a second copy is a copy that can drift. What this hook\n * \"owns\" is the BEHAVIOUR built on top of that controlled pair (toggle one,\n * replace the set, clear) so every input source computes a selection change\n * the same way, mirroring why `requestMove` exists as a single funnel for\n * moves rather than one per source.\n */\n\nimport { useCallback, useMemo } from \"react\";\nimport { buildBoardModel } from \"./model\";\nimport { resolveMove } from \"./move\";\nimport type {\n  BoardColumnModel,\n  BoardItemId,\n  BoardMoveRequest,\n  BoardMoveOutcome,\n  UseBoardOptions,\n} from \"./types\";\n\n/** Stable reference so a board with no `selection` option doesn't hand back a\n *  new empty array — and therefore a new `selected` identity — every render. */\nconst EMPTY_SELECTION: readonly BoardItemId[] = [];\n\nexport interface UseBoardResult<T> {\n  /** One entry per declared column, in `columns` order, ready to render. */\n  columns: readonly BoardColumnModel<T>[];\n  /** Items whose `getColumnId` matched no declared column. See model.ts. */\n  unassigned: readonly T[];\n  /** The current controlled selection, or `[]` when `selection` was not supplied. */\n  selected: readonly BoardItemId[];\n  /** No-ops when `selection` was not supplied — see the file header. */\n  toggleSelected: (id: BoardItemId) => void;\n  setSelected: (ids: readonly BoardItemId[]) => void;\n  clearSelection: () => void;\n  /** The single funnel every input source calls. See the file header. */\n  requestMove: (request: BoardMoveRequest) => BoardMoveOutcome;\n}\n\nexport function useBoard<T>(options: UseBoardOptions<T>): UseBoardResult<T> {\n  const { items, columns, accessors, validateMove, onMove, selection } = options;\n\n  const model = useMemo(\n    () => buildBoardModel(items, columns, accessors),\n    [items, columns, accessors],\n  );\n\n  const requestMove = useCallback(\n    (request: BoardMoveRequest): BoardMoveOutcome => {\n      const resolved = resolveMove({ items, columns, accessors, validateMove }, request);\n      /* `onMove` fires only for a request that is both valid AND leaves at\n         least one real change — see move.ts's header for why those are\n         checked as two separate questions. A verdict of `ok:true` with an\n         empty `commit` (every move was a no-op) must not reach the consumer\n         as a write. */\n      if (resolved.verdict.ok && resolved.commit.length > 0) {\n        onMove({ moves: resolved.commit, source: request.source });\n      }\n      return resolved.verdict;\n    },\n    [items, columns, accessors, validateMove, onMove],\n  );\n\n  /* DEPEND ON THE VALUES, NEVER ON THE `selection` OBJECT — the same rule\n     `DragDrop.tsx` states for its `autoScroll` options, and for the same\n     reason: `selection` is written inline by every realistic consumer\n     (`selection={{ selected, onChange }}`), so a dependency on its IDENTITY\n     changes on every render. There the cost was tearing down the auto-scroll\n     loop mid-gesture; here it is quieter and therefore easier to ship — all\n     three callbacks below get a new identity every render, so every memoised\n     card receiving one re-renders, on a board the domain analysis says runs to\n     hundreds of cards. Destructuring first makes the deps the actual array and\n     the actual function, which a consumer CAN hold stable. */\n  const selectedItems = selection?.selected;\n  const onSelectionChange = selection?.onChange;\n  const selected = selectedItems ?? EMPTY_SELECTION;\n\n  const setSelected = useCallback(\n    (ids: readonly BoardItemId[]) => {\n      onSelectionChange?.(ids);\n    },\n    [onSelectionChange],\n  );\n\n  const toggleSelected = useCallback(\n    (id: BoardItemId) => {\n      if (!onSelectionChange || !selectedItems) return;\n      const next = selectedItems.includes(id)\n        ? selectedItems.filter((existing) => existing !== id)\n        : [...selectedItems, id];\n      onSelectionChange(next);\n    },\n    [selectedItems, onSelectionChange],\n  );\n\n  const clearSelection = useCallback(() => {\n    /* Mirrors move.ts's no-op discipline: clearing an already-empty selection\n       writes nothing rather than firing `onChange([])` for no reason. */\n    if (!onSelectionChange || !selectedItems || selectedItems.length === 0) return;\n    onSelectionChange([]);\n  }, [selectedItems, onSelectionChange]);\n\n  return {\n    columns: model.columns,\n    unassigned: model.unassigned,\n    selected,\n    toggleSelected,\n    setSelected,\n    clearSelection,\n    requestMove,\n  };\n}\n"],"names":["EMPTY_SELECTION","useBoard","options","items","columns","accessors","validateMove","onMove","selection","model","useMemo","buildBoardModel","requestMove","useCallback","request","resolved","resolveMove","selectedItems","onSelectionChange","selected","setSelected","ids","toggleSelected","id","next","existing","clearSelection"],"mappings":";;;AA6CA,MAAMA,IAA0C,CAAA;AAiBzC,SAASC,EAAYC,GAAgD;AAC1E,QAAM,EAAE,OAAAC,GAAO,SAAAC,GAAS,WAAAC,GAAW,cAAAC,GAAc,QAAAC,GAAQ,WAAAC,MAAcN,GAEjEO,IAAQC;AAAA,IACZ,MAAMC,EAAgBR,GAAOC,GAASC,CAAS;AAAA,IAC/C,CAACF,GAAOC,GAASC,CAAS;AAAA,EAAA,GAGtBO,IAAcC;AAAA,IAClB,CAACC,MAAgD;AAC/C,YAAMC,IAAWC,EAAY,EAAE,OAAAb,GAAO,SAAAC,GAAS,WAAAC,GAAW,cAAAC,EAAA,GAAgBQ,CAAO;AAMjF,aAAIC,EAAS,QAAQ,MAAMA,EAAS,OAAO,SAAS,KAClDR,EAAO,EAAE,OAAOQ,EAAS,QAAQ,QAAQD,EAAQ,QAAQ,GAEpDC,EAAS;AAAA,IAClB;AAAA,IACA,CAACZ,GAAOC,GAASC,GAAWC,GAAcC,CAAM;AAAA,EAAA,GAa5CU,IAAgBT,GAAW,UAC3BU,IAAoBV,GAAW,UAC/BW,IAAWF,KAAiBjB,GAE5BoB,IAAcP;AAAA,IAClB,CAACQ,MAAgC;AAC/B,MAAAH,IAAoBG,CAAG;AAAA,IACzB;AAAA,IACA,CAACH,CAAiB;AAAA,EAAA,GAGdI,IAAiBT;AAAA,IACrB,CAACU,MAAoB;AACnB,UAAI,CAACL,KAAqB,CAACD,EAAe;AAC1C,YAAMO,IAAOP,EAAc,SAASM,CAAE,IAClCN,EAAc,OAAO,CAACQ,MAAaA,MAAaF,CAAE,IAClD,CAAC,GAAGN,GAAeM,CAAE;AACzB,MAAAL,EAAkBM,CAAI;AAAA,IACxB;AAAA,IACA,CAACP,GAAeC,CAAiB;AAAA,EAAA,GAG7BQ,IAAiBb,EAAY,MAAM;AAGvC,IAAI,CAACK,KAAqB,CAACD,KAAiBA,EAAc,WAAW,KACrEC,EAAkB,CAAA,CAAE;AAAA,EACtB,GAAG,CAACD,GAAeC,CAAiB,CAAC;AAErC,SAAO;AAAA,IACL,SAAST,EAAM;AAAA,IACf,YAAYA,EAAM;AAAA,IAClB,UAAAU;AAAA,IACA,gBAAAG;AAAA,IACA,aAAAF;AAAA,IACA,gBAAAM;AAAA,IACA,aAAAd;AAAA,EAAA;AAEJ;"}

package/dist/lib/calendar/band-packer.js

@@ -0,0 +1,44 @@
+function h(n, r) {
+  const e = (n.priority ?? 0) - (r.priority ?? 0);
+  if (e !== 0) return e;
+  const s = r.endColumn - r.startColumn - (n.endColumn - n.startColumn);
+  return s !== 0 ? s : n.startColumn !== r.startColumn ? n.startColumn - r.startColumn : n.key < r.key ? -1 : n.key > r.key ? 1 : 0;
+}
+function k(n, r) {
+  const { columns: e, maxRows: s } = r, p = [...n].sort(h), l = [], u = [];
+  for (const t of p) {
+    const c = Math.max(0, t.startColumn), f = Math.min(e - 1, t.endColumn);
+    if (f < c) continue;
+    let o = 0;
+    for (; ; ) {
+      l[o] || (l[o] = new Array(e).fill(!1));
+      let i = !0;
+      for (let m = c; m <= f; m++)
+        if (l[o][m]) {
+          i = !1;
+          break;
+        }
+      if (i) break;
+      o++;
+    }
+    for (let i = c; i <= f; i++) l[o][i] = !0;
+    u.push({ ...t, row: o });
+  }
+  if (s === void 0)
+    return {
+      placed: u,
+      hidden: [],
+      overflow: new Array(e).fill(0),
+      rows: l.length
+    };
+  const d = l.length, a = d > s ? Math.max(0, s - 1) : d, y = u.filter((t) => t.row < a), w = u.filter((t) => t.row >= a), C = new Array(e).fill(0);
+  for (const t of w) {
+    const c = Math.max(0, t.startColumn), f = Math.min(e - 1, t.endColumn);
+    for (let o = c; o <= f; o++) C[o]++;
+  }
+  return { placed: y, hidden: w, overflow: C, rows: a };
+}
+export {
+  k as packBand
+};
+//# sourceMappingURL=band-packer.js.map

package/dist/lib/calendar/band-packer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"band-packer.js","sources":["../../../src/lib/calendar/band-packer.ts"],"sourcesContent":["/* ============================================================================\n   THE BAND PACKER — greedy first-fit rows for items that span COLUMNS.\n\n   ONE PACKER SERVES BOTH THE MONTH ROW AND THE ALL-DAY BAND, deliberately.\n   FullCalendar literally embeds a dayGrid row inside its timeGrid to get this,\n   which is the same conclusion by a heavier route. Two implementations of one\n   idea means two bug sets, and they will not be the same two.\n\n   THE RULE THAT MAKES MULTI-DAY EVENTS WORK: rows are assigned across the WHOLE\n   ROW-SEGMENT, and hiding is by row index, uniformly. Per-CELL decisions are\n   exactly why a multi-day event truncated on day 1 vanishes from days 2-5 in\n   react-big-calendar — three open issues. An item is shown across its entire\n   span or hidden across its entire span; there is no state in between.\n   ========================================================================= */\n\n/** A contiguous run of columns within one row of the grid. Both ends inclusive. */\nexport interface BandInput {\n  readonly key: string;\n  readonly startColumn: number;\n  readonly endColumn: number;\n  /**\n   * Ordering weight. Lower sorts earlier, so pinned items keep their place as\n   * neighbours come and go. Ties fall through to span length, then key.\n   */\n  readonly priority?: number;\n}\n\nexport interface BandPlacement extends BandInput {\n  /** 0-based row within the band. */\n  readonly row: number;\n}\n\nexport interface BandResult {\n  /** Everything that fits, in row order. */\n  readonly placed: readonly BandPlacement[];\n  /** Everything pushed past the limit, in the same order it would have had. */\n  readonly hidden: readonly BandInput[];\n  /** Per column, how many hidden items cover it — the \"+N more\" count. */\n  readonly overflow: readonly number[];\n  /** Rows actually used by `placed`. */\n  readonly rows: number;\n}\n\nexport interface BandOptions {\n  /** How many columns the row has. Required — it sizes the overflow tally. */\n  readonly columns: number;\n  /**\n   * Most rows the band may occupy, INCLUDING the row the \"+N more\" affordance\n   * takes.\n   *\n   * Counting the affordance is what stops the classic off-by-one where the\n   * overflow link is drawn on top of the last event. When items do not fit,\n   * events get `maxRows - 1` rows and the last is reserved — which is\n   * FullCalendar's `dayMaxEventRows` semantics, and the only version that\n   * leaves room for the thing it just decided to draw.\n   *\n   * Omit for no limit. The all-day band MUST pass one: an uncapped band eats\n   * the container and makes the time grid unreachable — an open FullCalendar\n   * bug, and react-big-calendar's default is literally `Infinity`.\n   */\n  readonly maxRows?: number;\n}\n\nfunction compare(a: BandInput, b: BandInput): number {\n  const priority = (a.priority ?? 0) - (b.priority ?? 0);\n  if (priority !== 0) return priority;\n  /* Longer spans first: a bar crossing the whole week claims a row before the\n     single-day items that can slot around it. The reverse leaves the long bar\n     hunting for a row with a gap in exactly the right place. */\n  const bySpan = b.endColumn - b.startColumn - (a.endColumn - a.startColumn);\n  if (bySpan !== 0) return bySpan;\n  if (a.startColumn !== b.startColumn) return a.startColumn - b.startColumn;\n  /* Total order — see the same note in `lane-packer.ts`. Without the key, the\n     same events in a different array order produce a different layout. */\n  return a.key < b.key ? -1 : a.key > b.key ? 1 : 0;\n}\n\n/**\n * Assign each item the first row where every column it covers is free.\n *\n * Greedy first-fit. Not optimal in the sense of minimising rows — that is\n * NP-hard and nobody wants it anyway, because the optimal packing reshuffles\n * every event's row whenever one is added, and a calendar whose events jump\n * rows as you type is worse than one that uses an extra row.\n */\nexport function packBand(inputs: readonly BandInput[], options: BandOptions): BandResult {\n  const { columns, maxRows } = options;\n  const sorted = [...inputs].sort(compare);\n\n  /* One occupancy bitmap per row, indexed by column. */\n  const occupied: boolean[][] = [];\n  const assigned: BandPlacement[] = [];\n\n  for (const item of sorted) {\n    const from = Math.max(0, item.startColumn);\n    const to = Math.min(columns - 1, item.endColumn);\n    /* An item entirely outside the row contributes nothing — it belongs to a\n       different row-segment and will be placed there. */\n    if (to < from) continue;\n\n    let row = 0;\n    for (;;) {\n      if (!occupied[row]) occupied[row] = new Array<boolean>(columns).fill(false);\n      let free = true;\n      for (let c = from; c <= to; c++) {\n        if (occupied[row][c]) {\n          free = false;\n          break;\n        }\n      }\n      if (free) break;\n      row++;\n    }\n    for (let c = from; c <= to; c++) occupied[row][c] = true;\n    assigned.push({ ...item, row });\n  }\n\n  if (maxRows === undefined) {\n    return {\n      placed: assigned,\n      hidden: [],\n      overflow: new Array<number>(columns).fill(0),\n      rows: occupied.length,\n    };\n  }\n\n  const needed = occupied.length;\n  /* Only reserve a row for the affordance when something is actually going to\n     overflow. Reserving unconditionally throws away a usable row on every\n     ordinary week. */\n  const visibleRows = needed > maxRows ? Math.max(0, maxRows - 1) : needed;\n\n  const placed = assigned.filter((item) => item.row < visibleRows);\n  const hidden = assigned.filter((item) => item.row >= visibleRows);\n\n  const overflow = new Array<number>(columns).fill(0);\n  for (const item of hidden) {\n    const from = Math.max(0, item.startColumn);\n    const to = Math.min(columns - 1, item.endColumn);\n    /* Counted per COLUMN, because \"+2 more\" is a statement about one day's\n       cell — but decided per ITEM above, so a hidden multi-day bar is hidden on\n       every day it covers rather than dropping out of some of them. */\n    for (let c = from; c <= to; c++) overflow[c]++;\n  }\n\n  return { placed, hidden, overflow, rows: visibleRows };\n}\n"],"names":["compare","a","b","priority","bySpan","packBand","inputs","options","columns","maxRows","sorted","occupied","assigned","item","from","to","row","free","c","needed","visibleRows","placed","hidden","overflow"],"mappings":"AA+DA,SAASA,EAAQC,GAAcC,GAAsB;AACnD,QAAMC,KAAYF,EAAE,YAAY,MAAMC,EAAE,YAAY;AACpD,MAAIC,MAAa,EAAG,QAAOA;AAI3B,QAAMC,IAASF,EAAE,YAAYA,EAAE,eAAeD,EAAE,YAAYA,EAAE;AAC9D,SAAIG,MAAW,IAAUA,IACrBH,EAAE,gBAAgBC,EAAE,cAAoBD,EAAE,cAAcC,EAAE,cAGvDD,EAAE,MAAMC,EAAE,MAAM,KAAKD,EAAE,MAAMC,EAAE,MAAM,IAAI;AAClD;AAUO,SAASG,EAASC,GAA8BC,GAAkC;AACvF,QAAM,EAAE,SAAAC,GAAS,SAAAC,EAAA,IAAYF,GACvBG,IAAS,CAAC,GAAGJ,CAAM,EAAE,KAAKN,CAAO,GAGjCW,IAAwB,CAAA,GACxBC,IAA4B,CAAA;AAElC,aAAWC,KAAQH,GAAQ;AACzB,UAAMI,IAAO,KAAK,IAAI,GAAGD,EAAK,WAAW,GACnCE,IAAK,KAAK,IAAIP,IAAU,GAAGK,EAAK,SAAS;AAG/C,QAAIE,IAAKD,EAAM;AAEf,QAAIE,IAAM;AACV,eAAS;AACP,MAAKL,EAASK,CAAG,MAAGL,EAASK,CAAG,IAAI,IAAI,MAAeR,CAAO,EAAE,KAAK,EAAK;AAC1E,UAAIS,IAAO;AACX,eAASC,IAAIJ,GAAMI,KAAKH,GAAIG;AAC1B,YAAIP,EAASK,CAAG,EAAEE,CAAC,GAAG;AACpB,UAAAD,IAAO;AACP;AAAA,QACF;AAEF,UAAIA,EAAM;AACV,MAAAD;AAAA,IACF;AACA,aAASE,IAAIJ,GAAMI,KAAKH,GAAIG,IAAK,CAAAP,EAASK,CAAG,EAAEE,CAAC,IAAI;AACpD,IAAAN,EAAS,KAAK,EAAE,GAAGC,GAAM,KAAAG,GAAK;AAAA,EAChC;AAEA,MAAIP,MAAY;AACd,WAAO;AAAA,MACL,QAAQG;AAAA,MACR,QAAQ,CAAA;AAAA,MACR,UAAU,IAAI,MAAcJ,CAAO,EAAE,KAAK,CAAC;AAAA,MAC3C,MAAMG,EAAS;AAAA,IAAA;AAInB,QAAMQ,IAASR,EAAS,QAIlBS,IAAcD,IAASV,IAAU,KAAK,IAAI,GAAGA,IAAU,CAAC,IAAIU,GAE5DE,IAAST,EAAS,OAAO,CAACC,MAASA,EAAK,MAAMO,CAAW,GACzDE,IAASV,EAAS,OAAO,CAACC,MAASA,EAAK,OAAOO,CAAW,GAE1DG,IAAW,IAAI,MAAcf,CAAO,EAAE,KAAK,CAAC;AAClD,aAAWK,KAAQS,GAAQ;AACzB,UAAMR,IAAO,KAAK,IAAI,GAAGD,EAAK,WAAW,GACnCE,IAAK,KAAK,IAAIP,IAAU,GAAGK,EAAK,SAAS;AAI/C,aAASK,IAAIJ,GAAMI,KAAKH,GAAIG,OAAcA,CAAC;AAAA,EAC7C;AAEA,SAAO,EAAE,QAAAG,GAAQ,QAAAC,GAAQ,UAAAC,GAAU,MAAMH,EAAA;AAC3C;"}