@vorra/core 0.3.0

package/dist/reactivity.cjs

@@ -0,0 +1,232 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/reactivity.ts
+/**
+* The currently-executing reactive context (effect or computed).
+* When a signal is read, it registers itself as a dependency of this context.
+*/
+let activeContext = null;
+/**
+* Batch depth counter. When > 0, signal writes are queued rather than
+* flushed immediately.
+*/
+let batchDepth = 0;
+/** Queue of effects to re-run after the current batch completes. */
+const pendingEffects = /* @__PURE__ */ new Set();
+function trackDep(node) {
+	if (activeContext === null) return;
+	node.subscribers.add(activeContext);
+	activeContext.deps.add(node);
+}
+function unsubscribeContext(ctx) {
+	for (const dep of ctx.deps) dep.subscribers.delete(ctx);
+	ctx.deps.clear();
+}
+function notifySubscribers(node) {
+	for (const sub of [...node.subscribers]) sub.notify();
+}
+/**
+* Groups multiple signal writes into a single flush, preventing intermediate
+* effect executions. Effects only run once after the outermost batch ends.
+*
+* @example
+* batch(() => {
+*   firstName.set('Jane');
+*   lastName.set('Doe');
+* });
+* // Effects depending on either signal run exactly once.
+*/
+function batch(fn) {
+	batchDepth++;
+	try {
+		fn();
+	} finally {
+		batchDepth--;
+		if (batchDepth === 0) flushEffects();
+	}
+}
+function flushEffects() {
+	while (pendingEffects.size > 0) {
+		const snapshot = [...pendingEffects];
+		pendingEffects.clear();
+		for (const node of snapshot) if (!node.destroyed) runEffect(node);
+	}
+}
+function scheduleEffect(node) {
+	if (node.scheduled || node.destroyed) return;
+	node.scheduled = true;
+	pendingEffects.add(node);
+	if (batchDepth === 0) flushEffects();
+}
+/**
+* Creates a reactive signal — a piece of state that automatically notifies
+* any effects or computed values that read it when it changes.
+*
+* @example
+* const count = signal(0);
+* count();           // read → 0
+* count.set(1);      // write
+* count.update(n => n + 1);  // functional update
+*/
+function signal(initialValue, options) {
+	const node = {
+		value: initialValue,
+		subscribers: /* @__PURE__ */ new Set(),
+		equals: options?.equals ?? Object.is
+	};
+	function getter() {
+		trackDep(node);
+		return node.value;
+	}
+	function setter(value) {
+		if (node.equals(node.value, value)) return;
+		node.value = value;
+		notifySubscribers(node);
+	}
+	const writableSignal = getter;
+	Object.defineProperty(writableSignal, "__type", { value: "signal" });
+	writableSignal.set = setter;
+	writableSignal.update = (fn) => {
+		setter(fn(node.value));
+	};
+	writableSignal.asReadonly = () => {
+		const ro = (() => {
+			trackDep(node);
+			return node.value;
+		});
+		Object.defineProperty(ro, "__type", { value: "signal" });
+		return ro;
+	};
+	return writableSignal;
+}
+/**
+* Creates a lazily-evaluated derived value. Re-evaluates only when one of
+* its signal dependencies changes, and only when read.
+*
+* @example
+* const count = signal(2);
+* const doubled = computed(() => count() * 2);
+* doubled(); // → 4
+*/
+function computed(compute, options) {
+	const node = {
+		dirty: true,
+		value: void 0,
+		deps: /* @__PURE__ */ new Set(),
+		compute,
+		subscribers: /* @__PURE__ */ new Set(),
+		equals: options?.equals ?? Object.is,
+		notify() {
+			if (!node.dirty) {
+				node.dirty = true;
+				notifySubscribers(node);
+			}
+		}
+	};
+	function getter() {
+		if (activeContext !== null) {
+			node.subscribers.add(activeContext);
+			activeContext.deps.add(node);
+		}
+		if (node.dirty) {
+			unsubscribeContext(node);
+			const prevContext = activeContext;
+			activeContext = node;
+			try {
+				const newValue = compute();
+				if (node.value === void 0 || !node.equals(node.value, newValue)) node.value = newValue;
+			} finally {
+				activeContext = prevContext;
+				node.dirty = false;
+			}
+		}
+		return node.value;
+	}
+	const computedSignal = getter;
+	Object.defineProperty(computedSignal, "__type", { value: "signal" });
+	return computedSignal;
+}
+/**
+* Runs a side-effect function immediately and re-runs it whenever any signal
+* read inside it changes.
+*
+* The function may optionally return a cleanup function that runs before the
+* next execution or when the effect is destroyed.
+*
+* @returns An EffectHandle with a `destroy()` method to stop the effect.
+*
+* @example
+* const count = signal(0);
+* const handle = effect(() => {
+*   console.log('count is', count());
+*   return () => console.log('cleanup');
+* });
+* handle.destroy(); // stops the effect
+*/
+function effect(fn) {
+	const node = {
+		fn,
+		cleanup: void 0,
+		deps: /* @__PURE__ */ new Set(),
+		scheduled: false,
+		destroyed: false,
+		notify() {
+			scheduleEffect(node);
+		}
+	};
+	runEffect(node);
+	return { destroy() {
+		if (node.destroyed) return;
+		node.destroyed = true;
+		if (typeof node.cleanup === "function") node.cleanup();
+		unsubscribeContext(node);
+		pendingEffects.delete(node);
+	} };
+}
+function runEffect(node) {
+	if (node.destroyed) return;
+	if (typeof node.cleanup === "function") {
+		node.cleanup();
+		node.cleanup = void 0;
+	}
+	unsubscribeContext(node);
+	node.scheduled = false;
+	const prevContext = activeContext;
+	activeContext = node;
+	try {
+		node.cleanup = node.fn();
+	} finally {
+		activeContext = prevContext;
+	}
+}
+/**
+* Reads signals inside `fn` without registering them as dependencies of the
+* current reactive context. Useful for reading state in an effect without
+* creating subscriptions.
+*
+* @example
+* effect(() => {
+*   triggerSignal(); // subscribed
+*   const val = untrack(() => otherSignal()); // NOT subscribed
+* });
+*/
+function untrack(fn) {
+	const prevContext = activeContext;
+	activeContext = null;
+	try {
+		return fn();
+	} finally {
+		activeContext = prevContext;
+	}
+}
+function isSignal(value) {
+	return typeof value === "function" && value.__type === "signal";
+}
+//#endregion
+exports.batch = batch;
+exports.computed = computed;
+exports.effect = effect;
+exports.isSignal = isSignal;
+exports.signal = signal;
+exports.untrack = untrack;
+
+//# sourceMappingURL=reactivity.cjs.map

