@derivesome/core 1.0.0

package/src/common/has.ts

@@ -0,0 +1,7 @@
+export function has<Keys extends [...PropertyKey[]]>(x: unknown, ...keys: Keys): x is ({
+  [Prop in keyof Keys as [Keys[Prop]] extends [string] ? Keys[Prop] : never]: unknown
+}) {
+  if (typeof x === 'undefined' || x === null) return false;
+  if (keys.every(key => Object.hasOwn(x, key) || (typeof x === 'object' && (key in x)))) return true;
+  return false;
+}

package/src/common/index.ts

@@ -0,0 +1,11 @@
+export * from './types';
+export * from './is';
+export * from './stack';
+export * from './compare';
+export * from './unique-array';
+export * from './has';
+export * from './array';
+export * from './diff';
+export * from './patch';
+export * from './match';
+export * from './string';

package/src/common/is.ts

@@ -0,0 +1,14 @@
+import { Loose, LooseFunction } from "./types";
+
+export function isFunction(x: unknown): x is LooseFunction;
+export function isFunction(x: Loose): x is LooseFunction;
+export function isFunction(x: unknown): x is LooseFunction {
+  return x instanceof Function || typeof x === "function";
+}
+
+export const isPlainObject = (x: any): x is Record<PropertyKey, unknown> => {
+  if (x === null || typeof x === "undefined") return false;
+  if (Array.isArray(x)) return false;
+  if (x instanceof Date) return false;
+  return Object.getPrototypeOf(x) === Object.prototype;
+};

package/src/common/match.ts

@@ -0,0 +1,90 @@
+import { isPlainObject } from "./is";
+import { IsLiteral } from "./types";
+
+export type ToPattern<
+  T,
+  U extends Exclude<T, undefined> = Exclude<T, undefined>,
+> =
+  [IsLiteral<T>] extends [true] ? U
+  : [U] extends [string] ? string
+  : [U] extends [number] ? number
+  : [U] extends [boolean] ? boolean
+  : [U] extends [BigInt] ? BigInt
+  : [U] extends [null] ? null
+  : [U] extends [Array<infer A>] ? Array<ToPattern<A>>
+  : [U] extends [Record<PropertyKey, unknown>] ?
+    {
+      [P in keyof U]?: ToPattern<U[P]>;
+    }
+  : T;
+
+export type Unpattern<I, P> =
+  [IsLiteral<I>, IsLiteral<P>] extends [true, true] ?
+    [I] extends [P] ?
+      P
+    : never
+  : [I, P] extends [string, string] ? P
+  : [I, P] extends [number, number] ? P
+  : [I, P] extends [boolean, boolean] ? P
+  : [I, P] extends [BigInt, BigInt] ? P
+  : [I, P] extends [Array<infer AI>, Array<infer AP>] ? Array<Unpattern<AI, AP>>
+  : [[I], [P]] extends (
+    [
+      [infer AI extends Record<PropertyKey, unknown>],
+      [infer AP extends Record<PropertyKey, unknown>],
+    ]
+  ) ?
+    Extract<
+      AI,
+      {
+        [KP in keyof AP]: AP[KP];
+      }
+    >
+  : "ERROR";
+
+export function match<Input, const Pattern extends ToPattern<Input>>(
+  input: Input | Unpattern<Input, Pattern>,
+  pattern: Pattern,
+): input is Unpattern<Input, Pattern> {
+  if (input === pattern) return true;
+
+  if (Array.isArray(pattern)) {
+    if (!Array.isArray(input)) return false;
+    return pattern.every((p, i) => match(input[i], p));
+  }
+
+  switch (typeof pattern) {
+    case 'string':
+    case 'boolean':
+    case 'undefined':
+    case 'function':
+    case 'symbol':
+    case 'number': return input === pattern;
+    case 'bigint': return (typeof input === 'bigint') && input.toString() === pattern.toString();
+    case 'object': {
+      if (isPlainObject(input) && isPlainObject(pattern)) {
+        for (const [k, pv] of Object.entries(pattern)) {
+          const iv = input[k];
+          if (!match(iv, pv)) return false;
+        }
+
+        const symbols = Object.getOwnPropertySymbols(pattern);
+
+        for (const symbol of symbols) {
+          if (!(symbol in input)) return false;
+          const iv = input[symbol];
+          const pv = pattern[symbol];
+          if (!match(iv, pv)) return false;
+        }
+        
+        return true;
+      } else {
+        console.error(`Tried to match`, input, pattern);
+        throw new Error(`Cannot match`);
+      }
+    };
+  }
+  
+  
+  return false;
+}

