@derivesome/core 1.0.0

package/src/observable.ts

@@ -0,0 +1,40 @@
+import { has } from "./common";
+import {
+  Boxed,
+  SubscribeOptions,
+  Subscription,
+  VoidFunction,
+} from "./common/types";
+import { PubSub } from "./pubsub";
+
+export const OBSERVABLE = Symbol("Observable");
+export type OBSERVABLE = typeof OBSERVABLE;
+
+export interface Observable<T> extends PubSub<T> {
+  [OBSERVABLE]: true;
+  observe: (fn: Subscription<T>, options?: SubscribeOptions) => VoidFunction;
+}
+
+export function observable<T>(state: Boxed<T>, ps: PubSub<T>): Observable<T> {
+  const observe = (
+    fn: Subscription<T>,
+    options: SubscribeOptions = {},
+  ): VoidFunction => {
+    if (options.immediate) {
+      fn(state.value);
+    }
+    return ps.subscribe(fn, options.cleanup);
+  };
+
+  return {
+    [OBSERVABLE]: true,
+    ...ps,
+    observe,
+  };
+}
+
+export function isObservable<X extends Observable<unknown>>(x: X): x is X;
+export function isObservable(x: unknown): x is Observable<unknown>;
+export function isObservable(x: unknown): x is Observable<unknown> {
+  return has(x, OBSERVABLE);
+}

package/src/pubsub.test.ts

@@ -0,0 +1,29 @@
+import { describe, assert } from "vitest";
+import { pubsub } from "./pubsub";
+
+describe("pubsub", (it) => {
+  it("notifies subscribers", () => {
+    const ps = pubsub<number>();
+
+    let last: number = -1;
+
+    const unsub = ps.subscribe((value) => {
+      last = value;
+    });
+    assert.strictEqual(last, -1);
+
+    ps.publish(1);
+    assert.strictEqual(last, 1);
+
+    ps.publish(2);
+    assert.strictEqual(last, 2);
+
+    ps.publish(3);
+    assert.strictEqual(last, 3);
+
+    unsub();
+
+    ps.publish(4);
+    assert.strictEqual(last, 3);
+  });
+});

package/src/pubsub.ts

@@ -0,0 +1,71 @@
+import { Subscription, VoidFunction } from "./common/types";
+import { Context } from "./context";
+
+export interface PubSub<T> {
+  subscribers: Set<Subscription<T>>;
+  effects: Set<VoidFunction>;
+  publish: (value: T) => void;
+  subscribe: (fn: Subscription<T>, cleanup?: VoidFunction) => VoidFunction;
+  addEffect: (effect: VoidFunction, cleanup?: VoidFunction) => VoidFunction;
+  dispose: () => void;
+}
+
+export function pubsub<T>(): PubSub<T> {
+  const subscribers = new Set<Subscription<T>>();
+  const effects = new Set<VoidFunction>();
+  const trash = new Set<VoidFunction>();
+
+  const addTrash = (fn: VoidFunction): VoidFunction => {
+    trash.add(fn);
+    return fn;
+  };
+
+  const publish = (value: T): void => {
+    effects.forEach((fx) => {
+      Context.runEffect(fx);
+    });
+    subscribers.forEach((sub) => {
+      sub(value);
+    });
+  };
+
+  const addEffect = (
+    effect: VoidFunction,
+    cleanup?: VoidFunction,
+  ): VoidFunction => {
+    effects.add(effect);
+
+    return addTrash(() => {
+      effects.delete(effect);
+      cleanup?.();
+    });
+  };
+
+  const subscribe = (
+    fn: Subscription<T>,
+    cleanup?: VoidFunction,
+  ): VoidFunction => {
+    subscribers.add(fn);
+
+    return addTrash(() => {
+      subscribers.delete(fn);
+      cleanup?.();
+    });
+  };
+
+  const dispose = (): void => {
+    trash.forEach((fn) => fn());
+    trash.clear();
+    subscribers.clear();
+    effects.clear();
+  };
+
+  return {
+    subscribers,
+    effects,
+    publish,
+    subscribe,
+    addEffect,
+    dispose,
+  };
+}

package/src/reference.test.ts

@@ -0,0 +1,32 @@
+import { describe, assert } from "vitest";
+import { ref } from "./reference";
+import { Context } from "./context";
+
+describe("reference", (it) => {
+  it("notifies subscribers through context", () => {
+    const r = ref<number>(0);
+
+    let last: number = -1;
+
+    Context.runEffect(() => {
+      const next = r.get();
+      last = next;
+    });
+
+    assert.strictEqual(last, 0);
+
+    r.set(1);
+    assert.strictEqual(last, 1);
+
+    r.set(2);
+    assert.strictEqual(last, 2);
+
+    r.set(3);
+    assert.strictEqual(last, 3);
+
+    r.dispose();
+
+    r.set(4);
+    assert.strictEqual(last, 3);
+  });
+});