package/dist/reactivity.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"reactivity.cjs","names":[],"sources":["../src/reactivity.ts"],"sourcesContent":["// =============================================================================\r\n// Vorra Reactivity Core\r\n// signal() / computed() / effect() / batch() / untrack()\r\n// =============================================================================\r\n\r\n// ---------------------------------------------------------------------------\r\n// Types\r\n// ---------------------------------------------------------------------------\r\n\r\nexport type SignalGetter<T> = () => T;\r\nexport type SignalSetter<T> = (value: T | ((prev: T) => T)) => void;\r\nexport type Signal<T> = [SignalGetter<T>, SignalSetter<T>];\r\n\r\nexport interface ReadonlySignal<T> {\r\n  (): T;\r\n  readonly __type: 'signal';\r\n}\r\n\r\nexport interface WritableSignal<T> extends ReadonlySignal<T> {\r\n  set(value: T): void;\r\n  update(fn: (prev: T) => T): void;\r\n  asReadonly(): ReadonlySignal<T>;\r\n}\r\n\r\nexport interface ComputedSignal<T> extends ReadonlySignal<T> {\r\n  readonly __type: 'signal';\r\n}\r\n\r\nexport interface EffectHandle {\r\n  /** Stops the effect from running again and releases all subscriptions. */\r\n  destroy(): void;\r\n}\r\n\r\n// ---------------------------------------------------------------------------\r\n// Internal tracking state\r\n// ---------------------------------------------------------------------------\r\n\r\n/**\r\n * The currently-executing reactive context (effect or computed).\r\n * When a signal is read, it registers itself as a dependency of this context.\r\n */\r\nlet activeContext: ReactiveContext | null = null;\r\n\r\n/**\r\n * Batch depth counter. When > 0, signal writes are queued rather than\r\n * flushed immediately.\r\n */\r\nlet batchDepth = 0;\r\n\r\n/** Queue of effects to re-run after the current batch completes. */\r\nconst pendingEffects = new Set<EffectNode>();\r\n\r\n// ---------------------------------------------------------------------------\r\n// Internal node types\r\n// ---------------------------------------------------------------------------\r\n\r\ninterface ReactiveContext {\r\n  /** Called when a dependency notifies this context of a change. */\r\n  notify(): void;\r\n  /** The set of signal nodes this context is currently subscribed to. */\r\n  deps: Set<SignalNode<unknown>>;\r\n}\r\n\r\ninterface SignalNode<T> {\r\n  value: T;\r\n  /** All reactive contexts currently subscribed to this signal. */\r\n  subscribers: Set<ReactiveContext>;\r\n  /** Equality check — defaults to Object.is */\r\n  equals: (a: T, b: T) => boolean;\r\n}\r\n\r\ninterface ComputedNode<T> extends ReactiveContext {\r\n  dirty: boolean;\r\n  value: T | undefined;\r\n  deps: Set<SignalNode<unknown>>;\r\n  compute: () => T;\r\n  subscribers: Set<ReactiveContext>;\r\n  equals: (a: T, b: T) => boolean;\r\n}\r\n\r\ninterface EffectNode extends ReactiveContext {\r\n  fn: () => void | (() => void);\r\n  cleanup: (() => void) | void;\r\n  deps: Set<SignalNode<unknown>>;\r\n  scheduled: boolean;\r\n  destroyed: boolean;\r\n}\r\n\r\n// ---------------------------------------------------------------------------\r\n// Dependency tracking helpers\r\n// ---------------------------------------------------------------------------\r\n\r\nfunction trackDep<T>(node: SignalNode<T>): void {\r\n  if (activeContext === null) return;\r\n  node.subscribers.add(activeContext);\r\n  activeContext.deps.add(node as SignalNode<unknown>);\r\n}\r\n\r\nfunction unsubscribeContext(ctx: ReactiveContext): void {\r\n  for (const dep of ctx.deps) {\r\n    dep.subscribers.delete(ctx);\r\n  }\r\n  ctx.deps.clear();\r\n}\r\n\r\nfunction notifySubscribers(node: SignalNode<unknown>): void {\r\n  // Copy subscribers before iterating — a subscriber's notify() could\r\n  // mutate the set (e.g. a computed re-subscribing).\r\n  for (const sub of [...node.subscribers]) {\r\n    sub.notify();\r\n  }\r\n}\r\n\r\n// ---------------------------------------------------------------------------\r\n// Batch / flush\r\n// ---------------------------------------------------------------------------\r\n\r\n/**\r\n * Groups multiple signal writes into a single flush, preventing intermediate\r\n * effect executions. Effects only run once after the outermost batch ends.\r\n *\r\n * @example\r\n * batch(() => {\r\n *   firstName.set('Jane');\r\n *   lastName.set('Doe');\r\n * });\r\n * // Effects depending on either signal run exactly once.\r\n */\r\nexport function batch(fn: () => void): void {\r\n  batchDepth++;\r\n  try {\r\n    fn();\r\n  } finally {\r\n    batchDepth--;\r\n    if (batchDepth === 0) flushEffects();\r\n  }\r\n}\r\n\r\nfunction flushEffects(): void {\r\n  // Drain the pending set. Effects may schedule new effects during flush,\r\n  // so we loop until the set is empty.\r\n  while (pendingEffects.size > 0) {\r\n    const snapshot = [...pendingEffects];\r\n    pendingEffects.clear();\r\n    for (const node of snapshot) {\r\n      if (!node.destroyed) runEffect(node);\r\n    }\r\n  }\r\n}\r\n\r\nfunction scheduleEffect(node: EffectNode): void {\r\n  if (node.scheduled || node.destroyed) return;\r\n  node.scheduled = true;\r\n  pendingEffects.add(node);\r\n  if (batchDepth === 0) flushEffects();\r\n}\r\n\r\n// ---------------------------------------------------------------------------\r\n// signal()\r\n// ---------------------------------------------------------------------------\r\n\r\n/**\r\n * Creates a reactive signal — a piece of state that automatically notifies\r\n * any effects or computed values that read it when it changes.\r\n *\r\n * @example\r\n * const count = signal(0);\r\n * count();           // read → 0\r\n * count.set(1);      // write\r\n * count.update(n => n + 1);  // functional update\r\n */\r\nexport function signal<T>(\r\n  initialValue: T,\r\n  options?: { equals?: (a: T, b: T) => boolean }\r\n): WritableSignal<T> {\r\n  const node: SignalNode<T> = {\r\n    value: initialValue,\r\n    subscribers: new Set(),\r\n    equals: options?.equals ?? Object.is,\r\n  };\r\n\r\n  function getter(): T {\r\n    trackDep(node);\r\n    return node.value;\r\n  }\r\n\r\n  function setter(value: T): void {\r\n    if (node.equals(node.value, value)) return;\r\n    node.value = value;\r\n    notifySubscribers(node as SignalNode<unknown>);\r\n  }\r\n\r\n  const writableSignal = getter as WritableSignal<T>;\r\n\r\n  Object.defineProperty(writableSignal, '__type', { value: 'signal' });\r\n\r\n  writableSignal.set = setter;\r\n\r\n  writableSignal.update = (fn: (prev: T) => T): void => {\r\n    setter(fn(node.value));\r\n  };\r\n\r\n  writableSignal.asReadonly = (): ReadonlySignal<T> => {\r\n    const ro = (() => {\r\n      trackDep(node);\r\n      return node.value;\r\n    }) as ReadonlySignal<T>;\r\n    Object.defineProperty(ro, '__type', { value: 'signal' });\r\n    return ro;\r\n  };\r\n\r\n  return writableSignal;\r\n}\r\n\r\n// ---------------------------------------------------------------------------\r\n// computed()\r\n// ---------------------------------------------------------------------------\r\n\r\n/**\r\n * Creates a lazily-evaluated derived value. Re-evaluates only when one of\r\n * its signal dependencies changes, and only when read.\r\n *\r\n * @example\r\n * const count = signal(2);\r\n * const doubled = computed(() => count() * 2);\r\n * doubled(); // → 4\r\n */\r\nexport function computed<T>(\r\n  compute: () => T,\r\n  options?: { equals?: (a: T, b: T) => boolean }\r\n): ComputedSignal<T> {\r\n  const node: ComputedNode<T> = {\r\n    dirty: true,\r\n    value: undefined,\r\n    deps: new Set(),\r\n    compute,\r\n    subscribers: new Set(),\r\n    equals: options?.equals ?? Object.is,\r\n    notify() {\r\n      if (!node.dirty) {\r\n        node.dirty = true;\r\n        // Propagate dirtiness to downstream subscribers without re-evaluating.\r\n        notifySubscribers(node as unknown as SignalNode<unknown>);\r\n      }\r\n    },\r\n  };\r\n\r\n  function getter(): T {\r\n    // Register this computed as a dependency of the outer context.\r\n    if (activeContext !== null) {\r\n      (node as unknown as SignalNode<unknown>).subscribers.add(activeContext);\r\n      activeContext.deps.add(node as unknown as SignalNode<unknown>);\r\n    }\r\n\r\n    if (node.dirty) {\r\n      // Unsubscribe from old deps before re-running.\r\n      unsubscribeContext(node);\r\n\r\n      const prevContext = activeContext;\r\n      activeContext = node;\r\n      try {\r\n        const newValue = compute();\r\n        if (node.value === undefined || !node.equals(node.value as T, newValue)) {\r\n          node.value = newValue;\r\n        }\r\n      } finally {\r\n        activeContext = prevContext;\r\n        node.dirty = false;\r\n      }\r\n    }\r\n\r\n    return node.value as T;\r\n  }\r\n\r\n  const computedSignal = getter as ComputedSignal<T>;\r\n  Object.defineProperty(computedSignal, '__type', { value: 'signal' });\r\n  return computedSignal;\r\n}\r\n\r\n// ---------------------------------------------------------------------------\r\n// effect()\r\n// ---------------------------------------------------------------------------\r\n\r\n/**\r\n * Runs a side-effect function immediately and re-runs it whenever any signal\r\n * read inside it changes.\r\n *\r\n * The function may optionally return a cleanup function that runs before the\r\n * next execution or when the effect is destroyed.\r\n *\r\n * @returns An EffectHandle with a `destroy()` method to stop the effect.\r\n *\r\n * @example\r\n * const count = signal(0);\r\n * const handle = effect(() => {\r\n *   console.log('count is', count());\r\n *   return () => console.log('cleanup');\r\n * });\r\n * handle.destroy(); // stops the effect\r\n */\r\nexport function effect(fn: () => void | (() => void)): EffectHandle {\r\n  const node: EffectNode = {\r\n    fn,\r\n    cleanup: undefined,\r\n    deps: new Set(),\r\n    scheduled: false,\r\n    destroyed: false,\r\n    notify() {\r\n      scheduleEffect(node);\r\n    },\r\n  };\r\n\r\n  // Run immediately (synchronously).\r\n  runEffect(node);\r\n\r\n  return {\r\n    destroy() {\r\n      if (node.destroyed) return;\r\n      node.destroyed = true;\r\n      if (typeof node.cleanup === 'function') node.cleanup();\r\n      unsubscribeContext(node);\r\n      pendingEffects.delete(node);\r\n    },\r\n  };\r\n}\r\n\r\nfunction runEffect(node: EffectNode): void {\r\n  if (node.destroyed) return;\r\n\r\n  // Run previous cleanup.\r\n  if (typeof node.cleanup === 'function') {\r\n    node.cleanup();\r\n    node.cleanup = undefined;\r\n  }\r\n\r\n  // Unsubscribe from previous deps before re-tracking.\r\n  unsubscribeContext(node);\r\n\r\n  node.scheduled = false;\r\n\r\n  const prevContext = activeContext;\r\n  activeContext = node;\r\n  try {\r\n    node.cleanup = node.fn() as (() => void) | void;\r\n  } finally {\r\n    activeContext = prevContext;\r\n  }\r\n}\r\n\r\n// ---------------------------------------------------------------------------\r\n// untrack()\r\n// ---------------------------------------------------------------------------\r\n\r\n/**\r\n * Reads signals inside `fn` without registering them as dependencies of the\r\n * current reactive context. Useful for reading state in an effect without\r\n * creating subscriptions.\r\n *\r\n * @example\r\n * effect(() => {\r\n *   triggerSignal(); // subscribed\r\n *   const val = untrack(() => otherSignal()); // NOT subscribed\r\n * });\r\n */\r\nexport function untrack<T>(fn: () => T): T {\r\n  const prevContext = activeContext;\r\n  activeContext = null;\r\n  try {\r\n    return fn();\r\n  } finally {\r\n    activeContext = prevContext;\r\n  }\r\n}\r\n\r\n// ---------------------------------------------------------------------------\r\n// isSignal() type guard\r\n// ---------------------------------------------------------------------------\r\n\r\nexport function isSignal(value: unknown): value is ReadonlySignal<unknown> {\r\n  return typeof value === 'function' && (value as ReadonlySignal<unknown>).__type === 'signal';\r\n}\r\n"],"mappings":"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"}