package/src/common/patch.test.ts

@@ -0,0 +1,118 @@
+import { describe, it, assert } from 'vitest';
+import { diff } from './diff';
+import { patch } from './patch';
+
+describe('patch', () => {
+  it('should patch a changed primitive at root', () => {
+    const diffs = diff(1, 2);
+    const result = patch(1, diffs);
+    assert.equal(result, 2);
+  });
+
+  it('should patch changed object properties in-place', () => {
+    const target = { a: 1, b: 2 };
+    const ref = target;
+    const diffs = diff(target, { a: 1, b: 99 });
+    const result = patch(target, diffs);
+    assert.strictEqual(result, ref);
+    assert.deepEqual(result, { a: 1, b: 99 });
+  });
+
+  it('should add new properties in-place', () => {
+    const target: Record<string, number> = { a: 1 };
+    const ref = target;
+    const diffs = diff(target, { a: 1, b: 2 });
+    const result = patch(target, diffs);
+    assert.strictEqual(result, ref);
+    assert.deepEqual(result, { a: 1, b: 2 });
+  });
+
+  it('should remove properties in-place', () => {
+    const target: Record<string, number> = { a: 1, b: 2 };
+    const ref = target;
+    const diffs = diff(target, { a: 1 });
+    const result = patch(target, diffs);
+    assert.strictEqual(result, ref);
+    assert.deepEqual(result, { a: 1 });
+    assert.isFalse('b' in result);
+  });
+
+  it('should patch nested objects in-place', () => {
+    const target = { x: { y: { z: 1 } } };
+    const innerRef = target.x.y;
+    const diffs = diff(target, { x: { y: { z: 42 } } });
+    const result = patch(target, diffs);
+    assert.strictEqual(result.x.y, innerRef);
+    assert.deepEqual(result, { x: { y: { z: 42 } } });
+  });
+
+  it('should patch array elements in-place', () => {
+    const target = [1, 2, 3];
+    const ref = target;
+    const diffs = diff(target, [1, 99, 3]);
+    const result = patch(target, diffs);
+    assert.strictEqual(result, ref);
+    assert.deepEqual(result, [1, 99, 3]);
+  });
+
+  it('should add array elements in-place', () => {
+    const target = [1, 2];
+    const ref = target;
+    const diffs = diff(target, [1, 2, 3]);
+    const result = patch(target, diffs);
+    assert.strictEqual(result, ref);
+    assert.deepEqual(result, [1, 2, 3]);
+  });
+
+  it('should remove array elements in-place', () => {
+    const target = [1, 2, 3];
+    const ref = target;
+    const diffs = diff(target, [1, 2]);
+    const result = patch(target, diffs);
+    assert.strictEqual(result, ref);
+    assert.deepEqual(result, [1, 2]);
+  });
+
+  it('should patch nested arrays inside objects in-place', () => {
+    const target = { items: [10, 20, 30] };
+    const arrRef = target.items;
+    const diffs = diff(target, { items: [10, 25, 30] });
+    const result = patch(target, diffs);
+    assert.strictEqual(result.items, arrRef);
+    assert.deepEqual(result, { items: [10, 25, 30] });
+  });
+
+  it('should patch deeply nested mixed structures in-place', () => {
+    const target = { users: [{ name: 'Alice', scores: [10, 20] }] };
+    const scoresRef = target.users[0]!.scores;
+    const diffs = diff(target, { users: [{ name: 'Alice', scores: [10, 30] }] });
+    const result = patch(target, diffs);
+    assert.strictEqual(result.users[0]!.scores, scoresRef);
+    assert.deepEqual(result, { users: [{ name: 'Alice', scores: [10, 30] }] });
+  });
+
+  it('should handle type change from object to primitive', () => {
+    const target: any = { a: { b: 1 } };
+    const diffs = diff(target, { a: 42 } as any);
+    const result = patch(target, diffs);
+    assert.deepEqual(result, { a: 42 });
+  });
+
+  it('should handle symbol keys', () => {
+    const sym = Symbol('test');
+    const target = { [sym]: 1 };
+    const ref = target;
+    const diffs = diff(target, { [sym]: 2 });
+    const result = patch(target, diffs);
+    assert.strictEqual(result, ref);
+    assert.equal(result[sym], 2);
+  });
+
+  it('should produce the same result as b when diffing a->b and patching a', () => {
+    const a = { x: 1, y: [1, 2, 3], z: { nested: true, value: 'hello' } };
+    const b = { x: 2, y: [1, 3], z: { nested: false, extra: 'world' } };
+    const diffs = diff(a, b as any);
+    const result = patch(a, diffs);
+    assert.deepEqual(result, b as unknown);
+  });
+});

