statewire 0.0.0-0 → 0.0.1

package/src/wire/ops.ts

@@ -0,0 +1,201 @@
+import { recordMutations } from "../client/optimistic";
+
+export type StatewirePath = readonly (string | number)[];
+
+export type StatewireOp =
+  | { op: "replace"; path: StatewirePath; value: unknown }
+  | { op: "add"; path: StatewirePath; value: unknown }
+  | { op: "append"; path: StatewirePath; value: unknown }
+  | { op: "remove"; path: StatewirePath }
+  | { op: "event"; value: object };
+
+const isUnsafe = (key: string, parent: string | number | undefined) =>
+  key === "__proto__" || (key === "prototype" && parent === "constructor");
+
+const warnStripped = (key: string, parent: string | undefined) => {
+  if (
+    typeof process === "undefined" ||
+    process.env["NODE_ENV"] !== "production"
+  ) {
+    console.warn(
+      `statewire: stripped unsafe key "${key}"` +
+        (parent === undefined ? "" : ` under "${parent}"`),
+    );
+  }
+};
+
+export const sanitizeValue = (value: unknown, parent?: string): unknown => {
+  if (typeof value !== "object" || value === null) return value;
+  if (value instanceof Date) return new Date(value.getTime());
+  if (Array.isArray(value)) return value.map((item) => sanitizeValue(item));
+  const out: Record<string, unknown> = {};
+  for (const key of Object.keys(value)) {
+    if (isUnsafe(key, parent)) warnStripped(key, parent);
+    else out[key] = sanitizeValue((value as Record<string, unknown>)[key], key);
+  }
+  return out;
+};
+
+type MutableOp = Extract<
+  StatewireOp,
+  { op: "replace" | "add" | "append" | "remove" }
+>;
+
+const invalid = (op: MutableOp) =>
+  new Error(`Statewire cannot apply ${op.op} at path: ${op.path.join(".")}`);
+
+const appended = (
+  current: unknown,
+  op: Extract<MutableOp, { op: "append" }>,
+): string => {
+  if (typeof current !== "string" || typeof op.value !== "string") {
+    throw invalid(op);
+  }
+  return current + op.value;
+};
+
+const applyAtRoot = (box: { state: unknown }, op: MutableOp) => {
+  if (op.op === "replace") {
+    box.state = sanitizeValue(op.value);
+  } else if (op.op === "append") {
+    box.state = appended(box.state, op);
+  } else {
+    throw invalid(op);
+  }
+};
+
+const applyInList = (list: unknown[], index: number, op: MutableOp) => {
+  if (op.op === "replace") {
+    if (index >= list.length) throw invalid(op);
+    list[index] = sanitizeValue(op.value);
+  } else if (op.op === "add") {
+    if (index > list.length) throw invalid(op);
+    list.splice(index, 0, sanitizeValue(op.value));
+  } else if (op.op === "append") {
+    if (index >= list.length) throw invalid(op);
+    list[index] = appended(list[index], op);
+  } else {
+    if (index >= list.length) throw invalid(op);
+    list.splice(index, 1);
+  }
+};
+
+const applyInObject = (
+  obj: Record<string, unknown>,
+  key: string,
+  op: MutableOp,
+) => {
+  const exists = Object.hasOwn(obj, key);
+  if (op.op === "replace") {
+    obj[key] = sanitizeValue(op.value, key);
+  } else if (op.op === "append") {
+    obj[key] = appended(exists ? obj[key] : undefined, op);
+  } else if (op.op === "remove") {
+    if (!exists) throw invalid(op);
+    delete obj[key];
+  } else {
+    throw invalid(op);
+  }
+};
+
+const applyOpToDraft = (box: { state: unknown }, op: MutableOp): void => {
+  if (op.path.length === 0) {
+    applyAtRoot(box, op);
+    return;
+  }
+  let node: unknown = box.state;
+  for (let depth = 0; depth < op.path.length; depth++) {
+    const key = op.path[depth]!;
+    const last = depth === op.path.length - 1;
+    if (typeof key === "number") {
+      if (!Array.isArray(node) || !Number.isInteger(key) || key < 0) {
+        throw invalid(op);
+      }
+      if (last) {
+        applyInList(node, key, op);
+        return;
+      }
+      if (key >= node.length) throw invalid(op);
+      node = node[key];
+    } else {
+      if (
+        isUnsafe(key, op.path[depth - 1]) ||
+        typeof node !== "object" ||
+        node === null ||
+        Array.isArray(node)
+      ) {
+        throw invalid(op);
+      }
+      const obj = node as Record<string, unknown>;
+      if (last) {
+        applyInObject(obj, key, op);
+        return;
+      }
+      if (!Object.hasOwn(obj, key)) throw invalid(op);
+      node = obj[key];
+    }
+  }
+};
+
+const warnedOps = new Set<unknown>();
+const warnUnknownOp = (type: unknown) => {
+  if (warnedOps.has(type)) return;
+  warnedOps.add(type);
+  console.warn(`statewire: ignoring unknown op type ${JSON.stringify(type)}`);
+};
+
+const unboxPaths = (paths: readonly StatewirePath[]): StatewirePath[] =>
+  paths.map((path) => path.slice(1));
+
+export const applyOp = (
+  root: unknown,
+  op: MutableOp,
+): { state: unknown; changedPaths: StatewirePath[] } => {
+  const recorded = recordMutations({ state: root }, (draft) =>
+    applyOpToDraft(draft, op),
+  );
+  return {
+    state: recorded.state.state,
+    changedPaths: unboxPaths(recorded.changedPaths),
+  };
+};
+
+export const applyOps = (
+  state: unknown,
+  ops: readonly unknown[],
+): {
+  state: unknown;
+  events: { event: unknown; state: unknown }[];
+  changedPaths: StatewirePath[];
+} => {
+  const events: { event: unknown; state: unknown }[] = [];
+  const changedPaths: StatewirePath[] = [];
+  let segment: MutableOp[] = [];
+  const flush = () => {
+    if (segment.length === 0) return;
+    const ops = segment;
+    segment = [];
+    const recorded = recordMutations({ state }, (draft) => {
+      for (const op of ops) applyOpToDraft(draft, op);
+    });
+    state = recorded.state.state;
+    changedPaths.push(...unboxPaths(recorded.changedPaths));
+  };
+  for (const op of ops as StatewireOp[]) {
+    if (op.op === "event") {
+      flush();
+      events.push({ event: sanitizeValue(op.value), state });
+    } else if (
+      op.op === "replace" ||
+      op.op === "add" ||
+      op.op === "append" ||
+      op.op === "remove"
+    ) {
+      segment.push(op);
+    } else {
+      warnUnknownOp((op as { op: unknown }).op);
+    }
+  }
+  flush();
+  return { state, events, changedPaths };
+};

package/index.js

@@ -1 +0,0 @@
-throw new Error("statewire: placeholder release — not yet published");