informa 1.0.0

package/src/quirks/basestatified.ts

@@ -0,0 +1,194 @@
+import {
+  exitProxySymbol,
+  getMetadataOf,
+  globalStateMode,
+  setMetadataOf,
+  statifySealKey,
+  type Statify,
+} from "../internals.js";
+import {
+  emitDescendantPathEvents,
+  extract,
+  hook,
+  StateMetadata,
+  unhook,
+  type ExitProxyValue,
+  type StatifiableObj,
+} from "../low.js";
+
+type ClassType<T extends any[] = any[], U = object> = new (...args: T) => U;
+const classMapMemo = new WeakMap<ClassType, ClassType>();
+//
+const blanketProtoMemo = new WeakMap<object, object>();
+const blanketProtoSet = new WeakSet<object>();
+
+function getBlanketPrototype(actualProto: object) {
+  const maybeMemoed = blanketProtoMemo.get(actualProto);
+  if (maybeMemoed) return maybeMemoed;
+
+  const storage = Object.create(actualProto) as {
+    [statifySealKey]: true;
+    [exitProxySymbol]: ExitProxyValue;
+  };
+  // storage[statifySealKey] = true;
+
+  const blanket = new Proxy(storage, {
+    get(target, prop, recv) {
+      if (prop === statifySealKey) return true;
+
+      if (globalStateMode === "extract-proxy-path") {
+        if (prop === exitProxySymbol) {
+          return { path: [], stateRoot: recv as Statify<StatifiableObj> };
+        }
+
+        return extract(undefined, recv as Statify<StatifiableObj>, [prop]);
+      }
+
+      return Reflect.get(target, prop, recv);
+    },
+
+    set(target, prop, newVal, recv) {
+      const stateMetadata = getMetadataOf(recv as Statify<StatifiableObj>);
+
+      const had = Reflect.has(recv, prop);
+      const oldVal = Reflect.get(recv, prop) as unknown;
+
+      const result = Reflect.set(target, prop, newVal, recv);
+
+      try {
+        if (result) {
+          if (
+            typeof newVal === "object"
+            && newVal != null
+            && (newVal as any)[statifySealKey]
+          ) {
+            hook(
+              stateMetadata,
+              prop,
+              getMetadataOf(newVal as Statify<StatifiableObj>),
+            );
+          }
+
+          if (had) {
+            if (
+              oldVal !== newVal
+              && typeof oldVal === "object"
+              && oldVal != null
+              && (oldVal as any)[statifySealKey]
+            ) {
+              unhook(
+                stateMetadata,
+                prop,
+                getMetadataOf(oldVal as Statify<StatifiableObj>),
+              );
+            }
+
+            stateMetadata.emit("replaceProp", newVal, prop);
+          }
+
+          stateMetadata.emit("setProp", newVal, prop);
+
+          const maybeEventEmitterAtPath = stateMetadata.eventEmitterAtPathMaybe([prop]);
+          if (maybeEventEmitterAtPath) {
+            if (had) {
+              maybeEventEmitterAtPath.emit("replace", newVal);
+            }
+
+            maybeEventEmitterAtPath.emit("set", newVal);
+
+            emitDescendantPathEvents(
+              stateMetadata,
+              [prop],
+              newVal,
+              had,
+            );
+          }
+        }
+      } finally {
+        return result;
+      }
+    },
+
+    has(target, prop) {
+      if (globalStateMode === "extract-proxy-path" && prop === exitProxySymbol) {
+        return true;
+      }
+
+      return Reflect.has(target, prop);
+    },
+  });
+
+  blanketProtoMemo.set(actualProto, blanket);
+  blanketProtoSet.add(blanket);
+
+  return blanket;
+}
+//
+
+export function MakeStatified<
+  V extends ClassType<T, U>,
+  T extends any[],
+  U extends object,
+>(
+  OriginalClass: V,
+): V & ClassType<T, Record<string | symbol, any>> {
+  const maybeMemoed = classMapMemo.get(OriginalClass);
+  if (maybeMemoed) return maybeMemoed as V;
+
+  const Statified = function (...args: T) {
+    const ctor = new.target ?? Statified;
+
+    const inst = Reflect.construct(OriginalClass, args, ctor) as Statify<U>;
+
+    setMetadataOf(inst, new StateMetadata());
+
+    const actualProto = ctor.prototype;
+    const finalProto = blanketProtoSet.has(actualProto)
+      ? actualProto
+      : getBlanketPrototype(actualProto);
+
+    Reflect.setPrototypeOf(inst, finalProto);
+
+    return inst;
+  } as unknown as (new (...args: T) => Statify<U>); // TODO: solve
+
+  Statified.prototype = new Proxy(
+    {
+      [statifySealKey]: true,
+    } as { [statifySealKey]: true; [exitProxySymbol]: ExitProxyValue; },
+    {
+      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: recv };
+          }
+
+          return extract(result, recv, [prop])
+        }
+
+        return result;
+      },
+
+      has(target, prop) {
+        if (globalStateMode === "extract-proxy-path") {
+          if (prop === exitProxySymbol) {
+            return true;
+          }
+        }
+
+        return Reflect.has(target, prop);
+      },
+    }
+  );
+  Reflect.setPrototypeOf(Statified.prototype, OriginalClass.prototype);
+
+  classMapMemo.set(OriginalClass, Statified);
+
+  return Statified as V; // & ClassType<T, Record<string | symbol, any>>;
+}
+
+export const BaseStatified = MakeStatified(Object);

