@panphora/clayjs 1.13.1 → 1.14.0

package/src/page/ybind/binding.js

@@ -0,0 +1,92 @@
+import * as Y from "../../vendor/yjs.vendor.js";
+import { NET, createPageDoc, walk, docOf } from "./core.js";
+import { createBridge, keepViewPos } from "./bridge.js";
+import { createYProvider, entriesOf, dec } from "./provider.js";
+
+export function createYPageBinding({ store, ydoc = new Y.Doc(), onNotice = () => {}, ownedTokens = [], authorToken = null, setTimer = setTimeout, clearTimer = clearTimeout, compact, captureTimeout = 500, checkpointWithin = () => {}, requestCheckpoint = null, registerUnsavedState = null, onStopped = () => {} }) {
+  for (const [, v] of entriesOf(store.value.y)) Y.applyUpdateV2(ydoc, dec(v), NET);
+  const pd = createPageDoc(ydoc);
+  const provider = createYProvider({ store, ydoc, setTimer, clearTimer, compact, onStopped });
+  const stats = { groups: 0, mismatch: 0, renders: 0, first: null };
+  const bridge = createBridge({ pd, onNotice, ownedTokens, authorToken, stats, captureTimeout });
+  const waiters = new Set();
+  let disposed = false;
+  let checksQueued = false;
+  const unsaved = registerUnsavedState?.({ id: "page:live", isPending: () => store.pending.length > 0 || provider.reconcilePending, flush });
+  const changed = () => {
+    unsaved?.changed();
+    if (checksQueued) return;
+    checksQueued = true;
+    Promise.resolve().then(() => {
+      checksQueued = false;
+      if (!disposed) for (const waiter of [...waiters]) waiter.check();
+    });
+  };
+  const offLocal = store.onLocal(() => { checkpointWithin(1500); changed(); });
+  const offRebase = store.onRebase(changed);
+  const offConfirm = store.onConfirm(changed);
+
+  function flush({ timeoutMs = 10_000 } = {}) {
+    if (disposed) return Promise.resolve({ ok: false, code: "disposed" });
+    return new Promise((resolve) => {
+      const deadline = Date.now() + timeoutMs;
+      let done = false, checking = false, checkpointing = false, timer = null;
+      const waiter = { check, finish };
+      function finish(result) {
+        if (done) return;
+        done = true;
+        waiters.delete(waiter);
+        clearTimer(timer);
+        resolve(result);
+      }
+      function check() {
+        if (done || checking || checkpointing) return;
+        checking = true;
+        try {
+          provider.settle();
+          if (store.pending.length) {
+            checkpointWithin(0);
+            if (store.pending.length) return;
+          }
+          checkpointing = true;
+          if (!requestCheckpoint) { finish({ ok: true }); return; }
+          Promise.resolve().then(() => {
+            if (!done) return requestCheckpoint({ timeoutMs: Math.max(0, deadline - Date.now()) });
+          }).then(finish, (error) => finish({ ok: false, code: "checkpoint-failed", message: error?.message || String(error) }));
+        } catch (error) {
+          finish({ ok: false, code: "flush-failed", message: error?.message || String(error) });
+        } finally { checking = false; }
+      }
+      waiters.add(waiter);
+      timer = setTimer(() => finish({ ok: false, code: "timeout" }), timeoutMs);
+      check();
+    });
+  }
+
+  return {
+    ydoc, pd, provider, bridge, stats, flush,
+    doc: () => keepViewPos(docOf(pd, walk(pd))),
+    attach: (view) => bridge.attach(view),
+    dispatch: (tr) => bridge.dispatch(tr),
+    moveBlocks: (args) => bridge.moveBlocks(args),
+    board: bridge.board,
+    undo: () => bridge.undo(),
+    redo: () => bridge.redo(),
+    restore: (sourceKey, revision) => bridge.restore(sourceKey, revision),
+    get recoverable() { return bridge.recoverable; },
+    get notices() { return bridge.notices; },
+    subscribeRecovery: (listener) => bridge.subscribeRecovery(listener),
+    dismiss: (sourceKey, revision) => bridge.dismiss(sourceKey, revision),
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      offLocal();
+      offRebase();
+      offConfirm();
+      unsaved?.dispose();
+      for (const waiter of [...waiters]) waiter.finish({ ok: false, code: "disposed" });
+      bridge.dispose();
+      provider.dispose();
+    },
+  };
+}