package/dist/reactivity.d.ts

@@ -0,0 +1,88 @@
+export type SignalGetter<T> = () => T;
+export type SignalSetter<T> = (value: T | ((prev: T) => T)) => void;
+export type Signal<T> = [SignalGetter<T>, SignalSetter<T>];
+export interface ReadonlySignal<T> {
+    (): T;
+    readonly __type: 'signal';
+}
+export interface WritableSignal<T> extends ReadonlySignal<T> {
+    set(value: T): void;
+    update(fn: (prev: T) => T): void;
+    asReadonly(): ReadonlySignal<T>;
+}
+export interface ComputedSignal<T> extends ReadonlySignal<T> {
+    readonly __type: 'signal';
+}
+export interface EffectHandle {
+    /** Stops the effect from running again and releases all subscriptions. */
+    destroy(): void;
+}
+/**
+ * Groups multiple signal writes into a single flush, preventing intermediate
+ * effect executions. Effects only run once after the outermost batch ends.
+ *
+ * @example
+ * batch(() => {
+ *   firstName.set('Jane');
+ *   lastName.set('Doe');
+ * });
+ * // Effects depending on either signal run exactly once.
+ */
+export declare function batch(fn: () => void): void;
+/**
+ * Creates a reactive signal — a piece of state that automatically notifies
+ * any effects or computed values that read it when it changes.
+ *
+ * @example
+ * const count = signal(0);
+ * count();           // read → 0
+ * count.set(1);      // write
+ * count.update(n => n + 1);  // functional update
+ */
+export declare function signal<T>(initialValue: T, options?: {
+    equals?: (a: T, b: T) => boolean;
+}): WritableSignal<T>;
+/**
+ * Creates a lazily-evaluated derived value. Re-evaluates only when one of
+ * its signal dependencies changes, and only when read.
+ *
+ * @example
+ * const count = signal(2);
+ * const doubled = computed(() => count() * 2);
+ * doubled(); // → 4
+ */
+export declare function computed<T>(compute: () => T, options?: {
+    equals?: (a: T, b: T) => boolean;
+}): ComputedSignal<T>;
+/**
+ * Runs a side-effect function immediately and re-runs it whenever any signal
+ * read inside it changes.
+ *
+ * The function may optionally return a cleanup function that runs before the
+ * next execution or when the effect is destroyed.
+ *
+ * @returns An EffectHandle with a `destroy()` method to stop the effect.
+ *
+ * @example
+ * const count = signal(0);
+ * const handle = effect(() => {
+ *   console.log('count is', count());
+ *   return () => console.log('cleanup');
+ * });
+ * handle.destroy(); // stops the effect
+ */
+export declare function effect(fn: () => void | (() => void)): EffectHandle;
+/**
+ * Reads signals inside `fn` without registering them as dependencies of the
+ * current reactive context. Useful for reading state in an effect without
+ * creating subscriptions.
+ *
+ * @example
+ * effect(() => {
+ *   triggerSignal(); // subscribed
+ *   const val = untrack(() => otherSignal()); // NOT subscribed
+ * });
+ */
+export declare function untrack<T>(fn: () => T): T;
+export declare function isSignal(value: unknown): value is ReadonlySignal<unknown>;
+//# sourceMappingURL=reactivity.d.ts.map