package/src/quirks/set.ts

@@ -0,0 +1,48 @@
+import { exitProxySymbol, setMetadataOf, statifySealKey, type Statify } from "../internals.js";
+import { StateMetadata, type ExitProxyValue, type StatifiableProp } from "../low.js";
+
+export class StatifiedSet<T extends StatifiableProp> extends Set<T> implements Statify<Set<T>> {
+  [statifySealKey]: true = true;
+  declare [exitProxySymbol]: ExitProxyValue;
+
+  #metadata: StateMetadata;
+
+  constructor(args?: Iterable<T> | null) {
+    super(args);
+
+    this.#metadata = setMetadataOf(this, new StateMetadata());
+  }
+
+  add(value: T): this {
+    if (!super.has(value)) {
+      super.add(value);
+      this.#metadata.emit("addItem", value);
+      this.#metadata.emit("sizeChanged");
+    }
+
+    return this;
+  }
+
+  clear(): void {
+    const oldValues = [...this.values()];
+
+    super.clear();
+
+    for (const value of oldValues) {
+      this.#metadata.emit("deleteItem", value);
+    }
+    if (oldValues.length > 0) {
+      this.#metadata.emit("sizeChanged");
+    }
+  }
+
+  delete(value: T): boolean {
+    if (super.delete(value)) {
+      this.#metadata.emit("deleteItem", value);
+      this.#metadata.emit("sizeChanged");
+      return true;
+    }
+
+    return false;
+  }
+}

package/src/test.ts

@@ -0,0 +1,49 @@
+import $ from "./high.js";
+import { BaseStatified } from "./quirks/basestatified.js";
+import { StatifiedSet } from "./quirks/set.js";
+
+const stateful = $.state<{ a: ({ d: number })[], b?: { c?: { d?: Set<number> } } }>({ a: [] });
+
+$.onSpliceInElement(() => stateful.a, (v) => {
+  console.log("pushed", v);
+
+  $.onSet(() => v.d, (newValue) => {
+    console.log("New value is", newValue);
+  });
+});
+
+$.onSet(() => stateful.b?.c?.d, (newValue) => {
+  console.log("New value of .b.c.d is", newValue);
+});
+
+const b = $.state({ d: 3 });
+stateful.a.push(b);
+
+b.d = 10;
+
+const asdf = $.state({ d: new Set<number>() });
+const asdf2 = $.state({ c: asdf });
+
+// const aassddff = $.state(new Set());
+stateful.b = asdf2;
+
+class Wayland extends BaseStatified {
+  displays = new StatifiedSet();
+
+  #state = 0;
+  get state() { return this.#state; }
+  set state(v: number) {
+    console.log("set", v)
+    this.#state = v;
+    super.state = v;
+  }
+
+  constructor() {
+    super();
+  }
+}
+
+const w = new Wayland();
+$.onSet(() => w.state, (v) => console.log("asdf awawa!!", v));
+
+w.state = 5;

package/src/utils.ts

@@ -0,0 +1,31 @@
+export function ofWhichIsProto<T extends object, U extends symbol>(target: object, expect: Map<T, U>): U | undefined {
+  let current = Reflect.getPrototypeOf(target);
+
+  while (current) {
+    const correspondingSymbol = expect.get(current as T);
+    if (correspondingSymbol) {
+      return correspondingSymbol;
+    }
+
+    current = Reflect.getPrototypeOf(current);
+  }
+
+  return undefined;
+}
+
+export const isSetProto = Symbol();
+export const supportedQuirks = new Map([
+  [Set.prototype, isSetProto]
+] as const);
+
+
+export function isListInGrid<T>(
+  grid: T[][],
+  list: T[],
+) {
+  return grid.some((row) => {
+    if (row.length !== list.length) return false;
+
+    return row.every((v, i) => v === list[i]);
+  });
+}

package/tsconfig.json

@@ -0,0 +1,44 @@
+{
+  // Visit https://aka.ms/tsconfig to read more about this file
+  "compilerOptions": {
+    // File Layout
+    "rootDir": "./src",
+    "outDir": "./dist",
+
+    // Environment Settings
+    // See also https://aka.ms/tsconfig/module
+    "module": "nodenext",
+    "target": "esnext",
+    // "types": [],
+    // For nodejs:
+    "lib": ["esnext"],
+    "types": ["node"],
+    // and npm install -D @types/node
+
+    // Other Outputs
+    "sourceMap": true,
+    "declaration": true,
+    "declarationMap": true,
+
+    // Stricter Typechecking Options
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true,
+
+    // Style Options
+    // "noImplicitReturns": true,
+    // "noImplicitOverride": true,
+    // "noUnusedLocals": true,
+    // "noUnusedParameters": true,
+    // "noFallthroughCasesInSwitch": true,
+    // "noPropertyAccessFromIndexSignature": true,
+
+    // Recommended Options
+    "strict": true,
+    "jsx": "react-jsx",
+    "verbatimModuleSyntax": true,
+    "isolatedModules": true,
+    "noUncheckedSideEffectImports": true,
+    "moduleDetection": "force",
+    "skipLibCheck": true,
+  }
+}