package/src/page/ybind/board-commands.js

@@ -0,0 +1,170 @@
+import { schema } from "../schema.js";
+import { isKey, keyBetween, newId, orderedIds } from "../model.js";
+import { canon } from "../projection.js";
+import { LOCAL } from "./layout.js";
+import { walk } from "./walk.js";
+import { fieldsOf } from "./doc.js";
+import { attrKey, recoveredSource } from "./recovery.js";
+import { removedBoardEntities, writeBoard } from "./board.js";
+
+const refuse = (code) => ({ status: "refused", code });
+const copy = (value) => JSON.parse(JSON.stringify(value));
+const CARD_FIELDS = ["title", "owner", "due"];
+const DUE = /^\d{4}-\d{2}-\d{2}$/;
+const validValue = (field, value) => {
+  if (field === "title") return typeof value === "string";
+  if (field === "due") return value === null || (typeof value === "string" && DUE.test(value));
+  return value === null || (typeof value === "string" && value.length > 0);
+};
+const record = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+
+export function slotKey(positions, index) {
+  const lower = index > 0 ? positions[index - 1] : null;
+  const upper = positions.slice(index).find((pos) => lower === null || pos > lower) ?? null;
+  const fits = (key) => (lower === null || key > lower) && (upper === null || key < upper);
+  for (const [a, b] of [[lower, upper], [null, upper], [lower, null]]) {
+    if ((a !== null && !isKey(a)) || (b !== null && !isKey(b)) || (a !== null && b !== null && a >= b)) continue;
+    const key = keyBetween(a, b);
+    if (fits(key)) return key;
+  }
+  return `${positions.reduce((max, pos) => (pos > max ? pos : max), "")}V`;
+}
+
+export function placeAt(ids, posOf, index) {
+  const positions = ids.map(posOf);
+  const lower = index > 0 ? positions[index - 1] : null;
+  let end = index;
+  while (lower !== null && end < positions.length && positions[end] === lower) end++;
+  if (end === index) return { pos: slotKey(positions, index), rekey: [] };
+  const upper = positions.slice(end).find((pos) => pos > lower) ?? null;
+  const keys = [];
+  for (let i = index, prev = lower; i <= end; i++) keys.push(prev = slotKey(upper === null ? [prev] : [prev, upper], 1));
+  return { pos: keys[0], rekey: ids.slice(index, end).map((id, i) => [id, keys[i + 1]]) };
+}
+
+const place = (map, ids, index) => {
+  const { pos, rekey } = placeAt(ids, (id) => map[id].pos, index);
+  for (const [id, next] of rekey) map[id] = { ...map[id], pos: next };
+  return pos;
+};
+
+export function createBoardCommands({ pd, um = null, origins = null, render = () => {} }) {
+  const boardAt = (blockId) => {
+    if (typeof blockId !== "string") return null;
+    const seg = walk(pd, origins).visible.find((candidate) => candidate.id === blockId);
+    if (!seg || seg.t !== "board") return null;
+    const fields = seg.fields ?? fieldsOf(pd, seg, schema.nodes.board);
+    return { columns: copy(fields.columns ?? {}), cards: copy(fields.cards ?? {}) };
+  };
+  const commit = (blockId, before, after, result) => {
+    const source = recoveredSource(blockId);
+    um?.stopCapturing();
+    pd.ydoc.transact(() => {
+      if (!source) writeBoard(pd, blockId, before, after);
+      else for (const attr of ["columns", "cards"]) if (canon(before[attr]) !== canon(after[attr])) pd.gone.set(attrKey(source, attr), copy(after[attr]));
+    }, LOCAL);
+    um?.stopCapturing();
+    render();
+    return result;
+  };
+  const cardsIn = (board, columnId, without = null) => orderedIds(Object.fromEntries(Object.entries(board.cards).filter(([id, card]) => card.col === columnId && id !== without)));
+  const indexAfter = (ids, afterId) => (afterId === undefined ? ids.length : afterId === null ? 0 : ids.indexOf(afterId) + 1);
+  const badAfter = (ids, afterId) => afterId !== undefined && afterId !== null && !ids.includes(afterId);
+  const withBoard = (blockId, run) => {
+    const board = boardAt(blockId);
+    return board ? run(board, copy(board)) : refuse("missing-board");
+  };
+
+  return {
+    read: (blockId) => boardAt(blockId),
+    removed(blockId) {
+      if (!boardAt(blockId)) return null;
+      return recoveredSource(blockId) ? { columns: {}, cards: {} } : removedBoardEntities(pd.boardFields, blockId);
+    },
+    createColumn: (blockId, { name = "", afterId } = {}) => withBoard(blockId, (board, after) => {
+      if (typeof name !== "string") return refuse("invalid-value");
+      const ids = orderedIds(board.columns);
+      if (badAfter(ids, afterId)) return refuse("missing-destination");
+      const id = newId("c");
+      after.columns[id] = { pos: place(after.columns, ids, indexAfter(ids, afterId)), name };
+      return commit(blockId, board, after, { status: "created", id });
+    }),
+    renameColumn: (blockId, columnId, name) => withBoard(blockId, (board, after) => {
+      if (!Object.hasOwn(board.columns, columnId)) return refuse("missing-column");
+      if (typeof name !== "string") return refuse("invalid-value");
+      if (board.columns[columnId].name === name) return { status: "unchanged" };
+      after.columns[columnId].name = name;
+      return commit(blockId, board, after, { status: "changed" });
+    }),
+    moveColumn: (blockId, columnId, { afterId = null } = {}) => withBoard(blockId, (board, after) => {
+      if (!Object.hasOwn(board.columns, columnId)) return refuse("missing-column");
+      const ids = orderedIds(board.columns).filter((id) => id !== columnId);
+      if (badAfter(ids, afterId)) return refuse("missing-destination");
+      const index = indexAfter(ids, afterId);
+      const current = orderedIds(board.columns);
+      if ([...ids.slice(0, index), columnId, ...ids.slice(index)].every((id, i) => id === current[i])) return { status: "unchanged" };
+      after.columns[columnId].pos = place(after.columns, ids, index);
+      return commit(blockId, board, after, { status: "moved" });
+    }),
+    removeColumn: (blockId, columnId) => withBoard(blockId, (board, after) => {
+      if (!Object.hasOwn(board.columns, columnId)) return refuse("missing-column");
+      delete after.columns[columnId];
+      return commit(blockId, board, after, { status: "removed", cards: cardsIn(board, columnId).length });
+    }),
+    restoreColumn: (blockId, columnId) => withBoard(blockId, (board, after) => {
+      if (Object.hasOwn(board.columns, columnId)) return { status: "unchanged" };
+      const removed = recoveredSource(blockId) ? null : removedBoardEntities(pd.boardFields, blockId).columns[columnId];
+      if (!removed) return refuse("missing-column");
+      after.columns[columnId] = removed;
+      return commit(blockId, board, after, { status: "restored" });
+    }),
+    createCard: (blockId, { columnId, title = "", owner = null, due = null, afterId } = {}) => withBoard(blockId, (board, after) => {
+      if (!Object.hasOwn(board.columns, columnId)) return refuse("missing-column");
+      if (!validValue("title", title) || !validValue("owner", owner) || !validValue("due", due)) return refuse("invalid-value");
+      const ids = cardsIn(board, columnId);
+      if (badAfter(ids, afterId)) return refuse("missing-destination");
+      const id = newId("k");
+      after.cards[id] = { pos: place(after.cards, ids, indexAfter(ids, afterId)), col: columnId, title, ...(owner !== null ? { owner } : {}), ...(due !== null ? { due } : {}) };
+      return commit(blockId, board, after, { status: "created", id });
+    }),
+    editCard: (blockId, cardId, patch) => withBoard(blockId, (board, after) => {
+      if (!Object.hasOwn(board.cards, cardId)) return refuse("missing-card");
+      if (!record(patch) || !Object.keys(patch).length || Object.keys(patch).some((field) => !CARD_FIELDS.includes(field))) return refuse("invalid-field");
+      if (Object.entries(patch).some(([field, value]) => !validValue(field, value))) return refuse("invalid-value");
+      const next = { ...board.cards[cardId] };
+      for (const [field, value] of Object.entries(patch)) {
+        if (value === null) delete next[field];
+        else next[field] = value;
+      }
+      if (canon(next) === canon(board.cards[cardId])) return { status: "unchanged" };
+      after.cards[cardId] = next;
+      return commit(blockId, board, after, { status: "changed" });
+    }),
+    moveCard: (blockId, cardId, { columnId, afterId = null } = {}) => withBoard(blockId, (board, after) => {
+      if (!Object.hasOwn(board.cards, cardId)) return refuse("missing-card");
+      if (!Object.hasOwn(board.columns, columnId)) return refuse("missing-column");
+      const ids = cardsIn(board, columnId, cardId);
+      if (badAfter(ids, afterId)) return refuse("missing-destination");
+      const index = indexAfter(ids, afterId);
+      const card = board.cards[cardId];
+      if (card.col === columnId) {
+        const current = cardsIn(board, columnId);
+        if ([...ids.slice(0, index), cardId, ...ids.slice(index)].every((id, i) => id === current[i])) return { status: "unchanged" };
+      }
+      after.cards[cardId] = { ...card, col: columnId, pos: place(after.cards, ids, index) };
+      return commit(blockId, board, after, { status: "moved" });
+    }),
+    removeCard: (blockId, cardId) => withBoard(blockId, (board, after) => {
+      if (!Object.hasOwn(board.cards, cardId)) return refuse("missing-card");
+      delete after.cards[cardId];
+      return commit(blockId, board, after, { status: "removed" });
+    }),
+    restoreCard: (blockId, cardId) => withBoard(blockId, (board, after) => {
+      if (Object.hasOwn(board.cards, cardId)) return { status: "unchanged" };
+      const removed = recoveredSource(blockId) ? null : removedBoardEntities(pd.boardFields, blockId).cards[cardId];
+      if (!removed) return refuse("missing-card");
+      after.cards[cardId] = removed;
+      return commit(blockId, board, after, { status: "restored" });
+    }),
+  };
+}

