@oscarpalmer/mora 0.1.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

@@ -0,0 +1,34 @@
+"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" });
+exports.activeEffect = void 0;
+class Effect {
+  constructor() {
+    __publicField(this, "callback");
+    __publicField(this, "signals", /* @__PURE__ */ new Set());
+  }
+}
+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();
+  } finally {
+    exports.activeEffect = previousEffect;
+  }
+}
+function effect(callback) {
+  const instance = new Effect();
+  instance.callback = callback;
+  runEffect(instance);
+  return instance;
+}
+exports.Effect = Effect;
+exports.effect = effect;
+exports.runEffect = runEffect;

package/dist/effect.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);
+let activeEffect;
+class Effect {
+  constructor() {
+    __publicField(this, "callback");
+    __publicField(this, "signals", /* @__PURE__ */ new Set());
+  }
+}
+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();
+  } finally {
+    activeEffect = previousEffect;
+  }
+}
+function effect(callback) {
+  const instance = new Effect();
+  instance.callback = callback;
+  runEffect(instance);
+  return instance;
+}
+export {
+  Effect,
+  activeEffect,
+  effect,
+  runEffect
+};

package/dist/index.cjs

@@ -1 +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 +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

@@ -1,6 +1,129 @@
-(function () {
-	'use strict';
+var Mora = (function (exports) {
+    'use strict';
 
+    let activeEffect;
+    class Effect {
+        callback;
+        signals = new Set();
+    }
+    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();
+        }
+        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);
+    }
 
-})();
+    const dirtyEffects = new Set();
+    let batchDepth = 0;
+    class Signal {
+        state;
+        constructor(value) {
+            this.state = {
+                value,
+                observers: new Set(),
+            };
+        }
+        get() {
+            if (activeEffect != null) {
+                this.state.observers.add(activeEffect);
+                activeEffect.signals.add(this);
+            }
+            return this.state.value;
+        }
+        set(value) {
+            if (Object.is(this.state.value, value)) {
+                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;
+                }
+            }
+        }
+        update(callback) {
+            this.set(callback(this.state.value));
+        }
+    }
+    function signal(value) {
+        return new Signal(value);
+    }
+
+    exports.computed = computed;
+    exports.effect = effect;
+    exports.signal = signal;
+
+    return exports;
+
+})({});

package/dist/signal.cjs

@@ -0,0 +1,70 @@
+"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 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()
+    };
+  }
+  get() {
+    if (effect.activeEffect != null) {
+      this.state.observers.add(effect.activeEffect);
+      effect.activeEffect.signals.add(this);
+    }
+    return this.state.value;
+  }
+  set(value) {
+    if (Object.is(this.state.value, value)) {
+      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;
+      }
+    }
+  }
+  update(callback) {
+    this.set(callback(this.state.value));
+  }
+}
+function signal(value) {
+  return new Signal(value);
+}
+exports.Signal = Signal;
+exports.signal = signal;

package/dist/signal.js

@@ -0,0 +1,70 @@
+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;
+class Signal {
+  constructor(value) {
+    __publicField(this, "state");
+    this.state = {
+      value,
+      observers: /* @__PURE__ */ new Set()
+    };
+  }
+  get() {
+    if (activeEffect != null) {
+      this.state.observers.add(activeEffect);
+      activeEffect.signals.add(this);
+    }
+    return this.state.value;
+  }
+  set(value) {
+    if (Object.is(this.state.value, value)) {
+      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;
+      }
+    }
+  }
+  update(callback) {
+    this.set(callback(this.state.value));
+  }
+}
+function signal(value) {
+  return new Signal(value);
+}
+export {
+  Signal,
+  signal
+};

package/package.json

