@panphora/clayjs 1.10.0 → 1.11.0

package/src/live/ops.js

@@ -0,0 +1,291 @@
+// The operation model behind clay.live stores. Pure: no DOM, no network.
+// Every client and the server apply the same ops to the same value and get
+// byte-identical JSON, object key order included, so nothing here may depend
+// on timing or on where a value came from.
+
+const INDEX = /^(0|[1-9]\d*)$/;
+const OPS = new Set(["set", "del", "add"]);
+
+const isContainer = (v) => v !== null && typeof v === "object";
+const has = (obj, key) => Object.prototype.hasOwnProperty.call(obj, key);
+
+function setOwn(obj, key, value) {
+  Object.defineProperty(obj, key, { value, enumerable: true, writable: true, configurable: true });
+}
+
+// "players.alice.x" or ["players", "alice", "x"] -> segments. In the dotted form a
+// canonical non-negative integer becomes an index; a key containing a dot needs
+// the array form.
+export function parsePath(path) {
+  if (Array.isArray(path)) {
+    for (const seg of path) checkSegment(seg);
+    return path.slice();
+  }
+  if (typeof path !== "string") throw new TypeError("clay.live: a path is a dotted string or an array of keys");
+  if (path === "") return [];
+  return path.split(".").map((s) => (INDEX.test(s) ? Number(s) : s));
+}
+
+function checkSegment(seg) {
+  if (typeof seg === "string") return;
+  if (Number.isInteger(seg) && seg >= 0) return;
+  throw new TypeError(`clay.live: path segment ${String(seg)} is not a string or a non-negative integer`);
+}
+
+// A deep copy that refuses anything JSON cannot hold, so a stored value can
+// never be mutated through an outside reference and always serializes.
+export function cloneJson(value, seen = new Set()) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") return value;
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) throw new TypeError("clay.live: numbers must be finite");
+    return value;
+  }
+  if (typeof value !== "object") throw new TypeError(`clay.live: a ${typeof value} is not JSON`);
+  if (seen.has(value)) throw new TypeError("clay.live: the value contains a cycle");
+  seen.add(value);
+  let out;
+  if (Array.isArray(value)) {
+    out = [];
+    for (let i = 0; i < value.length; i++) {
+      if (!(i in value)) throw new TypeError("clay.live: sparse arrays are not JSON");
+      out.push(cloneJson(value[i], seen));
+    }
+  } else {
+    const proto = Object.getPrototypeOf(value);
+    if (proto !== Object.prototype && proto !== null) throw new TypeError("clay.live: only plain objects and arrays are JSON");
+    out = {};
+    for (const key of Object.keys(value)) setOwn(out, key, cloneJson(value[key], seen));
+  }
+  seen.delete(value);
+  return out;
+}
+
+// Shape check, before anything is touched. Returns a normalized op with its
+// value already cloned.
+export function validateOp(op) {
+  if (!isContainer(op) || !OPS.has(op.op)) throw new TypeError("clay.live: an op is { op: \"set\" | \"del\" | \"add\", path, ... }");
+  const path = parsePath(op.path);
+  if (op.op === "set") {
+    if (op.value === undefined) throw new TypeError("clay.live: set needs a value; use delete to remove");
+    const value = cloneJson(op.value);
+    if (path.length === 0 && !isContainer(value)) throw new TypeError("clay.live: the whole value must be an object or an array");
+    return { op: "set", path, value };
+  }
+  if (path.length === 0) throw new TypeError(`clay.live: ${op.op} needs a path`);
+  if (op.op === "add") {
+    if (typeof op.n !== "number" || !Number.isFinite(op.n)) throw new TypeError("clay.live: add needs a finite number");
+    return { op: "add", path, n: op.n };
+  }
+  return { op: "del", path };
+}
+
+function indexOf(arr, seg) {
+  if (typeof seg === "number") return seg;
+  if (INDEX.test(seg)) return Number(seg);
+  return -1;
+}
+
+function read(container, seg) {
+  if (Array.isArray(container)) {
+    const i = indexOf(container, seg);
+    return i >= 0 && i < container.length ? container[i] : undefined;
+  }
+  const key = String(seg);
+  return has(container, key) ? container[key] : undefined;
+}
+
+// Throws, without mutating anything, when op cannot apply to root: a string
+// key on a list, or a list index past the end. A missing or non-container
+// step along the way is not an error: applyOp replaces it with a container.
+export function checkOp(root, op) {
+  if (op.path.length === 0) {
+    if (op.op === "set" && (!isContainer(op.value) || Array.isArray(op.value) !== Array.isArray(root))) {
+      throw new TypeError(`clay.live: the whole value must stay ${Array.isArray(root) ? "a list" : "an object"}`);
+    }
+    return;
+  }
+  let node = root;
+  for (let i = 0; i < op.path.length; i++) {
+    const seg = op.path[i];
+    const last = i === op.path.length - 1;
+    if (!isContainer(node)) {
+      // The rest of the path will be created, and a new list starts empty: an
+      // index other than 0 would leave holes, which are not JSON.
+      if (op.op === "del") return;
+      for (let j = i; j < op.path.length; j++) {
+        if (typeof op.path[j] === "number" && op.path[j] !== 0) {
+          throw new RangeError(`clay.live: index ${op.path[j]} would leave holes in a new list at ${op.path.slice(0, j).join(".") || "the root"}`);
+        }
+      }
+      return;
+    }
+    if (Array.isArray(node)) {
+      const idx = indexOf(node, seg);
+      if (idx < 0) throw new TypeError(`clay.live: "${seg}" is not an index of the list at ${op.path.slice(0, i).join(".") || "the root"}`);
+      const limit = last && op.op !== "del" ? node.length : node.length - 1;
+      if (idx > limit && !(last && op.op === "del")) throw new RangeError(`clay.live: index ${idx} is past the end of the list at ${op.path.slice(0, i).join(".") || "the root"}`);
+    }
+    if (last) return;
+    node = read(node, seg);
+  }
+}
+
+function put(container, seg, value) {
+  if (Array.isArray(container)) container[indexOf(container, seg)] = value;
+  else setOwn(container, String(seg), value);
+}
+
+// Applies one checked op. Mutates root and returns it, or returns the new root
+// for a whole-value set.
+export function applyOp(root, op) {
+  const { path } = op;
+  if (path.length === 0) return cloneJson(op.value);
+  let parent = root;
+  for (let i = 0; i < path.length - 1; i++) {
+    let next = read(parent, path[i]);
+    if (!isContainer(next)) {
+      if (op.op === "del") return root;
+      next = typeof path[i + 1] === "number" ? [] : {};
+      put(parent, path[i], next);
+    }
+    parent = next;
+  }
+  const last = path[path.length - 1];
+  if (op.op === "set") {
+    put(parent, last, cloneJson(op.value));
+  } else if (op.op === "add") {
+    const cur = read(parent, last);
+    put(parent, last, (typeof cur === "number" && Number.isFinite(cur) ? cur : 0) + op.n);
+  } else if (Array.isArray(parent)) {
+    const idx = indexOf(parent, last);
+    if (idx >= 0 && idx < parent.length) parent.splice(idx, 1);
+  } else {
+    delete parent[String(last)];
+  }
+  return root;
+}
+
+// Applies a list of ops in order; checks each one against the value as it
+// stands at that point. Callers that need atomicity apply to a clone.
+export function applyOps(root, ops) {
+  let value = root;
+  for (const op of ops) {
+    checkOp(value, op);
+    value = applyOp(value, op);
+  }
+  return value;
+}
+
+const samePath = (a, b) => a.length === b.length && a.every((s, i) => String(s) === String(b[i]));
+
+// Merges neighbouring ops on the same path, without changing the result:
+// set,set -> the later set; add,add -> one add of the sum; set,add -> one set of
+// the sum; set,del and add,del -> the del, but only on a one-segment path (a
+// deeper set may have created the parents the del leaves behind). A del is never
+// merged with what follows it (on a list it shifts the indexes after it).
+export function coalesce(ops) {
+  const out = [];
+  for (const op of ops) {
+    const prev = out[out.length - 1];
+    if (!prev || prev.op === "del" || !samePath(prev.path, op.path)) {
+      out.push(op);
+      continue;
+    }
+    if (op.op === "del" && op.path.length > 1) {
+      out.push(op);
+    } else if (op.op === "set" || op.op === "del") {
+      out[out.length - 1] = op;
+    } else if (prev.op === "add") {
+      out[out.length - 1] = { op: "add", path: prev.path, n: prev.n + op.n };
+    } else {
+      const base = typeof prev.value === "number" ? prev.value : 0;
+      out[out.length - 1] = { op: "set", path: prev.path, value: base + op.n };
+    }
+  }
+  return out;
+}
+
+// True when one path is a prefix of the other: an op on one can change what
+// the other reads.
+export function overlaps(a, b) {
+  const n = Math.min(a.length, b.length);
+  for (let i = 0; i < n; i++) if (String(a[i]) !== String(b[i])) return false;
+  return true;
+}
+
+// Makes target equal next in place, keeping the identity of every nested
+// object or list that still sits at the same path with the same type, so a
+// reference handed out earlier stays live. Object keys end up in next's order.
+// next's own nested values are moved in, not copied: pass a fresh value.
+export function assignDeep(target, next) {
+  if (Array.isArray(target)) {
+    for (let i = 0; i < next.length; i++) target[i] = reuse(i < target.length ? target[i] : undefined, next[i]);
+    target.length = next.length;
+    return target;
+  }
+  const keys = Object.keys(next);
+  const values = keys.map((k) => reuse(has(target, k) ? target[k] : undefined, next[k]));
+  for (const k of Object.keys(target)) delete target[k];
+  keys.forEach((k, i) => setOwn(target, k, values[i]));
+  return target;
+}
+
+function reuse(cur, next) {
+  if (isContainer(cur) && isContainer(next) && Array.isArray(cur) === Array.isArray(next)) return assignDeep(cur, next);
+  return next;
+}
+
+// The text a live store writes into its script tag. `<` is escaped so a value
+// holding "</script>" can never end the element.
+export function serializeLive(value) {
+  return JSON.stringify(value).replace(/</g, "\\u003c");
+}
+
+// A live tag's lineage, `live-at="<epoch>:<seq>:<hash>"`: the room position its
+// value was written at, and a hash of the exact text, so a room can tell its own
+// unedited value from an edit of it.
+const STAMP = /^([A-Za-z0-9-]{1,64}):(0|[1-9]\d*):([0-9a-f]{8})$/;
+
+// FNV-1a over UTF-16 code units, as 8 hex digits. Both copies must agree.
+export function textHash(text) {
+  let h = 0x811c9dc5;
+  for (let i = 0; i < text.length; i++) {
+    h ^= text.charCodeAt(i);
+    h = Math.imul(h, 0x01000193) >>> 0;
+  }
+  return h.toString(16).padStart(8, "0");
+}
+
+export function stampOf(epoch, seq, text) {
+  return `${epoch}:${seq}:${textHash(text)}`;
+}
+
+export function parseStamp(value) {
+  const m = typeof value === "string" ? STAMP.exec(value) : null;
+  return m ? { epoch: m[1], seq: Number(m[2]), hash: m[3] } : null;
+}
+
+// The leaf-level ops that turn before into after: set for a changed or added
+// leaf, del for a removed key, a whole-value set where the container kind or a
+// list's length changes. Every op is idempotent, so replaying the result over a
+// value that already holds `after` at those paths changes nothing.
+export function diffOps(before, after, path = []) {
+  if (!isContainer(before) || !isContainer(after) || Array.isArray(before) !== Array.isArray(after)) {
+    return [{ op: "set", path, value: cloneJson(after) }];
+  }
+  if (Array.isArray(before)) {
+    if (before.length !== after.length) return [{ op: "set", path, value: cloneJson(after) }];
+    const out = [];
+    for (let i = 0; i < after.length; i++) {
+      if (serializeLive(before[i]) !== serializeLive(after[i])) out.push(...diffOps(before[i], after[i], [...path, i]));
+    }
+    return out;
+  }
+  const out = [];
+  for (const key of Object.keys(before)) if (!has(after, key)) out.push({ op: "del", path: [...path, key] });
+  for (const key of Object.keys(after)) {
+    if (!has(before, key)) out.push({ op: "set", path: [...path, key], value: cloneJson(after[key]) });
+    else if (serializeLive(before[key]) !== serializeLive(after[key])) out.push(...diffOps(before[key], after[key], [...path, key]));
+  }
+  return out;
+}