package/src/page/ybind/board.js

@@ -0,0 +1,89 @@
+import { canon, orderedIds } from "../projection.js";
+import { YDecodeError } from "./provider.js";
+
+export const BOARD_FIELDS = Object.freeze({ column: Object.freeze(["alive", "name", "pos"]), card: Object.freeze(["alive", "title", "owner", "due", "placement"]) });
+const FIELDS = { column: new Set(BOARD_FIELDS.column), card: new Set(BOARD_FIELDS.card) };
+const ENTITIES = [["column", "columns"], ["card", "cards"]];
+const record = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+const validId = (id) => typeof id === "string" && id.length > 0 && !["__proto__", "constructor", "prototype"].includes(id);
+const fail = (key) => { throw new YDecodeError("unsupported-content", `Unsupported board field: ${key}`); };
+const copy = (value) => (value === null || typeof value !== "object" ? value : JSON.parse(JSON.stringify(value)));
+
+export const boardKey = (blockId, kind, entityId, field) => JSON.stringify([blockId, kind, entityId, field]);
+
+function entitiesOf(fields, blockId) {
+  const groups = new Map();
+  for (const [key, value] of fields) {
+    let tuple;
+    try { tuple = JSON.parse(key); } catch { fail(key); }
+    if (!Array.isArray(tuple) || tuple.length !== 4) fail(key);
+    const [owner, kind, entityId, field] = tuple;
+    if (!validId(owner) || !validId(entityId) || !Object.hasOwn(FIELDS, kind) || !FIELDS[kind].has(field)) fail(key);
+    if (field === "alive" ? typeof value !== "boolean"
+      : field === "placement" ? !record(value) || Object.keys(value).sort().join(",") !== "columnId,pos" || typeof value.columnId !== "string" || typeof value.pos !== "string"
+        : field === "owner" || field === "due" ? value !== null && typeof value !== "string"
+          : typeof value !== "string") fail(key);
+    if (owner !== blockId) continue;
+    const bucket = groups.get(kind) ?? new Map();
+    const entity = bucket.get(entityId) ?? {};
+    entity[field] = value;
+    bucket.set(entityId, entity);
+    groups.set(kind, bucket);
+  }
+  return groups;
+}
+
+const columnOf = (item) => ({ pos: item.pos ?? "", name: item.name ?? "" });
+const cardOf = (item) => ({ pos: item.placement?.pos ?? "", col: item.placement?.columnId ?? "", title: item.title ?? "", ...(item.owner != null ? { owner: item.owner } : {}), ...(item.due != null ? { due: item.due } : {}) });
+const pick = (groups, kind, shape, alive) => Object.fromEntries([...(groups.get(kind) ?? [])].filter(([, item]) => (item.alive !== false) === alive).map(([id, item]) => [id, shape(item)]));
+
+export function resolveBoardFields(fields, blockId = null) {
+  const groups = entitiesOf(fields, blockId);
+  const columns = pick(groups, "column", columnOf, true);
+  const cards = pick(groups, "card", cardOf, true);
+  const columnIds = orderedIds(columns);
+  const missing = [...new Set(Object.values(cards).map((card) => card.col))].filter((id) => !Object.hasOwn(columns, id)).sort();
+  const cardIds = [...columnIds, ...missing].flatMap((columnId) => orderedIds(Object.fromEntries(Object.entries(cards).filter(([, card]) => card.col === columnId))));
+  return {
+    columns: Object.fromEntries(columnIds.map((id) => [id, columns[id]])),
+    cards: Object.fromEntries(cardIds.map((id) => [id, cards[id]])),
+  };
+}
+
+export function removedBoardEntities(fields, blockId) {
+  const groups = entitiesOf(fields, blockId);
+  return { columns: pick(groups, "column", columnOf, false), cards: pick(groups, "card", cardOf, false) };
+}
+
+const DEFAULTS = { name: "", pos: "", title: "", owner: null, due: null, placement: { columnId: "", pos: "" } };
+const fieldOf = (kind, entity, field) => {
+  if (kind === "card" && field === "placement") return { columnId: entity.col ?? "", pos: entity.pos ?? "" };
+  return entity[field] ?? DEFAULTS[field];
+};
+
+export function boardChanges(blockId, fields, before, after) {
+  const out = [];
+  for (const [kind, attr] of ENTITIES) {
+    const was = record(before?.[attr]) ? before[attr] : {}, now = record(after?.[attr]) ? after[attr] : {};
+    for (const id of new Set([...Object.keys(was), ...Object.keys(now)])) {
+      const old = was[id], next = now[id];
+      if (!next) {
+        if (old) out.push([boardKey(blockId, kind, id, "alive"), false]);
+        continue;
+      }
+      if (!old) out.push([boardKey(blockId, kind, id, "alive"), true]);
+      for (const field of BOARD_FIELDS[kind]) {
+        if (field === "alive") continue;
+        const key = boardKey(blockId, kind, id, field);
+        const value = fieldOf(kind, next, field);
+        const prior = old ? fieldOf(kind, old, field) : fields.has(key) ? fields.get(key) : DEFAULTS[field];
+        if (canon(prior) !== canon(value)) out.push([key, copy(value)]);
+      }
+    }
+  }
+  return out;
+}
+
+export function writeBoard(pd, blockId, before, after) {
+  for (const [key, value] of boardChanges(blockId, pd.boardFields, before, after)) pd.boardFields.set(key, value);
+}