informa 1.0.0

package/src/low.ts

@@ -0,0 +1,411 @@
+import { exitProxySymbol, getMetadataOf, globalStateMode, metadataMap, proxyMemoized, setGlobalStateMode, setMetadataOf, statifySealKey, type Statify } from "./internals.js";
+import { EventEmitter } from "node:events";
+import { StatifiedSet } from "./quirks/set.js";
+import { isListInGrid } from "./utils.js";
+import { EnumerableWeakMap } from "./EnumerableWeakMap.js";
+
+type ProxyEventEmitterEvents = {
+  "set": [any],
+  "replace": [any],
+
+  // "changeDeep": [unknown], // TODO
+  "deleteProp": [any, string | symbol],
+  "setProp": [any, string | symbol],
+  "replaceProp": [any, string | symbol],
+
+  "lengthChanged": [],
+  "spliceInElement": [any, number],
+  "spliceOutElement": [any, number],
+  "replaceElement": [any, number],
+
+  "sizeChanged": [],
+  "addItem": [any],
+  "deleteItem": [any],
+} & Record<string, never>;
+
+class Tree<T, U> {
+  value: U;
+  children = new Map<T, Tree<T, U>>();
+
+  constructor(value: U) {
+    this.value = value;
+  }
+
+  get(key: T) {
+    return this.children.get(key);
+  }
+  getOrCreate(key: T, creation: (k: T) => U) {
+    if (!this.children.has(key)) {
+      const result = new Tree<T, U>(creation(key));
+      this.children.set(key, result);
+
+      return result;
+    }
+
+    return this.children.get(key)!;
+  }
+}
+
+export class StateMetadata extends EventEmitter<ProxyEventEmitterEvents> {
+  eventEmitterTree = new Tree<string | symbol, StateMetadata>(this);
+
+  parents = new EnumerableWeakMap<StateMetadata, Set<string | symbol>>();
+
+  eventEmitterAtPath(path: (string | symbol)[]) {
+    if (path.length === 0) return this;
+
+    let node = this.eventEmitterTree;
+    for (let i = 0; i < path.length; i += 1) {
+      const nextAccess = path[i]!;
+      node = node.getOrCreate(nextAccess, () => new StateMetadata());
+    }
+
+    return node.value;
+  }
+
+  eventEmitterAtPathMaybe(path: (string | symbol)[]) {
+    if (path.length === 0) return this;
+
+    let node = this.eventEmitterTree;
+    for (let i = 0; i < path.length; i += 1) {
+      const nextAccess = path[i]!;
+
+      const maybeNode = node.get(nextAccess);
+      if (!maybeNode) return undefined;
+
+      node = maybeNode;
+    }
+
+    return node.value;
+  }
+
+  #pushParents(
+    queue: { ancestor: StateMetadata; path: (string | symbol)[] }[],
+    suffixPath: (string | symbol)[],
+  ) {
+    for (const [parent, keys] of this.parents) {
+      for (const key of keys) {
+        queue.push({
+          ancestor: parent,
+          path: [key, ...suffixPath],
+        });
+      }
+    }
+  }
+
+  emit<E extends string | symbol>(
+    eventName: string | E,
+    ...args: E extends string
+      ? ProxyEventEmitterEvents[E]
+      : E extends keyof EventEmitter.EventEmitterEventMap
+      ? EventEmitter.EventEmitterEventMap[E]
+      : any[]
+  ): boolean {
+    let result = super.emit(eventName, ...args);
+
+    const queue: { ancestor: StateMetadata; path: (string | symbol)[] }[] = [];
+    this.#pushParents(queue, []);
+
+    const seen = new Map<StateMetadata, (string | symbol)[][]>();
+
+    while (queue.length > 0) {
+      const { ancestor, path } = queue.pop()!;
+
+      const paths = seen.get(ancestor);
+
+      if (isListInGrid(paths ?? [], path)) continue;
+
+      if (paths) paths.push(path);
+      else seen.set(ancestor, [path]);
+
+      const target = ancestor.eventEmitterAtPathMaybe(path);
+      if (target) result ||= target.emit(eventName, ...args);
+
+      ancestor.#pushParents(queue, path);
+    }
+
+    return result;
+  }
+}
+
+export interface ExitProxyValue {
+  path: (string | symbol)[],
+  stateRoot: Statify<StatifiableObj>,
+}
+
+export interface Exitable {
+  [exitProxySymbol]: ExitProxyValue;
+}
+
+export type StatifiableProp = boolean | string | number | bigint | symbol | null | undefined | StatifiableObj | Statify<StatifiableObj>;
+export type StatifiableObj = { [k: string | symbol]: StatifiableProp } | {};
+
+export type Statified<T extends StatifiableProp> = T extends object
+  ? T extends Set<infer U>
+    ? StatifiedSet<Statified<U>>
+    : T extends Set<any>
+      ? never
+      : Statify<{ [K in keyof T]: Statified<T[K]> }>
+  : T;
+
+export function statifyObject<T extends { [k: string | symbol]: Statified<StatifiableProp> }>(target: T): Statified<T> {
+  if ((target as Statified<T>)[statifySealKey]) {
+    return target as Statified<T>;
+  }
+
+  if (proxyMemoized.has(target)) {
+    return proxyMemoized.get(target)! as Statified<T>;
+  }
+
+  let stateMetadata: StateMetadata;
+
+  const proxyObj = new Proxy(target, {
+    get(target, prop, recv) {
+      if (prop === statifySealKey) return true;
+
+      const result = Reflect.get(target, prop, recv);
+
+      if (globalStateMode === "extract-proxy-path") {
+        if (prop === exitProxySymbol) {
+          return { path: [], stateRoot: proxyObj };
+        }
+
+        return extract(result, proxyObj, [prop])
+      }
+
+      return result;
+    },
+
+    set(target, prop, newVal, recv) {
+      const had = Reflect.has(target, prop);
+      const oldVal = Reflect.get(target, prop) as unknown;
+
+      const result = Reflect.set(target, prop, newVal, recv);
+
+      try {
+        if (result) {
+          if (
+            oldVal !== newVal
+            && typeof newVal === "object"
+            && newVal != null
+            && newVal[statifySealKey]
+          ) {
+            const newValMetadata = getMetadataOf(newVal as Statify<StatifiableObj>);
+
+            hook(stateMetadata, prop, newValMetadata);
+          }
+
+          if (had) {
+            if (
+              oldVal !== newVal
+              && typeof oldVal === "object"
+              && oldVal != null
+              && (oldVal as any)[statifySealKey]
+            ) {
+              const oldValMetadata = getMetadataOf(oldVal as Statify<StatifiableObj>);
+
+              unhook(stateMetadata, prop, oldValMetadata);
+            }
+
+            if (
+              typeof prop !== "symbol" &&
+              Number.isInteger(Number(prop)) &&
+              Array.isArray(target)
+            ) {
+              stateMetadata.emit('replaceElement', newVal, Number(prop));
+            }
+
+            stateMetadata.emit('replaceProp', newVal, prop);
+          }
+
+          stateMetadata.emit('setProp', newVal, prop);
+
+          const maybeEventEmitterAtVal = stateMetadata.eventEmitterAtPathMaybe([prop]);
+          if (maybeEventEmitterAtVal) {
+            if (had) {
+              maybeEventEmitterAtVal.emit('replace', newVal);
+            }
+
+            maybeEventEmitterAtVal.emit('set', newVal);
+
+            emitDescendantPathEvents(
+              stateMetadata,
+              [prop],
+              newVal,
+              had,
+            );
+          }
+        }
+      } finally {
+        return result;
+      }
+    },
+
+    deleteProperty(target, prop) {
+      const oldVal = target[prop as keyof typeof target] as unknown;
+
+      const result = Reflect.deleteProperty(target, prop);
+
+      try {
+        if (result) {
+          if (
+            typeof oldVal === "object"
+            && oldVal != null
+            && (oldVal as Statify<StatifiableObj>)[statifySealKey]
+          ) {
+            const oldValMetadata = getMetadataOf(oldVal as Statify<StatifiableObj>);
+
+            unhook(stateMetadata, prop, oldValMetadata);
+          }
+
+          stateMetadata.emit('deleteProp', oldVal, prop);
+        }
+      } finally {
+        return result;
+      }
+    },
+
+    has(target, prop) {
+      if (globalStateMode === "extract-proxy-path") {
+        if (prop === exitProxySymbol) {
+          return true;
+        }
+      }
+
+      return Reflect.has(target, prop);
+    },
+  }) as Statified<typeof target>;
+
+  stateMetadata = setMetadataOf(proxyObj, new StateMetadata());
+
+  proxyMemoized.set(target, proxyObj);
+
+  return proxyObj;
+}
+
+export function extract(
+  targetMaybePrimitive: unknown,
+  stateRoot: Statify<StatifiableObj>,
+  path: (string | symbol)[],
+):
+  Record<string | symbol, unknown> & Exitable
+{
+  const target = Object(targetMaybePrimitive);
+
+  return new Proxy(target, {
+    get(target, prop, recv) {
+      if (prop === exitProxySymbol) {
+        return { path, stateRoot };
+      }
+
+      if (Array.isArray(target)) {
+        // TODO
+        throw new Error("Array index check is not yet supported.");
+      }
+
+      return extract(Reflect.get(target, prop, recv), stateRoot, [...path, prop]);
+    },
+    has(target, prop) {
+      if (globalStateMode === "extract-proxy-path") {
+        if (prop === exitProxySymbol) return true;
+      }
+
+      return Reflect.has(target, prop);
+    },
+  });
+}
+
+export function selectorToRootAndPath(selector: () => Statify<StatifiableObj>) {
+  setGlobalStateMode("extract-proxy-path");
+
+  let result;
+  try  {
+    result = (selector() as Exitable)[exitProxySymbol];
+  } finally {
+    setGlobalStateMode("normal");
+  }
+
+  return result;
+}
+
+export function hook(
+  fromMetadata: StateMetadata,
+  prop: string | symbol,
+  toMetadata: StateMetadata,
+) {
+  let resultingSet = toMetadata.parents.get(fromMetadata);
+
+  if (!resultingSet) {
+    resultingSet = new Set();
+
+    toMetadata.parents.set(fromMetadata, resultingSet);
+  }
+
+  resultingSet.add(prop);
+}
+
+export function unhook(
+  fromMetadata: StateMetadata,
+  prop: string | symbol,
+  toMetadata: StateMetadata,
+) {
+  const set = toMetadata.parents.get(fromMetadata);
+  if (set) {
+    set.delete(prop);
+
+    if (set.size === 0) {
+      toMetadata.parents.delete(fromMetadata);
+    }
+  }
+}
+
+function getAtPathMaybe(
+  value: unknown,
+  path: (string | symbol)[],
+) {
+  let current = value;
+
+  for (const key of path) {
+    if (current == null) return undefined;
+    current = Reflect.get(Object(current), key);
+  }
+
+  return current;
+}
+
+export function emitDescendantPathEvents(
+  rootMetadata: StateMetadata,
+  prefixPath: (string | symbol)[],
+  nextRootValue: unknown,
+  emitReplace: boolean,
+) {
+  let node = rootMetadata.eventEmitterTree;
+
+  for (const key of prefixPath) {
+    const next = node.get(key);
+    if (!next) return;
+    node = next;
+  }
+
+  const walk = (
+    tree: Tree<string | symbol, StateMetadata>,
+    suffixPath: (string | symbol)[],
+  ) => {
+    if (suffixPath.length > 0) {
+      const value = getAtPathMaybe(nextRootValue, suffixPath);
+
+      if (emitReplace) {
+        tree.value.emit("replace", value);
+      }
+      tree.value.emit("set", value);
+    }
+
+    for (const [key, child] of tree.children) {
+      walk(child, [...suffixPath, key]);
+    }
+  };
+
+  for (const [key, child] of node.children) {
+    walk(child, [key]);
+  }
+}