package/dist/reactivity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reactivity.d.ts","sourceRoot":"","sources":["../src/reactivity.ts"],"names":[],"mappings":"AASA,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI,MAAM,CAAC,CAAC;AACtC,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC,KAAK,IAAI,CAAC;AACpE,MAAM,MAAM,MAAM,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC;AAE3D,MAAM,WAAW,cAAc,CAAC,CAAC;IAC/B,IAAI,CAAC,CAAC;IACN,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC;CAC3B;AAED,MAAM,WAAW,cAAc,CAAC,CAAC,CAAE,SAAQ,cAAc,CAAC,CAAC,CAAC;IAC1D,GAAG,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC;IACpB,MAAM,CAAC,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC;IACjC,UAAU,IAAI,cAAc,CAAC,CAAC,CAAC,CAAC;CACjC;AAED,MAAM,WAAW,cAAc,CAAC,CAAC,CAAE,SAAQ,cAAc,CAAC,CAAC,CAAC;IAC1D,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC;CAC3B;AAED,MAAM,WAAW,YAAY;IAC3B,0EAA0E;IAC1E,OAAO,IAAI,IAAI,CAAC;CACjB;AAsFD;;;;;;;;;;GAUG;AACH,wBAAgB,KAAK,CAAC,EAAE,EAAE,MAAM,IAAI,GAAG,IAAI,CAQ1C;AAyBD;;;;;;;;;GASG;AACH,wBAAgB,MAAM,CAAC,CAAC,EACtB,YAAY,EAAE,CAAC,EACf,OAAO,CAAC,EAAE;IAAE,MAAM,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,OAAO,CAAA;CAAE,GAC7C,cAAc,CAAC,CAAC,CAAC,CAsCnB;AAMD;;;;;;;;GAQG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EACxB,OAAO,EAAE,MAAM,CAAC,EAChB,OAAO,CAAC,EAAE;IAAE,MAAM,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,OAAO,CAAA;CAAE,GAC7C,cAAc,CAAC,CAAC,CAAC,CA+CnB;AAMD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,MAAM,CAAC,EAAE,EAAE,MAAM,IAAI,GAAG,CAAC,MAAM,IAAI,CAAC,GAAG,YAAY,CAwBlE;AA6BD;;;;;;;;;;GAUG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAQzC;AAMD,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,cAAc,CAAC,OAAO,CAAC,CAEzE"}