@@ -6,13 +6,14 @@
 	"description": "Signals and stuff…",
 	"devDependencies": {
 		"@biomejs/biome": "^1.9",
+		"@oscarpalmer/atoms": "^0.82",
 		"@rollup/plugin-node-resolve": "^16",
 		"@rollup/plugin-typescript": "^12.1",
-		"@types/node": "^22.10",
+		"@types/node": "^22.13",
 		"@vitest/coverage-istanbul": "^3",
 		"dts-bundle-generator": "^9.5",
 		"glob": "^11",
-		"happy-dom": "^16.6",
+		"happy-dom": "^17",
 		"tslib": "^2.8",
 		"typescript": "^5.7",
 		"vite": "^6",
@@ -25,7 +26,7 @@
 				"default": "./dist/index.js"
 			},
 			"require": {
-				"types": "./types/index.d.ts",
+				"types": "./types/index.d.cts",
 				"default": "./dist/index.cjs"
 			}
 		}
@@ -59,5 +60,5 @@
 	},
 	"type": "module",
 	"types": "./types/index.d.ts",
-	"version": "0.1.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

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

package/src/index.ts

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

package/src/signal.ts

@@ -0,0 +1,85 @@
+import {Computed} from './computed';
+import {type Effect, activeEffect, runEffect} from './effect';
+
+type SignalState<Value> = {
+	observers: Set<Computed<never> | Effect>;
+	value: Value;
+};
+
+const dirtyEffects = new Set<Effect>();
+
+let batchDepth = 0;
+
+export class Signal<Value> {
+	readonly state: SignalState<Value>;
+
+	constructor(value: Value) {
+		this.state = {
+			value,
+			observers: new Set(),
+		};
+	}
+
+	get(): Value {
+		if (activeEffect != null) {
+			this.state.observers.add(activeEffect);
+			activeEffect.signals.add(this as never);
+		}
+
+		return this.state.value;
+	}
+
+	set(value: Value): void {
+		if (Object.is(this.state.value, value)) {
+			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;
+			}
+		}
+	}
+
+	update(callback: (value: Value) => Value): void {
+		this.set(callback(this.state.value));
+	}
+}
+
+export function signal<Value>(value: Value): Signal<Value> {
+	return new Signal(value);
+}

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

@@ -0,0 +1,30 @@
+// Generated by dts-bundle-generator v9.5.1
+
+export type GenericCallback = (...args: any[]) => any;
+export declare let activeEffect: Effect | undefined;
+export declare class Effect {
+	callback: GenericCallback;
+	signals: Set<Signal<unknown>>;
+}
+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

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

package/types/index.d.cts

@@ -1,3 +1,30 @@
 // Generated by dts-bundle-generator v9.5.1
 
+export type GenericCallback = (...args: any[]) => any;
+export declare class Effect {
+	callback: GenericCallback;
+	signals: Set<Signal<unknown>>;
+}
+export declare function effect(callback: GenericCallback): 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>;
+export type SignalState<Value> = {
+	observers: Set<Computed<never> | Effect>;
+	value: Value;
+};
+export declare class Signal<Value> {
+	readonly state: SignalState<Value>;
+	constructor(value: Value);
+	get(): Value;
+	set(value: Value): void;
+	update(callback: (value: Value) => Value): void;
+}
+export declare function signal<Value>(value: Value): Signal<Value>;
+
 export {};

package/types/index.d.ts

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

package/types/signal.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>>;
+}
+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>;
+	constructor(value: Value);
+	get(): Value;
+	set(value: Value): void;
+	update(callback: (value: Value) => Value): void;
+}
+export declare function signal<Value>(value: Value): Signal<Value>;
+
+export {};

package/types/signal.d.ts

@@ -0,0 +1,15 @@
+import { Computed } from './computed';
+import { type Effect } from './effect';
+type SignalState<Value> = {
+    observers: Set<Computed<never> | Effect>;
+    value: Value;
+};
+export declare class Signal<Value> {
+    readonly state: SignalState<Value>;
+    constructor(value: Value);
+    get(): Value;
+    set(value: Value): void;
+    update(callback: (value: Value) => Value): void;
+}
+export declare function signal<Value>(value: Value): Signal<Value>;
+export {};