package/src/reference.ts

@@ -0,0 +1,63 @@
+import { has } from "./common";
+import { compare } from "./common/compare";
+import { isFunction } from "./common/is";
+import { Boxed, Dispatch, Loose, SetStateAction } from "./common/types";
+import { Context } from "./context";
+import { Effect } from "./effect";
+import { observable, Observable } from "./observable";
+import { pubsub } from "./pubsub";
+
+export const REFERENCE = Symbol("Reference");
+export type REFERENCE = typeof REFERENCE;
+
+export interface Reference<T> extends Observable<T> {
+  [REFERENCE]: true;
+  get: () => T;
+  set: Dispatch<SetStateAction<T>>;
+  peek: () => T;
+}
+
+export function ref<T>(value: T): Reference<T> {
+  const ps = pubsub<T>();
+  const state: Boxed<T> = { value };
+  const obs = observable<T>(state, ps);
+
+  const addEffectDependency = (fx: Effect) => {
+    ps.addEffect(fx.run, fx.cleanup);
+  };
+
+  const get = (): T => {
+    const fx = Context.scope.current.effect;
+    if (fx) addEffectDependency(fx);
+    return state.value;
+  };
+
+  const set: Dispatch<SetStateAction<T>> = (fn) => {
+    const prev = state.value;
+    const next = isFunction(fn) ? fn(state.value) : fn;
+    if (!compare(next, prev)) {
+      state.value = next;
+      ps.publish(state.value);
+    }
+  };
+
+  const peek = (): T => {
+    return state.value;
+  };
+
+  return {
+    [REFERENCE]: true,
+    ...ps,
+    ...obs,
+    get,
+    set,
+    peek,
+  };
+}
+
+export function isReference(x: Loose): x is Reference<Loose>;
+export function isReference(x: unknown): x is Reference<unknown>;
+export function isReference<X extends Reference<unknown>>(x: X): x is X;
+export function isReference(x: unknown): x is Reference<unknown> {
+  return has(x, REFERENCE);
+}

package/src/utils/findRefs.ts

@@ -0,0 +1,22 @@
+import { isReference, Reference } from "../reference";
+
+export const findRefs = (x: unknown): Reference<unknown>[] => {
+
+  if (typeof x === 'undefined' || x === null) return [];
+  if (isReference(x)) return [x];
+
+
+  if (Array.isArray(x)) {
+    return x.map(it => findRefs(it)).flat();
+  }
+
+  if (typeof x === 'object' && x !== null) {
+    const refs: Array<Reference<unknown>> = [];
+    for (const [_k, v] of Object.entries(x)) {
+      refs.push(...findRefs(v));
+    }
+    return refs;
+  }
+  
+  return [];
+}

package/src/utils/index.ts

@@ -0,0 +1 @@
+export * from './findRefs';

package/tsconfig.cjs.json

@@ -0,0 +1,8 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "module": "commonjs",
+    "moduleResolution": "node10",
+    "outDir": "./dist/cjs"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    "rootDir": "./src",
+    "outDir": "./dist/esm",
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "target": "esnext",
+    "lib": ["esnext"],
+    "types": ["node"],
+    "sourceMap": true,
+    "declaration": true,
+    "declarationMap": true,
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true,
+    "strict": true,
+    "isolatedModules": true,
+    "esModuleInterop": true,
+    "noUncheckedSideEffectImports": true,
+    "moduleDetection": "force",
+    "skipLibCheck": true
+  },
+  "include": ["./src/**/*.ts"],
+  "exclude": ["./src/**/*.test.ts"]
+}

package/tsconfig.json~

@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    "rootDir": "./src",
+    "outDir": "./dist/esm",
+    "module": "nodenext",
+    "moduleResolution": "bundler",
+    "target": "esnext",
+    "lib": ["esnext"],
+    "types": ["node"],
+    "sourceMap": true,
+    "declaration": true,
+    "declarationMap": true,
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true,
+    "strict": true,
+    "isolatedModules": true,
+    "esModuleInterop": true,
+    "noUncheckedSideEffectImports": true,
+    "moduleDetection": "force",
+    "skipLibCheck": true
+  },
+  "include": ["./src/**/*.ts"],
+  "exclude": ["./src/**/*.test.ts"]
+}