@oscarpalmer/mora 0.2.0 → 0.3.0

package/dist/computed.cjs

@@ -0,0 +1,35 @@
+"use strict";
+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);
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const effect = require("./effect.cjs");
+class Computed extends effect.Effect {
+  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;
+      }
+    };
+    effect.runEffect(this);
+  }
+  get() {
+    if (effect.activeEffect != null && effect.activeEffect !== this) {
+      this.effects.add(effect.activeEffect);
+    }
+    if (this.dirty) {
+      effect.runEffect(this);
+    }
+    return this.value;
+  }
+}
+function computed(callback) {
+  return new Computed(callback);
+}
+exports.Computed = Computed;
+exports.computed = computed;

package/dist/computed.js

@@ -0,0 +1,35 @@
+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 {
+  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;
+      }
+    };
+    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);
+}
+export {
+  Computed,
+  computed
+};

package/dist/effect.cjs

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

package/dist/effect.js

@@ -3,30 +3,29 @@ 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(callback) {
-    __publicField(this, "state");
-    this.state = {
-      callback,
-      signals: /* @__PURE__ */ new Set()
-    };
-    runEffect(this);
+  constructor() {
+    __publicField(this, "callback");
+    __publicField(this, "signals", /* @__PURE__ */ new Set());
   }
 }
 function runEffect(effect2) {
-  for (const signal of effect2.state.signals) {
-    signal.state.effects.delete(effect2);
+  for (const signal of effect2.signals) {
+    signal.state.observers.delete(effect2);
   }
-  effect2.state.signals.clear();
+  effect2.signals.clear();
   const previousEffect = activeEffect;
   activeEffect = effect2;
   try {
-    effect2.state.callback();
+    effect2.callback();
   } finally {
     activeEffect = previousEffect;
   }
 }
 function effect(callback) {
-  return new Effect(callback);
+  const instance = new Effect();
+  instance.callback = callback;
+  runEffect(instance);
+  return instance;
 }
 export {
   Effect,

package/dist/index.cjs

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const computed = require("./computed.cjs");
 const effect = require("./effect.cjs");
 const signal = require("./signal.cjs");
+exports.computed = computed.computed;
 exports.effect = effect.effect;
 exports.signal = signal.signal;

package/dist/index.js

@@ -1,6 +1,8 @@
+import { computed } from "./computed.js";
 import { effect } from "./effect.js";
 import { signal } from "./signal.js";
 export {
+  computed,
   effect,
   signal
 };

package/dist/mora.iife.js

@@ -3,31 +3,56 @@ var Mora = (function (exports) {
 
     let activeEffect;
     class Effect {
-        state;
-        constructor(callback) {
-            this.state = {
-                callback,
-                signals: new Set(),
-            };
-            runEffect(this);
-        }
+        callback;
+        signals = new Set();
     }
     function runEffect(effect) {
-        for (const signal of effect.state.signals) {
-            signal.state.effects.delete(effect);
+        for (const signal of effect.signals) {
+            signal.state.observers.delete(effect);
         }
-        effect.state.signals.clear();
+        effect.signals.clear();
         const previousEffect = activeEffect;
         activeEffect = effect;
         try {
-            effect.state.callback();
+            effect.callback();
         }
         finally {
             activeEffect = previousEffect;
         }
     }
     function effect(callback) {
-        return new 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);
     }
 
     const dirtyEffects = new Set();
@@ -37,13 +62,13 @@ var Mora = (function (exports) {
         constructor(value) {
             this.state = {
                 value,
-                effects: new Set(),
+                observers: new Set(),
             };
         }
         get() {
             if (activeEffect != null) {
-                this.state.effects.add(activeEffect);
-                activeEffect.state.signals.add(this);
+                this.state.observers.add(activeEffect);
+                activeEffect.signals.add(this);
             }
             return this.state.value;
         }
@@ -55,8 +80,17 @@ var Mora = (function (exports) {
             const isOutermostBatch = batchDepth === 0;
             batchDepth += 1;
             try {
-                for (const effect of this.state.effects) {
-                    dirtyEffects.add(effect);
+                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(() => {
@@ -86,6 +120,7 @@ var Mora = (function (exports) {
         return new Signal(value);
     }
 
+    exports.computed = computed;
     exports.effect = effect;
     exports.signal = signal;
 

package/dist/signal.cjs

@@ -3,6 +3,7 @@ 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);
 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;
@@ -11,13 +12,13 @@ class Signal {
     __publicField(this, "state");
     this.state = {
       value,
-      effects: /* @__PURE__ */ new Set()
+      observers: /* @__PURE__ */ new Set()
     };
   }
   get() {
     if (effect.activeEffect != null) {
-      this.state.effects.add(effect.activeEffect);
-      effect.activeEffect.state.signals.add(this);
+      this.state.observers.add(effect.activeEffect);
+      effect.activeEffect.signals.add(this);
     }
     return this.state.value;
   }
@@ -29,8 +30,16 @@ class Signal {
     const isOutermostBatch = batchDepth === 0;
     batchDepth += 1;
     try {
-      for (const effect2 of this.state.effects) {
-        dirtyEffects.add(effect2);
+      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(() => {

package/dist/signal.js

@@ -1,6 +1,7 @@
 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 { activeEffect, runEffect } from "./effect.js";
 const dirtyEffects = /* @__PURE__ */ new Set();
 let batchDepth = 0;
@@ -9,13 +10,13 @@ class Signal {
     __publicField(this, "state");
     this.state = {
       value,
-      effects: /* @__PURE__ */ new Set()
+      observers: /* @__PURE__ */ new Set()
     };
   }
   get() {
     if (activeEffect != null) {
-      this.state.effects.add(activeEffect);
-      activeEffect.state.signals.add(this);
+      this.state.observers.add(activeEffect);
+      activeEffect.signals.add(this);
     }
     return this.state.value;
   }
@@ -27,8 +28,16 @@ class Signal {
     const isOutermostBatch = batchDepth === 0;
     batchDepth += 1;
     try {
-      for (const effect of this.state.effects) {
-        dirtyEffects.add(effect);
+      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(() => {

package/package.json

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

package/src/computed.ts

@@ -0,0 +1,36 @@
+import {Effect, activeEffect, runEffect} from './effect';
+
+export class Computed<Value> extends Effect {
+	dirty = true;
+	effects = new Set<Effect>();
+	value!: Value;
+
+	constructor(callback: () => Value) {
+		super();
+
+		this.callback = () => {
+			if (this.dirty) {
+				this.value = callback();
+				this.dirty = false;
+			}
+		};
+
+		runEffect(this);
+	}
+
+	get(): Value {
+		if (activeEffect != null && activeEffect !== this) {
+			this.effects.add(activeEffect);
+		}
+
+		if (this.dirty) {
+			runEffect(this);
+		}
+
+		return this.value;
+	}
+}
+
+export function computed<Value>(callback: () => Value): Computed<Value> {
+	return new Computed(callback);
+}

package/src/effect.ts

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

package/src/index.ts

@@ -1,2 +1,3 @@
+export {computed, type Computed} from './computed';
 export {effect, type Effect} from './effect';
 export {signal, type Signal} from './signal';

package/src/signal.ts

@@ -1,7 +1,8 @@
+import {Computed} from './computed';
 import {type Effect, activeEffect, runEffect} from './effect';
 
 type SignalState<Value> = {
-	effects: Set<Effect>;
+	observers: Set<Computed<never> | Effect>;
 	value: Value;
 };
 
@@ -15,14 +16,14 @@ export class Signal<Value> {
 	constructor(value: Value) {
 		this.state = {
 			value,
-			effects: new Set(),
+			observers: new Set(),
 		};
 	}
 
 	get(): Value {
 		if (activeEffect != null) {
-			this.state.effects.add(activeEffect);
-			activeEffect.state.signals.add(this as never);
+			this.state.observers.add(activeEffect);
+			activeEffect.signals.add(this as never);
 		}
 
 		return this.state.value;
@@ -40,8 +41,18 @@ export class Signal<Value> {
 		batchDepth += 1;
 
 		try {
-			for (const effect of this.state.effects) {
-				dirtyEffects.add(effect);
+			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) {

package/types/computed.d.cts

@@ -0,0 +1,28 @@
+// Generated by dts-bundle-generator v9.5.1
+
+export type GenericCallback = (...args: any[]) => any;
+declare class Effect {
+	callback: GenericCallback;
+	signals: Set<Signal<unknown>>;
+}
+export declare class Computed<Value> extends Effect {
+	dirty: boolean;
+	effects: Set<Effect>;
+	value: 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

@@ -0,0 +1,9 @@
+import { Effect } from './effect';
+export declare class Computed<Value> extends Effect {
+    dirty: boolean;
+    effects: Set<Effect>;
+    value: Value;
+    constructor(callback: () => Value);
+    get(): Value;
+}
+export declare function computed<Value>(callback: () => Value): Computed<Value>;

package/types/effect.d.cts

@@ -1,20 +1,23 @@
 // Generated by dts-bundle-generator v9.5.1
 
 export type GenericCallback = (...args: any[]) => any;
-export type EffectState = {
-	callback: GenericCallback;
-	signals: Set<Signal<never>>;
-};
 export declare let activeEffect: Effect | undefined;
 export declare class Effect {
-	readonly state: EffectState;
-	constructor(callback: GenericCallback);
+	callback: GenericCallback;
+	signals: Set<Signal<unknown>>;
 }
 export declare function runEffect(effect: Effect): void;
 export declare function effect(callback: GenericCallback): Effect;
-export type SignalState<Value> = {
+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>;

package/types/effect.d.ts

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

package/types/index.d.cts

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

package/types/index.d.ts

@@ -1,2 +1,3 @@
+export { computed, type Computed } from './computed';
 export { effect, type Effect } from './effect';
 export { signal, type Signal } from './signal';

package/types/signal.d.cts

@@ -1,17 +1,20 @@
 // Generated by dts-bundle-generator v9.5.1
 
 export type GenericCallback = (...args: any[]) => any;
-export type EffectState = {
-	callback: GenericCallback;
-	signals: Set<Signal<never>>;
-};
 declare class Effect {
-	readonly state: EffectState;
-	constructor(callback: GenericCallback);
+	callback: GenericCallback;
+	signals: Set<Signal<unknown>>;
 }
-export type SignalState<Value> = {
+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;
 };
 export declare class Signal<Value> {
 	readonly state: SignalState<Value>;

package/types/signal.d.ts

@@ -1,6 +1,7 @@
+import { Computed } from './computed';
 import { type Effect } from './effect';
 type SignalState<Value> = {
-    effects: Set<Effect>;
+    observers: Set<Computed<never> | Effect>;
     value: Value;
 };
 export declare class Signal<Value> {