@oscarpalmer/mora 0.7.0 → 0.9.0

package/README.md

@@ -1,5 +1,7 @@
 # Mora
 
+[![npm](https://badge.fury.io/js/@oscarpalmer%2Fmora.svg)](https://www.npmjs.com/package/@oscarpalmer/mora) [![Tests](https://github.com/oscarpalmer/mora/actions/workflows/test.yml/badge.svg)](https://github.com/oscarpalmer/mora/actions/workflows/test.yml)
+
 Signals and stuff…
 
 ## License

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,
@@ -24,9 +27,8 @@ class Computed {
         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;
-            effect.dirtyEffects.add(comp.state.effect);
+          for (const computed2 of this.state.computeds) {
+            computed2.state.dirty = true;
           }
           for (const effect2 of this.state.effects) {
             effect.dirtyEffects.add(effect2);
@@ -46,15 +48,17 @@ class Computed {
     if (effect.activeEffect != null && effect.activeEffect !== this.state.effect) {
       this.state.effects.add(effect.activeEffect);
     }
-    if (this.state.dirty) {
-      if (batch.batchDepth === 0) {
-        effect.runEffect(this.state.effect);
-      } else {
-        effect.dirtyEffects.add(this.state.effect);
-      }
+    if (this.state.dirty && batch.batchDepth === 0) {
+      effect.runEffect(this.state.effect);
     }
     return this.state.value;
   }
+  /**
+   * Get the value _(without reactivity)_
+   */
+  peek() {
+    return this.state.value;
+  }
 }
 function computed(callback) {
   return new Computed(callback);

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,
@@ -22,9 +25,8 @@ class Computed {
         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 computed2 of this.state.computeds) {
+            computed2.state.dirty = true;
           }
           for (const effect2 of this.state.effects) {
             dirtyEffects.add(effect2);
@@ -44,15 +46,17 @@ class Computed {
     if (activeEffect != null && activeEffect !== this.state.effect) {
       this.state.effects.add(activeEffect);
     }
-    if (this.state.dirty) {
-      if (batchDepth === 0) {
-        runEffect(this.state.effect);
-      } else {
-        dirtyEffects.add(this.state.effect);
-      }
+    if (this.state.dirty && batchDepth === 0) {
+      runEffect(this.state.effect);
     }
     return this.state.value;
   }
+  /**
+   * Get the value _(without reactivity)_
+   */
+  peek() {
+    return this.state.value;
+  }
 }
 function computed(callback) {
   return new Computed(callback);

package/dist/effect.cjs

@@ -1,11 +1,10 @@
 "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" });
 class Effect {
   constructor(callback) {
-    __publicField(this, "state");
+    Object.defineProperty(this, "$mora", {
+      value: "effect"
+    });
     this.state = {
       callback
     };

package/dist/effect.js

@@ -1,9 +1,8 @@
-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);
 class Effect {
   constructor(callback) {
-    __publicField(this, "state");
+    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,6 +1,8 @@
 class Effect {
-    state;
     constructor(callback) {
+        Object.defineProperty(this, '$mora', {
+            value: 'effect',
+        });
         this.state = {
             callback,
         };
@@ -56,6 +58,9 @@ let activeComputed;
 class Computed {
     state;
     constructor(callback) {
+        Object.defineProperty(this, '$mora', {
+            value: 'computed',
+        });
         this.state = {
             computeds: new Set(),
             dirty: true,
@@ -71,9 +76,8 @@ class Computed {
                 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 computed of this.state.computeds) {
+                        computed.state.dirty = true;
                     }
                     for (const effect of this.state.effects) {
                         dirtyEffects.add(effect);
@@ -93,16 +97,17 @@ class Computed {
         if (activeEffect != null && activeEffect !== this.state.effect) {
             this.state.effects.add(activeEffect);
         }
-        if (this.state.dirty) {
-            if (batchDepth === 0) {
-                runEffect(this.state.effect);
-            }
-            else {
-                dirtyEffects.add(this.state.effect);
-            }
+        if (this.state.dirty && batchDepth === 0) {
+            runEffect(this.state.effect);
         }
         return this.state.value;
     }
+    /**
+     * Get the value _(without reactivity)_
+     */
+    peek() {
+        return this.state.value;
+    }
 }
 /**
  * Create a computed value
@@ -111,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(),
@@ -132,6 +165,12 @@ class Signal {
         }
         return this.state.value;
     }
+    /**
+     * Get the value _(without reactivity)_
+     */
+    peek() {
+        return this.state.value;
+    }
     /**
      * Set the value
      */
@@ -140,9 +179,8 @@ class Signal {
             return;
         }
         this.state.value = value;
-        for (const comp of this.state.computeds) {
-            comp.state.dirty = true;
-            dirtyEffects.add(comp.state.effect);
+        for (const computed of this.state.computeds) {
+            computed.state.dirty = true;
         }
         for (const effect of this.state.effects) {
             dirtyEffects.add(effect);
@@ -162,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(),
@@ -27,6 +30,12 @@ class Signal {
     }
     return this.state.value;
   }
+  /**
+   * Get the value _(without reactivity)_
+   */
+  peek() {
+    return this.state.value;
+  }
   /**
    * Set the value
    */
@@ -35,9 +44,8 @@ class Signal {
       return;
     }
     this.state.value = value;
-    for (const comp of this.state.computeds) {
-      comp.state.dirty = true;
-      effect.dirtyEffects.add(comp.state.effect);
+    for (const computed2 of this.state.computeds) {
+      computed2.state.dirty = true;
     }
     for (const effect$1 of this.state.effects) {
       effect.dirtyEffects.add(effect$1);

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(),
@@ -25,6 +28,12 @@ class Signal {
     }
     return this.state.value;
   }
+  /**
+   * Get the value _(without reactivity)_
+   */
+  peek() {
+    return this.state.value;
+  }
   /**
    * Set the value
    */
@@ -33,9 +42,8 @@ class Signal {
       return;
     }
     this.state.value = value;
-    for (const comp of this.state.computeds) {
-      comp.state.dirty = true;
-      dirtyEffects.add(comp.state.effect);
+    for (const computed of this.state.computeds) {
+      computed.state.dirty = true;
     }
     for (const effect of this.state.effects) {
       dirtyEffects.add(effect);

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.7.0"
+	"version": "0.9.0"
 }

package/src/computed.ts

@@ -22,76 +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;
 
-						dirtyEffects.add(computed.state.effect);
-					}
+					if (!Object.is(this.state.value, value)) {
+						this.state.value = value;
+
+						for (const computed of this.state.computeds) {
+							computed.state.dirty = true;
+						}
 
-					for (const effect of this.state.effects) {
-						dirtyEffects.add(effect);
+						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) {
-			if (batchDepth === 0) {
+			if (this.state.dirty && batchDepth === 0) {
 				runEffect(this.state.effect);
-			} else {
-				dirtyEffects.add(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,70 +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>;
+
+		constructor(value: Value) {
+			Object.defineProperty(this, '$mora', {
+				value: 'signal',
+			});
 
-		if (activeEffect != null) {
-			this.state.effects.add(activeEffect);
+			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);
+			}
+
+			return this.state.value;
+		}
 
-	/**
-	 * Set the value
-	 */
-	set(value: Value): void {
-		if (Object.is(this.state.value, value)) {
-			return;
+		/**
+		 * Get the value _(without reactivity)_
+		 */
+		peek(): Value {
+			return this.state.value;
 		}
 
-		this.state.value = value;
+		/**
+		 * Set the value
+		 */
+		set(value: Value): void {
+			if (Object.is(this.state.value, value)) {
+				return;
+			}
 
-		for (const computed of this.state.computeds) {
-			(computed as unknown as InternalComputed).state.dirty = true;
+			this.state.value = value;
 
-			dirtyEffects.add((computed as unknown as InternalComputed).state.effect);
-		}
+			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);
-		}
+			for (const effect of this.state.effects) {
+				dirtyEffects.add(effect);
+			}
 
-		if (batchDepth === 0) {
-			flushEffects();
+			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,12 +18,17 @@ export type InternalComputed = {
 };
 export declare let activeComputed: Computed<unknown> | undefined;
 export 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;
 }
 /**
  * Create a computed value

package/types/computed.d.ts

@@ -11,12 +11,17 @@ export type InternalComputed = {
 };
 export declare let activeComputed: Computed<unknown> | undefined;
 export 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;
 }
 /**
  * Create a computed 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,12 +1,17 @@
 // Generated by dts-bundle-generator v9.5.1
 
 export 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
 	 */
@@ -17,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);
 }
@@ -35,16 +33,41 @@ 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);
 	/**
 	 * Get the value
 	 */
 	get(): Value;
+	/**
+	 * Get the value _(without reactivity)_
+	 */
+	peek(): 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,12 +1,17 @@
 // Generated by dts-bundle-generator v9.5.1
 
 export 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
 	 */

package/types/signal.d.ts

@@ -1,10 +1,15 @@
 export 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
      */