@webreflection/signals 0.1.9 → 0.2.1

package/README.md

@@ -12,6 +12,8 @@ Once minified and compressed, this module is actually [0.5KB](https://cdn.jsdeli
 ```js
 // basic core features
 import {
+  Signal,     // class for brand check
+  Computed,   // extends Signal: brand check
   batch,      // Preact-like API
   computed,   // Preact-like API
   effect,     // Preact-like API
@@ -29,38 +31,15 @@ Exposes a Preact-like [createModel](https://github.com/preactjs/signals/blob/mai
 import {
   // extra:
   disposable, // equivalent of createModel(fn)
-  // ... same as core features ...
-  batch,
-  computed,
-  effect,
-  signal,
-  untracked,
+  // all other exports from core
+  ...core
 } from '@webreflection/signals/disposable';
 ```
 
 
-### branded
-
-This variant offers an `isSignal` utility that returns `true` or `false` if the passed argument is either a `signal` or a `computed` reference.
-
-```js
-// extra core features
-import {
-  // extra:
-  disposable, // equivalent of createModel(fn)
-  isSignal,   // true if `isSignal(ref)` is signal or computed
-  // ... same as core features ...
-  batch,
-  computed,
-  effect,
-  signal,
-  untracked,
-} from '@webreflection/signals/branded';
-```
-
 ### In Depth
 
-  * simply stack-based, maybe not the best approach, but one that can guarantee reasonable performance with minimal code size.
+  * simply (swapped) stack-based, maybe not the best approach, but one that can guarantee reasonable performance with minimal code size.
   * only `signal` and `computed` subscribe while reading values, unless `sig_or_comp.peek()` is used.
   * any `effect` updates synchronously but then runs only in isolation. Every effect is disposed of if the outer effect is running, meaning stacked effects work out of the box and always™ do the right thing.
   * `disposable` uses the very same `effect` logic to dispose itself when not needed anymore.
@@ -73,26 +52,10 @@ import {
 You know, nowadays it's hard to find libraries that are still 100% under control, minimalistic, not bloated, yet correct, and this one would like to be one of those 😇
 
 
-#### The Beauty
-
-  * [signal](https://github.com/WebReflection/signals/blob/main/src/signal.js) is 26 LOC.
-  * [computed](https://github.com/WebReflection/signals/blob/main/src/computed.js) is 31 LOC.
-  * the shared [stack](https://github.com/WebReflection/signals/blob/main/src/stack.js) is 18 LOC.
-  * [effect](https://github.com/WebReflection/signals/blob/main/src/effect.js) is where business happens, 65 LOC.
-  * [disposable](https://github.com/WebReflection/signals/blob/main/src/disposable.js) is 10 LOC, based on the core library mentioned in the previous points.
-  * [branded](https://github.com/WebReflection/signals/blob/main/src/branded.js) is 25 LOC extra needed only for libraries building on top.
-
-I mean ... that's coding, isn't it ... today I really needed something that would remind me why I love what I do ❤️
-
-
 #### Benchmark
 
 ![benchmark](https://raw.githubusercontent.com/WebReflection/usignal/main/test/benchmark.png)
 
-There is a *huge* difference between *NodeJS* and *Bun* but that's likely because *JSC* handles *Set* or *Map* in a better way, meaning all *WebKit* based browsers and mobile devices will have similar *Preact* performance, while *Chromium* based browsers will have half Preact size, but 1.5X slowdown.
-
-However, in common scenarios with no more than 10 to 100 signals per *effect*, the performance are consistently better or really close to Preact.
-
 ## Architecture
 
 Fine-tuned signals are a piece of art:
@@ -179,8 +142,8 @@ No *effect*? No reactivity! This is the *signals* contract, but there is a *catc
 
 Great questions. Here are the details about why that's never a concern:
 
-  * *effect* never subscribes to changes, it just registers itself as an *observer*
-  * *effect* never runs if it knows outer *effects* are queued to resolve the latest change
+  * *effect* never add subscribers to itself, like signals or computeds do, it just registers itself as an *observer* (*subscriber*)
+  * *effect* never runs if it knows outer *effects* are queued to resolve the latest change or changes are happening while it's running
   * the previous point means if `signal.value` is registered both at the *inner* effect level and at the *outer* one, the *outer* one will dictate the execution because ...
   * only the top-most subscribed effects will eventually execute, and ...
   * any *effect* previously registered for its outer *effect* will be **disposed** and never react to anything again!
@@ -190,7 +153,7 @@ I am not sure you are still following, but because *effect* is a bottom-up probl
 
 ### Batch
 
-If you followed everything else I've explained around this architecture, `batch(callback)` simply represents a running *callback* with no tracking whatsoever, except the implementation keeps tracing what should run fresh and what doesn't exist anymore. The latest *effect* that got it right will trigger and eventually access, or *re-subscribe* to, anything in it, but just once, after the *batch* callback has finished.
+If you followed everything else I've explained around this architecture, `batch(callback)` simply represents a running *callback* with no instant reactivity, it simply accumulates changes and trigger after all changes happend for whatever effect was involved.
 
 ### Untracked
 

package/dist/disposable.js

@@ -1 +1 @@
-var c=!0,a=t=>{c=t},s,p=t=>{c&&s&&t.add(s)},l=(t,e)=>{let r=s;s=t;try{return e()}finally{s=r}};var i=new WeakMap,u,y=t=>{let e=u;e||(u=[]);try{return t()}finally{if(!e){[e,u]=[u,e];for(let[r,o]of e)i.has(r)&&o()}}},b=t=>{t.c?.(),t.s.length&&t.s.splice(0).forEach(m)},m=t=>{let e=i.get(t);e.d=!0,b(e),i.delete(t)},d=t=>{let e=()=>{o||f.d||(o=!0,s||(u?u.push([e,r]):r()))},r=()=>{for(;o;)if(o=!1,b(f),f.c=l(e,t),f.d)return},o=!0,n,f={s:[],d:!o,c:n};return s&&i.get(s).s.push(e),i.set(e,f),r(),()=>{f.d||m(e)}};var S=t=>{let e=new Set,r=!0,o,n=()=>{for(;r;)r=!1,o=l(f,t);return o},f=()=>{if(r)return;r=!0;let x=e;e=new Set;for(let h of x)h()};return{get value(){return p(e),n()},peek:n}};var M=t=>{let e=new Set;return{get value(){return p(e),t},set value(r){if(t=r,c){let o=e;e=new Set;for(let n of o)n()}},peek(){return t}}};var j=t=>{let e=c;a(!1);try{return t()}finally{a(e)}};var G=t=>function(...r){let o,n=d(()=>{o??=t.apply(this,r)??this});return o[Symbol.dispose]=n,o};export{y as batch,S as computed,G as disposable,d as effect,M as signal,j as untracked};
+var r,p,u,f,i,n=!0,o=class{static{p=s=>s.#t,u=s=>s.#s,f=(s,e)=>{s.#s=e}}#s=new Set;#t;constructor(s){this.#t=s}get value(){return y(this.#s),this.#t}set value(s){if(this.#t=s,n){let e=this.#s;this.#s=new Set,k(e)}}peek(){return this.#t}},a=Symbol(),h=class extends o{#s=!0;#t;[a](){if(this.#s)return;this.#s=!0;let s=u(this);f(this,new Set),k(s)}get value(){return y(u(this)),this.peek()}peek(){for(;this.#s;)this.#s=!1,this.#t=x(this,p(this));return this.#t}},l=class{disposed=!1;invalid=!0;sub=[];cleanup;fn;constructor(s){this.fn=s}[a](){this.invalid||this.disposed||(this.invalid=!0,i||(r?r.push(this):this.peek()))}peek(){for(;this.invalid&&!this.disposed;)this.invalid=!1,b(this),this.cleanup=x(this,this.fn)}},g=t=>{let s=r;s||(r=[]);try{return t()}finally{if(!s){[s,r]=[r,s];for(let e of s)e.peek()}}},b=t=>{t.cleanup?.(),t.sub.length&&t.sub.splice(0).forEach(d)},m=t=>new h(t),d=t=>{t.disposed=!0,b(t)},v=t=>{let s=new l(t);return i&&i.sub.push(s),s.peek(),()=>{s.disposed||d(s)}},k=t=>{for(let s of t)s[a]()},y=t=>{n&&i&&t.add(i)},x=(t,s)=>{let e=i;i=t;try{return s()}finally{i=e}},S=t=>new o(t),V=t=>{let s=n;n=!1;try{return t()}finally{n=s}};var z=t=>function(...e){let c,w=v(()=>{c??=t.apply(this,e)??this});return c[Symbol.dispose]=w,c};export{h as Computed,o as Signal,g as batch,m as computed,z as disposable,v as effect,S as signal,V as untracked};

package/dist/signals.js

@@ -1 +1 @@
-var f=!0,a=t=>{f=t},s,l=t=>{f&&s&&t.add(s)},p=(t,e)=>{let r=s;s=t;try{return e()}finally{s=r}};var i=new WeakMap,u,k=t=>{let e=u;e||(u=[]);try{return t()}finally{if(!e){[e,u]=[u,e];for(let[r,o]of e)i.has(r)&&o()}}},b=t=>{t.c?.(),t.s.length&&t.s.splice(0).forEach(x)},x=t=>{let e=i.get(t);e.d=!0,b(e),i.delete(t)},w=t=>{let e=()=>{o||n.d||(o=!0,s||(u?u.push([e,r]):r()))},r=()=>{for(;o;)if(o=!1,b(n),n.c=p(e,t),n.d)return},o=!0,c,n={s:[],d:!o,c};return s&&i.get(s).s.push(e),i.set(e,n),r(),()=>{n.d||x(e)}};var S=t=>{let e=new Set,r=!0,o,c=()=>{for(;r;)r=!1,o=p(n,t);return o},n=()=>{if(r)return;r=!0;let d=e;e=new Set;for(let m of d)m()};return{get value(){return l(e),c()},peek:c}};var M=t=>{let e=new Set;return{get value(){return l(e),t},set value(r){if(t=r,f){let o=e;e=new Set;for(let c of o)c()}},peek(){return t}}};var j=t=>{let e=f;a(!1);try{return t()}finally{a(e)}};export{k as batch,S as computed,w as effect,M as signal,j as untracked};
+var r,a,c,f,e,n=!0,o=class{static{a=s=>s.#t,c=s=>s.#s,f=(s,i)=>{s.#s=i}}#s=new Set;#t;constructor(s){this.#t=s}get value(){return k(this.#s),this.#t}set value(s){if(this.#t=s,n){let i=this.#s;this.#s=new Set,d(i)}}peek(){return this.#t}},l=Symbol(),u=class extends o{#s=!0;#t;[l](){if(this.#s)return;this.#s=!0;let s=c(this);f(this,new Set),d(s)}get value(){return k(c(this)),this.peek()}peek(){for(;this.#s;)this.#s=!1,this.#t=v(this,a(this));return this.#t}},h=class{disposed=!1;invalid=!0;sub=[];cleanup;fn;constructor(s){this.fn=s}[l](){this.invalid||this.disposed||(this.invalid=!0,e||(r?r.push(this):this.peek()))}peek(){for(;this.invalid&&!this.disposed;)this.invalid=!1,p(this),this.cleanup=v(this,this.fn)}},w=t=>{let s=r;s||(r=[]);try{return t()}finally{if(!s){[s,r]=[r,s];for(let i of s)i.peek()}}},p=t=>{t.cleanup?.(),t.sub.length&&t.sub.splice(0).forEach(b)},y=t=>new u(t),b=t=>{t.disposed=!0,p(t)},x=t=>{let s=new h(t);return e&&e.sub.push(s),s.peek(),()=>{s.disposed||b(s)}},d=t=>{for(let s of t)s[l]()},k=t=>{n&&e&&t.add(e)},v=(t,s)=>{let i=e;e=t;try{return s()}finally{e=i}},g=t=>new o(t),S=t=>{let s=n;n=!1;try{return t()}finally{n=s}};export{u as Computed,o as Signal,w as batch,y as computed,x as effect,g as signal,S as untracked};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webreflection/signals",
-  "version": "0.1.9",
+  "version": "0.2.1",
   "description": "A minimalistic Preact-like signals implementation",
   "main": "src/index.js",
   "module": "src/index.js",
@@ -13,19 +13,27 @@
   ],
   "types": {
     ".": "./types/index.d.ts",
-    "./branded": "./types/branded.d.ts",
     "./disposable": "./types/disposable.d.ts",
     "./disp": "./types/disposable.d.ts",
-    "./dist": "./types/index.d.ts",
-    "./package.json": "./types/package.d.json"
+    "./dist": "./types/index.d.ts"
   },
   "exports": {
-    ".": "./src/index.js",
-    "./brand": "./dist/branded.js",
-    "./branded": "./src/branded.js",
-    "./disposable": "./src/disposable.js",
-    "./disp": "./dist/disposable.js",
-    "./dist": "./dist/signals.js",
+    ".": {
+      "types": "./types/index.d.ts",
+      "import": "./src/index.js"
+    },
+    "./disposable": {
+      "types": "./types/disposable.d.ts",
+      "import": "./src/disposable.js"
+    },
+    "./disp": {
+      "types": "./types/disposable.d.ts",
+      "import": "./dist/disposable.js"
+    },
+    "./dist": {
+      "types": "./types/index.d.ts",
+      "import": "./dist/signals.js"
+    },
     "./package.json": "./package.json"
   },
   "overrides": {
@@ -34,13 +42,12 @@
     }
   },
   "scripts": {
-    "build": "npm run build:dist && npm run build:disp && npm run build:branded && npm run build:types && npm run test && npm run size",
-    "build:branded": "esbuild src/branded.js --bundle --minify --platform=neutral --format=esm --outfile=dist/branded.js",
+    "build": "npm run build:dist && npm run build:disp && npm run build:types && npm run test && npm run size",
     "build:dist": "esbuild src/index.js --bundle --minify --platform=neutral --format=esm --outfile=dist/signals.js",
     "build:disp": "esbuild src/disposable.js --bundle --minify --platform=neutral --format=esm --outfile=dist/disposable.js",
-    "build:types": "tsc --allowJs --declaration --emitDeclarationOnly --stripInternal --outDir types --target es2022 --lib es2024 --module nodenext --moduleResolution nodenext src/*.js",
+    "build:types": "tsc --allowJs --declaration --emitDeclarationOnly --stripInternal --removeComments --outDir types --target es2022 --lib es2024 --module nodenext --moduleResolution nodenext src/*.js",
     "coverage": "mkdir -p ./coverage; c8 report --reporter=text-lcov > ./coverage/lcov.info",
-    "size": "echo 'signals'; cat dist/signals.js | brotli | wc -c; echo '\ndisposable'; cat dist/disposable.js | brotli | wc -c; echo '\nbranded'; cat dist/branded.js | brotli | wc -c",
+    "size": "echo 'signals'; cat dist/signals.js | brotli | wc -c; echo '\ndisposable'; cat dist/disposable.js | brotli | wc -c",
     "test": "c8 node --expose-gc test/coverage.js"
   },
   "keywords": [

package/src/disposable.js

@@ -1,5 +1,5 @@
 export * from './index.js';
-import { effect } from './effect.js';
+import { effect } from './index.js';
 
 export const disposable = fn => function disposable(...args) {
   let ref, value = effect(() => {

package/src/index.js

@@ -1,4 +1,171 @@
-export * from './effect.js';
-export * from './computed.js';
-export * from './signal.js';
-export * from './untracked.js';
+let batches, getValue, getSubscribers, setSubscribers, stack, tracking = true;
+
+/** @template T */
+export class Signal {
+  static {
+    getValue = self => self.#value;
+    getSubscribers = self => self.#subscribers;
+    setSubscribers = (self, subscribers) => {
+      self.#subscribers = subscribers;
+    };
+  }
+
+  #subscribers = new Set;
+  #value;
+
+  /** @param {T} init */
+  constructor(init) { this.#value = init }
+
+  get value() {
+    push(this.#subscribers);
+    return this.#value;
+  }
+
+  set value(value) {
+    this.#value = value;
+    if (tracking) {
+      const subscribers = this.#subscribers;
+      this.#subscribers = new Set;
+      notify(subscribers);
+    }
+  }
+
+  peek() {
+    return this.#value;
+  }
+}
+
+/** @type {never} */
+const compute = Symbol();
+
+/**
+ * @template T
+ * @extends {Signal<() => T>}
+ */
+export class Computed extends Signal {
+  #invalid = true;
+  #result;
+
+  [compute]() {
+    if (this.#invalid) return;
+    this.#invalid = true;
+    const subscribers = getSubscribers(this);
+    setSubscribers(this, new Set);
+    notify(subscribers);
+  }
+
+  /** @readonly @returns {T} */
+  get value() {
+    push(getSubscribers(this));
+    return this.peek();
+  }
+
+  /** @returns {T} */
+  peek() {
+    while (this.#invalid) {
+      this.#invalid = false;
+      this.#result = run(this, getValue(this));
+    }
+    return this.#result;
+  }
+}
+
+class Effect {
+  disposed = false;
+  invalid = true;
+  sub = [];
+  cleanup;
+  fn;
+
+  constructor(fn) { this.fn = fn }
+
+  [compute]() {
+    if (this.invalid || this.disposed) return;
+    this.invalid = true;
+    if (!stack) {
+      if (batches) batches.push(this);
+      else this.peek();
+    }
+  }
+
+  peek() {
+    while (this.invalid && !this.disposed) {
+      this.invalid = false;
+      cleanup(this);
+      this.cleanup = run(this, this.fn);
+    }
+  }
+}
+
+/** @type {<T>(fn: () => T) => T} */
+export const batch = fn => {
+  let before = batches;
+  if (!before) batches = [];
+  try { return fn() }
+  finally {
+    if (!before) {
+      [before, batches] = [batches, before];
+      for (const fx of before) fx.peek();
+    }
+  }
+};
+
+const cleanup = fx => {
+  fx.cleanup?.();
+  if (fx.sub.length) fx.sub.splice(0).forEach(dispose);
+};
+
+/**
+ * @template T
+ * @param {() => T} fn
+ * @returns {Computed<T>}
+ */
+export const computed = fn => new Computed(fn);
+
+const dispose = fx => {
+  fx.disposed = true;
+  cleanup(fx);
+};
+
+/**
+ * @param {() => (void | (() => void))} fn
+ * @returns {() => void}
+ */
+export const effect = fn => {
+  const fx = new Effect(fn);
+  if (stack) stack.sub.push(fx);
+  fx.peek();
+  return () => {
+    if (!fx.disposed) dispose(fx);
+  };
+};
+
+const notify = subscribers => {
+  for (const subscriber of subscribers) subscriber[compute]();
+};
+
+const push = subscribers => {
+  if (tracking && stack) subscribers.add(stack);
+};
+
+const run = (state, callback) => {
+  const before = stack;
+  stack = state;
+  try { return callback() }
+  finally { stack = before }
+};
+
+/**
+ * @template T
+ * @param {T} init
+ * @returns
+ */
+export const signal = init => new Signal(init);
+
+/** @type {<T>(fn: () => T) => T} */
+export const untracked = fn => {
+  const before = tracking;
+  tracking = false; 
+  try { return fn() }
+  finally { tracking = before }
+};

package/types/index.d.ts

@@ -1,4 +1,19 @@
-export * from "./effect.js";
-export * from "./computed.js";
-export * from "./signal.js";
-export * from "./untracked.js";
+export class Signal<T> {
+    constructor(init: T);
+    set value(value: T);
+    get value(): T;
+    peek(): T;
+    #private;
+}
+export class Computed<T> extends Signal<() => T> {
+    [x: number]: () => void;
+    constructor(init: () => T);
+    readonly get value(): T;
+    peek(): T;
+    #private;
+}
+export const batch: <T>(fn: () => T) => T;
+export function computed<T>(fn: () => T): Computed<T>;
+export function effect(fn: () => (void | (() => void))): () => void;
+export function signal<T>(init: T): Signal<T>;
+export const untracked: <T>(fn: () => T) => T;

package/dist/branded.js

@@ -1 +0,0 @@
-var f=!0,l=t=>{f=t},s,u=t=>{f&&s&&t.add(s)},a=(t,e)=>{let r=s;s=t;try{return e()}finally{s=r}};var i=new WeakMap,p,S=t=>{let e=p;e||(p=[]);try{return t()}finally{if(!e){[e,p]=[p,e];for(let[r,o]of e)i.has(r)&&o()}}},d=t=>{t.c?.(),t.s.length&&t.s.splice(0).forEach(x)},x=t=>{let e=i.get(t);e.d=!0,d(e),i.delete(t)},b=t=>{let e=()=>{o||c.d||(o=!0,s||(p?p.push([e,r]):r()))},r=()=>{for(;o;)if(o=!1,d(c),c.c=a(e,t),c.d)return},o=!0,n,c={s:[],d:!o,c:n};return s&&i.get(s).s.push(e),i.set(e,c),r(),()=>{c.d||x(e)}};var g=t=>{let e=new Set,r=!0,o,n=()=>{for(;r;)r=!1,o=a(c,t);return o},c=()=>{if(r)return;r=!0;let k=e;e=new Set;for(let w of k)w()};return{get value(){return u(e),n()},peek:n}};var h=t=>{let e=new Set;return{get value(){return u(e),t},set value(r){if(t=r,f){let o=e;e=new Set;for(let n of o)n()}},peek(){return t}}};var j=t=>{let e=f;l(!1);try{return t()}finally{l(e)}};var G=t=>function(...r){let o,n=b(()=>{o??=t.apply(this,r)??this});return o[Symbol.dispose]=n,o};var m=new WeakSet,L=t=>{let e=g(t);return m.add(e),e},N=t=>m.has(t),O=t=>{let e=h(t);return m.add(e),e};export{S as batch,L as computed,G as disposable,b as effect,N as isSignal,O as signal,j as untracked};

package/src/branded.js

@@ -1,25 +0,0 @@
-export * from './disposable.js';
-export * from './effect.js';
-export * from './untracked.js';
-
-import { computed as $computed } from './computed.js';
-import { signal as $signal } from './signal.js';
-
-const branded = new WeakSet;
-
-/** @type {<T>(fn: () => T) => { readonly value: T, peek: () => T }} */
-export const computed = fn => {
-  const computed = $computed(fn);
-  branded.add(computed);
-  return computed;
-};
-
-/** @type {(value: unknown) => boolean} */
-export const isSignal = value => branded.has(value);
-
-/** @type {<T>(init: T) => { value: T, peek: () => T }} */
-export const signal = init => {
-  const signal = $signal(init);
-  branded.add(signal);
-  return signal;
-};

package/src/computed.js

@@ -1,31 +0,0 @@
-import { push, run } from './stack.js';
-
-/** @type {<T>(fn: () => T) => { readonly value: T, peek: () => T }} */
-export const computed = fn => {
-  let subscribers = new Set, invalid = true, value;
-
-  const peek = () => {
-    while (invalid) {
-      invalid = false;
-      value = run(subscriber, fn);
-    }
-    return value;
-  };
-
-  const subscriber = () => {
-    if (invalid) return;
-    invalid = true;
-    const before = subscribers;
-    subscribers = new Set;
-    for (const sub of before) sub();
-  };
-
-  return {
-    get value() {
-      push(subscribers);
-      return peek();
-    },
-
-    peek,
-  };
-};

package/src/effect.js

@@ -1,65 +0,0 @@
-import { run, stack } from './stack.js';
-
-const effects = new WeakMap;
-
-let batches;
-
-/** @type {<T>(fn: () => T) => T} */
-export const batch = fn => {
-  let before = batches;
-  if (!before) batches = [];
-  try { return fn() }
-  finally {
-    if (!before) {
-      [before, batches] = [batches, before];
-      for (const [sub, loop] of before) {
-        if (effects.has(sub)) loop();
-      }
-    }
-  }
-};
-
-const cleanUp = state => {
-  state.c?.();
-  if (state.s.length) state.s.splice(0).forEach(dispose);
-};
-
-const dispose = subscriber => {
-  const state = effects.get(subscriber);
-  state.d = true;
-  cleanUp(state);
-  effects.delete(subscriber);
-};
-
-/** @type {(fn: (() => void | (() => void))) => (() => void)} */
-export const effect = fn => {
-  const subscriber = () => {
-    if (invalid || state.d) return;
-    invalid = true;
-    if (!stack) {
-      if (batches) batches.push([subscriber, loop]);
-      else loop();
-    }
-  };
-
-  const loop = () => {
-    while (invalid) {
-      invalid = false;
-      cleanUp(state);
-      state.c = run(subscriber, fn);
-      if (state.d) return;
-    }
-  };
-
-  let invalid = true, c, state = { s: [], d: !invalid, c };
-
-  if (stack) effects.get(stack).s.push(subscriber);
-
-  effects.set(subscriber, state);
-
-  loop();
-
-  return () => {
-    if (!state.d) dispose(subscriber);
-  };
-};

package/src/signal.js

@@ -1,26 +0,0 @@
-import { push, tracking } from './stack.js';
-
-/** @type {<T>(init: T) => { value: T, peek: () => T }} */
-export const signal = init => {
-  let subscribers = new Set;
-
-  return {
-    get value() {
-      push(subscribers);
-      return init;
-    },
-
-    set value(value) {
-      init = value;
-      if (tracking) {
-        const before = subscribers;
-        subscribers = new Set;
-        for (const sub of before) sub();
-      }
-    },
-
-    peek() {
-      return init;
-    },
-  };
-};

package/src/stack.js

@@ -1,18 +0,0 @@
-export let tracking = true;
-
-export const forceTracking = value => {
-  tracking = value;
-};
-
-export let stack;
-
-export const push = subscribers => {
-  if (tracking && stack) subscribers.add(stack);
-};
-
-export const run = (subscriber, callback) => {
-  const before = stack;
-  stack = subscriber;
-  try { return callback() }
-  finally { stack = before }
-};

package/src/untracked.js

@@ -1,9 +0,0 @@
-import { forceTracking, tracking } from './stack.js';
-
-/** @type {<T>(fn: () => T) => T} */
-export const untracked = fn => {
-  const before = tracking;
-  forceTracking(false); 
-  try { return fn() }
-  finally { forceTracking(before) }
-};

package/types/branded.d.ts

@@ -1,15 +0,0 @@
-export * from "./disposable.js";
-export * from "./effect.js";
-export * from "./untracked.js";
-/** @type {<T>(fn: () => T) => { readonly value: T, peek: () => T }} */
-export const computed: <T>(fn: () => T) => {
-    readonly value: T;
-    peek: () => T;
-};
-/** @type {(value: unknown) => boolean} */
-export const isSignal: (value: unknown) => boolean;
-/** @type {<T>(init: T) => { value: T, peek: () => T }} */
-export const signal: <T>(init: T) => {
-    value: T;
-    peek: () => T;
-};

package/types/computed.d.ts

@@ -1,5 +0,0 @@
-/** @type {<T>(fn: () => T) => { readonly value: T, peek: () => T }} */
-export const computed: <T>(fn: () => T) => {
-    readonly value: T;
-    peek: () => T;
-};

package/types/effect.d.ts

@@ -1,4 +0,0 @@
-/** @type {<T>(fn: () => T) => T} */
-export const batch: <T>(fn: () => T) => T;
-/** @type {(fn: (() => void | (() => void))) => (() => void)} */
-export const effect: (fn: (() => void | (() => void))) => (() => void);

package/types/signal.d.ts

@@ -1,5 +0,0 @@
-/** @type {<T>(init: T) => { value: T, peek: () => T }} */
-export const signal: <T>(init: T) => {
-    value: T;
-    peek: () => T;
-};

package/types/stack.d.ts

@@ -1,5 +0,0 @@
-export let tracking: boolean;
-export function forceTracking(value: any): void;
-export let stack: any;
-export function push(subscribers: any): void;
-export function run(subscriber: any, callback: any): any;

package/types/untracked.d.ts

@@ -1,2 +0,0 @@
-/** @type {<T>(fn: () => T) => T} */
-export const untracked: <T>(fn: () => T) => T;