package/src/common/patch.ts

@@ -0,0 +1,47 @@
+import type { Diff } from './diff';
+
+export const patch = <T>(target: T, diffs: Diff[]): T => {
+  for (const d of diffs) {
+    target = applyDiff(target, d, 0);
+  }
+  return target;
+};
+
+const applyDiff = <T>(target: T, d: Diff, depth: number): T => {
+  if (depth === d.path.length) {
+    if (d.type === 'changed' || d.type === 'added') {
+      return d.newValue as T;
+    }
+    return undefined as T;
+  }
+
+  const key = d.path[depth]!;
+
+  if (Array.isArray(target)) {
+    const index = key as number;
+
+    if (d.type === 'removed' && depth === d.path.length - 1) {
+      target.splice(index, 1);
+    } else if (d.type === 'added' && depth === d.path.length - 1) {
+      target.splice(index, 0, d.newValue);
+    } else {
+      target[index] = applyDiff(target[index], d, depth + 1);
+    }
+
+    return target;
+  }
+
+  if (typeof target === 'object' && target !== null) {
+    const obj = target as Record<PropertyKey, unknown>;
+
+    if (d.type === 'removed' && depth === d.path.length - 1) {
+      delete obj[key];
+    } else {
+      obj[key] = applyDiff(obj[key], d, depth + 1);
+    }
+
+    return target;
+  }
+
+  return target;
+};

package/src/common/stack.ts

@@ -0,0 +1,22 @@
+export class Stack<T> {
+  items: T[];
+
+  constructor(items: T[] = []) {
+    this.items = items;
+  }
+
+  get current(): T {
+    const item = this.items[this.items.length - 1];
+    if (!item) throw new Error(`Stack is empty`);
+    return item;
+  }
+
+  push(item: T): this {
+    this.items.push(item);
+    return this;
+  }
+
+  pop(): T | null {
+    return this.items.pop() || null;
+  }
+}

package/src/common/string.test.ts

@@ -0,0 +1,46 @@
+import { describe, assert } from 'vitest';
+import { unjoin } from './string';
+
+describe("unjoin", (it) => {
+  it("unjoins a '/' joined string", () => {
+    const path: string = 'foo/bar/baz';
+    const parts = unjoin(path, '/');
+
+    console.log(parts);
+
+    const expected: string[] = ['foo', '/', 'bar', '/', 'baz'];
+    assert.strictEqual(parts.length, expected.length);
+
+    for (let i = 0; i < expected.length; i++) {
+      assert.strictEqual(parts[i], expected[i]);
+    }
+  });
+
+  it("unjoins a '/' joined string starting with '/'", () => {
+    const path: string = '/foo/bar/baz';
+    const parts = unjoin(path, '/');
+
+    console.log(parts);
+
+    const expected: string[] = ['/', 'foo', '/', 'bar', '/', 'baz'];
+    assert.strictEqual(parts.length, expected.length);
+
+    for (let i = 0; i < expected.length; i++) {
+      assert.strictEqual(parts[i], expected[i]);
+    }
+  });
+
+  it("unjoins a non-joined string", () => {
+    const path: string = 'foobar';
+    const parts = unjoin(path, '/');
+
+    console.log(parts);
+
+    const expected: string[] = ['foobar'];
+    assert.strictEqual(parts.length, expected.length);
+
+    for (let i = 0; i < expected.length; i++) {
+      assert.strictEqual(parts[i], expected[i]);
+    }
+  })
+})

package/src/common/string.ts

@@ -0,0 +1,35 @@
+export const unjoin = (value: string, delim: string): string[] => {
+  const parts: string[] = [];
+
+  const len = value.length;
+  if (len <= 0) return parts;
+
+  let i = 0;
+  let c = value[i++]!;
+
+  let current: string = "";
+
+  while (c && i <= len) {
+    if (c === delim) {
+      while (c && i <= len && c === delim) {
+        parts.push(delim);
+        c = value[i++]!;
+      }
+      continue;
+    } else {
+      current = "";
+      while (c && i <= len && c !== delim) {
+        current += c;
+        c = value[i++]!;
+      }
+      parts.push(current);
+
+      while (c && i <= len && c === delim) {
+        parts.push(delim);
+        c = value[i++]!;
+      }
+    }
+  }
+
+  return parts;
+};