package/src/live/server-lane.js

@@ -0,0 +1,84 @@
+import { onStream } from "./stream-bridge.js";
+
+// The host side of clay.live's fast lane on a host that advertises `live-data`:
+// one POST per frame of ops, one GET for the room's whole state. Both name the
+// document with Document-URL, as the sync relay and presence do.
+
+const DATA_PATH = "/_/sync/data";
+
+function dataUrl() {
+  return new URL(DATA_PATH, window.location.origin);
+}
+
+/**
+ * Send one frame ({ name, n, ops }). Resolves { status, body, retryAfter }:
+ * status 0 when the request never got an answer.
+ */
+export async function relayData(clientId, frame) {
+  const url = dataUrl();
+  url.searchParams.set("client-id", clientId);
+  try {
+    const response = await fetch(url.href, {
+      method: "POST",
+      credentials: "same-origin",
+      headers: { "Content-Type": "application/json", "Document-URL": window.location.href },
+      body: JSON.stringify(frame),
+    });
+    let body = null;
+    try {
+      body = await response.json();
+    } catch {}
+    const retryAfter = Number(response.headers?.get?.("Retry-After")) || 0;
+    return { status: response.status, body, retryAfter };
+  } catch {
+    return { status: 0, body: null, retryAfter: 0 };
+  }
+}
+
+/**
+ * The room's { epoch, seq, writer, stores }; { status } when the host refused;
+ * null when the request never got an answer. clientId marks this tab as taking part.
+ */
+export async function fetchLiveState(clientId) {
+  const url = dataUrl();
+  if (clientId) url.searchParams.set("client-id", clientId);
+  try {
+    const response = await fetch(url.href, {
+      credentials: "same-origin",
+      cache: "no-store",
+      headers: { "Document-URL": window.location.href },
+    });
+    if (!response.ok) return { status: response.status };
+    const state = await response.json();
+    // The stream is open but the host has not seen its subscription yet: not
+    // ready, and the lane reads again.
+    if (state && typeof state.epoch === "string" && state.conn === null) return null;
+    return state;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * The fast-lane transport (fast-lane.js) for a host that advertises live-data:
+ * frames go up by POST, and come down as named events on the live-lane stream.
+ */
+export function serverTransport() {
+  return {
+    start(handlers) {
+      return onStream({
+        open(info) {
+          if (info.lane === "live") handlers.open(info);
+        },
+        close: () => handlers.close(),
+        event(type, data) {
+          if (type === "data") handlers.frame(data);
+          else if (type === "data-state") handlers.state(data);
+          else if (type === "data-writer") handlers.writer(data);
+        },
+      });
+    },
+    send: relayData,
+    fetchState: fetchLiveState,
+  };
+}

package/src/live/store.js

@@ -0,0 +1,291 @@
+// A clay.live store: one JSON value held in memory and changed only through ops.
+// What page code reads (state) is the last value the store accepted from outside
+// (authoritative) with this tab's own unconfirmed ops (pending) replayed over it.
+// Local ops change state at once. When authoritative moves, state is rebuilt in
+// place, so an object or list page code holds a reference to stays live.
+
+import { validateOp, checkOp, applyOp, applyOps, cloneJson, assignDeep, coalesce, serializeLive } from "./ops.js";
+
+const MUTATORS = new Set(["push", "pop", "shift", "unshift", "splice", "sort", "reverse", "fill", "copyWithin"]);
+const INDEX = /^(0|[1-9]\d*)$/;
+const isContainer = (v) => v !== null && typeof v === "object";
+const kind = (v) => (Array.isArray(v) ? "a list" : "an object");
+
+function readPath(root, path) {
+  let node = root;
+  for (const seg of path) {
+    if (!isContainer(node)) return undefined;
+    if (Array.isArray(node)) node = node[Number(seg)];
+    else node = Object.prototype.hasOwnProperty.call(node, seg) ? node[seg] : undefined;
+  }
+  return node;
+}
+
+// applyOp, except that a set replacing a container with one of the same kind
+// rewrites it in place, so a proxy over the old container still points at the
+// value page code sees.
+function applyInPlace(root, op) {
+  if (op.op === "set") {
+    const current = readPath(root, op.path);
+    if (isContainer(current) && isContainer(op.value) && Array.isArray(current) === Array.isArray(op.value)) {
+      assignDeep(current, cloneJson(op.value));
+      return;
+    }
+  }
+  applyOp(root, op);
+}
+
+export function createStore({ name, value, ephemeral = false }) {
+  if (!isContainer(value)) throw new TypeError(`clay.live("${name}"): the tag must hold a JSON object or list`);
+
+  let authoritative = cloneJson(value);
+  const state = cloneJson(value);
+  // This tab's unconfirmed ops, oldest first, each with a local id that only grows.
+  let pending = [];
+  let nextId = 1;
+  let batch = null;
+  let mode = "file";
+  const listeners = new Set();
+  const sinks = new Set();
+  const views = new WeakMap();
+
+  function emit(source, ops) {
+    const event = { source, ops };
+    for (const fn of [...listeners]) {
+      try {
+        fn(event);
+      } catch (err) {
+        console.error(`clay.live("${name}"): a change listener threw`, err);
+      }
+    }
+  }
+
+  function rebuild() {
+    let next = cloneJson(authoritative);
+    const kept = [];
+    for (const entry of pending) {
+      try {
+        checkOp(next, entry.op);
+        next = applyOp(next, entry.op);
+        kept.push(entry);
+      } catch {}
+    }
+    pending = kept;
+    assignDeep(state, next);
+  }
+
+  function publish(ops) {
+    for (const sink of [...sinks]) {
+      try {
+        sink(ops);
+      } catch (err) {
+        console.error(`clay.live("${name}"): a transport threw`, err);
+      }
+    }
+    emit("local", ops);
+  }
+
+  function commit(rawOps) {
+    const ops = rawOps.map(validateOp);
+    for (const op of ops) {
+      if (op.path.length === 0 && kind(op.value) !== kind(state)) {
+        throw new TypeError(`clay.live("${name}"): the whole value must stay ${kind(state)}`);
+      }
+    }
+    if (ops.length === 1) checkOp(state, ops[0]);
+    else applyOps(cloneJson(state), ops);
+    for (const op of ops) applyInPlace(state, op);
+    pending.push(...ops.map((op) => ({ id: nextId++, op })));
+    if (batch) batch.push(...ops);
+    else publish(ops);
+  }
+
+  function view(target, path) {
+    let byPath = views.get(target);
+    if (!byPath) views.set(target, (byPath = new Map()));
+    const key = JSON.stringify(path);
+    let proxy = byPath.get(key);
+    if (!proxy) {
+      proxy = new Proxy(target, traps(path));
+      byPath.set(key, proxy);
+    }
+    return proxy;
+  }
+
+  function traps(path) {
+    return {
+      get(target, prop) {
+        if (Array.isArray(target) && MUTATORS.has(prop)) {
+          return (...args) => {
+            const copy = cloneJson(target);
+            const result = Array.prototype[prop].apply(copy, args);
+            commit([{ op: "set", path, value: copy }]);
+            return result === copy ? view(target, path) : result;
+          };
+        }
+        const value = target[prop];
+        if (typeof prop === "symbol" || !isContainer(value) || !Object.prototype.hasOwnProperty.call(target, prop)) return value;
+        return view(value, [...path, Array.isArray(target) ? Number(prop) : prop]);
+      },
+      set(target, prop, value) {
+        if (typeof prop === "symbol") throw new TypeError(`clay.live("${name}"): symbol keys are not JSON`);
+        if (Array.isArray(target)) {
+          if (prop === "length") {
+            const copy = cloneJson(target);
+            copy.length = value;
+            commit([{ op: "set", path, value: copy }]);
+            return true;
+          }
+          if (!INDEX.test(prop)) throw new TypeError(`clay.live("${name}"): "${prop}" is not a list index`);
+          commit([{ op: "set", path: [...path, Number(prop)], value }]);
+          return true;
+        }
+        commit([{ op: "set", path: [...path, prop], value }]);
+        return true;
+      },
+      deleteProperty(target, prop) {
+        if (typeof prop === "symbol") return true;
+        if (Array.isArray(target)) throw new TypeError(`clay.live("${name}"): remove a list item with splice`);
+        commit([{ op: "del", path: [...path, prop] }]);
+        return true;
+      },
+      defineProperty() {
+        throw new TypeError(`clay.live("${name}"): assign values instead of defining properties`);
+      },
+      setPrototypeOf() {
+        return false;
+      },
+      preventExtensions() {
+        return false;
+      },
+    };
+  }
+
+  const data = view(state, []);
+  let resolveReady;
+  const ready = new Promise((resolve) => {
+    resolveReady = resolve;
+  });
+
+  const handle = Object.freeze({
+    name,
+    ephemeral,
+    ready,
+    get data() {
+      return data;
+    },
+    get status() {
+      return { mode };
+    },
+    set(path, value) {
+      commit([{ op: "set", path, value }]);
+    },
+    delete(path) {
+      commit([{ op: "del", path }]);
+    },
+    add(path, n = 1) {
+      commit([{ op: "add", path, n }]);
+    },
+    update(fn) {
+      if (typeof fn !== "function") throw new TypeError(`clay.live("${name}"): update() takes a function`);
+      if (batch) return fn(data);
+      batch = [];
+      const mark = pending.length;
+      const markId = nextId;
+      let result;
+      try {
+        result = fn(data);
+        if (result && typeof result.then === "function") {
+          throw new TypeError(`clay.live("${name}"): update() runs synchronously; do async work before calling it`);
+        }
+      } catch (err) {
+        batch = null;
+        pending.length = mark;
+        nextId = markId;
+        rebuild();
+        throw err;
+      }
+      const ops = coalesce(batch);
+      batch = null;
+      pending.length = mark;
+      nextId = markId;
+      pending.push(...ops.map((op) => ({ id: nextId++, op })));
+      if (ops.length) publish(ops);
+      return result;
+    },
+    on(type, fn) {
+      if (type !== "change") throw new TypeError(`clay.live("${name}"): the only event is "change"`);
+      if (typeof fn !== "function") throw new TypeError(`clay.live("${name}"): on() takes a function`);
+      listeners.add(fn);
+      return () => listeners.delete(fn);
+    },
+    off(type, fn) {
+      listeners.delete(fn);
+    },
+    toJSON() {
+      return cloneJson(state);
+    },
+  });
+  resolveReady(handle);
+
+  return {
+    handle,
+    name,
+    ephemeral,
+    // The live value itself, for serializing into a save. Never mutate it.
+    get value() {
+      return state;
+    },
+    get authoritative() {
+      return authoritative;
+    },
+    get pending() {
+      return pending.map((entry) => entry.op);
+    },
+    // The same ops with their ids, for a transport that resends them.
+    pendingEntries() {
+      return pending.map((entry) => ({ id: entry.id, op: entry.op }));
+    },
+    // The id of the newest op this store has committed (0 before the first).
+    get mark() {
+      return nextId - 1;
+    },
+    setMode(next) {
+      mode = next;
+    },
+    // A transport hears every local op batch, in order, as it is committed.
+    onLocal(fn) {
+      sinks.add(fn);
+      return () => sinks.delete(fn);
+    },
+    // This tab's ops up to and including `through` are in the file (the save
+    // that carried them was accepted) and no newer value arrived since: they
+    // become part of authoritative. The value page code sees does not change.
+    confirm(through) {
+      const taken = pending.filter((entry) => entry.id <= through);
+      if (!taken.length) return;
+      try {
+        authoritative = applyOps(cloneJson(authoritative), taken.map((entry) => entry.op));
+      } catch {
+        authoritative = cloneJson(state);
+      }
+      pending = pending.filter((entry) => entry.id > through);
+    },
+    // A new value from outside. Ops already in it are dropped: the first
+    // `confirmed` pending ops, or every op up to the mark `through`. The rest
+    // replay over it; a pending op that no longer applies is dropped too.
+    // Listeners hear about it only when the value page code sees changed.
+    rebase(next, { source = "remote", confirmed = 0, through } = {}) {
+      if (!isContainer(next) || kind(next) !== kind(state)) {
+        console.warn(`clay.live("${name}"): ignored an incoming value that is not ${kind(state)}`);
+        return false;
+      }
+      const before = serializeLive(state);
+      authoritative = cloneJson(next);
+      pending = through === undefined ? pending.slice(confirmed) : pending.filter((entry) => entry.id > through);
+      rebuild();
+      if (serializeLive(state) !== before) emit(source, null);
+      return true;
+    },
+  };
+}