package/dist/reactivity.js

@@ -0,0 +1,226 @@
+//#region src/reactivity.ts
+/**
+* The currently-executing reactive context (effect or computed).
+* When a signal is read, it registers itself as a dependency of this context.
+*/
+let activeContext = null;
+/**
+* Batch depth counter. When > 0, signal writes are queued rather than
+* flushed immediately.
+*/
+let batchDepth = 0;
+/** Queue of effects to re-run after the current batch completes. */
+const pendingEffects = /* @__PURE__ */ new Set();
+function trackDep(node) {
+	if (activeContext === null) return;
+	node.subscribers.add(activeContext);
+	activeContext.deps.add(node);
+}
+function unsubscribeContext(ctx) {
+	for (const dep of ctx.deps) dep.subscribers.delete(ctx);
+	ctx.deps.clear();
+}
+function notifySubscribers(node) {
+	for (const sub of [...node.subscribers]) sub.notify();
+}
+/**
+* Groups multiple signal writes into a single flush, preventing intermediate
+* effect executions. Effects only run once after the outermost batch ends.
+*
+* @example
+* batch(() => {
+*   firstName.set('Jane');
+*   lastName.set('Doe');
+* });
+* // Effects depending on either signal run exactly once.
+*/
+function batch(fn) {
+	batchDepth++;
+	try {
+		fn();
+	} finally {
+		batchDepth--;
+		if (batchDepth === 0) flushEffects();
+	}
+}
+function flushEffects() {
+	while (pendingEffects.size > 0) {
+		const snapshot = [...pendingEffects];
+		pendingEffects.clear();
+		for (const node of snapshot) if (!node.destroyed) runEffect(node);
+	}
+}
+function scheduleEffect(node) {
+	if (node.scheduled || node.destroyed) return;
+	node.scheduled = true;
+	pendingEffects.add(node);
+	if (batchDepth === 0) flushEffects();
+}
+/**
+* Creates a reactive signal — a piece of state that automatically notifies
+* any effects or computed values that read it when it changes.
+*
+* @example
+* const count = signal(0);
+* count();           // read → 0
+* count.set(1);      // write
+* count.update(n => n + 1);  // functional update
+*/
+function signal(initialValue, options) {
+	const node = {
+		value: initialValue,
+		subscribers: /* @__PURE__ */ new Set(),
+		equals: options?.equals ?? Object.is
+	};
+	function getter() {
+		trackDep(node);
+		return node.value;
+	}
+	function setter(value) {
+		if (node.equals(node.value, value)) return;
+		node.value = value;
+		notifySubscribers(node);
+	}
+	const writableSignal = getter;
+	Object.defineProperty(writableSignal, "__type", { value: "signal" });
+	writableSignal.set = setter;
+	writableSignal.update = (fn) => {
+		setter(fn(node.value));
+	};
+	writableSignal.asReadonly = () => {
+		const ro = (() => {
+			trackDep(node);
+			return node.value;
+		});
+		Object.defineProperty(ro, "__type", { value: "signal" });
+		return ro;
+	};
+	return writableSignal;
+}
+/**
+* Creates a lazily-evaluated derived value. Re-evaluates only when one of
+* its signal dependencies changes, and only when read.
+*
+* @example
+* const count = signal(2);
+* const doubled = computed(() => count() * 2);
+* doubled(); // → 4
+*/
+function computed(compute, options) {
+	const node = {
+		dirty: true,
+		value: void 0,
+		deps: /* @__PURE__ */ new Set(),
+		compute,
+		subscribers: /* @__PURE__ */ new Set(),
+		equals: options?.equals ?? Object.is,
+		notify() {
+			if (!node.dirty) {
+				node.dirty = true;
+				notifySubscribers(node);
+			}
+		}
+	};
+	function getter() {
+		if (activeContext !== null) {
+			node.subscribers.add(activeContext);
+			activeContext.deps.add(node);
+		}
+		if (node.dirty) {
+			unsubscribeContext(node);
+			const prevContext = activeContext;
+			activeContext = node;
+			try {
+				const newValue = compute();
+				if (node.value === void 0 || !node.equals(node.value, newValue)) node.value = newValue;
+			} finally {
+				activeContext = prevContext;
+				node.dirty = false;
+			}
+		}
+		return node.value;
+	}
+	const computedSignal = getter;
+	Object.defineProperty(computedSignal, "__type", { value: "signal" });
+	return computedSignal;
+}
+/**
+* Runs a side-effect function immediately and re-runs it whenever any signal
+* read inside it changes.
+*
+* The function may optionally return a cleanup function that runs before the
+* next execution or when the effect is destroyed.
+*
+* @returns An EffectHandle with a `destroy()` method to stop the effect.
+*
+* @example
+* const count = signal(0);
+* const handle = effect(() => {
+*   console.log('count is', count());
+*   return () => console.log('cleanup');
+* });
+* handle.destroy(); // stops the effect
+*/
+function effect(fn) {
+	const node = {
+		fn,
+		cleanup: void 0,
+		deps: /* @__PURE__ */ new Set(),
+		scheduled: false,
+		destroyed: false,
+		notify() {
+			scheduleEffect(node);
+		}
+	};
+	runEffect(node);
+	return { destroy() {
+		if (node.destroyed) return;
+		node.destroyed = true;
+		if (typeof node.cleanup === "function") node.cleanup();
+		unsubscribeContext(node);
+		pendingEffects.delete(node);
+	} };
+}
+function runEffect(node) {
+	if (node.destroyed) return;
+	if (typeof node.cleanup === "function") {
+		node.cleanup();
+		node.cleanup = void 0;
+	}
+	unsubscribeContext(node);
+	node.scheduled = false;
+	const prevContext = activeContext;
+	activeContext = node;
+	try {
+		node.cleanup = node.fn();
+	} finally {
+		activeContext = prevContext;
+	}
+}
+/**
+* Reads signals inside `fn` without registering them as dependencies of the
+* current reactive context. Useful for reading state in an effect without
+* creating subscriptions.
+*
+* @example
+* effect(() => {
+*   triggerSignal(); // subscribed
+*   const val = untrack(() => otherSignal()); // NOT subscribed
+* });
+*/
+function untrack(fn) {
+	const prevContext = activeContext;
+	activeContext = null;
+	try {
+		return fn();
+	} finally {
+		activeContext = prevContext;
+	}
+}
+function isSignal(value) {
+	return typeof value === "function" && value.__type === "signal";
+}
+//#endregion
+export { batch, computed, effect, isSignal, signal, untrack };
+
+//# sourceMappingURL=reactivity.js.map