package/src/common/types.ts

@@ -0,0 +1,61 @@
+export type Loose = any;
+export type Boxed<T> = { value: T };
+export type Subscription<T> = (value: T) => void;
+export type SubscriptionCaller<T> = (fn: Subscription<T>, value: T) => void;
+export type ReturningFunction<T> = () => T;
+export type VoidFunction = () => void;
+export type VoidAsyncFunction = () => void;
+export type VoidSyncOrAsyncFunction = () => void | Promise<void>;
+export type LooseFunction = (...args: Loose[]) => Loose;
+export type SetStateAction<S> = S | ((prevState: S) => S);
+export type Dispatch<A> = (value: A) => void;
+export type UnknownDict = Record<string, unknown>;
+export type LooseDict = Record<string, Loose>;
+
+export type SubscribeOptions = {
+  cleanup?: VoidFunction;
+  immediate?: boolean;
+}
+
+export type Distribute<T> = T extends T ? T : never;
+
+export type UnionToIntersection<union> =
+  (union extends Loose ? (k: union) => void : never) extends (
+    (k: infer intersection) => void
+  ) ?
+    intersection
+  : never;
+
+export type IsUnion<a> = [a] extends [UnionToIntersection<a>] ? false : true;
+
+export type UnionToTuple<union, output extends Loose[] = []> =
+  UnionToIntersection<
+    union extends Loose ? (t: union) => union : never
+  > extends (_: Loose) => infer elem ?
+    UnionToTuple<Exclude<union, elem>, [elem, ...output]>
+  : output;
+
+
+export type IsLiteral<a> =
+  [a] extends [null | undefined] ? true
+  : [a] extends [string] ?
+    string extends a ?
+      false
+    : true
+  : [a] extends [number] ?
+    number extends a ?
+      false
+    : true
+  : [a] extends [boolean] ?
+    boolean extends a ?
+      false
+    : true
+  : [a] extends [symbol] ?
+    symbol extends a ?
+      false
+    : true
+  : [a] extends [bigint] ?
+    bigint extends a ?
+      false
+    : true
+  : false;

package/src/common/unique-array.ts

@@ -0,0 +1,80 @@
+import { ArrayProxy } from "../array-proxy";
+
+export class UniqueArray<T> {
+  private lookup: Set<T> = new Set();
+  items: ArrayProxy<T> = new ArrayProxy<T>();
+
+  constructor(items: T[] = []) {
+    this.push(...items);
+  }
+
+  get length(): number {
+    if (this.items.length !== this.lookup.size) {
+      throw new Error("UniqueArray: array length is unsynced with lookup");
+    }
+    return this.items.length;
+  }
+
+  values(): Array<T> {
+    return this.items;
+  }
+
+  copyValues(): Array<T> {
+    return [...this.items];
+  }
+
+  includes(searchElement: T): boolean {
+    return this.lookup.has(searchElement);
+  }
+
+  push(...items: T[]): number {
+    for (const item of items) {
+      if (this.includes(item)) continue;
+      this.items.push(item);
+      this.lookup.add(item);
+    }
+    return this.lookup.size;
+  }
+
+  pop(): T | undefined {
+    const item = this.items.pop();
+    if (item) {
+      this.lookup.delete(item);
+    }
+    return item;
+  }
+
+  indexOf(item: T): number {
+    const idx = this.items.indexOf(item);
+    if (
+      (idx >= 0 && !this.includes(item)) ||
+      (idx < 0 && this.includes(item))
+    ) {
+      throw new Error("UniqueArray: array is unsynced with lookup");
+    }
+    return idx;
+  }
+
+  delete(item: T) {
+    const idx = this.indexOf(item);
+    if (idx < 0) return;
+    this.items.splice(idx, 1);
+    this.lookup.delete(item);
+  }
+
+  clear() {
+    this.items.splice(0);
+    this.lookup.clear();
+  }
+
+  insert(offset: number, values: T[]) {
+    if (offset < 0 || offset >= this.length) {
+      return this.push(...values);
+    }
+    const items = Array.from(new Set(values.filter(x => !this.includes(x))));
+    const left = this.items.slice(0, offset);
+    const right = this.items.slice(offset);
+    this.clear();
+    this.push(...left, ...items, ...right);
+  }
+}