package/src/quirks/array.ts

@@ -0,0 +1,211 @@
+import { exitProxySymbol, getMetadataOf, setMetadataOf, statifySealKey, type Statify } from "../internals.js";
+import { StateMetadata, type ExitProxyValue, type StatifiableProp } from "../low.js";
+import { MakeStatified } from "./basestatified.js";
+
+const StatifiableOrgArray = MakeStatified(Array);
+
+export class StatifiedArray<T extends StatifiableProp>
+  extends StatifiableOrgArray<T> implements Array<T>, Statify<T[]>
+{
+  [statifySealKey]: true = true;
+  declare [exitProxySymbol]: ExitProxyValue;
+
+  #metadata: StateMetadata;
+
+  constructor(arrayLength: number);
+  constructor(...items: T[]);
+  constructor(arrayLengthOrFirstItem?: number | T, ...rest: T[]) {
+    if (arrayLengthOrFirstItem == undefined) {
+      super();
+    } else if (typeof arrayLengthOrFirstItem === "number") {
+      super(arrayLengthOrFirstItem);
+    } else {
+      super(arrayLengthOrFirstItem, ...rest);
+    }
+
+    this.#metadata = getMetadataOf(this);
+  }
+
+  push(...items: T[]): number {
+    const result = super.push(...items);
+
+    for (let i = result - items.length; i < result; i += 1) {
+      this.#metadata.emit("spliceInElement", this[i]!, i);
+    }
+
+    if (items.length > 0) {
+      this.#metadata.emit("lengthChanged");
+    }
+
+    return result;
+  }
+  unshift(...items: T[]): number {
+    const result = super.unshift(...items);
+
+    for (let i = 0; i < items.length; i += 1) {
+      this.#metadata.emit("spliceInElement", this[i]!, i);
+    }
+
+    if (items.length > 0) {
+      this.#metadata.emit("lengthChanged");
+    }
+
+    return result;
+  }
+
+  pop(): T | undefined {
+    if (this.length > 0) {
+      const result = super.pop();
+
+      this.#metadata.emit("spliceOutElement", result, super.length);
+      this.#metadata.emit("lengthChanged");
+      return result;
+    }
+
+    return undefined;
+  }
+  shift(): T | undefined {
+    if (this.length > 0) {
+      const result = super.shift();
+
+      this.#metadata.emit("spliceOutElement", result, 0);
+      this.#metadata.emit("lengthChanged");
+      return result;
+    }
+    return undefined;
+  }
+
+  #normalizeSplice(start: number, deleteCount?: number, ...items: T[]): [number, number, T[]] {
+    if (start == undefined) {
+      start = 0;
+    } else if (-this.length <= start && start < 0) {
+      start += this.length;
+    } else if (start < -this.length) {
+      start = 0;
+    } else if (start >= this.length) {
+      [start, deleteCount] = [this.length - 1, 0];
+    } else if (arguments.length === 0) {
+      return [0, 0, []];
+    }
+
+    if (arguments.length === 1) {
+      return [start, this.length - start, []];
+    } else if (deleteCount == undefined) {
+      deleteCount = 0;
+    }
+
+    deleteCount = Math.min(this.length - start, deleteCount);
+
+    return [start, deleteCount, items];
+  }
+  splice(start: number, deleteCount?: number, ...items: T[]): T[] {
+    const [startNormed, deleteCountNormed, itemsNormed] = arguments.length === 1
+      ? this.#normalizeSplice(start)
+      : this.#normalizeSplice(start, deleteCount, ...items);
+
+    const result = super.splice(startNormed, deleteCountNormed, ...itemsNormed);
+
+    for (let i = startNormed + deleteCountNormed; i > startNormed + itemsNormed.length; i -= 1) {
+      this.#metadata.emit("spliceOutElement", result[i - startNormed], i);
+    }
+
+    for (let i = startNormed; i < startNormed + Math.min(itemsNormed.length, deleteCountNormed); i += 1) {
+      this.#metadata.emit("replaceElement", this[i], i);
+    }
+
+    for (let i = startNormed + deleteCountNormed; i < startNormed + itemsNormed.length; i += 1) {
+      this.#metadata.emit("spliceInElement", this[i], i);
+    }
+
+    if (itemsNormed.length !== deleteCountNormed) {
+      this.#metadata.emit("lengthChanged");
+    }
+
+    return result;
+  }
+
+  #normalizeStartEnd(start?: number, end?: number): [number, number] {
+    if (start == undefined) {
+      start = 0;
+    }
+
+    if (-this.length <= start && start < 0) {
+      start = start + this.length;
+    } else if (start < -this.length) {
+      start = 0;
+    } else if (start >= this.length) {
+      return [0, 0];
+    }
+
+    if (end == undefined) {
+      end = this.length;
+    }
+
+    if (-this.length <= end && end < 0) {
+      end += this.length;
+    } else if (end < -this.length) {
+      end = 0;
+    } else if (end >= this.length) {
+      end = this.length;
+    }
+
+    if (end < start) {
+      end = start;
+    }
+
+    return [start, end];
+  }
+  fill(value: T, start?: number, end?: number): this {
+    const [startNormed, endNormed] = arguments.length === 1
+      ? this.#normalizeStartEnd()
+      : arguments.length === 2
+        ? this.#normalizeStartEnd(start)
+        : this.#normalizeStartEnd(start, end);
+
+    const result = super.fill(value, startNormed, endNormed);
+
+    for (let i = startNormed; i < endNormed; i += 1) {
+      this.#metadata.emit("replaceElement", this[i], i);
+    }
+
+    return result;
+  }
+  copyWithin(target: number, start: number, end?: number): this {
+    const [startNormed, endNormed] = arguments.length === 2
+      ? this.#normalizeStartEnd(start)
+      : this.#normalizeStartEnd(start, end);
+
+    const result = super.copyWithin(target, startNormed, endNormed);
+
+    for (let i = target; i < target + endNormed - startNormed; i += 1) {
+      this.#metadata.emit("replaceElement", this[i], i);
+    }
+
+    return result;
+  }
+
+  reverse(): T[] {
+    const result = super.reverse();
+
+    const parity = this.length % 2;
+    const half = (this.length / 2) | 0;
+    for (let i = 0; i < this.length - parity; i += 1) {
+      if (i > half) {
+        this.#metadata.emit("replaceElement", this[i], i + parity);
+      } else {
+        this.#metadata.emit("replaceElement", this[i], i);
+      }
+    }
+
+    return result;
+  }
+  sort(compareFn?: ((a: T, b: T) => number) | undefined): this {
+    const result = super.sort(compareFn);
+
+    for (let i = 0; i < this.length; i += 1) {
+      this.#metadata.emit("replaceElement", this[i], i);
+    }
+
+    return result;
+  }
+}