package/dist/reactivity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reactivity.js","names":[],"sources":["../src/reactivity.ts"],"sourcesContent":["// =============================================================================\r\n// Vorra Reactivity Core\r\n// signal() / computed() / effect() / batch() / untrack()\r\n// =============================================================================\r\n\r\n// ---------------------------------------------------------------------------\r\n// Types\r\n// ---------------------------------------------------------------------------\r\n\r\nexport type SignalGetter<T> = () => T;\r\nexport type SignalSetter<T> = (value: T | ((prev: T) => T)) => void;\r\nexport type Signal<T> = [SignalGetter<T>, SignalSetter<T>];\r\n\r\nexport interface ReadonlySignal<T> {\r\n  (): T;\r\n  readonly __type: 'signal';\r\n}\r\n\r\nexport interface WritableSignal<T> extends ReadonlySignal<T> {\r\n  set(value: T): void;\r\n  update(fn: (prev: T) => T): void;\r\n  asReadonly(): ReadonlySignal<T>;\r\n}\r\n\r\nexport interface ComputedSignal<T> extends ReadonlySignal<T> {\r\n  readonly __type: 'signal';\r\n}\r\n\r\nexport interface EffectHandle {\r\n  /** Stops the effect from running again and releases all subscriptions. */\r\n  destroy(): void;\r\n}\r\n\r\n// ---------------------------------------------------------------------------\r\n// Internal tracking state\r\n// ---------------------------------------------------------------------------\r\n\r\n/**\r\n * The currently-executing reactive context (effect or computed).\r\n * When a signal is read, it registers itself as a dependency of this context.\r\n */\r\nlet activeContext: ReactiveContext | null = null;\r\n\r\n/**\r\n * Batch depth counter. When > 0, signal writes are queued rather than\r\n * flushed immediately.\r\n */\r\nlet batchDepth = 0;\r\n\r\n/** Queue of effects to re-run after the current batch completes. */\r\nconst pendingEffects = new Set<EffectNode>();\r\n\r\n// ---------------------------------------------------------------------------\r\n// Internal node types\r\n// ---------------------------------------------------------------------------\r\n\r\ninterface ReactiveContext {\r\n  /** Called when a dependency notifies this context of a change. */\r\n  notify(): void;\r\n  /** The set of signal nodes this context is currently subscribed to. */\r\n  deps: Set<SignalNode<unknown>>;\r\n}\r\n\r\ninterface SignalNode<T> {\r\n  value: T;\r\n  /** All reactive contexts currently subscribed to this signal. */\r\n  subscribers: Set<ReactiveContext>;\r\n  /** Equality check — defaults to Object.is */\r\n  equals: (a: T, b: T) => boolean;\r\n}\r\n\r\ninterface ComputedNode<T> extends ReactiveContext {\r\n  dirty: boolean;\r\n  value: T | undefined;\r\n  deps: Set<SignalNode<unknown>>;\r\n  compute: () => T;\r\n  subscribers: Set<ReactiveContext>;\r\n  equals: (a: T, b: T) => boolean;\r\n}\r\n\r\ninterface EffectNode extends ReactiveContext {\r\n  fn: () => void | (() => void);\r\n  cleanup: (() => void) | void;\r\n  deps: Set<SignalNode<unknown>>;\r\n  scheduled: boolean;\r\n  destroyed: boolean;\r\n}\r\n\r\n// ---------------------------------------------------------------------------\r\n// Dependency tracking helpers\r\n// ---------------------------------------------------------------------------\r\n\r\nfunction trackDep<T>(node: SignalNode<T>): void {\r\n  if (activeContext === null) return;\r\n  node.subscribers.add(activeContext);\r\n  activeContext.deps.add(node as SignalNode<unknown>);\r\n}\r\n\r\nfunction unsubscribeContext(ctx: ReactiveContext): void {\r\n  for (const dep of ctx.deps) {\r\n    dep.subscribers.delete(ctx);\r\n  }\r\n  ctx.deps.clear();\r\n}\r\n\r\nfunction notifySubscribers(node: SignalNode<unknown>): void {\r\n  // Copy subscribers before iterating — a subscriber's notify() could\r\n  // mutate the set (e.g. a computed re-subscribing).\r\n  for (const sub of [...node.subscribers]) {\r\n    sub.notify();\r\n  }\r\n}\r\n\r\n// ---------------------------------------------------------------------------\r\n// Batch / flush\r\n// ---------------------------------------------------------------------------\r\n\r\n/**\r\n * Groups multiple signal writes into a single flush, preventing intermediate\r\n * effect executions. Effects only run once after the outermost batch ends.\r\n *\r\n * @example\r\n * batch(() => {\r\n *   firstName.set('Jane');\r\n *   lastName.set('Doe');\r\n * });\r\n * // Effects depending on either signal run exactly once.\r\n */\r\nexport function batch(fn: () => void): void {\r\n  batchDepth++;\r\n  try {\r\n    fn();\r\n  } finally {\r\n    batchDepth--;\r\n    if (batchDepth === 0) flushEffects();\r\n  }\r\n}\r\n\r\nfunction flushEffects(): void {\r\n  // Drain the pending set. Effects may schedule new effects during flush,\r\n  // so we loop until the set is empty.\r\n  while (pendingEffects.size > 0) {\r\n    const snapshot = [...pendingEffects];\r\n    pendingEffects.clear();\r\n    for (const node of snapshot) {\r\n      if (!node.destroyed) runEffect(node);\r\n    }\r\n  }\r\n}\r\n\r\nfunction scheduleEffect(node: EffectNode): void {\r\n  if (node.scheduled || node.destroyed) return;\r\n  node.scheduled = true;\r\n  pendingEffects.add(node);\r\n  if (batchDepth === 0) flushEffects();\r\n}\r\n\r\n// ---------------------------------------------------------------------------\r\n// signal()\r\n// ---------------------------------------------------------------------------\r\n\r\n/**\r\n * Creates a reactive signal — a piece of state that automatically notifies\r\n * any effects or computed values that read it when it changes.\r\n *\r\n * @example\r\n * const count = signal(0);\r\n * count();           // read → 0\r\n * count.set(1);      // write\r\n * count.update(n => n + 1);  // functional update\r\n */\r\nexport function signal<T>(\r\n  initialValue: T,\r\n  options?: { equals?: (a: T, b: T) => boolean }\r\n): WritableSignal<T> {\r\n  const node: SignalNode<T> = {\r\n    value: initialValue,\r\n    subscribers: new Set(),\r\n    equals: options?.equals ?? Object.is,\r\n  };\r\n\r\n  function getter(): T {\r\n    trackDep(node);\r\n    return node.value;\r\n  }\r\n\r\n  function setter(value: T): void {\r\n    if (node.equals(node.value, value)) return;\r\n    node.value = value;\r\n    notifySubscribers(node as SignalNode<unknown>);\r\n  }\r\n\r\n  const writableSignal = getter as WritableSignal<T>;\r\n\r\n  Object.defineProperty(writableSignal, '__type', { value: 'signal' });\r\n\r\n  writableSignal.set = setter;\r\n\r\n  writableSignal.update = (fn: (prev: T) => T): void => {\r\n    setter(fn(node.value));\r\n  };\r\n\r\n  writableSignal.asReadonly = (): ReadonlySignal<T> => {\r\n    const ro = (() => {\r\n      trackDep(node);\r\n      return node.value;\r\n    }) as ReadonlySignal<T>;\r\n    Object.defineProperty(ro, '__type', { value: 'signal' });\r\n    return ro;\r\n  };\r\n\r\n  return writableSignal;\r\n}\r\n\r\n// ---------------------------------------------------------------------------\r\n// computed()\r\n// ---------------------------------------------------------------------------\r\n\r\n/**\r\n * Creates a lazily-evaluated derived value. Re-evaluates only when one of\r\n * its signal dependencies changes, and only when read.\r\n *\r\n * @example\r\n * const count = signal(2);\r\n * const doubled = computed(() => count() * 2);\r\n * doubled(); // → 4\r\n */\r\nexport function computed<T>(\r\n  compute: () => T,\r\n  options?: { equals?: (a: T, b: T) => boolean }\r\n): ComputedSignal<T> {\r\n  const node: ComputedNode<T> = {\r\n    dirty: true,\r\n    value: undefined,\r\n    deps: new Set(),\r\n    compute,\r\n    subscribers: new Set(),\r\n    equals: options?.equals ?? Object.is,\r\n    notify() {\r\n      if (!node.dirty) {\r\n        node.dirty = true;\r\n        // Propagate dirtiness to downstream subscribers without re-evaluating.\r\n        notifySubscribers(node as unknown as SignalNode<unknown>);\r\n      }\r\n    },\r\n  };\r\n\r\n  function getter(): T {\r\n    // Register this computed as a dependency of the outer context.\r\n    if (activeContext !== null) {\r\n      (node as unknown as SignalNode<unknown>).subscribers.add(activeContext);\r\n      activeContext.deps.add(node as unknown as SignalNode<unknown>);\r\n    }\r\n\r\n    if (node.dirty) {\r\n      // Unsubscribe from old deps before re-running.\r\n      unsubscribeContext(node);\r\n\r\n      const prevContext = activeContext;\r\n      activeContext = node;\r\n      try {\r\n        const newValue = compute();\r\n        if (node.value === undefined || !node.equals(node.value as T, newValue)) {\r\n          node.value = newValue;\r\n        }\r\n      } finally {\r\n        activeContext = prevContext;\r\n        node.dirty = false;\r\n      }\r\n    }\r\n\r\n    return node.value as T;\r\n  }\r\n\r\n  const computedSignal = getter as ComputedSignal<T>;\r\n  Object.defineProperty(computedSignal, '__type', { value: 'signal' });\r\n  return computedSignal;\r\n}\r\n\r\n// ---------------------------------------------------------------------------\r\n// effect()\r\n// ---------------------------------------------------------------------------\r\n\r\n/**\r\n * Runs a side-effect function immediately and re-runs it whenever any signal\r\n * read inside it changes.\r\n *\r\n * The function may optionally return a cleanup function that runs before the\r\n * next execution or when the effect is destroyed.\r\n *\r\n * @returns An EffectHandle with a `destroy()` method to stop the effect.\r\n *\r\n * @example\r\n * const count = signal(0);\r\n * const handle = effect(() => {\r\n *   console.log('count is', count());\r\n *   return () => console.log('cleanup');\r\n * });\r\n * handle.destroy(); // stops the effect\r\n */\r\nexport function effect(fn: () => void | (() => void)): EffectHandle {\r\n  const node: EffectNode = {\r\n    fn,\r\n    cleanup: undefined,\r\n    deps: new Set(),\r\n    scheduled: false,\r\n    destroyed: false,\r\n    notify() {\r\n      scheduleEffect(node);\r\n    },\r\n  };\r\n\r\n  // Run immediately (synchronously).\r\n  runEffect(node);\r\n\r\n  return {\r\n    destroy() {\r\n      if (node.destroyed) return;\r\n      node.destroyed = true;\r\n      if (typeof node.cleanup === 'function') node.cleanup();\r\n      unsubscribeContext(node);\r\n      pendingEffects.delete(node);\r\n    },\r\n  };\r\n}\r\n\r\nfunction runEffect(node: EffectNode): void {\r\n  if (node.destroyed) return;\r\n\r\n  // Run previous cleanup.\r\n  if (typeof node.cleanup === 'function') {\r\n    node.cleanup();\r\n    node.cleanup = undefined;\r\n  }\r\n\r\n  // Unsubscribe from previous deps before re-tracking.\r\n  unsubscribeContext(node);\r\n\r\n  node.scheduled = false;\r\n\r\n  const prevContext = activeContext;\r\n  activeContext = node;\r\n  try {\r\n    node.cleanup = node.fn() as (() => void) | void;\r\n  } finally {\r\n    activeContext = prevContext;\r\n  }\r\n}\r\n\r\n// ---------------------------------------------------------------------------\r\n// untrack()\r\n// ---------------------------------------------------------------------------\r\n\r\n/**\r\n * Reads signals inside `fn` without registering them as dependencies of the\r\n * current reactive context. Useful for reading state in an effect without\r\n * creating subscriptions.\r\n *\r\n * @example\r\n * effect(() => {\r\n *   triggerSignal(); // subscribed\r\n *   const val = untrack(() => otherSignal()); // NOT subscribed\r\n * });\r\n */\r\nexport function untrack<T>(fn: () => T): T {\r\n  const prevContext = activeContext;\r\n  activeContext = null;\r\n  try {\r\n    return fn();\r\n  } finally {\r\n    activeContext = prevContext;\r\n  }\r\n}\r\n\r\n// ---------------------------------------------------------------------------\r\n// isSignal() type guard\r\n// ---------------------------------------------------------------------------\r\n\r\nexport function isSignal(value: unknown): value is ReadonlySignal<unknown> {\r\n  return typeof value === 'function' && (value as ReadonlySignal<unknown>).__type === 'signal';\r\n}\r\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@vorra/core",
+  "version": "0.3.0",
+  "description": "Vorra core — reactivity primitives and dependency injection",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ubergeoff/vorra.git",
+    "directory": "packages/core"
+  },
+  "homepage": "https://github.com/ubergeoff/vorra/tree/main/packages/core#readme",
+  "keywords": [
+    "vorra",
+    "signals",
+    "reactivity",
+    "dependency-injection",
+    "framework"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "types": "./dist/index.d.ts"
+    },
+    "./reactivity": {
+      "import": "./dist/reactivity.js",
+      "require": "./dist/reactivity.cjs",
+      "types": "./dist/reactivity.d.ts"
+    },
+    "./di": {
+      "import": "./dist/di.js",
+      "require": "./dist/di.cjs",
+      "types": "./dist/di.d.ts"
+    },
+    "./dom": {
+      "import": "./dist/dom.js",
+      "require": "./dist/dom.cjs",
+      "types": "./dist/dom.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "rolldown -c rolldown.config.mjs",
+    "clean": "rm -rf dist *.tsbuildinfo"
+  },
+  "devDependencies": {
+    "rolldown": "*",
+    "typescript": "*",
+    "vitest": "*"
+  },
+  "sideEffects": false
+}