@rohal12/spindle 0.51.2 → 0.51.4

package/src/utils/object-path.ts

@@ -0,0 +1,109 @@
+import { isDraft } from 'immer';
+
+/** Traverse dot-path segments on an object and return the nested value. */
+export function getByPath(
+  obj: Record<string, unknown>,
+  segments: readonly string[],
+): unknown {
+  let current: unknown = obj;
+  for (const seg of segments) {
+    if (current == null || typeof current !== 'object') return undefined;
+    current = (current as Record<string, unknown>)[seg];
+  }
+  return current;
+}
+
+/**
+ * Shallow copy that keeps the prototype, so a registered class instance
+ * stays an instance of its class (with the same own keys deepClone copies).
+ */
+function shallowCopy(value: object): Record<string, unknown> {
+  let copy: object;
+  if (Array.isArray(value)) copy = [];
+  else if (value instanceof Map) copy = new Map(value);
+  else if (value instanceof Set) copy = new Set(value);
+  else if (value instanceof Date) copy = new Date(value.getTime());
+  else copy = Object.create(Object.getPrototypeOf(value)) as object;
+  return Object.assign(copy, value) as Record<string, unknown>;
+}
+
+export interface SetByPathOptions {
+  /**
+   * Create a plain object for a missing or non-object intermediate instead
+   * of throwing.
+   */
+  createMissing?: boolean;
+}
+
+/**
+ * Set a value at dot-path `segments` below `root`.
+ *
+ * When `root` is an Immer draft, objects Immer does not draft (registered
+ * class instances and everything below them) are copied on the way down and
+ * the copy is assigned to its parent, so the write produces new references
+ * up to the root. Writing into such an object directly would mutate the
+ * instance shared with the previous state and with history, and subscribers
+ * would see no change. Outside a draft (a private working copy) the path is
+ * written in place.
+ */
+export function setByPath(
+  root: Record<string, unknown>,
+  segments: readonly string[],
+  value: unknown,
+  options: SetByPathOptions = {},
+): void {
+  const parent = walkToParent(root, segments, options.createMissing ?? false);
+  parent[segments[segments.length - 1]!] = value;
+}
+
+/**
+ * Delete the property at dot-path `segments` below `root`, copying
+ * undrafted objects on the way down like setByPath(). Does nothing when an
+ * intermediate is missing or not an object, or the property is absent.
+ */
+export function deleteByPath(
+  root: Record<string, unknown>,
+  segments: readonly string[],
+): void {
+  const last = segments[segments.length - 1]!;
+  // Check first, so a no-op delete copies nothing.
+  const holder = getByPath(root, segments.slice(0, -1));
+  if (holder == null || typeof holder !== 'object' || !(last in holder)) {
+    return;
+  }
+  const parent = walkToParent(root, segments, false);
+  delete parent[last];
+}
+
+/**
+ * Walk to the object holding the last of `segments`, copying undrafted
+ * objects when `root` is an Immer draft (see setByPath). A missing or
+ * non-object intermediate is replaced by a plain object when
+ * `createMissing` is set, and throws a TypeError otherwise.
+ */
+function walkToParent(
+  root: Record<string, unknown>,
+  segments: readonly string[],
+  createMissing: boolean,
+): Record<string, unknown> {
+  const copyOnWrite = isDraft(root);
+  let current: Record<string, unknown> = root;
+  for (let i = 0; i < segments.length - 1; i++) {
+    const seg = segments[i]!;
+    let next = current[seg];
+    if (next == null || typeof next !== 'object') {
+      if (!createMissing) {
+        throw new TypeError(
+          `spindle: Cannot set property "${segments[i + 1]}" on ${next === null ? 'null' : typeof next} (at "${segments.slice(0, i + 1).join('.')}")`,
+        );
+      }
+      next = {};
+      current[seg] = next;
+    } else if (copyOnWrite && !isDraft(next)) {
+      next = shallowCopy(next);
+      current[seg] = next;
+    }
+    current = next as Record<string, unknown>;
+  }
+  return current;
+}

package/src/utils/stable-key.ts

@@ -0,0 +1,77 @@
+import { getClassName } from '../class-registry';
+
+type Constructor = new (...args: any[]) => any;
+
+/**
+ * Content-derived string key for a value, used to remount components when
+ * the value's contents change (e.g. {for} iterations, #45).
+ *
+ * JSON-compatible values (strings, finite numbers, booleans, null, arrays and
+ * plain objects of those) produce exactly their `JSON.stringify` output. Other
+ * values get distinct, unambiguous markers so their contents are reflected
+ * too: Map and Set entries (nested at any depth), Date, RegExp, BigInt,
+ * undefined, NaN/±Infinity, symbols, functions and registered class
+ * instances. Cyclic references become a back-reference marker instead of
+ * throwing, and the function never throws.
+ */
+export function stableKey(value: unknown): string {
+  try {
+    return keyOf(value, []);
+  } catch {
+    return '<unkeyable>';
+  }
+}
+
+function keyOf(val: unknown, ancestors: object[]): string {
+  switch (typeof val) {
+    case 'string':
+      return JSON.stringify(val);
+    case 'number':
+      return Number.isFinite(val) ? JSON.stringify(val) : String(val);
+    case 'boolean':
+      return String(val);
+    case 'bigint':
+      return `${val}n`;
+    case 'undefined':
+      return 'undefined';
+    case 'symbol':
+      return val.toString();
+    case 'function':
+      return `<function ${JSON.stringify(val.name)}>`;
+  }
+  if (val === null) return 'null';
+
+  const obj = val as object;
+  const depth = ancestors.indexOf(obj);
+  if (depth !== -1) return `<cycle ${ancestors.length - depth}>`;
+
+  if (val instanceof Date) return `Date(${val.getTime()})`;
+  if (val instanceof RegExp) return `RegExp(${String(val)})`;
+
+  ancestors.push(obj);
+  try {
+    if (Array.isArray(val)) {
+      return `[${val.map((v) => keyOf(v, ancestors)).join(',')}]`;
+    }
+    if (val instanceof Map) {
+      const entries = [...val].map(
+        ([k, v]) => `[${keyOf(k, ancestors)},${keyOf(v, ancestors)}]`,
+      );
+      return `Map[${entries.join(',')}]`;
+    }
+    if (val instanceof Set) {
+      return `Set[${[...val].map((v) => keyOf(v, ancestors)).join(',')}]`;
+    }
+
+    const record = obj as Record<string, unknown>;
+    const body = Object.keys(record)
+      .map((k) => `${JSON.stringify(k)}:${keyOf(record[k], ancestors)}`)
+      .join(',');
+    const className = getClassName(obj.constructor as Constructor);
+    return className === undefined
+      ? `{${body}}`
+      : `Class(${JSON.stringify(className)}){${body}}`;
+  } finally {
+    ancestors.pop();
+  }
+}