@derivesome/core 1.0.0 → 1.0.2

package/src/common/diff.ts

@@ -1,6 +1,6 @@
-import { isPlainObject } from './is';
+import { isPlainObject } from "./is";
 
-export type DiffType = 'added' | 'removed' | 'changed';
+export type DiffType = "added" | "removed" | "changed";
 
 export type Diff = {
   type: DiffType;
@@ -15,7 +15,12 @@ export const diff = <T>(a: T, b: T): Diff[] => {
   return diffs;
 };
 
-const diffRecursive = (a: unknown, b: unknown, path: PropertyKey[], diffs: Diff[]): void => {
+const diffRecursive = (
+  a: unknown,
+  b: unknown,
+  path: PropertyKey[],
+  diffs: Diff[],
+): void => {
   if (a === b) return;
 
   const aIsArray = Array.isArray(a);
@@ -34,7 +39,7 @@ const diffRecursive = (a: unknown, b: unknown, path: PropertyKey[], diffs: Diff[
     return;
   }
 
-  diffs.push({ type: 'changed', path, oldValue: a, newValue: b });
+  diffs.push({ type: "changed", path, oldValue: a, newValue: b });
 };
 
 const diffObjects = (
@@ -50,7 +55,7 @@ const diffObjects = (
   for (const key of aKeys) {
     const childPath = [...path, key];
     if (!bKeySet.has(key)) {
-      diffs.push({ type: 'removed', path: childPath, oldValue: a[key] });
+      diffs.push({ type: "removed", path: childPath, oldValue: a[key] });
     } else {
       diffRecursive(a[key], b[key], childPath, diffs);
     }
@@ -59,7 +64,7 @@ const diffObjects = (
   const aKeySet = new Set(aKeys);
   for (const key of bKeys) {
     if (!aKeySet.has(key)) {
-      diffs.push({ type: 'added', path: [...path, key], newValue: b[key] });
+      diffs.push({ type: "added", path: [...path, key], newValue: b[key] });
     }
   }
 };
@@ -75,9 +80,9 @@ const diffArrays = (
   for (let i = 0; i < maxLen; i++) {
     const childPath = [...path, i];
     if (i >= a.length) {
-      diffs.push({ type: 'added', path: childPath, newValue: b[i] });
+      diffs.push({ type: "added", path: childPath, newValue: b[i] });
     } else if (i >= b.length) {
-      diffs.push({ type: 'removed', path: childPath, oldValue: a[i] });
+      diffs.push({ type: "removed", path: childPath, oldValue: a[i] });
     } else {
       diffRecursive(a[i], b[i], childPath, diffs);
     }

package/src/common/has.ts

@@ -1,7 +1,17 @@
-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;
+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

@@ -1,11 +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';
+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/match.ts

@@ -4,43 +4,51 @@ 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;
+> = [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
+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";
+  : [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>,
@@ -54,14 +62,18 @@ export function match<Input, const Pattern extends ToPattern<Input>>(
   }
 
   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': {
+    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];
@@ -76,15 +88,14 @@ export function match<Input, const Pattern extends ToPattern<Input>>(
           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

@@ -1,15 +1,15 @@
-import { describe, it, assert } from 'vitest';
-import { diff } from './diff';
-import { patch } from './patch';
+import { describe, it, assert } from "vitest";
+import { diff } from "./diff";
+import { patch } from "./patch";
 
-describe('patch', () => {
-  it('should patch a changed primitive at root', () => {
+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', () => {
+  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 });
@@ -18,7 +18,7 @@ describe('patch', () => {
     assert.deepEqual(result, { a: 1, b: 99 });
   });
 
-  it('should add new properties in-place', () => {
+  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 });
@@ -27,17 +27,17 @@ describe('patch', () => {
     assert.deepEqual(result, { a: 1, b: 2 });
   });
 
-  it('should remove properties in-place', () => {
+  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);
+    assert.isFalse("b" in result);
   });
 
-  it('should patch nested objects in-place', () => {
+  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 } } });
@@ -46,7 +46,7 @@ describe('patch', () => {
     assert.deepEqual(result, { x: { y: { z: 42 } } });
   });
 
-  it('should patch array elements in-place', () => {
+  it("should patch array elements in-place", () => {
     const target = [1, 2, 3];
     const ref = target;
     const diffs = diff(target, [1, 99, 3]);
@@ -55,7 +55,7 @@ describe('patch', () => {
     assert.deepEqual(result, [1, 99, 3]);
   });
 
-  it('should add array elements in-place', () => {
+  it("should add array elements in-place", () => {
     const target = [1, 2];
     const ref = target;
     const diffs = diff(target, [1, 2, 3]);
@@ -64,7 +64,7 @@ describe('patch', () => {
     assert.deepEqual(result, [1, 2, 3]);
   });
 
-  it('should remove array elements in-place', () => {
+  it("should remove array elements in-place", () => {
     const target = [1, 2, 3];
     const ref = target;
     const diffs = diff(target, [1, 2]);
@@ -73,7 +73,7 @@ describe('patch', () => {
     assert.deepEqual(result, [1, 2]);
   });
 
-  it('should patch nested arrays inside objects in-place', () => {
+  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] });
@@ -82,24 +82,26 @@ describe('patch', () => {
     assert.deepEqual(result, { items: [10, 25, 30] });
   });
 
-  it('should patch deeply nested mixed structures in-place', () => {
-    const target = { users: [{ name: 'Alice', scores: [10, 20] }] };
+  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 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] }] });
+    assert.deepEqual(result, { users: [{ name: "Alice", scores: [10, 30] }] });
   });
 
-  it('should handle type change from object to primitive', () => {
+  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');
+  it("should handle symbol keys", () => {
+    const sym = Symbol("test");
     const target = { [sym]: 1 };
     const ref = target;
     const diffs = diff(target, { [sym]: 2 });
@@ -108,9 +110,9 @@ describe('patch', () => {
     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' } };
+  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

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

package/src/common/string.test.ts

@@ -1,14 +1,14 @@
-import { describe, assert } from 'vitest';
-import { unjoin } from './string';
+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, '/');
+    const path: string = "foo/bar/baz";
+    const parts = unjoin(path, "/");
 
     console.log(parts);
 
-    const expected: string[] = ['foo', '/', 'bar', '/', 'baz'];
+    const expected: string[] = ["foo", "/", "bar", "/", "baz"];
     assert.strictEqual(parts.length, expected.length);
 
     for (let i = 0; i < expected.length; i++) {
@@ -17,12 +17,12 @@ describe("unjoin", (it) => {
   });
 
   it("unjoins a '/' joined string starting with '/'", () => {
-    const path: string = '/foo/bar/baz';
-    const parts = unjoin(path, '/');
+    const path: string = "/foo/bar/baz";
+    const parts = unjoin(path, "/");
 
     console.log(parts);
 
-    const expected: string[] = ['/', 'foo', '/', 'bar', '/', 'baz'];
+    const expected: string[] = ["/", "foo", "/", "bar", "/", "baz"];
     assert.strictEqual(parts.length, expected.length);
 
     for (let i = 0; i < expected.length; i++) {
@@ -31,16 +31,16 @@ describe("unjoin", (it) => {
   });
 
   it("unjoins a non-joined string", () => {
-    const path: string = 'foobar';
-    const parts = unjoin(path, '/');
+    const path: string = "foobar";
+    const parts = unjoin(path, "/");
 
     console.log(parts);
 
-    const expected: string[] = ['foobar'];
+    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/types.ts

@@ -1,6 +1,6 @@
 export type Loose = any;
 export type Boxed<T> = { value: T };
-export type Subscription<T> = (value: T) => void;
+export type Subscription<T> = (value: T) => void | Promise<void>;
 export type SubscriptionCaller<T> = (fn: Subscription<T>, value: T) => void;
 export type ReturningFunction<T> = () => T;
 export type VoidFunction = () => void;
@@ -15,15 +15,14 @@ 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
+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;
@@ -31,31 +30,30 @@ 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;
+  > 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;
+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/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

@@ -71,7 +71,7 @@ export class UniqueArray<T> {
     if (offset < 0 || offset >= this.length) {
       return this.push(...values);
     }
-    const items = Array.from(new Set(values.filter(x => !this.includes(x))));
+    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();

package/src/context.ts

@@ -1,6 +1,6 @@
 import { isFunction } from "./common/is";
 import { Stack } from "./common/stack";
-import { VoidFunction } from "./common/types";
+import { VoidFunction, VoidSyncOrAsyncFunction } from "./common/types";
 import { Effect } from "./effect";
 
 export type ScopeData = {
@@ -20,7 +20,23 @@ export class Context {
     return this.scopes.current;
   }
 
-  static runEffect(effect: VoidFunction | Effect) {
+  static async runEffectAsync(
+    effect: VoidSyncOrAsyncFunction | Effect,
+  ): Promise<void> {
+    if (isFunction(effect)) {
+      const prev = this.scope.current.effect;
+      this.scope.current.effect = { run: effect };
+      await effect();
+      this.scope.current.effect = prev;
+    } else {
+      const prev = this.scope.current.effect;
+      this.scope.current.effect = effect;
+      await effect.run();
+      this.scope.current.effect = prev;
+    }
+  }
+
+  static runEffect(effect: VoidFunction | Effect): void {
     if (isFunction(effect)) {
       const prev = this.scope.current.effect;
       this.scope.current.effect = { run: effect };