@oscarpalmer/atoms 0.29.0 → 0.31.0

package/dist/js/index.js

@@ -286,18 +286,25 @@ function isPlainObject(value) {
 
 // src/js/queue.ts
 function queue(callback) {
-  queued.add(callback);
-  if (queued.size > 0) {
+  _atomic_queued.add(callback);
+  if (_atomic_queued.size > 0) {
     queueMicrotask(() => {
-      const callbacks = Array.from(queued);
-      queued.clear();
+      const callbacks = Array.from(_atomic_queued);
+      _atomic_queued.clear();
       for (const callback2 of callbacks) {
         callback2();
       }
     });
   }
 }
-var queued = new Set;
+if (globalThis._atomic_queued === undefined) {
+  const queued = new Set;
+  Object.defineProperty(globalThis, "_atomic_queued", {
+    get() {
+      return queued;
+    }
+  });
+}
 
 // src/js/value.ts
 var _cloneNested = function(value) {
@@ -610,132 +617,6 @@ class Manager {
   }
 }
 var cloned = new Map;
-// src/js/signal.ts
-function computed(callback) {
-  return new Computed(callback);
-}
-function effect(callback) {
-  return new Effect(callback);
-}
-var getValue = function(reactive) {
-  const effect2 = effects[effects.length - 1];
-  if (effect2 !== undefined) {
-    reactive._effects.add(effect2);
-    effect2._reactives.add(reactive);
-  }
-  return reactive._value;
-};
-function isComputed(value2) {
-  return value2 instanceof Computed;
-}
-function isEffect(value2) {
-  return value2 instanceof Effect;
-}
-function isReactive(value2) {
-  return value2 instanceof Computed || value2 instanceof Signal;
-}
-function isSignal(value2) {
-  return value2 instanceof Signal;
-}
-var setValue = function(reactive, value2, run) {
-  if (!run && Object.is(value2, reactive._value)) {
-    return;
-  }
-  reactive._value = value2;
-  if (reactive._active) {
-    for (const effect2 of reactive._effects) {
-      queue(effect2._callback);
-    }
-  }
-};
-function signal(value2) {
-  return new Signal(value2);
-}
-
-class Reactive {
-  _active = true;
-  _effects = new Set;
-  peek() {
-    return this._value;
-  }
-  toJSON() {
-    return this.value;
-  }
-  toString() {
-    return String(this.value);
-  }
-}
-
-class Computed extends Reactive {
-  _effect;
-  get value() {
-    return getValue(this);
-  }
-  constructor(callback) {
-    super();
-    this._effect = effect(() => setValue(this, callback(), false));
-  }
-  run() {
-    this._effect.run();
-  }
-  stop() {
-    this._effect.stop();
-  }
-}
-
-class Effect {
-  _callback;
-  _active = false;
-  _reactives = new Set;
-  constructor(_callback) {
-    this._callback = _callback;
-    this.run();
-  }
-  run() {
-    if (this._active) {
-      return;
-    }
-    this._active = true;
-    const index = effects.push(this) - 1;
-    this._callback();
-    effects.splice(index, 1);
-  }
-  stop() {
-    if (!this._active) {
-      return;
-    }
-    this._active = false;
-    for (const value2 of this._reactives) {
-      value2._effects.delete(this);
-    }
-    this._reactives.clear();
-  }
-}
-
-class Signal extends Reactive {
-  _value;
-  get value() {
-    return getValue(this);
-  }
-  set value(value2) {
-    setValue(this, value2, false);
-  }
-  constructor(_value) {
-    super();
-    this._value = _value;
-  }
-  run() {
-    if (this._active) {
-      return;
-    }
-    this._active = true;
-    setValue(this, this._value, true);
-  }
-  stop() {
-    this._active = false;
-  }
-}
-var effects = [];
 // src/js/timer.ts
 function repeat(callback, options) {
   const count = typeof options?.count === "number" ? options.count : Number.POSITIVE_INFINITY;
@@ -763,8 +644,11 @@ var work = function(type, timer, state, options) {
   }
   state.active = true;
   const isRepeated = count > 0;
-  const milliseconds = 16.666666666666668;
   let index = 0;
+  let total = count * interval;
+  if (total < milliseconds) {
+    total = milliseconds;
+  }
   let start;
   function step(timestamp) {
     if (!state.active) {
@@ -772,14 +656,13 @@ var work = function(type, timer, state, options) {
     }
     start ??= timestamp;
     const elapsed = timestamp - start;
-    const maximum = elapsed + milliseconds;
-    const minimum = elapsed - milliseconds;
-    if (minimum < interval && interval < maximum) {
+    const finished = elapsed >= total;
+    if (finished || elapsed - 2 < interval && interval < elapsed + 2) {
       if (state.active) {
         callback(isRepeated ? index : undefined);
       }
       index += 1;
-      if (index < count) {
+      if (!finished && index < count) {
         start = undefined;
       } else {
         state.active = false;
@@ -793,6 +676,7 @@ var work = function(type, timer, state, options) {
   state.frame = requestAnimationFrame(step);
   return timer;
 };
+var milliseconds = 0;
 
 class Timer {
   get active() {
@@ -819,23 +703,30 @@ class Timer {
     return work("stop", this, this.state, this.options);
   }
 }
+(() => {
+  let start;
+  function fn(time) {
+    if (start === undefined) {
+      start = time;
+      requestAnimationFrame(fn);
+    } else {
+      milliseconds = time - start;
+    }
+  }
+  requestAnimationFrame(fn);
+})();
 export {
   wait,
   unsubscribe,
   unique,
   subscribe,
   splice,
-  signal,
   set,
   repeat,
   queue,
   push,
   proxy,
   merge,
-  isSignal,
-  isReactive,
-  isEffect,
-  isComputed,
   insert,
   indexOf,
   groupBy,
@@ -851,10 +742,8 @@ export {
   find,
   filter,
   exists,
-  effect,
   diff,
   createUuid,
-  computed,
   cloneProxy,
   clone,
   clamp,

package/dist/js/index.mjs

@@ -5,7 +5,6 @@ export * from "./event";
 export * from "./number";
 export * from "./proxy";
 export * from "./queue";
-export * from "./signal";
 export * from "./string";
 export * from "./timer";
 export * from "./value";

package/dist/js/proxy.js

@@ -21,18 +21,25 @@ function isPlainObject(value) {
 
 // src/js/queue.ts
 function queue(callback) {
-  queued.add(callback);
-  if (queued.size > 0) {
+  _atomic_queued.add(callback);
+  if (_atomic_queued.size > 0) {
     queueMicrotask(() => {
-      const callbacks = Array.from(queued);
-      queued.clear();
+      const callbacks = Array.from(_atomic_queued);
+      _atomic_queued.clear();
       for (const callback2 of callbacks) {
         callback2();
       }
     });
   }
 }
-var queued = new Set;
+if (globalThis._atomic_queued === undefined) {
+  const queued = new Set;
+  Object.defineProperty(globalThis, "_atomic_queued", {
+    get() {
+      return queued;
+    }
+  });
+}
 
 // src/js/value.ts
 var _cloneNested = function(value) {

package/dist/js/queue.js

@@ -1,17 +1,24 @@
 // src/js/queue.ts
 function queue(callback) {
-  queued.add(callback);
-  if (queued.size > 0) {
+  _atomic_queued.add(callback);
+  if (_atomic_queued.size > 0) {
     queueMicrotask(() => {
-      const callbacks = Array.from(queued);
-      queued.clear();
+      const callbacks = Array.from(_atomic_queued);
+      _atomic_queued.clear();
       for (const callback2 of callbacks) {
         callback2();
       }
     });
   }
 }
-var queued = new Set;
+if (globalThis._atomic_queued === undefined) {
+  const queued = new Set;
+  Object.defineProperty(globalThis, "_atomic_queued", {
+    get() {
+      return queued;
+    }
+  });
+}
 export {
   queue
 };

package/dist/js/queue.mjs

@@ -1,17 +1,24 @@
 // src/js/queue.ts
 function queue(callback) {
-  queued.add(callback);
-  if (queued.size > 0) {
+  _atomic_queued.add(callback);
+  if (_atomic_queued.size > 0) {
     queueMicrotask(() => {
-      const callbacks = Array.from(queued);
-      queued.clear();
+      const callbacks = Array.from(_atomic_queued);
+      _atomic_queued.clear();
       for (const callback2 of callbacks) {
         callback2();
       }
     });
   }
 }
-var queued = new Set;
+if (globalThis._atomic_queued === undefined) {
+  const queued = new Set;
+  Object.defineProperty(globalThis, "_atomic_queued", {
+    get() {
+      return queued;
+    }
+  });
+}
 export {
   queue
 };

package/dist/js/signal.js

@@ -1,17 +1,24 @@
 // src/js/queue.ts
 function queue(callback) {
-  queued.add(callback);
-  if (queued.size > 0) {
+  _atomic_queued.add(callback);
+  if (_atomic_queued.size > 0) {
     queueMicrotask(() => {
-      const callbacks = Array.from(queued);
-      queued.clear();
+      const callbacks = Array.from(_atomic_queued);
+      _atomic_queued.clear();
       for (const callback2 of callbacks) {
         callback2();
       }
     });
   }
 }
-var queued = new Set;
+if (globalThis._atomic_effects === undefined) {
+  const queued = new Set;
+  Object.defineProperty(globalThis, "_atomic_queued", {
+    get() {
+      return queued;
+    }
+  });
+}
 
 // src/js/signal.ts
 function computed(callback) {
@@ -21,7 +28,7 @@ function effect(callback) {
   return new Effect(callback);
 }
 var getValue = function(reactive) {
-  const effect2 = effects[effects.length - 1];
+  const effect2 = _atomic_effects[_atomic_effects.length - 1];
   if (effect2 !== undefined) {
     reactive._effects.add(effect2);
     effect2._reactives.add(reactive);
@@ -29,16 +36,19 @@ var getValue = function(reactive) {
   return reactive._value;
 };
 function isComputed(value) {
-  return value instanceof Computed;
+  return isInstance(/^computed$/i, value);
 }
 function isEffect(value) {
-  return value instanceof Effect;
+  return isInstance(/^effect$/i, value);
 }
+var isInstance = function(expression, value) {
+  return expression.test(value?.constructor?.name ?? "") && value.atomic === true;
+};
 function isReactive(value) {
-  return value instanceof Computed || value instanceof Signal;
+  return isComputed(value) || isSignal(value);
 }
 function isSignal(value) {
-  return value instanceof Signal;
+  return isInstance(/^signal$/i, value);
 }
 var setValue = function(reactive, value, run) {
   if (!run && Object.is(value, reactive._value)) {
@@ -54,8 +64,27 @@ var setValue = function(reactive, value, run) {
 function signal(value) {
   return new Signal(value);
 }
+if (globalThis._atomic_effects === undefined) {
+  const effects = [];
+  Object.defineProperty(globalThis, "_atomic_effects", {
+    get() {
+      return effects;
+    }
+  });
+}
 
-class Reactive {
+class Atomic {
+  constructor() {
+    Object.defineProperty(this, "atomic", {
+      value: true
+    });
+  }
+}
+
+class Reactive extends Atomic {
+  constructor() {
+    super(...arguments);
+  }
   _active = true;
   _effects = new Set;
   peek() {
@@ -86,11 +115,12 @@ class Computed extends Reactive {
   }
 }
 
-class Effect {
+class Effect extends Atomic {
   _callback;
   _active = false;
   _reactives = new Set;
   constructor(_callback) {
+    super();
     this._callback = _callback;
     this.run();
   }
@@ -99,9 +129,9 @@ class Effect {
       return;
     }
     this._active = true;
-    const index = effects.push(this) - 1;
+    const index = _atomic_effects.push(this) - 1;
     this._callback();
-    effects.splice(index, 1);
+    _atomic_effects.splice(index, 1);
   }
   stop() {
     if (!this._active) {
@@ -138,7 +168,6 @@ class Signal extends Reactive {
     this._active = false;
   }
 }
-var effects = [];
 export {
   signal,
   isSignal,

package/dist/js/timer.js

@@ -25,8 +25,11 @@ var work = function(type, timer, state, options) {
   }
   state.active = true;
   const isRepeated = count > 0;
-  const milliseconds = 16.666666666666668;
   let index = 0;
+  let total = count * interval;
+  if (total < milliseconds) {
+    total = milliseconds;
+  }
   let start;
   function step(timestamp) {
     if (!state.active) {
@@ -34,14 +37,13 @@ var work = function(type, timer, state, options) {
     }
     start ??= timestamp;
     const elapsed = timestamp - start;
-    const maximum = elapsed + milliseconds;
-    const minimum = elapsed - milliseconds;
-    if (minimum < interval && interval < maximum) {
+    const finished = elapsed >= total;
+    if (finished || elapsed - 2 < interval && interval < elapsed + 2) {
       if (state.active) {
         callback(isRepeated ? index : undefined);
       }
       index += 1;
-      if (index < count) {
+      if (!finished && index < count) {
         start = undefined;
       } else {
         state.active = false;
@@ -55,6 +57,7 @@ var work = function(type, timer, state, options) {
   state.frame = requestAnimationFrame(step);
   return timer;
 };
+var milliseconds = 0;
 
 class Timer {
   get active() {
@@ -81,6 +84,18 @@ class Timer {
     return work("stop", this, this.state, this.options);
   }
 }
+(() => {
+  let start;
+  function fn(time) {
+    if (start === undefined) {
+      start = time;
+      requestAnimationFrame(fn);
+    } else {
+      milliseconds = time - start;
+    }
+  }
+  requestAnimationFrame(fn);
+})();
 export {
   wait,
   repeat,

package/dist/js/timer.mjs

@@ -25,8 +25,11 @@ var work = function(type, timer, state, options) {
   }
   state.active = true;
   const isRepeated = count > 0;
-  const milliseconds = 16.666666666666668;
   let index = 0;
+  let total = count * interval;
+  if (total < milliseconds) {
+    total = milliseconds;
+  }
   let start;
   function step(timestamp) {
     if (!state.active) {
@@ -34,14 +37,13 @@ var work = function(type, timer, state, options) {
     }
     start ??= timestamp;
     const elapsed = timestamp - start;
-    const maximum = elapsed + milliseconds;
-    const minimum = elapsed - milliseconds;
-    if (minimum < interval && interval < maximum) {
+    const finished = elapsed >= total;
+    if (finished || elapsed - 2 < interval && interval < elapsed + 2) {
       if (state.active) {
         callback(isRepeated ? index : undefined);
       }
       index += 1;
-      if (index < count) {
+      if (!finished && index < count) {
         start = undefined;
       } else {
         state.active = false;
@@ -55,6 +57,7 @@ var work = function(type, timer, state, options) {
   state.frame = requestAnimationFrame(step);
   return timer;
 };
+var milliseconds = 0;
 
 class Timer {
   get active() {
@@ -81,6 +84,18 @@ class Timer {
     return work("stop", this, this.state, this.options);
   }
 }
+(() => {
+  let start;
+  function fn(time) {
+    if (start === undefined) {
+      start = time;
+      requestAnimationFrame(fn);
+    } else {
+      milliseconds = time - start;
+    }
+  }
+  requestAnimationFrame(fn);
+})();
 export {
   wait,
   repeat,

package/package.json

@@ -12,6 +12,9 @@
 		"typescript": "^5.4"
 	},
 	"exports": {
+		".": {
+			"types": "./types/index.d.ts"
+		},
 		"./array": {
 			"bun": "./src/js/array.ts",
 			"import": "./dist/js/array.mjs",
@@ -60,12 +63,6 @@
 			"require": "./dist/js/queue.js",
 			"types": "./types/queue.d.ts"
 		},
-		"./signal": {
-			"bun": "./src/js/signal.ts",
-			"import": "./dist/js/signal.mjs",
-			"require": "./dist/js/signal.js",
-			"types": "./types/signal.d.ts"
-		},
 		"./string": {
 			"bun": "./src/js/string.ts",
 			"import": "./dist/js/string.mjs",
@@ -117,5 +114,5 @@
 	},
 	"type": "module",
 	"types": "./types/index.d.ts",
-	"version": "0.29.0"
+	"version": "0.31.0"
 }

package/src/js/index.ts

@@ -4,7 +4,6 @@ export * from './event';
 export * from './number';
 export * from './proxy';
 export * from './queue';
-export * from './signal';
 export * from './string';
 export * from './timer';
 export * from './value';

package/src/js/queue.ts

@@ -1,16 +1,28 @@
-const queued = new Set<() => void>();
+declare global {
+	var _atomic_queued: Set<() => void>;
+}
+
+if (globalThis._atomic_queued === undefined) {
+	const queued = new Set<() => void>();
+
+	Object.defineProperty(globalThis, '_atomic_queued', {
+		get() {
+			return queued;
+		},
+	});
+}
 
 /**
  * Queues a callback to be executed at the next best time
  */
 export function queue(callback: () => void): void {
-	queued.add(callback);
+	_atomic_queued.add(callback);
 
-	if (queued.size > 0) {
+	if (_atomic_queued.size > 0) {
 		queueMicrotask(() => {
-			const callbacks = Array.from(queued);
+			const callbacks = Array.from(_atomic_queued);
 
-			queued.clear();
+			_atomic_queued.clear();
 
 			for (const callback of callbacks) {
 				callback();

package/src/js/timer.ts

@@ -39,6 +39,8 @@ type TimerState = {
 
 type WorkType = 'restart' | 'start' | 'stop';
 
+let milliseconds = 0;
+
 /**
  * A timer that can be started, stopped, and restarted as neeeded
  */
@@ -154,9 +156,13 @@ function work(
 	state.active = true;
 
 	const isRepeated = count > 0;
-	const milliseconds = 1000 / 60;
 
 	let index = 0;
+	let total = count * interval;
+
+	if (total < milliseconds) {
+		total = milliseconds;
+	}
 
 	let start: DOMHighResTimeStamp | undefined;
 
@@ -168,17 +174,16 @@ function work(
 		start ??= timestamp;
 
 		const elapsed = timestamp - start;
-		const maximum = elapsed + milliseconds;
-		const minimum = elapsed - milliseconds;
+		const finished = elapsed >= total;
 
-		if (minimum < interval && interval < maximum) {
+		if (finished || (elapsed - 2 < interval && interval < elapsed + 2)) {
 			if (state.active) {
 				callback((isRepeated ? index : undefined) as never);
 			}
 
 			index += 1;
 
-			if (index < count) {
+			if (!finished && index < count) {
 				start = undefined;
 			} else {
 				state.active = false;
@@ -197,3 +202,22 @@ function work(
 
 	return timer;
 }
+
+/**
+ * Called immediately to calculate an approximate refresh rate in milliseconds
+ */
+(() => {
+	let start: number;
+
+	function fn(time: number) {
+		if (start === undefined) {
+			start = time;
+
+			requestAnimationFrame(fn);
+		} else {
+			milliseconds = time - start;
+		}
+	}
+
+	requestAnimationFrame(fn);
+})();

package/types/index.d.ts

@@ -4,7 +4,6 @@ export * from './event';
 export * from './number';
 export * from './proxy';
 export * from './queue';
-export * from './signal';
 export * from './string';
 export * from './timer';
 export * from './value';

package/types/queue.d.ts

@@ -1,3 +1,6 @@
+declare global {
+    var _atomic_queued: Set<() => void>;
+}
 /**
  * Queues a callback to be executed at the next best time
  */

package/src/js/signal.ts

@@ -1,259 +0,0 @@
-import {queue} from './queue';
-
-type InternalEffect = {
-	_active: boolean;
-	_callback: () => void;
-	_reactives: Set<InternalReactive>;
-};
-
-type InternalReactive = {
-	_active: boolean;
-	_effects: Set<InternalEffect>;
-	_value: unknown;
-};
-
-/**
- * The base class for reactive values
- */
-abstract class Reactive<T = unknown> {
-	protected _active = true;
-	protected _effects = new Set<InternalEffect>();
-	protected declare _value: T;
-
-	/**
-	 * The current value
-	 */
-	abstract get value(): T;
-
-	/**
-	 * The current value, returned without triggering computations or effects
-	 */
-	peek(): T {
-		return this._value;
-	}
-
-	/**
-	 * Allows reactivity for value, if it was stopped
-	 */
-	abstract run(): void;
-
-	/**
-	 * Stops reactivity for value, if it's running
-	 */
-	abstract stop(): void;
-
-	/**
-	 * Returns the JSON representation of the value
-	 */
-	toJSON(): T {
-		return this.value;
-	}
-
-	/**
-	 * Returns the string representation of the value
-	 */
-	toString(): string {
-		return String(this.value);
-	}
-}
-
-/**
- * A computed, reactive value
- */
-class Computed<T> extends Reactive<T> {
-	private readonly _effect: Effect;
-
-	/**
-	 * @inheritdoc
-	 */
-	get value(): T {
-		return getValue(this as never) as T;
-	}
-
-	constructor(callback: () => T) {
-		super();
-
-		this._effect = effect(() => setValue(this as never, callback(), false));
-	}
-
-	/**
-	 * @inheritdoc
-	 */
-	run(): void {
-		this._effect.run();
-	}
-
-	/**
-	 * @inheritdoc
-	 */
-	stop(): void {
-		this._effect.stop();
-	}
-}
-
-/**
- * A reactive effect
- */
-class Effect {
-	private _active = false;
-	private readonly _reactives = new Set<InternalReactive>();
-
-	constructor(private readonly _callback: () => void) {
-		this.run();
-	}
-
-	/**
-	 * Starts and runs the effect, if it was stopped
-	 */
-	run(): void {
-		if (this._active) {
-			return;
-		}
-
-		this._active = true;
-
-		const index = effects.push(this as never) - 1;
-
-		this._callback();
-
-		effects.splice(index, 1);
-	}
-
-	/**
-	 * Stops the effect, if it's running
-	 */
-	stop(): void {
-		if (!this._active) {
-			return;
-		}
-
-		this._active = false;
-
-		for (const value of this._reactives) {
-			value._effects.delete(this as never);
-		}
-
-		this._reactives.clear();
-	}
-}
-
-/**
- * A reactive value
- */
-class Signal<T> extends Reactive<T> {
-	/**
-	 * @inheritdoc
-	 */
-	get value(): T {
-		return getValue(this as never) as T;
-	}
-
-	/**
-	 * Sets the value
-	 */
-	set value(value: T) {
-		setValue(this as never, value, false);
-	}
-
-	constructor(protected readonly _value: T) {
-		super();
-	}
-
-	/**
-	 * @inheritdoc
-	 */
-	run(): void {
-		if (this._active) {
-			return;
-		}
-
-		this._active = true;
-
-		setValue(this as never, this._value, true);
-	}
-
-	/**
-	 * @inheritdoc
-	 */
-	stop(): void {
-		this._active = false;
-	}
-}
-
-const effects: InternalEffect[] = [];
-
-/**
- * Creates a computed, reactive value
- */
-export function computed<T>(callback: () => T): Computed<T> {
-	return new Computed(callback);
-}
-
-/**
- * Creates a reactive effect
- */
-export function effect(callback: () => void): Effect {
-	return new Effect(callback);
-}
-
-function getValue(reactive: InternalReactive): unknown {
-	const effect = effects[effects.length - 1];
-
-	if (effect !== undefined) {
-		reactive._effects.add(effect);
-		effect._reactives.add(reactive);
-	}
-
-	return reactive._value;
-}
-
-/**
- * Is the value a computed, reactive value?
- */
-export function isComputed(value: unknown): value is Computed<unknown> {
-	return value instanceof Computed;
-}
-
-/**
- * Is the value a reactive effect?
- */
-export function isEffect(value: unknown): value is Effect {
-	return value instanceof Effect;
-}
-
-/**
- * Is the value a reactive value?
- */
-export function isReactive(value: unknown): value is Reactive<unknown> {
-	return value instanceof Computed || value instanceof Signal;
-}
-
-/**
- * Is the value a reactive value?
- */
-export function isSignal(value: unknown): value is Signal<unknown> {
-	return value instanceof Signal;
-}
-
-function setValue<T>(reactive: InternalReactive, value: T, run: boolean): void {
-	if (!run && Object.is(value, reactive._value)) {
-		return;
-	}
-
-	reactive._value = value;
-
-	if (reactive._active) {
-		for (const effect of reactive._effects) {
-			queue(effect._callback);
-		}
-	}
-}
-
-/**
- * Creates a reactive value
- */
-export function signal<T>(value: T): Signal<T> {
-	return new Signal(value);
-}
-
-export type {Computed, Effect, Reactive, Signal};

package/types/signal.d.ts

@@ -1,130 +0,0 @@
-type InternalEffect = {
-    _active: boolean;
-    _callback: () => void;
-    _reactives: Set<InternalReactive>;
-};
-type InternalReactive = {
-    _active: boolean;
-    _effects: Set<InternalEffect>;
-    _value: unknown;
-};
-/**
- * The base class for reactive values
- */
-declare abstract class Reactive<T = unknown> {
-    protected _active: boolean;
-    protected _effects: Set<InternalEffect>;
-    protected _value: T;
-    /**
-     * The current value
-     */
-    abstract get value(): T;
-    /**
-     * The current value, returned without triggering computations or effects
-     */
-    peek(): T;
-    /**
-     * Allows reactivity for value, if it was stopped
-     */
-    abstract run(): void;
-    /**
-     * Stops reactivity for value, if it's running
-     */
-    abstract stop(): void;
-    /**
-     * Returns the JSON representation of the value
-     */
-    toJSON(): T;
-    /**
-     * Returns the string representation of the value
-     */
-    toString(): string;
-}
-/**
- * A computed, reactive value
- */
-declare class Computed<T> extends Reactive<T> {
-    private readonly _effect;
-    /**
-     * @inheritdoc
-     */
-    get value(): T;
-    constructor(callback: () => T);
-    /**
-     * @inheritdoc
-     */
-    run(): void;
-    /**
-     * @inheritdoc
-     */
-    stop(): void;
-}
-/**
- * A reactive effect
- */
-declare class Effect {
-    private readonly _callback;
-    private _active;
-    private readonly _reactives;
-    constructor(_callback: () => void);
-    /**
-     * Starts and runs the effect, if it was stopped
-     */
-    run(): void;
-    /**
-     * Stops the effect, if it's running
-     */
-    stop(): void;
-}
-/**
- * A reactive value
- */
-declare class Signal<T> extends Reactive<T> {
-    protected readonly _value: T;
-    /**
-     * @inheritdoc
-     */
-    get value(): T;
-    /**
-     * Sets the value
-     */
-    set value(value: T);
-    constructor(_value: T);
-    /**
-     * @inheritdoc
-     */
-    run(): void;
-    /**
-     * @inheritdoc
-     */
-    stop(): void;
-}
-/**
- * Creates a computed, reactive value
- */
-export declare function computed<T>(callback: () => T): Computed<T>;
-/**
- * Creates a reactive effect
- */
-export declare function effect(callback: () => void): Effect;
-/**
- * Is the value a computed, reactive value?
- */
-export declare function isComputed(value: unknown): value is Computed<unknown>;
-/**
- * Is the value a reactive effect?
- */
-export declare function isEffect(value: unknown): value is Effect;
-/**
- * Is the value a reactive value?
- */
-export declare function isReactive(value: unknown): value is Reactive<unknown>;
-/**
- * Is the value a reactive value?
- */
-export declare function isSignal(value: unknown): value is Signal<unknown>;
-/**
- * Creates a reactive value
- */
-export declare function signal<T>(value: T): Signal<T>;
-export type { Computed, Effect, Reactive, Signal };