@oscarpalmer/mora 0.8.0 → 0.9.0

package/dist/computed.cjs

@@ -9,6 +9,9 @@ exports.activeComputed = void 0;
 class Computed {
   constructor(callback) {
     __publicField(this, "state");
+    Object.defineProperty(this, "$mora", {
+      value: "computed"
+    });
     this.state = {
       computeds: /* @__PURE__ */ new Set(),
       dirty: true,

package/dist/computed.js

@@ -7,6 +7,9 @@ let activeComputed;
 class Computed {
   constructor(callback) {
     __publicField(this, "state");
+    Object.defineProperty(this, "$mora", {
+      value: "computed"
+    });
     this.state = {
       computeds: /* @__PURE__ */ new Set(),
       dirty: true,

package/dist/effect.cjs

@@ -2,6 +2,9 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 class Effect {
   constructor(callback) {
+    Object.defineProperty(this, "$mora", {
+      value: "effect"
+    });
     this.state = {
       callback
     };

package/dist/effect.js

@@ -1,5 +1,8 @@
 class Effect {
   constructor(callback) {
+    Object.defineProperty(this, "$mora", {
+      value: "effect"
+    });
     this.state = {
       callback
     };

package/dist/index.cjs

@@ -3,9 +3,13 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const batch = require("./batch.cjs");
 const computed = require("./computed.cjs");
 const effect = require("./effect.cjs");
+const is = require("./is.cjs");
 const signal = require("./signal.cjs");
 exports.startBatch = batch.startBatch;
 exports.stopBatch = batch.stopBatch;
 exports.computed = computed.computed;
 exports.effect = effect.effect;
+exports.isComputed = is.isComputed;
+exports.isEffect = is.isEffect;
+exports.isSignal = is.isSignal;
 exports.signal = signal.signal;

package/dist/index.js

@@ -1,10 +1,14 @@
 import { startBatch, stopBatch } from "./batch.js";
 import { computed } from "./computed.js";
 import { effect } from "./effect.js";
+import { isComputed, isEffect, isSignal } from "./is.js";
 import { signal } from "./signal.js";
 export {
   computed,
   effect,
+  isComputed,
+  isEffect,
+  isSignal,
   signal,
   startBatch,
   stopBatch

package/dist/is.cjs

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function isComputed(value) {
+  return isMora(value, "computed");
+}
+function isEffect(value) {
+  return isMora(value, "effect");
+}
+function isMora(value, name) {
+  return typeof value === "object" && value != null && "$mora" in value && value.$mora === name;
+}
+function isSignal(value) {
+  return isMora(value, "signal");
+}
+exports.isComputed = isComputed;
+exports.isEffect = isEffect;
+exports.isSignal = isSignal;

package/dist/is.js

@@ -0,0 +1,17 @@
+function isComputed(value) {
+  return isMora(value, "computed");
+}
+function isEffect(value) {
+  return isMora(value, "effect");
+}
+function isMora(value, name) {
+  return typeof value === "object" && value != null && "$mora" in value && value.$mora === name;
+}
+function isSignal(value) {
+  return isMora(value, "signal");
+}
+export {
+  isComputed,
+  isEffect,
+  isSignal
+};

package/dist/mora.full.js

@@ -1,5 +1,8 @@
 class Effect {
     constructor(callback) {
+        Object.defineProperty(this, '$mora', {
+            value: 'effect',
+        });
         this.state = {
             callback,
         };
@@ -55,6 +58,9 @@ let activeComputed;
 class Computed {
     state;
     constructor(callback) {
+        Object.defineProperty(this, '$mora', {
+            value: 'computed',
+        });
         this.state = {
             computeds: new Set(),
             dirty: true,
@@ -110,9 +116,37 @@ function computed(callback) {
     return new Computed(callback);
 }
 
+/**
+ * Is the value a computed signal?
+ */
+function isComputed(value) {
+    return isMora(value, 'computed');
+}
+/**
+ * Is the value an effect?
+ */
+function isEffect(value) {
+    return isMora(value, 'effect');
+}
+function isMora(value, name) {
+    return (typeof value === 'object' &&
+        value != null &&
+        '$mora' in value &&
+        value.$mora === name);
+}
+/**
+ * Is the value a signal?
+ */
+function isSignal(value) {
+    return isMora(value, 'signal');
+}
+
 class Signal {
     state;
     constructor(value) {
+        Object.defineProperty(this, '$mora', {
+            value: 'signal',
+        });
         this.state = {
             value,
             computeds: new Set(),
@@ -166,4 +200,4 @@ function signal(value) {
     return new Signal(value);
 }
 
-export { computed, effect, signal, startBatch, stopBatch };
+export { computed, effect, isComputed, isEffect, isSignal, signal, startBatch, stopBatch };

package/dist/signal.cjs

@@ -9,6 +9,9 @@ const effect = require("./effect.cjs");
 class Signal {
   constructor(value) {
     __publicField(this, "state");
+    Object.defineProperty(this, "$mora", {
+      value: "signal"
+    });
     this.state = {
       value,
       computeds: /* @__PURE__ */ new Set(),

package/dist/signal.js

@@ -7,6 +7,9 @@ import { activeEffect, dirtyEffects } from "./effect.js";
 class Signal {
   constructor(value) {
     __publicField(this, "state");
+    Object.defineProperty(this, "$mora", {
+      value: "signal"
+    });
     this.state = {
       value,
       computeds: /* @__PURE__ */ new Set(),

package/package.json

@@ -3,10 +3,12 @@
 		"name": "Oscar Palmér",
 		"url": "https://oscarpalmer.se"
 	},
+	"dependencies": {
+		"@oscarpalmer/atoms": "^0.100"
+	},
 	"description": "Signals and stuff…",
 	"devDependencies": {
 		"@biomejs/biome": "^1.9",
-		"@oscarpalmer/atoms": "^0.100",
 		"@rollup/plugin-node-resolve": "^16",
 		"@rollup/plugin-typescript": "^12.1",
 		"@types/node": "^22.15",
@@ -52,5 +54,5 @@
 	},
 	"type": "module",
 	"types": "./types/index.d.ts",
-	"version": "0.8.0"
+	"version": "0.9.0"
 }

package/src/computed.ts

@@ -22,70 +22,76 @@ export type InternalComputed = {
 export let activeComputed: Computed<unknown> | undefined;
 
 export class Computed<Value> {
-	private readonly state: ComputedState<Value>;
+		private declare readonly $mora: string;
 
-	constructor(callback: () => Value) {
-		this.state = {
-			computeds: new Set(),
-			dirty: true,
-			effect: undefined as never,
-			effects: new Set(),
-			value: undefined as never,
-		};
+		private readonly state: ComputedState<Value>;
 
-		this.state.effect = effect(() => {
-			if (this.state.dirty) {
-				const previousComputed = activeComputed;
+		constructor(callback: () => Value) {
+			Object.defineProperty(this, '$mora', {
+				value: 'computed',
+			});
 
-				activeComputed = this;
+			this.state = {
+				computeds: new Set(),
+				dirty: true,
+				effect: undefined as never,
+				effects: new Set(),
+				value: undefined as never,
+			};
 
-				const value = callback();
+			this.state.effect = effect(() => {
+				if (this.state.dirty) {
+					const previousComputed = activeComputed;
 
-				activeComputed = previousComputed;
+					activeComputed = this;
 
-				if (!Object.is(this.state.value, value)) {
-					this.state.value = value;
+					const value = callback();
 
-					for (const computed of this.state.computeds) {
-						computed.state.dirty = true;
-					}
+					activeComputed = previousComputed;
+
+					if (!Object.is(this.state.value, value)) {
+						this.state.value = value;
 
-					for (const effect of this.state.effects) {
-						dirtyEffects.add(effect);
+						for (const computed of this.state.computeds) {
+							computed.state.dirty = true;
+						}
+
+						for (const effect of this.state.effects) {
+							dirtyEffects.add(effect);
+						}
 					}
+
+					this.state.dirty = false;
 				}
+			});
+		}
 
-				this.state.dirty = false;
+		/**
+		 * Get the value
+		 */
+		get(): Value {
+			if (activeComputed != null && activeComputed !== this) {
+				this.state.computeds.add(activeComputed);
 			}
-		});
-	}
 
-	/**
-	 * Get the value
-	 */
-	get(): Value {
-		if (activeComputed != null && activeComputed !== this) {
-			this.state.computeds.add(activeComputed);
-		}
+			if (activeEffect != null && activeEffect !== this.state.effect) {
+				this.state.effects.add(activeEffect);
+			}
 
-		if (activeEffect != null && activeEffect !== this.state.effect) {
-			this.state.effects.add(activeEffect);
-		}
+			if (this.state.dirty && batchDepth === 0) {
+				runEffect(this.state.effect);
+			}
 
-		if (this.state.dirty && batchDepth === 0) {
-			runEffect(this.state.effect);
+			return this.state.value;
 		}
 
-		return this.state.value;
-	}
-
-	/**
-	 * Get the value _(without reactivity)_
-	 */
-	peek(): Value {
-		return this.state.value;
+		/**
+		 * Get the value _(without reactivity)_
+		 */
+		peek(): Value {
+			return this.state.value;
+		}
 	}
-}
 
 /**
  * Create a computed value

package/src/effect.ts

@@ -9,16 +9,22 @@ type InternalEffect = {
 };
 
 export class Effect {
-	private declare readonly state: EffectState;
+		private declare readonly $mora: string;
 
-	constructor(callback: GenericCallback) {
-		this.state = {
-			callback,
-		};
+		private declare readonly state: EffectState;
 
-		runEffect(this);
+		constructor(callback: GenericCallback) {
+			Object.defineProperty(this, '$mora', {
+				value: 'effect',
+			});
+
+			this.state = {
+				callback,
+			};
+
+			runEffect(this);
+		}
 	}
-}
 
 export function runEffect(effect: Effect): void {
 	const previousEffect = activeEffect;

package/src/index.ts

@@ -1,4 +1,5 @@
 export {startBatch, stopBatch} from './batch';
 export {computed, type Computed} from './computed';
 export {effect, type Effect} from './effect';
+export {isComputed, isEffect, isSignal} from './is';
 export {signal, type Signal} from './signal';

package/src/is.ts

@@ -0,0 +1,34 @@
+import type {PlainObject} from '@oscarpalmer/atoms/models';
+import type {Computed} from './computed';
+import type {Effect} from './effect';
+import type {Signal} from './signal';
+
+/**
+ * Is the value a computed signal?
+ */
+export function isComputed(value: unknown): value is Computed<unknown> {
+	return isMora<Computed<unknown>>(value, 'computed');
+}
+
+/**
+ * Is the value an effect?
+ */
+export function isEffect(value: unknown): value is Effect {
+	return isMora<Effect>(value, 'effect');
+}
+
+function isMora<T>(value: unknown, name: string): value is T {
+	return (
+		typeof value === 'object' &&
+		value != null &&
+		'$mora' in value &&
+		(value as PlainObject).$mora === name
+	);
+}
+
+/**
+ * Is the value a signal?
+ */
+export function isSignal(value: unknown): value is Signal<unknown> {
+	return isMora<Signal<unknown>>(value, 'signal');
+}

package/src/signal.ts

@@ -9,68 +9,74 @@ type SignalState<Value> = {
 };
 
 export class Signal<Value> {
-	private readonly state: SignalState<Value>;
-
-	constructor(value: Value) {
-		this.state = {
-			value,
-			computeds: new Set(),
-			effects: new Set(),
-		};
-	}
+		private declare readonly $mora: string;
 
-	/**
-	 * Get the value
-	 */
-	get(): Value {
-		if (activeComputed != null) {
-			this.state.computeds.add(activeComputed);
-		}
+		private readonly state: SignalState<Value>;
 
-		if (activeEffect != null) {
-			this.state.effects.add(activeEffect);
+		constructor(value: Value) {
+			Object.defineProperty(this, '$mora', {
+				value: 'signal',
+			});
+
+			this.state = {
+				value,
+				computeds: new Set(),
+				effects: new Set(),
+			};
 		}
 
-		return this.state.value;
-	}
+		/**
+		 * Get the value
+		 */
+		get(): Value {
+			if (activeComputed != null) {
+				this.state.computeds.add(activeComputed);
+			}
 
-	/**
-	 * Get the value _(without reactivity)_
-	 */
-	peek(): Value {
-		return this.state.value;
-	}
+			if (activeEffect != null) {
+				this.state.effects.add(activeEffect);
+			}
 
-	/**
-	 * Set the value
-	 */
-	set(value: Value): void {
-		if (Object.is(this.state.value, value)) {
-			return;
+			return this.state.value;
 		}
 
-		this.state.value = value;
-
-		for (const computed of this.state.computeds) {
-			(computed as unknown as InternalComputed).state.dirty = true;
+		/**
+		 * Get the value _(without reactivity)_
+		 */
+		peek(): Value {
+			return this.state.value;
 		}
 
-		for (const effect of this.state.effects) {
-			dirtyEffects.add(effect);
-		}
+		/**
+		 * Set the value
+		 */
+		set(value: Value): void {
+			if (Object.is(this.state.value, value)) {
+				return;
+			}
 
-		if (batchDepth === 0) {
-			flushEffects();
+			this.state.value = value;
+
+			for (const computed of this.state.computeds) {
+				(computed as unknown as InternalComputed).state.dirty = true;
+			}
+
+			for (const effect of this.state.effects) {
+				dirtyEffects.add(effect);
+			}
+
+			if (batchDepth === 0) {
+				flushEffects();
+			}
 		}
-	}
 
-	/**
-	 * Update the value
-	 */
-	update(callback: (value: Value) => Value): void {
-		this.set(callback(this.state.value));
+		/**
+		 * Update the value
+		 */
+		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

@@ -2,6 +2,7 @@
 
 export type GenericCallback = (...args: any[]) => any;
 declare class Effect {
+	private readonly $mora;
 	private readonly state;
 	constructor(callback: GenericCallback);
 }
@@ -17,6 +18,7 @@ export type InternalComputed = {
 };
 export declare let activeComputed: Computed<unknown> | undefined;
 export declare class Computed<Value> {
+	private readonly $mora;
 	private readonly state;
 	constructor(callback: () => Value);
 	/**

package/types/computed.d.ts

@@ -11,6 +11,7 @@ export type InternalComputed = {
 };
 export declare let activeComputed: Computed<unknown> | undefined;
 export declare class Computed<Value> {
+    private readonly $mora;
     private readonly state;
     constructor(callback: () => Value);
     /**

package/types/effect.d.cts

@@ -2,6 +2,7 @@
 
 export type GenericCallback = (...args: any[]) => any;
 export declare class Effect {
+	private readonly $mora;
 	private readonly state;
 	constructor(callback: GenericCallback);
 }

package/types/effect.d.ts

@@ -1,5 +1,6 @@
 import type { GenericCallback } from '@oscarpalmer/atoms/models';
 export declare class Effect {
+    private readonly $mora;
     private readonly state;
     constructor(callback: GenericCallback);
 }

package/types/index.d.cts

@@ -1,6 +1,7 @@
 // Generated by dts-bundle-generator v9.5.1
 
 export declare class Signal<Value> {
+	private readonly $mora;
 	private readonly state;
 	constructor(value: Value);
 	/**
@@ -21,16 +22,9 @@ export declare class Signal<Value> {
 	update(callback: (value: Value) => Value): void;
 }
 export declare function signal<Value>(value: Value): Signal<Value>;
-/**
- * Start batching effects _(use `stopBatch` to flush and run batched effects)_
- */
-export declare function startBatch(): void;
-/**
- * Stop batching effects and flush _(run)_ them
- */
-export declare function stopBatch(): void;
 export type GenericCallback = (...args: any[]) => any;
 export declare class Effect {
+	private readonly $mora;
 	private readonly state;
 	constructor(callback: GenericCallback);
 }
@@ -39,6 +33,7 @@ export declare class Effect {
  */
 export declare function effect(callback: GenericCallback): Effect;
 export declare class Computed<Value> {
+	private readonly $mora;
 	private readonly state;
 	constructor(callback: () => Value);
 	/**
@@ -54,5 +49,25 @@ export declare class Computed<Value> {
  * Create a computed value
  */
 export declare function computed<Value>(callback: () => Value): Computed<Value>;
+/**
+ * Is the value a computed signal?
+ */
+export declare function isComputed(value: unknown): value is Computed<unknown>;
+/**
+ * Is the value an effect?
+ */
+export declare function isEffect(value: unknown): value is Effect;
+/**
+ * Is the value a signal?
+ */
+export declare function isSignal(value: unknown): value is Signal<unknown>;
+/**
+ * Start batching effects _(use `stopBatch` to flush and run batched effects)_
+ */
+export declare function startBatch(): void;
+/**
+ * Stop batching effects and flush _(run)_ them
+ */
+export declare function stopBatch(): void;
 
 export {};

package/types/index.d.ts

@@ -1,4 +1,5 @@
 export { startBatch, stopBatch } from './batch';
 export { computed, type Computed } from './computed';
 export { effect, type Effect } from './effect';
+export { isComputed, isEffect, isSignal } from './is';
 export { signal, type Signal } from './signal';

package/types/is.d.cts

@@ -0,0 +1,56 @@
+// Generated by dts-bundle-generator v9.5.1
+
+declare class Signal<Value> {
+	private readonly $mora;
+	private readonly state;
+	constructor(value: Value);
+	/**
+	 * Get the value
+	 */
+	get(): Value;
+	/**
+	 * Get the value _(without reactivity)_
+	 */
+	peek(): Value;
+	/**
+	 * Set the value
+	 */
+	set(value: Value): void;
+	/**
+	 * Update the value
+	 */
+	update(callback: (value: Value) => Value): void;
+}
+export type GenericCallback = (...args: any[]) => any;
+declare class Effect {
+	private readonly $mora;
+	private readonly state;
+	constructor(callback: GenericCallback);
+}
+declare class Computed<Value> {
+	private readonly $mora;
+	private readonly state;
+	constructor(callback: () => Value);
+	/**
+	 * Get the value
+	 */
+	get(): Value;
+	/**
+	 * Get the value _(without reactivity)_
+	 */
+	peek(): Value;
+}
+/**
+ * Is the value a computed signal?
+ */
+export declare function isComputed(value: unknown): value is Computed<unknown>;
+/**
+ * Is the value an effect?
+ */
+export declare function isEffect(value: unknown): value is Effect;
+/**
+ * Is the value a signal?
+ */
+export declare function isSignal(value: unknown): value is Signal<unknown>;
+
+export {};

package/types/is.d.ts

@@ -0,0 +1,15 @@
+import type { Computed } from './computed';
+import type { Effect } from './effect';
+import type { Signal } from './signal';
+/**
+ * Is the value a computed signal?
+ */
+export declare function isComputed(value: unknown): value is Computed<unknown>;
+/**
+ * Is the value an effect?
+ */
+export declare function isEffect(value: unknown): value is Effect;
+/**
+ * Is the value a signal?
+ */
+export declare function isSignal(value: unknown): value is Signal<unknown>;

package/types/signal.d.cts

@@ -1,6 +1,7 @@
 // Generated by dts-bundle-generator v9.5.1
 
 export declare class Signal<Value> {
+	private readonly $mora;
 	private readonly state;
 	constructor(value: Value);
 	/**

package/types/signal.d.ts

@@ -1,4 +1,5 @@
 export declare class Signal<Value> {
+    private readonly $mora;
     private readonly state;
     constructor(value: Value);
     /**