@oscarpalmer/mora 0.1.0 → 0.2.0

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

package/dist/effect.js

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

package/dist/index.cjs

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

package/dist/index.js

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

package/dist/mora.iife.js

@@ -1,6 +1,94 @@
-(function () {
-	'use strict';
+var Mora = (function (exports) {
+    'use strict';
 
+    let activeEffect;
+    class Effect {
+        state;
+        constructor(callback) {
+            this.state = {
+                callback,
+                signals: new Set(),
+            };
+            runEffect(this);
+        }
+    }
+    function runEffect(effect) {
+        for (const signal of effect.state.signals) {
+            signal.state.effects.delete(effect);
+        }
+        effect.state.signals.clear();
+        const previousEffect = activeEffect;
+        activeEffect = effect;
+        try {
+            effect.state.callback();
+        }
+        finally {
+            activeEffect = previousEffect;
+        }
+    }
+    function effect(callback) {
+        return new Effect(callback);
+    }
 
+    const dirtyEffects = new Set();
+    let batchDepth = 0;
+    class Signal {
+        state;
+        constructor(value) {
+            this.state = {
+                value,
+                effects: new Set(),
+            };
+        }
+        get() {
+            if (activeEffect != null) {
+                this.state.effects.add(activeEffect);
+                activeEffect.state.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 effect of this.state.effects) {
+                    dirtyEffects.add(effect);
+                }
+                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.effect = effect;
+    exports.signal = signal;
+
+    return exports;
+
+})({});

package/dist/signal.cjs

@@ -0,0 +1,61 @@
+"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");
+const dirtyEffects = /* @__PURE__ */ new Set();
+let batchDepth = 0;
+class Signal {
+  constructor(value) {
+    __publicField(this, "state");
+    this.state = {
+      value,
+      effects: /* @__PURE__ */ new Set()
+    };
+  }
+  get() {
+    if (effect.activeEffect != null) {
+      this.state.effects.add(effect.activeEffect);
+      effect.activeEffect.state.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 effect2 of this.state.effects) {
+        dirtyEffects.add(effect2);
+      }
+      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,61 @@
+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 { activeEffect, runEffect } from "./effect.js";
+const dirtyEffects = /* @__PURE__ */ new Set();
+let batchDepth = 0;
+class Signal {
+  constructor(value) {
+    __publicField(this, "state");
+    this.state = {
+      value,
+      effects: /* @__PURE__ */ new Set()
+    };
+  }
+  get() {
+    if (activeEffect != null) {
+      this.state.effects.add(activeEffect);
+      activeEffect.state.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 effect of this.state.effects) {
+        dirtyEffects.add(effect);
+      }
+      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.2.0"
 }

package/src/effect.ts

@@ -0,0 +1,45 @@
+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);
+	}
+}
+
+export function runEffect(effect: Effect): void {
+	for (const signal of effect.state.signals) {
+		signal.state.effects.delete(effect);
+	}
+
+	effect.state.signals.clear();
+
+	const previousEffect = activeEffect;
+
+	activeEffect = effect;
+
+	try {
+		effect.state.callback();
+	} finally {
+		activeEffect = previousEffect;
+	}
+}
+
+export function effect(callback: GenericCallback): Effect {
+	return new Effect(callback);
+}
+

package/src/index.ts

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

package/src/signal.ts

@@ -0,0 +1,74 @@
+import {type Effect, activeEffect, runEffect} from './effect';
+
+type SignalState<Value> = {
+	effects: Set<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,
+			effects: new Set(),
+		};
+	}
+
+	get(): Value {
+		if (activeEffect != null) {
+			this.state.effects.add(activeEffect);
+			activeEffect.state.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 effect of this.state.effects) {
+				dirtyEffects.add(effect);
+			}
+
+			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/effect.d.cts

@@ -0,0 +1,27 @@
+// 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);
+}
+export declare function runEffect(effect: Effect): void;
+export declare function effect(callback: GenericCallback): Effect;
+export type SignalState<Value> = {
+	effects: Set<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,14 @@
+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);
+}
+export declare function runEffect(effect: Effect): void;
+export declare function effect(callback: GenericCallback): Effect;
+export {};

package/types/index.d.cts

@@ -1,3 +1,26 @@
 // 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);
+}
+export declare function effect(callback: GenericCallback): Effect;
+export type SignalState<Value> = {
+	effects: Set<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,2 @@
-export {};
+export { effect, type Effect } from './effect';
+export { signal, type Signal } from './signal';

package/types/signal.d.cts

@@ -0,0 +1,25 @@
+// 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);
+}
+export type SignalState<Value> = {
+	effects: Set<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,14 @@
+import { type Effect } from './effect';
+type SignalState<Value> = {
+    effects: Set<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 {};