@oscarpalmer/mora 0.3.0 → 0.4.0

package/dist/computed.cjs

@@ -4,28 +4,49 @@ var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { en
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const effect = require("./effect.cjs");
-class Computed extends effect.Effect {
+const signal = require("./signal.cjs");
+exports.activeComputed = void 0;
+class Computed {
   constructor(callback) {
-    super();
-    __publicField(this, "dirty", true);
-    __publicField(this, "effects", /* @__PURE__ */ new Set());
-    __publicField(this, "value");
-    this.callback = () => {
-      if (this.dirty) {
-        this.value = callback();
-        this.dirty = false;
-      }
+    __publicField(this, "state");
+    this.state = {
+      dirty: true,
+      computeds: /* @__PURE__ */ new Set(),
+      effect: void 0,
+      effects: /* @__PURE__ */ new Set(),
+      value: void 0
     };
-    effect.runEffect(this);
+    this.state.effect = effect.effect(() => {
+      if (this.state.dirty) {
+        const previousComputed = exports.activeComputed;
+        exports.activeComputed = this;
+        const value = callback();
+        exports.activeComputed = previousComputed;
+        if (!Object.is(this.state.value, value)) {
+          this.state.value = value;
+          for (const comp of this.state.computeds) {
+            comp.state.dirty = true;
+            signal.dirtyEffects.add(comp.state.effect);
+          }
+          for (const effect2 of this.state.effects) {
+            signal.dirtyEffects.add(effect2);
+          }
+        }
+        this.state.dirty = false;
+      }
+    });
   }
   get() {
-    if (effect.activeEffect != null && effect.activeEffect !== this) {
-      this.effects.add(effect.activeEffect);
+    if (exports.activeComputed != null && exports.activeComputed !== this) {
+      this.state.computeds.add(exports.activeComputed);
+    }
+    if (effect.activeEffect != null && effect.activeEffect !== this.state.effect) {
+      this.state.effects.add(effect.activeEffect);
     }
-    if (this.dirty) {
-      effect.runEffect(this);
+    if (this.state.dirty) {
+      effect.runEffect(this.state.effect);
     }
-    return this.value;
+    return this.state.value;
   }
 }
 function computed(callback) {

package/dist/computed.js

@@ -1,29 +1,50 @@
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-import { Effect, runEffect, activeEffect } from "./effect.js";
-class Computed extends Effect {
+import { effect, activeEffect, runEffect } from "./effect.js";
+import { dirtyEffects } from "./signal.js";
+let activeComputed;
+class Computed {
   constructor(callback) {
-    super();
-    __publicField(this, "dirty", true);
-    __publicField(this, "effects", /* @__PURE__ */ new Set());
-    __publicField(this, "value");
-    this.callback = () => {
-      if (this.dirty) {
-        this.value = callback();
-        this.dirty = false;
-      }
+    __publicField(this, "state");
+    this.state = {
+      dirty: true,
+      computeds: /* @__PURE__ */ new Set(),
+      effect: void 0,
+      effects: /* @__PURE__ */ new Set(),
+      value: void 0
     };
-    runEffect(this);
+    this.state.effect = effect(() => {
+      if (this.state.dirty) {
+        const previousComputed = activeComputed;
+        activeComputed = this;
+        const value = callback();
+        activeComputed = previousComputed;
+        if (!Object.is(this.state.value, value)) {
+          this.state.value = value;
+          for (const comp of this.state.computeds) {
+            comp.state.dirty = true;
+            dirtyEffects.add(comp.state.effect);
+          }
+          for (const effect2 of this.state.effects) {
+            dirtyEffects.add(effect2);
+          }
+        }
+        this.state.dirty = false;
+      }
+    });
   }
   get() {
-    if (activeEffect != null && activeEffect !== this) {
-      this.effects.add(activeEffect);
+    if (activeComputed != null && activeComputed !== this) {
+      this.state.computeds.add(activeComputed);
+    }
+    if (activeEffect != null && activeEffect !== this.state.effect) {
+      this.state.effects.add(activeEffect);
     }
-    if (this.dirty) {
-      runEffect(this);
+    if (this.state.dirty) {
+      runEffect(this.state.effect);
     }
-    return this.value;
+    return this.state.value;
   }
 }
 function computed(callback) {
@@ -31,5 +52,6 @@ function computed(callback) {
 }
 export {
   Computed,
+  activeComputed,
   computed
 };

package/dist/effect.cjs

@@ -5,29 +5,25 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 exports.activeEffect = void 0;
 class Effect {
-  constructor() {
-    __publicField(this, "callback");
-    __publicField(this, "signals", /* @__PURE__ */ new Set());
+  constructor(callback) {
+    __publicField(this, "state");
+    this.state = {
+      callback
+    };
+    runEffect(this);
   }
 }
 function runEffect(effect2) {
-  for (const signal of effect2.signals) {
-    signal.state.observers.delete(effect2);
-  }
-  effect2.signals.clear();
   const previousEffect = exports.activeEffect;
   exports.activeEffect = effect2;
   try {
-    effect2.callback();
+    effect2.state.callback();
   } finally {
     exports.activeEffect = previousEffect;
   }
 }
 function effect(callback) {
-  const instance = new Effect();
-  instance.callback = callback;
-  runEffect(instance);
-  return instance;
+  return new Effect(callback);
 }
 exports.Effect = Effect;
 exports.effect = effect;

package/dist/effect.js

@@ -3,29 +3,25 @@ var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { en
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 let activeEffect;
 class Effect {
-  constructor() {
-    __publicField(this, "callback");
-    __publicField(this, "signals", /* @__PURE__ */ new Set());
+  constructor(callback) {
+    __publicField(this, "state");
+    this.state = {
+      callback
+    };
+    runEffect(this);
   }
 }
 function runEffect(effect2) {
-  for (const signal of effect2.signals) {
-    signal.state.observers.delete(effect2);
-  }
-  effect2.signals.clear();
   const previousEffect = activeEffect;
   activeEffect = effect2;
   try {
-    effect2.callback();
+    effect2.state.callback();
   } finally {
     activeEffect = previousEffect;
   }
 }
 function effect(callback) {
-  const instance = new Effect();
-  instance.callback = callback;
-  runEffect(instance);
-  return instance;
+  return new Effect(callback);
 }
 export {
   Effect,

package/dist/mora.iife.js

@@ -3,72 +3,44 @@ var Mora = (function (exports) {
 
     let activeEffect;
     class Effect {
-        callback;
-        signals = new Set();
+        state;
+        constructor(callback) {
+            this.state = {
+                callback,
+            };
+            runEffect(this);
+        }
     }
     function runEffect(effect) {
-        for (const signal of effect.signals) {
-            signal.state.observers.delete(effect);
-        }
-        effect.signals.clear();
         const previousEffect = activeEffect;
         activeEffect = effect;
         try {
-            effect.callback();
+            effect.state.callback();
         }
         finally {
             activeEffect = previousEffect;
         }
     }
     function effect(callback) {
-        const instance = new Effect();
-        instance.callback = callback;
-        runEffect(instance);
-        return instance;
-    }
-
-    class Computed extends Effect {
-        dirty = true;
-        effects = new Set();
-        value;
-        constructor(callback) {
-            super();
-            this.callback = () => {
-                if (this.dirty) {
-                    this.value = callback();
-                    this.dirty = false;
-                }
-            };
-            runEffect(this);
-        }
-        get() {
-            if (activeEffect != null && activeEffect !== this) {
-                this.effects.add(activeEffect);
-            }
-            if (this.dirty) {
-                runEffect(this);
-            }
-            return this.value;
-        }
-    }
-    function computed(callback) {
-        return new Computed(callback);
+        return new Effect(callback);
     }
 
     const dirtyEffects = new Set();
-    let batchDepth = 0;
     class Signal {
         state;
         constructor(value) {
             this.state = {
                 value,
-                observers: new Set(),
+                computeds: new Set(),
+                effects: new Set(),
             };
         }
         get() {
+            if (activeComputed != null) {
+                this.state.computeds.add(activeComputed);
+            }
             if (activeEffect != null) {
-                this.state.observers.add(activeEffect);
-                activeEffect.signals.add(this);
+                this.state.effects.add(activeEffect);
             }
             return this.state.value;
         }
@@ -77,38 +49,18 @@ var Mora = (function (exports) {
                 return;
             }
             this.state.value = value;
-            const isOutermostBatch = batchDepth === 0;
-            batchDepth += 1;
-            try {
-                for (const observer of this.state.observers) {
-                    if (observer instanceof Computed) {
-                        observer.dirty = true;
-                        dirtyEffects.add(observer);
-                        for (const effect of observer.effects) {
-                            dirtyEffects.add(effect);
-                        }
-                    }
-                    else {
-                        dirtyEffects.add(observer);
-                    }
-                }
-                if (isOutermostBatch) {
-                    queueMicrotask(() => {
-                        try {
-                            for (const effect of dirtyEffects) {
-                                runEffect(effect);
-                            }
-                        }
-                        finally {
-                            dirtyEffects.clear();
-                            batchDepth = 0;
-                        }
-                    });
-                }
+            for (const computed of this.state.computeds) {
+                computed.state.dirty = true;
+                dirtyEffects.add(computed.state.effect);
             }
-            finally {
-                if (isOutermostBatch) {
-                    batchDepth -= 1;
+            for (const effect of this.state.effects) {
+                dirtyEffects.add(effect);
+            }
+            while (dirtyEffects.size > 0) {
+                const effects = [...dirtyEffects];
+                dirtyEffects.clear();
+                for (const effect of effects) {
+                    runEffect(effect);
                 }
             }
         }
@@ -120,6 +72,54 @@ var Mora = (function (exports) {
         return new Signal(value);
     }
 
+    let activeComputed;
+    class Computed {
+        state;
+        constructor(callback) {
+            this.state = {
+                dirty: true,
+                computeds: new Set(),
+                effect: undefined,
+                effects: new Set(),
+                value: undefined,
+            };
+            this.state.effect = effect(() => {
+                if (this.state.dirty) {
+                    const previousComputed = activeComputed;
+                    activeComputed = this;
+                    const value = callback();
+                    activeComputed = previousComputed;
+                    if (!Object.is(this.state.value, value)) {
+                        this.state.value = value;
+                        for (const comp of this.state.computeds) {
+                            comp.state.dirty = true;
+                            dirtyEffects.add(comp.state.effect);
+                        }
+                        for (const effect of this.state.effects) {
+                            dirtyEffects.add(effect);
+                        }
+                    }
+                    this.state.dirty = false;
+                }
+            });
+        }
+        get() {
+            if (activeComputed != null && activeComputed !== this) {
+                this.state.computeds.add(activeComputed);
+            }
+            if (activeEffect != null && activeEffect !== this.state.effect) {
+                this.state.effects.add(activeEffect);
+            }
+            if (this.state.dirty) {
+                runEffect(this.state.effect);
+            }
+            return this.state.value;
+        }
+    }
+    function computed(callback) {
+        return new Computed(callback);
+    }
+
     exports.computed = computed;
     exports.effect = effect;
     exports.signal = signal;

package/dist/signal.cjs

@@ -6,19 +6,21 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const computed = require("./computed.cjs");
 const effect = require("./effect.cjs");
 const dirtyEffects = /* @__PURE__ */ new Set();
-let batchDepth = 0;
 class Signal {
   constructor(value) {
     __publicField(this, "state");
     this.state = {
       value,
-      observers: /* @__PURE__ */ new Set()
+      computeds: /* @__PURE__ */ new Set(),
+      effects: /* @__PURE__ */ new Set()
     };
   }
   get() {
+    if (computed.activeComputed != null) {
+      this.state.computeds.add(computed.activeComputed);
+    }
     if (effect.activeEffect != null) {
-      this.state.observers.add(effect.activeEffect);
-      effect.activeEffect.signals.add(this);
+      this.state.effects.add(effect.activeEffect);
     }
     return this.state.value;
   }
@@ -27,35 +29,18 @@ class Signal {
       return;
     }
     this.state.value = value;
-    const isOutermostBatch = batchDepth === 0;
-    batchDepth += 1;
-    try {
-      for (const observer of this.state.observers) {
-        if (observer instanceof computed.Computed) {
-          observer.dirty = true;
-          dirtyEffects.add(observer);
-          for (const effect2 of observer.effects) {
-            dirtyEffects.add(effect2);
-          }
-        } else {
-          dirtyEffects.add(observer);
-        }
-      }
-      if (isOutermostBatch) {
-        queueMicrotask(() => {
-          try {
-            for (const effect$1 of dirtyEffects) {
-              effect.runEffect(effect$1);
-            }
-          } finally {
-            dirtyEffects.clear();
-            batchDepth = 0;
-          }
-        });
-      }
-    } finally {
-      if (isOutermostBatch) {
-        batchDepth -= 1;
+    for (const computed2 of this.state.computeds) {
+      computed2.state.dirty = true;
+      dirtyEffects.add(computed2.state.effect);
+    }
+    for (const effect2 of this.state.effects) {
+      dirtyEffects.add(effect2);
+    }
+    while (dirtyEffects.size > 0) {
+      const effects = [...dirtyEffects];
+      dirtyEffects.clear();
+      for (const effect$1 of effects) {
+        effect.runEffect(effect$1);
       }
     }
   }
@@ -67,4 +52,5 @@ function signal(value) {
   return new Signal(value);
 }
 exports.Signal = Signal;
+exports.dirtyEffects = dirtyEffects;
 exports.signal = signal;

package/dist/signal.js

@@ -1,22 +1,24 @@
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-import { Computed } from "./computed.js";
+import { activeComputed } from "./computed.js";
 import { activeEffect, runEffect } from "./effect.js";
 const dirtyEffects = /* @__PURE__ */ new Set();
-let batchDepth = 0;
 class Signal {
   constructor(value) {
     __publicField(this, "state");
     this.state = {
       value,
-      observers: /* @__PURE__ */ new Set()
+      computeds: /* @__PURE__ */ new Set(),
+      effects: /* @__PURE__ */ new Set()
     };
   }
   get() {
+    if (activeComputed != null) {
+      this.state.computeds.add(activeComputed);
+    }
     if (activeEffect != null) {
-      this.state.observers.add(activeEffect);
-      activeEffect.signals.add(this);
+      this.state.effects.add(activeEffect);
     }
     return this.state.value;
   }
@@ -25,35 +27,18 @@ class Signal {
       return;
     }
     this.state.value = value;
-    const isOutermostBatch = batchDepth === 0;
-    batchDepth += 1;
-    try {
-      for (const observer of this.state.observers) {
-        if (observer instanceof Computed) {
-          observer.dirty = true;
-          dirtyEffects.add(observer);
-          for (const effect of observer.effects) {
-            dirtyEffects.add(effect);
-          }
-        } else {
-          dirtyEffects.add(observer);
-        }
-      }
-      if (isOutermostBatch) {
-        queueMicrotask(() => {
-          try {
-            for (const effect of dirtyEffects) {
-              runEffect(effect);
-            }
-          } finally {
-            dirtyEffects.clear();
-            batchDepth = 0;
-          }
-        });
-      }
-    } finally {
-      if (isOutermostBatch) {
-        batchDepth -= 1;
+    for (const computed of this.state.computeds) {
+      computed.state.dirty = true;
+      dirtyEffects.add(computed.state.effect);
+    }
+    for (const effect of this.state.effects) {
+      dirtyEffects.add(effect);
+    }
+    while (dirtyEffects.size > 0) {
+      const effects = [...dirtyEffects];
+      dirtyEffects.clear();
+      for (const effect of effects) {
+        runEffect(effect);
       }
     }
   }
@@ -66,5 +51,6 @@ function signal(value) {
 }
 export {
   Signal,
+  dirtyEffects,
   signal
 };

package/package.json

@@ -60,5 +60,5 @@
 	},
 	"type": "module",
 	"types": "./types/index.d.ts",
-	"version": "0.3.0"
+	"version": "0.4.0"
 }

package/src/computed.ts

@@ -1,33 +1,71 @@
-import {Effect, activeEffect, runEffect} from './effect';
+import {type Effect, activeEffect, effect, runEffect} from './effect';
+import {dirtyEffects} from './signal';
 
-export class Computed<Value> extends Effect {
-	dirty = true;
-	effects = new Set<Effect>();
-	value!: Value;
+type ComputedState<Value> = {
+	dirty: boolean;
+	computeds: Set<Computed<unknown>>;
+	effect: Effect;
+	effects: Set<Effect>;
+	value: Value;
+};
 
-	constructor(callback: () => Value) {
-		super();
+export let activeComputed: Computed<unknown> | undefined;
 
-		this.callback = () => {
-			if (this.dirty) {
-				this.value = callback();
-				this.dirty = false;
-			}
+export class Computed<Value> {
+	readonly state: ComputedState<Value>;
+
+	constructor(callback: () => Value) {
+		this.state = {
+			dirty: true,
+			computeds: new Set(),
+			effect: undefined as never,
+			effects: new Set(),
+			value: undefined as never,
 		};
 
-		runEffect(this);
+		this.state.effect = effect(() => {
+			if (this.state.dirty) {
+				const previousComputed = activeComputed;
+
+				activeComputed = this;
+
+				const value = callback();
+
+				activeComputed = previousComputed;
+
+				if (!Object.is(this.state.value, value)) {
+					this.state.value = value;
+
+					for (const comp of this.state.computeds) {
+						comp.state.dirty = true;
+
+						dirtyEffects.add(comp.state.effect);
+					}
+
+					for (const effect of this.state.effects) {
+						dirtyEffects.add(effect);
+					}
+				}
+
+				this.state.dirty = false;
+			}
+		});
 	}
 
 	get(): Value {
-		if (activeEffect != null && activeEffect !== this) {
-			this.effects.add(activeEffect);
+		if (activeComputed != null && activeComputed !== this) {
+			this.state.computeds.add(activeComputed);
+		}
+
+		if (activeEffect != null && activeEffect !== this.state.effect) {
+			this.state.effects.add(activeEffect);
 		}
 
-		if (this.dirty) {
-			runEffect(this);
+		if (this.state.dirty) {
+			runEffect(this.state.effect);
 		}
 
-		return this.value;
+		return this.state.value;
 	}
 }
 

package/src/effect.ts

@@ -1,38 +1,35 @@
 import type {GenericCallback} from '@oscarpalmer/atoms/models';
-import type {Signal} from './signal';
+
+type EffectState = {
+	callback: GenericCallback;
+};
 
 export let activeEffect: Effect | undefined;
 
 export class Effect {
-		callback!: GenericCallback;
-		signals = new Set<Signal<unknown>>();
-	}
+	readonly state: EffectState;
 
-export function runEffect(effect: Effect): void {
-	for (const signal of effect.signals) {
-		signal.state.observers.delete(effect);
-	}
+	constructor(callback: GenericCallback) {
+		this.state = {
+			callback,
+		};
 
-	effect.signals.clear();
+		runEffect(this);
+	}
+}
 
+export function runEffect(effect: Effect): void {
 	const previousEffect = activeEffect;
 
 	activeEffect = effect;
 
 	try {
-		effect.callback();
+		effect.state.callback();
 	} finally {
 		activeEffect = previousEffect;
 	}
 }
 
 export function effect(callback: GenericCallback): Effect {
-	const instance = new Effect();
-
-	instance.callback = callback;
-
-	runEffect(instance);
-
-	return instance;
+	return new Effect(callback);
 }
-

package/src/signal.ts

@@ -1,14 +1,13 @@
-import {Computed} from './computed';
+import {type Computed, activeComputed} from './computed';
 import {type Effect, activeEffect, runEffect} from './effect';
 
 type SignalState<Value> = {
-	observers: Set<Computed<never> | Effect>;
+	computeds: Set<Computed<unknown>>;
+	effects: Set<Effect>;
 	value: Value;
 };
 
-const dirtyEffects = new Set<Effect>();
-
-let batchDepth = 0;
+export const dirtyEffects = new Set<Effect>();
 
 export class Signal<Value> {
 	readonly state: SignalState<Value>;
@@ -16,14 +15,18 @@ export class Signal<Value> {
 	constructor(value: Value) {
 		this.state = {
 			value,
-			observers: new Set(),
+			computeds: new Set(),
+			effects: new Set(),
 		};
 	}
 
 	get(): Value {
+		if (activeComputed != null) {
+			this.state.computeds.add(activeComputed);
+		}
+
 		if (activeEffect != null) {
-			this.state.observers.add(activeEffect);
-			activeEffect.signals.add(this as never);
+			this.state.effects.add(activeEffect);
 		}
 
 		return this.state.value;
@@ -36,41 +39,23 @@ export class Signal<Value> {
 
 		this.state.value = value;
 
-		const isOutermostBatch = batchDepth === 0;
+		for (const computed of this.state.computeds) {
+			computed.state.dirty = true;
 
-		batchDepth += 1;
+			dirtyEffects.add(computed.state.effect);
+		}
 
-		try {
-			for (const observer of this.state.observers) {
-				if (observer instanceof Computed) {
-					observer.dirty = true;
+		for (const effect of this.state.effects) {
+			dirtyEffects.add(effect);
+		}
 
-					dirtyEffects.add(observer);
+		while (dirtyEffects.size > 0) {
+			const effects = [...dirtyEffects];
 
-					for (const effect of observer.effects) {
-						dirtyEffects.add(effect);
-					}
-				} else {
-					dirtyEffects.add(observer);
-				}
-			}
+			dirtyEffects.clear();
 
-			if (isOutermostBatch) {
-				queueMicrotask(() => {
-					try {
-						for (const effect of dirtyEffects) {
-							runEffect(effect);
-						}
-					} finally {
-						dirtyEffects.clear();
-
-						batchDepth = 0;
-					}
-				});
-			}
-		} finally {
-			if (isOutermostBatch) {
-				batchDepth -= 1;
+			for (const effect of effects) {
+				runEffect(effect);
 			}
 		}
 	}

package/types/computed.d.cts

@@ -1,28 +1,26 @@
 // Generated by dts-bundle-generator v9.5.1
 
 export type GenericCallback = (...args: any[]) => any;
-declare class Effect {
+export type EffectState = {
 	callback: GenericCallback;
-	signals: Set<Signal<unknown>>;
+};
+declare class Effect {
+	readonly state: EffectState;
+	constructor(callback: GenericCallback);
 }
-export declare class Computed<Value> extends Effect {
+export type ComputedState<Value> = {
 	dirty: boolean;
+	computeds: Set<Computed<unknown>>;
+	effect: Effect;
 	effects: Set<Effect>;
 	value: Value;
+};
+export declare let activeComputed: Computed<unknown> | undefined;
+export declare class Computed<Value> {
+	readonly state: ComputedState<Value>;
 	constructor(callback: () => Value);
 	get(): Value;
 }
 export declare function computed<Value>(callback: () => Value): Computed<Value>;
-export type SignalState<Value> = {
-	observers: Set<Computed<never> | Effect>;
-	value: Value;
-};
-declare class Signal<Value> {
-	readonly state: SignalState<Value>;
-	constructor(value: Value);
-	get(): Value;
-	set(value: Value): void;
-	update(callback: (value: Value) => Value): void;
-}
 
 export {};

package/types/computed.d.ts

@@ -1,9 +1,16 @@
-import { Effect } from './effect';
-export declare class Computed<Value> extends Effect {
+import { type Effect } from './effect';
+type ComputedState<Value> = {
     dirty: boolean;
+    computeds: Set<Computed<unknown>>;
+    effect: Effect;
     effects: Set<Effect>;
     value: Value;
+};
+export declare let activeComputed: Computed<unknown> | undefined;
+export declare class Computed<Value> {
+    readonly state: ComputedState<Value>;
     constructor(callback: () => Value);
     get(): Value;
 }
 export declare function computed<Value>(callback: () => Value): Computed<Value>;
+export {};

package/types/effect.d.cts

@@ -1,30 +1,15 @@
 // Generated by dts-bundle-generator v9.5.1
 
 export type GenericCallback = (...args: any[]) => any;
+export type EffectState = {
+	callback: GenericCallback;
+};
 export declare let activeEffect: Effect | undefined;
 export declare class Effect {
-	callback: GenericCallback;
-	signals: Set<Signal<unknown>>;
+	readonly state: EffectState;
+	constructor(callback: GenericCallback);
 }
 export declare function runEffect(effect: Effect): void;
 export declare function effect(callback: GenericCallback): Effect;
-declare class Computed<Value> extends Effect {
-	dirty: boolean;
-	effects: Set<Effect>;
-	value: Value;
-	constructor(callback: () => Value);
-	get(): Value;
-}
-export type SignalState<Value> = {
-	observers: Set<Computed<never> | Effect>;
-	value: Value;
-};
-declare class Signal<Value> {
-	readonly state: SignalState<Value>;
-	constructor(value: Value);
-	get(): Value;
-	set(value: Value): void;
-	update(callback: (value: Value) => Value): void;
-}
 
 export {};

package/types/effect.d.ts

@@ -1,9 +1,12 @@
 import type { GenericCallback } from '@oscarpalmer/atoms/models';
-import type { Signal } from './signal';
+type EffectState = {
+    callback: GenericCallback;
+};
 export declare let activeEffect: Effect | undefined;
 export declare class Effect {
-    callback: GenericCallback;
-    signals: Set<Signal<unknown>>;
+    readonly state: EffectState;
+    constructor(callback: GenericCallback);
 }
 export declare function runEffect(effect: Effect): void;
 export declare function effect(callback: GenericCallback): Effect;
+export {};

package/types/index.d.cts

@@ -1,21 +1,30 @@
 // Generated by dts-bundle-generator v9.5.1
 
 export type GenericCallback = (...args: any[]) => any;
-export declare class Effect {
+export type EffectState = {
 	callback: GenericCallback;
-	signals: Set<Signal<unknown>>;
+};
+export declare class Effect {
+	readonly state: EffectState;
+	constructor(callback: GenericCallback);
 }
 export declare function effect(callback: GenericCallback): Effect;
-export declare class Computed<Value> extends Effect {
+export type ComputedState<Value> = {
 	dirty: boolean;
+	computeds: Set<Computed<unknown>>;
+	effect: Effect;
 	effects: Set<Effect>;
 	value: Value;
+};
+export declare class Computed<Value> {
+	readonly state: ComputedState<Value>;
 	constructor(callback: () => Value);
 	get(): Value;
 }
 export declare function computed<Value>(callback: () => Value): Computed<Value>;
 export type SignalState<Value> = {
-	observers: Set<Computed<never> | Effect>;
+	computeds: Set<Computed<unknown>>;
+	effects: Set<Effect>;
 	value: Value;
 };
 export declare class Signal<Value> {

package/types/signal.d.cts

@@ -1,21 +1,31 @@
 // Generated by dts-bundle-generator v9.5.1
 
 export type GenericCallback = (...args: any[]) => any;
-declare class Effect {
+export type EffectState = {
 	callback: GenericCallback;
-	signals: Set<Signal<unknown>>;
+};
+declare class Effect {
+	readonly state: EffectState;
+	constructor(callback: GenericCallback);
 }
-declare class Computed<Value> extends Effect {
+export type ComputedState<Value> = {
 	dirty: boolean;
+	computeds: Set<Computed<unknown>>;
+	effect: Effect;
 	effects: Set<Effect>;
 	value: Value;
+};
+declare class Computed<Value> {
+	readonly state: ComputedState<Value>;
 	constructor(callback: () => Value);
 	get(): Value;
 }
 export type SignalState<Value> = {
-	observers: Set<Computed<never> | Effect>;
+	computeds: Set<Computed<unknown>>;
+	effects: Set<Effect>;
 	value: Value;
 };
+export declare const dirtyEffects: Set<Effect>;
 export declare class Signal<Value> {
 	readonly state: SignalState<Value>;
 	constructor(value: Value);

package/types/signal.d.ts

@@ -1,9 +1,11 @@
-import { Computed } from './computed';
+import { type Computed } from './computed';
 import { type Effect } from './effect';
 type SignalState<Value> = {
-    observers: Set<Computed<never> | Effect>;
+    computeds: Set<Computed<unknown>>;
+    effects: Set<Effect>;
     value: Value;
 };
+export declare const dirtyEffects: Set<Effect>;
 export declare class Signal<Value> {
     readonly state: SignalState<Value>;
     constructor(value: Value);