package/src/context.ts

@@ -0,0 +1,36 @@
+import { isFunction } from "./common/is";
+import { Stack } from "./common/stack";
+import { VoidFunction } from "./common/types";
+import { Effect } from "./effect";
+
+export type ScopeData = {
+  effect: Effect | null;
+};
+
+export class Scope {
+  current: ScopeData = {
+    effect: null,
+  };
+}
+
+export class Context {
+  static scopes: Stack<Scope> = new Stack([new Scope()]);
+
+  static get scope(): Scope {
+    return this.scopes.current;
+  }
+
+  static runEffect(effect: VoidFunction | Effect) {
+    if (isFunction(effect)) {
+      const prev = this.scope.current.effect;
+      this.scope.current.effect = { run: effect };
+      effect();
+      this.scope.current.effect = prev;
+    } else {
+      const prev = this.scope.current.effect;
+      this.scope.current.effect = effect;
+      effect.run();
+      this.scope.current.effect = prev;
+    }
+  }
+}

package/src/derived.test.ts

@@ -0,0 +1,45 @@
+import { describe, assert } from "vitest";
+import { ref } from "./reference";
+import { derived } from "./derived";
+
+describe("derived", (it) => {
+  it("computes a derived value", () => {
+    const r = ref<number>(0);
+    const d = derived(() => r.get() * 2);
+    const ds = derived(() => `number is: ${d.get()}`);
+
+    assert.strictEqual(d.peek(), 0);
+    assert.strictEqual(ds.peek(), `number is: ${0}`);
+    r.set(1);
+    assert.strictEqual(d.peek(), 2);
+    assert.strictEqual(ds.peek(), `number is: ${2}`);
+    r.set(2);
+    assert.strictEqual(d.peek(), 4);
+    assert.strictEqual(ds.peek(), `number is: ${4}`);
+    r.set(3);
+    assert.strictEqual(d.peek(), 6);
+    assert.strictEqual(ds.peek(), `number is: ${6}`);
+  });
+
+  it("tracks conditional dependencies", () => {
+    const selected = ref<boolean>(false);
+    const counter = ref<number>(0);
+
+    let numCalls: number = 0;
+
+    const thing = derived(() => {
+      numCalls += 1;
+      if (!selected.get()) return -1;
+      return counter.get() * 2;
+    });
+
+    assert.strictEqual(numCalls, 1);
+    selected.set(true);
+    assert.strictEqual(numCalls, 2);
+    counter.set(1);
+    assert.strictEqual(numCalls, 3);
+    assert.strictEqual(selected.effects.size, 1);
+    assert.strictEqual(counter.effects.size, 1);
+    assert.strictEqual(thing.effects.size, 0);
+  });
+});

package/src/derived.ts

@@ -0,0 +1,35 @@
+import { compare } from "./common/compare";
+import { has } from "./common/has";
+import { Context } from "./context";
+import { ref, Reference } from "./reference";
+
+export const DERIVED = Symbol('Derived');
+export type DERIVED = typeof DERIVED;
+
+export type DeriveComputeFn<T> = () => T;
+
+export interface Derived<T> extends Reference<T> {
+  [DERIVED]: true
+}
+
+export function derived<T>(fn: DeriveComputeFn<T>): Derived<T> {
+  const state = ref<T>(null as T);
+
+  const compute = () => {
+    const prev = state.peek();
+    const next = fn();
+    if (!compare(next, prev)) {
+      state.set(next);
+    }
+  };
+
+  Context.runEffect(compute);
+
+  return Object.assign(state, { [DERIVED]: true as const });
+}
+
+export function isDerived<X extends Derived<unknown>>(x: X): x is X;
+export function isDerived(x: unknown): x is Derived<unknown>;
+export function isDerived(x: unknown): x is Derived<unknown> {
+  return has(x, DERIVED);
+}

package/src/effect.ts

@@ -0,0 +1,9 @@
+import { VoidSyncOrAsyncFunction } from "./common/types";
+import { Context } from "./context";
+
+export interface Effect {
+  run: () => void;
+  cleanup?: () => void;
+}
+
+export const effect = (fn: VoidSyncOrAsyncFunction) => Context.runEffect(fn);

package/src/index.ts

@@ -0,0 +1,7 @@
+export * from './common';
+export * from './context';
+export * from './effect';
+export * from './pubsub';
+export * from './reference';
+export * from './derived';
+export * from './utils';