@xaendar/core 0.9.18 → 0.9.22

package/dist/signals-C-55LNEj.cjs

@@ -0,0 +1,261 @@
+//#region ../packages/core/src/signals/input/input-instance.symbol.ts
+/**
+* Unique symbol used to mark an object as a valid `InputSignal` instance.
+*
+* Set to `true` on every `InputSignal` created by the `input()` factory.
+* Used by {@link isInputSignal} to distinguish input signals from plain
+* `Signal.State` instances at runtime without exposing the marker in the
+* public API.
+*
+* @internal
+*/
+var INPUT_SIGNAL_INSTANCE_SYMBOL = Symbol(`InputSignalInstance`);
+/**
+* Type guard that checks whether a given value is an `InputSignal` instance.
+*
+* Inspects the presence of {@link INPUT_SIGNAL_INSTANCE_SYMBOL} on the object,
+* which is set to `true` by the `input()` factory for every valid instance.
+*
+* @param instance - The value to inspect.
+* @returns `true` if `instance` is an `InputSignal`, `false` otherwise.
+*/
+function isInputSignal(instance) {
+	return instance?.[INPUT_SIGNAL_INSTANCE_SYMBOL];
+}
+//#endregion
+//#region ../packages/core/src/signals/input/input-set.symbol.ts
+/**
+* This symbol is used to call the set method of the InputSignal
+* Normally the set method is permitted internally and should not be called
+* by the User
+*/
+var INPUT_SIGNAL_SET_SYMBOL = Symbol(`InputSignalSet`);
+/**
+* Asserts that the provided symbol matches the internal {@link INPUT_SIGNAL_SET_SYMBOL} symbol,
+* ensuring the caller has access to internal APIs.
+*
+* Throws if the symbol does not match, preventing external code from
+* invoking methods intended for internal use only.
+*
+* @param symbol - The symbol to validate against {@link INPUT_SIGNAL_SET_SYMBOL}.
+* @throws {Error} If `symbol` does not match {@link INPUT_SIGNAL_SET_SYMBOL}.
+* @internal
+*/
+function assertPrivateContext(symbol) {
+	if (symbol !== INPUT_SIGNAL_SET_SYMBOL) throw new Error("Invalid symbol for InputSignal set method");
+}
+//#endregion
+//#region ../packages/core/src/signals/input/input.ts
+/**
+* Creates an `InputSignal` — a specialized reactive state designed for use
+* as a property signal in web components.
+*
+* Unlike a plain `Signal.State`, the `set` method of an `InputSignal` is
+* restricted to internal callers (identified by the private symbol) and
+* accepts an optional `transform` function that converts incoming values
+* (e.g. raw HTML attribute strings) into the internally stored type before
+* updating the signal.
+*
+* @param value - The initial value of the signal.
+* @param options - Optional configuration including an equality function,
+*   lifecycle hooks, and a `transform` function applied to incoming values.
+* @returns A new `InputSignal` instance.
+*/
+function input(value, options) {
+	const transform = options?.transform;
+	delete options?.transform;
+	const signal = new Signal.State(value, options);
+	const originalSet = signal.set;
+	const getter = function() {
+		return signal.get();
+	};
+	Object.assign(getter, {
+		set(newValue, symbol) {
+			assertPrivateContext(symbol);
+			const transformedValue = transform ? transform(newValue) : newValue;
+			originalSet.call(signal, transformedValue);
+		},
+		get: signal.get.bind(signal)
+	});
+	getter[INPUT_SIGNAL_INSTANCE_SYMBOL] = true;
+	return getter;
+}
+//#endregion
+//#region ../packages/core/src/signals/computed/computed.ts
+/**
+* Creates a read-only computed signal whose value is derived from other signals.
+*
+* Returns a callable getter that reads the current value, augmented with the
+* underlying {@link Signal.State} API.
+*
+* @template Value - The type of the computed value. Defaults to `any`.
+* @param value - The initial (seed) value of the computed signal.
+* @param options - Configuration options for the underlying signal.
+* @returns A {@link Computed} instance.
+*/
+function computed(value, options) {
+	const signal = new Signal.State(value, options);
+	const getter = function() {
+		return signal.get();
+	};
+	Object.assign(getter, { get: signal.get.bind(signal) });
+	return getter;
+}
+//#endregion
+//#region ../packages/core/src/signals/effect/effect.ts
+/**
+* Runs a side-effectful function and automatically re-runs it whenever any
+* Signal read during its execution changes.
+*
+* Internally, `effect` wraps the user callback inside a `Computed` node
+* (for dependency tracking) and observes it with a `Watcher` (for push
+* notifications). When any tracked dependency changes, the `Watcher`
+* schedules a microtask that re-evaluates the `Computed`, which in turn
+* re-runs the user callback and re-registers the new set of dependencies.
+*
+* The returned disposer function stops the effect: it unwatches the internal
+* `Computed` from the `Watcher`, severing all dependency subscriptions so
+* the callback is never called again and the graph nodes can be
+* garbage-collected.
+*
+* @example
+* ```ts
+* const count = new State(0);
+*
+* const stop = effect(() => {
+*   console.log('count is', count.get());
+* });
+* // logs: "count is 0"
+*
+* count.set(1); // logs: "count is 1"
+* count.set(2); // logs: "count is 2"
+*
+* stop();       // no more logs
+* count.set(3); // silent
+* ```
+*
+* @param fn - The side-effectful function to run. Any Signal read inside it
+*   is tracked as a dependency.
+* @returns A disposer function that, when called, permanently stops the effect.
+*/
+function effect(fn, options) {
+	/**
+	* Wrap the user callback in a Computed so that automatic dependency
+	* tracking (via pushComputed / popComputed) works for free.
+	* The Computed always returns `undefined` — we only care about the
+	* side-effects and the tracked sources, not the value.
+	*/
+	const computed = new Signal.Computed(() => fn());
+	let needsEnqueue = true;
+	/**
+	* The Watcher is notified synchronously as soon as any tracked dependency
+	* changes. Its job is purely to schedule the re-execution; the actual
+	* re-evaluation happens asynchronously in a microtask so that multiple
+	* synchronous signal updates are batched into a single re-run.
+	*/
+	const watcher = new Signal.subtle.Watcher(() => {
+		if (needsEnqueue) {
+			needsEnqueue = false;
+			queueMicrotask(() => {
+				needsEnqueue = true;
+				options?.onBeforeRun?.();
+				const pendings = watcher.getPending();
+				for (let i = 0; i < pendings.length; i++) pendings[i].get();
+				options?.onAfterRun?.();
+				watcher.watch();
+			});
+		}
+	});
+	options?.onBeforeRun?.();
+	watcher.watch(computed);
+	computed.get();
+	options?.onAfterRun?.();
+	/**
+	* Disposer — call this to permanently stop the effect.
+	*
+	* Unwatching the Computed tears down the entire live dependency chain
+	* (Watcher → Computed → all sources), preventing any further
+	* notifications and allowing GC.
+	*/
+	return () => {
+		options?.onCleanup?.();
+		watcher.unwatch(computed);
+	};
+}
+//#endregion
+//#region ../packages/core/src/signals/signal/signal.ts
+/**
+* Creates a writable reactive signal.
+*
+* Returns a callable getter that reads the current value, augmented with the
+* underlying {@link Signal.State} API and an `update` method to derive the next
+* value from the previous one.
+*
+* @template T - The type of the stored value. Defaults to `any`.
+* @param value - The initial value of the signal.
+* @param options - Configuration options for the signal.
+* @returns A {@link SignalType} instance.
+*/
+function signal(value, options) {
+	const signal = new Signal.State(value, options);
+	const getter = function() {
+		return signal.get();
+	};
+	Object.assign(getter, {
+		set: signal.set.bind(signal),
+		get: signal.get.bind(signal),
+		update: (updater) => signal.set(updater(signal.get()))
+	});
+	return getter;
+}
+//#endregion
+//#region ../packages/core/src/signals/untracked.ts
+/**
+* Executes a function without tracking any dependencies.
+* @param fn - The function to execute without tracking.
+* @returns The result of the function execution.
+*/
+var untracked = Signal.subtle.untrack;
+//#endregion
+Object.defineProperty(exports, "INPUT_SIGNAL_SET_SYMBOL", {
+	enumerable: true,
+	get: function() {
+		return INPUT_SIGNAL_SET_SYMBOL;
+	}
+});
+Object.defineProperty(exports, "computed", {
+	enumerable: true,
+	get: function() {
+		return computed;
+	}
+});
+Object.defineProperty(exports, "effect", {
+	enumerable: true,
+	get: function() {
+		return effect;
+	}
+});
+Object.defineProperty(exports, "input", {
+	enumerable: true,
+	get: function() {
+		return input;
+	}
+});
+Object.defineProperty(exports, "isInputSignal", {
+	enumerable: true,
+	get: function() {
+		return isInputSignal;
+	}
+});
+Object.defineProperty(exports, "signal", {
+	enumerable: true,
+	get: function() {
+		return signal;
+	}
+});
+Object.defineProperty(exports, "untracked", {
+	enumerable: true,
+	get: function() {
+		return untracked;
+	}
+});

package/dist/signals-CxEAdVoe.js

@@ -0,0 +1,220 @@
+//#region ../packages/core/src/signals/input/input-instance.symbol.ts
+/**
+* Unique symbol used to mark an object as a valid `InputSignal` instance.
+*
+* Set to `true` on every `InputSignal` created by the `input()` factory.
+* Used by {@link isInputSignal} to distinguish input signals from plain
+* `Signal.State` instances at runtime without exposing the marker in the
+* public API.
+*
+* @internal
+*/
+var INPUT_SIGNAL_INSTANCE_SYMBOL = Symbol(`InputSignalInstance`);
+/**
+* Type guard that checks whether a given value is an `InputSignal` instance.
+*
+* Inspects the presence of {@link INPUT_SIGNAL_INSTANCE_SYMBOL} on the object,
+* which is set to `true` by the `input()` factory for every valid instance.
+*
+* @param instance - The value to inspect.
+* @returns `true` if `instance` is an `InputSignal`, `false` otherwise.
+*/
+function isInputSignal(instance) {
+	return instance?.[INPUT_SIGNAL_INSTANCE_SYMBOL];
+}
+//#endregion
+//#region ../packages/core/src/signals/input/input-set.symbol.ts
+/**
+* This symbol is used to call the set method of the InputSignal
+* Normally the set method is permitted internally and should not be called
+* by the User
+*/
+var INPUT_SIGNAL_SET_SYMBOL = Symbol(`InputSignalSet`);
+/**
+* Asserts that the provided symbol matches the internal {@link INPUT_SIGNAL_SET_SYMBOL} symbol,
+* ensuring the caller has access to internal APIs.
+*
+* Throws if the symbol does not match, preventing external code from
+* invoking methods intended for internal use only.
+*
+* @param symbol - The symbol to validate against {@link INPUT_SIGNAL_SET_SYMBOL}.
+* @throws {Error} If `symbol` does not match {@link INPUT_SIGNAL_SET_SYMBOL}.
+* @internal
+*/
+function assertPrivateContext(symbol) {
+	if (symbol !== INPUT_SIGNAL_SET_SYMBOL) throw new Error("Invalid symbol for InputSignal set method");
+}
+//#endregion
+//#region ../packages/core/src/signals/input/input.ts
+/**
+* Creates an `InputSignal` — a specialized reactive state designed for use
+* as a property signal in web components.
+*
+* Unlike a plain `Signal.State`, the `set` method of an `InputSignal` is
+* restricted to internal callers (identified by the private symbol) and
+* accepts an optional `transform` function that converts incoming values
+* (e.g. raw HTML attribute strings) into the internally stored type before
+* updating the signal.
+*
+* @param value - The initial value of the signal.
+* @param options - Optional configuration including an equality function,
+*   lifecycle hooks, and a `transform` function applied to incoming values.
+* @returns A new `InputSignal` instance.
+*/
+function input(value, options) {
+	const transform = options?.transform;
+	delete options?.transform;
+	const signal = new Signal.State(value, options);
+	const originalSet = signal.set;
+	const getter = function() {
+		return signal.get();
+	};
+	Object.assign(getter, {
+		set(newValue, symbol) {
+			assertPrivateContext(symbol);
+			const transformedValue = transform ? transform(newValue) : newValue;
+			originalSet.call(signal, transformedValue);
+		},
+		get: signal.get.bind(signal)
+	});
+	getter[INPUT_SIGNAL_INSTANCE_SYMBOL] = true;
+	return getter;
+}
+//#endregion
+//#region ../packages/core/src/signals/computed/computed.ts
+/**
+* Creates a read-only computed signal whose value is derived from other signals.
+*
+* Returns a callable getter that reads the current value, augmented with the
+* underlying {@link Signal.State} API.
+*
+* @template Value - The type of the computed value. Defaults to `any`.
+* @param value - The initial (seed) value of the computed signal.
+* @param options - Configuration options for the underlying signal.
+* @returns A {@link Computed} instance.
+*/
+function computed(value, options) {
+	const signal = new Signal.State(value, options);
+	const getter = function() {
+		return signal.get();
+	};
+	Object.assign(getter, { get: signal.get.bind(signal) });
+	return getter;
+}
+//#endregion
+//#region ../packages/core/src/signals/effect/effect.ts
+/**
+* Runs a side-effectful function and automatically re-runs it whenever any
+* Signal read during its execution changes.
+*
+* Internally, `effect` wraps the user callback inside a `Computed` node
+* (for dependency tracking) and observes it with a `Watcher` (for push
+* notifications). When any tracked dependency changes, the `Watcher`
+* schedules a microtask that re-evaluates the `Computed`, which in turn
+* re-runs the user callback and re-registers the new set of dependencies.
+*
+* The returned disposer function stops the effect: it unwatches the internal
+* `Computed` from the `Watcher`, severing all dependency subscriptions so
+* the callback is never called again and the graph nodes can be
+* garbage-collected.
+*
+* @example
+* ```ts
+* const count = new State(0);
+*
+* const stop = effect(() => {
+*   console.log('count is', count.get());
+* });
+* // logs: "count is 0"
+*
+* count.set(1); // logs: "count is 1"
+* count.set(2); // logs: "count is 2"
+*
+* stop();       // no more logs
+* count.set(3); // silent
+* ```
+*
+* @param fn - The side-effectful function to run. Any Signal read inside it
+*   is tracked as a dependency.
+* @returns A disposer function that, when called, permanently stops the effect.
+*/
+function effect(fn, options) {
+	/**
+	* Wrap the user callback in a Computed so that automatic dependency
+	* tracking (via pushComputed / popComputed) works for free.
+	* The Computed always returns `undefined` — we only care about the
+	* side-effects and the tracked sources, not the value.
+	*/
+	const computed = new Signal.Computed(() => fn());
+	let needsEnqueue = true;
+	/**
+	* The Watcher is notified synchronously as soon as any tracked dependency
+	* changes. Its job is purely to schedule the re-execution; the actual
+	* re-evaluation happens asynchronously in a microtask so that multiple
+	* synchronous signal updates are batched into a single re-run.
+	*/
+	const watcher = new Signal.subtle.Watcher(() => {
+		if (needsEnqueue) {
+			needsEnqueue = false;
+			queueMicrotask(() => {
+				needsEnqueue = true;
+				options?.onBeforeRun?.();
+				const pendings = watcher.getPending();
+				for (let i = 0; i < pendings.length; i++) pendings[i].get();
+				options?.onAfterRun?.();
+				watcher.watch();
+			});
+		}
+	});
+	options?.onBeforeRun?.();
+	watcher.watch(computed);
+	computed.get();
+	options?.onAfterRun?.();
+	/**
+	* Disposer — call this to permanently stop the effect.
+	*
+	* Unwatching the Computed tears down the entire live dependency chain
+	* (Watcher → Computed → all sources), preventing any further
+	* notifications and allowing GC.
+	*/
+	return () => {
+		options?.onCleanup?.();
+		watcher.unwatch(computed);
+	};
+}
+//#endregion
+//#region ../packages/core/src/signals/signal/signal.ts
+/**
+* Creates a writable reactive signal.
+*
+* Returns a callable getter that reads the current value, augmented with the
+* underlying {@link Signal.State} API and an `update` method to derive the next
+* value from the previous one.
+*
+* @template T - The type of the stored value. Defaults to `any`.
+* @param value - The initial value of the signal.
+* @param options - Configuration options for the signal.
+* @returns A {@link SignalType} instance.
+*/
+function signal(value, options) {
+	const signal = new Signal.State(value, options);
+	const getter = function() {
+		return signal.get();
+	};
+	Object.assign(getter, {
+		set: signal.set.bind(signal),
+		get: signal.get.bind(signal),
+		update: (updater) => signal.set(updater(signal.get()))
+	});
+	return getter;
+}
+//#endregion
+//#region ../packages/core/src/signals/untracked.ts
+/**
+* Executes a function without tracking any dependencies.
+* @param fn - The function to execute without tracking.
+* @returns The result of the function execution.
+*/
+var untracked = Signal.subtle.untrack;
+//#endregion
+export { input as a, computed as i, signal as n, INPUT_SIGNAL_SET_SYMBOL as o, effect as r, isInputSignal as s, untracked as t };

package/dist/signals.d.ts

@@ -0,0 +1,180 @@
+import { EffectOptions } from '../../../../../schematics/packages/signals/src/public-api';
+import { NoArgsVoidFunction } from '../../../../../schematics/packages/types/src/public-api';
+import { SignalOptions } from '../../../../../schematics/packages/signals/src/public-api';
+
+/**
+ * A read-only reactive value derived from other signals.
+ *
+ * Wraps {@link Signal.Computed} and is also callable as a function to read the
+ * current computed value.
+ *
+ * @template Value - The type of the computed value. Defaults to `any`.
+ */
+declare type Computed<Value = any> = Signal.Computed<Value> & {
+    /**
+     * Reads the current computed value, recomputing it if any dependency changed.
+     *
+     * @returns The current value of type `Value`.
+     */
+    (): Value;
+};
+
+/**
+ * Creates a read-only computed signal whose value is derived from other signals.
+ *
+ * Returns a callable getter that reads the current value, augmented with the
+ * underlying {@link Signal.State} API.
+ *
+ * @template Value - The type of the computed value. Defaults to `any`.
+ * @param value - The initial (seed) value of the computed signal.
+ * @param options - Configuration options for the underlying signal.
+ * @returns A {@link Computed} instance.
+ */
+export declare function computed<Value = any>(value: Value, options?: SignalOptions<Value>): Computed<Value>;
+
+/**
+ * Runs a side-effectful function and automatically re-runs it whenever any
+ * Signal read during its execution changes.
+ *
+ * Internally, `effect` wraps the user callback inside a `Computed` node
+ * (for dependency tracking) and observes it with a `Watcher` (for push
+ * notifications). When any tracked dependency changes, the `Watcher`
+ * schedules a microtask that re-evaluates the `Computed`, which in turn
+ * re-runs the user callback and re-registers the new set of dependencies.
+ *
+ * The returned disposer function stops the effect: it unwatches the internal
+ * `Computed` from the `Watcher`, severing all dependency subscriptions so
+ * the callback is never called again and the graph nodes can be
+ * garbage-collected.
+ *
+ * @example
+ * ```ts
+ * const count = new State(0);
+ *
+ * const stop = effect(() => {
+ *   console.log('count is', count.get());
+ * });
+ * // logs: "count is 0"
+ *
+ * count.set(1); // logs: "count is 1"
+ * count.set(2); // logs: "count is 2"
+ *
+ * stop();       // no more logs
+ * count.set(3); // silent
+ * ```
+ *
+ * @param fn - The side-effectful function to run. Any Signal read inside it
+ *   is tracked as a dependency.
+ * @returns A disposer function that, when called, permanently stops the effect.
+ */
+export declare function effect(fn: NoArgsVoidFunction, options?: EffectOptions): NoArgsVoidFunction;
+
+/**
+ * Creates an `InputSignal` — a specialized reactive state designed for use
+ * as a property signal in web components.
+ *
+ * Unlike a plain `Signal.State`, the `set` method of an `InputSignal` is
+ * restricted to internal callers (identified by the private symbol) and
+ * accepts an optional `transform` function that converts incoming values
+ * (e.g. raw HTML attribute strings) into the internally stored type before
+ * updating the signal.
+ *
+ * @param value - The initial value of the signal.
+ * @param options - Optional configuration including an equality function,
+ *   lifecycle hooks, and a `transform` function applied to incoming values.
+ * @returns A new `InputSignal` instance.
+ */
+export declare function input<ActualValue = unknown, IncomingValue = ActualValue>(value?: ActualValue, options?: InputSignalOptions<ActualValue, IncomingValue>): InputSignal<ActualValue, IncomingValue>;
+
+/**
+ * A reactive value sourced from outside the component (e.g. an attribute).
+ *
+ * Wraps {@link Signal.State} without its `set` method (inputs are not set
+ * directly) and is callable as a function to read the current value. An
+ * optional {@link InputSignalOptions.transform} can convert the incoming value
+ * into the actual stored value.
+ *
+ * @template ActualValue - The internal type stored by the signal. Defaults to `unknown`.
+ * @template IncomingValue - The raw type received from outside. Defaults to `ActualValue`.
+ */
+declare type InputSignal<ActualValue = unknown, IncomingValue = ActualValue> = Omit<Signal.State<ActualValue>, 'set'> & {
+    /**
+     * Reads the current value of the input signal.
+     *
+     * @returns The current value of type `ActualValue`.
+     */
+    (): ActualValue;
+    /**
+     * Creates a new input signal.
+     *
+     * @param value - The initial incoming value.
+     * @param options - Optional configuration, including a `transform` function.
+     */
+    new (value: IncomingValue, options?: InputSignalOptions<ActualValue, IncomingValue>): InputSignal<ActualValue, IncomingValue>;
+};
+
+/**
+ * Options used to configure an `InputSignal`.
+ *
+ * Extends {@link SignalOptions} with an optional `transform` function that
+ * converts the incoming value (e.g. an attribute string) into the actual
+ * internal value stored by the signal.
+ *
+ * @template ActualValue - The internal type stored by the signal. Defaults to `unknown`.
+ * @template IncomingValue - The raw type received from outside (e.g. from an attribute). Defaults to `ActualValue`.
+ */
+declare type InputSignalOptions<ActualValue = unknown, IncomingValue = ActualValue> = SignalOptions<ActualValue> & {
+    /**
+     * Optional function to transform the incoming value before it is stored.
+     *
+     * @param value - The raw incoming value.
+     * @returns The transformed value of type `ActualValue`.
+     */
+    transform?: (value: IncomingValue) => ActualValue;
+};
+
+/**
+ * Creates a writable reactive signal.
+ *
+ * Returns a callable getter that reads the current value, augmented with the
+ * underlying {@link Signal.State} API and an `update` method to derive the next
+ * value from the previous one.
+ *
+ * @template T - The type of the stored value. Defaults to `any`.
+ * @param value - The initial value of the signal.
+ * @param options - Configuration options for the signal.
+ * @returns A {@link SignalType} instance.
+ */
+export declare function signal<T = any>(value: T, options?: SignalOptions<T>): Signal_2<T>;
+
+/**
+ * A writable reactive value.
+ *
+ * Wraps {@link Signal.State} and is also callable as a function to set a new
+ * value directly.
+ *
+ * @template Value - The type of the stored value. Defaults to `any`.
+ */
+declare type Signal_2<Value = any> = Signal.State<Value> & {
+    /**
+     * Get the current value of the signal.
+     *
+     * @returns The current value of the signal.
+     */
+    (): Value;
+    /**
+     * Updates the signal value based on its previous value.
+     *
+     * @param updater - Function receiving the previous value and returning the next one.
+     */
+    update(updater: (prev: Value) => Value): void;
+};
+
+/**
+ * Executes a function without tracking any dependencies.
+ * @param fn - The function to execute without tracking.
+ * @returns The result of the function execution.
+ */
+export declare const untracked: typeof Signal.subtle.untrack;
+
+export { }

package/dist/signals.js

@@ -0,0 +1,7 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_signals = require("./signals-C-55LNEj.cjs");
+exports.computed = require_signals.computed;
+exports.effect = require_signals.effect;
+exports.input = require_signals.input;
+exports.signal = require_signals.signal;
+exports.untracked = require_signals.untracked;

package/dist/{xaendar-core.es.d.ts → xaendar-core.d.ts}

@@ -604,7 +604,7 @@ declare type RenderElementAttribute = {
     /**
      * When `true`, the value is a static string literal; when `false`, it is a reactive expression.
      */
-    literal: boolean;
+    reactive: boolean;
 };
 
 /**

package/dist/{xaendar-core.es.js → xaendar-core.js}

@@ -1,3 +1,5 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_signals = require("./signals-C-55LNEj.cjs");
 //#region ../packages/core/src/decorators/event.decorator.ts
 function isEventOptions(value) {
 	return !!value && typeof value === "object" && ("bubbles" in value || "cancelable" in value || "composed" in value);
@@ -63,89 +65,6 @@ var INTERNAL_OBSERVED_ATTRIBUTES = `observedAttributes`;
 var SVG_NS = "http://www.w3.org/2000/svg";
 var MATHML_NS = "http://www.w3.org/1998/Math/MathML";
 //#endregion
-//#region ../packages/core/src/signals/input/input-instance.symbol.ts
-/**
-* Unique symbol used to mark an object as a valid `InputSignal` instance.
-*
-* Set to `true` on every `InputSignal` created by the `input()` factory.
-* Used by {@link isInputSignal} to distinguish input signals from plain
-* `Signal.State` instances at runtime without exposing the marker in the
-* public API.
-*
-* @internal
-*/
-var INPUT_SIGNAL_INSTANCE_SYMBOL = Symbol(`InputSignalInstance`);
-/**
-* Type guard that checks whether a given value is an `InputSignal` instance.
-*
-* Inspects the presence of {@link INPUT_SIGNAL_INSTANCE_SYMBOL} on the object,
-* which is set to `true` by the `input()` factory for every valid instance.
-*
-* @param instance - The value to inspect.
-* @returns `true` if `instance` is an `InputSignal`, `false` otherwise.
-*/
-function isInputSignal(instance) {
-	return instance?.[INPUT_SIGNAL_INSTANCE_SYMBOL];
-}
-//#endregion
-//#region ../packages/core/src/signals/input/input-set.symbol.ts
-/**
-* This symbol is used to call the set method of the InputSignal
-* Normally the set method is permitted internally and should not be called
-* by the User
-*/
-var INPUT_SIGNAL_SET_SYMBOL = Symbol(`InputSignalSet`);
-/**
-* Asserts that the provided symbol matches the internal {@link INPUT_SIGNAL_SET_SYMBOL} symbol,
-* ensuring the caller has access to internal APIs.
-*
-* Throws if the symbol does not match, preventing external code from
-* invoking methods intended for internal use only.
-*
-* @param symbol - The symbol to validate against {@link INPUT_SIGNAL_SET_SYMBOL}.
-* @throws {Error} If `symbol` does not match {@link INPUT_SIGNAL_SET_SYMBOL}.
-* @internal
-*/
-function assertPrivateContext(symbol) {
-	if (symbol !== INPUT_SIGNAL_SET_SYMBOL) throw new Error("Invalid symbol for InputSignal set method");
-}
-//#endregion
-//#region ../packages/core/src/signals/input/input.ts
-/**
-* Creates an `InputSignal` — a specialized reactive state designed for use
-* as a property signal in web components.
-*
-* Unlike a plain `Signal.State`, the `set` method of an `InputSignal` is
-* restricted to internal callers (identified by the private symbol) and
-* accepts an optional `transform` function that converts incoming values
-* (e.g. raw HTML attribute strings) into the internally stored type before
-* updating the signal.
-*
-* @param value - The initial value of the signal.
-* @param options - Optional configuration including an equality function,
-*   lifecycle hooks, and a `transform` function applied to incoming values.
-* @returns A new `InputSignal` instance.
-*/
-function input(value, options) {
-	const transform = options?.transform;
-	delete options?.transform;
-	const signal = new Signal.State(value, options);
-	const originalSet = signal.set;
-	const getter = function() {
-		return signal.get();
-	};
-	Object.assign(getter, {
-		set(newValue, symbol) {
-			assertPrivateContext(symbol);
-			const transformedValue = transform ? transform(newValue) : newValue;
-			originalSet.call(signal, transformedValue);
-		},
-		get: signal.get.bind(signal)
-	});
-	getter[INPUT_SIGNAL_INSTANCE_SYMBOL] = true;
-	return getter;
-}
-//#endregion
 //#region ../packages/core/src/decorators/property.decorator.ts
 var propertyDecoratorOptionsWithRequiredBrand = Symbol("PropertyDecoratorOptionsWithRequiredBrand");
 function createPropertyDecorator(value, options) {
@@ -161,7 +80,7 @@ function createPropertyDecorator(value, options) {
 			actualValue = value;
 			actualOptions = options;
 		} else actualOptions = value;
-		const signal = input(actualValue, {
+		const signal = require_signals.input(actualValue, {
 			equals: actualOptions?.equals,
 			watched: actualOptions?.watched,
 			unwatched: actualOptions?.unwatched,
@@ -338,8 +257,8 @@ var BaseWebComponent = class extends HTMLElement {
 	attributeChangedCallback(name, _oldValue, newValue) {
 		const context = this;
 		if (!(name in context)) throw new Error(`Attribute ${name} is not associated to any property`);
-		if (!isInputSignal(context[name])) throw new Error(`Property ${name} is not an InputSignal`);
-		context[name].set(newValue, INPUT_SIGNAL_SET_SYMBOL);
+		if (!require_signals.isInputSignal(context[name])) throw new Error(`Property ${name} is not an InputSignal`);
+		context[name].set(newValue, require_signals.INPUT_SIGNAL_SET_SYMBOL);
 	}
 	/**
 	* Called by the browser engine each time the element is inserted into the DOM.
@@ -362,142 +281,6 @@ var BaseWebComponent = class extends HTMLElement {
 	}
 };
 //#endregion
-//#region ../packages/core/src/signals/computed/computed.ts
-/**
-* Creates a read-only computed signal whose value is derived from other signals.
-*
-* Returns a callable getter that reads the current value, augmented with the
-* underlying {@link Signal.State} API.
-*
-* @template Value - The type of the computed value. Defaults to `any`.
-* @param value - The initial (seed) value of the computed signal.
-* @param options - Configuration options for the underlying signal.
-* @returns A {@link Computed} instance.
-*/
-function computed(value, options) {
-	const signal = new Signal.State(value, options);
-	const getter = function() {
-		return signal.get();
-	};
-	Object.assign(getter, { get: signal.get.bind(signal) });
-	return getter;
-}
-//#endregion
-//#region ../packages/core/src/signals/effect/effect.ts
-/**
-* Runs a side-effectful function and automatically re-runs it whenever any
-* Signal read during its execution changes.
-*
-* Internally, `effect` wraps the user callback inside a `Computed` node
-* (for dependency tracking) and observes it with a `Watcher` (for push
-* notifications). When any tracked dependency changes, the `Watcher`
-* schedules a microtask that re-evaluates the `Computed`, which in turn
-* re-runs the user callback and re-registers the new set of dependencies.
-*
-* The returned disposer function stops the effect: it unwatches the internal
-* `Computed` from the `Watcher`, severing all dependency subscriptions so
-* the callback is never called again and the graph nodes can be
-* garbage-collected.
-*
-* @example
-* ```ts
-* const count = new State(0);
-*
-* const stop = effect(() => {
-*   console.log('count is', count.get());
-* });
-* // logs: "count is 0"
-*
-* count.set(1); // logs: "count is 1"
-* count.set(2); // logs: "count is 2"
-*
-* stop();       // no more logs
-* count.set(3); // silent
-* ```
-*
-* @param fn - The side-effectful function to run. Any Signal read inside it
-*   is tracked as a dependency.
-* @returns A disposer function that, when called, permanently stops the effect.
-*/
-function effect(fn, options) {
-	/**
-	* Wrap the user callback in a Computed so that automatic dependency
-	* tracking (via pushComputed / popComputed) works for free.
-	* The Computed always returns `undefined` — we only care about the
-	* side-effects and the tracked sources, not the value.
-	*/
-	const computed = new Signal.Computed(() => fn());
-	let needsEnqueue = true;
-	/**
-	* The Watcher is notified synchronously as soon as any tracked dependency
-	* changes. Its job is purely to schedule the re-execution; the actual
-	* re-evaluation happens asynchronously in a microtask so that multiple
-	* synchronous signal updates are batched into a single re-run.
-	*/
-	const watcher = new Signal.subtle.Watcher(() => {
-		if (needsEnqueue) {
-			needsEnqueue = false;
-			queueMicrotask(() => {
-				needsEnqueue = true;
-				options?.onBeforeRun?.();
-				const pendings = watcher.getPending();
-				for (let i = 0; i < pendings.length; i++) pendings[i].get();
-				options?.onAfterRun?.();
-				watcher.watch();
-			});
-		}
-	});
-	options?.onBeforeRun?.();
-	watcher.watch(computed);
-	computed.get();
-	options?.onAfterRun?.();
-	/**
-	* Disposer — call this to permanently stop the effect.
-	*
-	* Unwatching the Computed tears down the entire live dependency chain
-	* (Watcher → Computed → all sources), preventing any further
-	* notifications and allowing GC.
-	*/
-	return () => {
-		options?.onCleanup?.();
-		watcher.unwatch(computed);
-	};
-}
-//#endregion
-//#region ../packages/core/src/signals/signal/signal.ts
-/**
-* Creates a writable reactive signal.
-*
-* Returns a callable getter that reads the current value, augmented with the
-* underlying {@link Signal.State} API and an `update` method to derive the next
-* value from the previous one.
-*
-* @template T - The type of the stored value. Defaults to `any`.
-* @param value - The initial value of the signal.
-* @param options - Configuration options for the signal.
-* @returns A {@link SignalType} instance.
-*/
-function signal(value, options) {
-	const signal = new Signal.State(value, options);
-	const getter = function() {
-		return signal.get();
-	};
-	Object.assign(getter, {
-		set: signal.set.bind(signal),
-		get: signal.get.bind(signal),
-		update: (updater) => signal.set(updater(signal.get()))
-	});
-	return getter;
-}
-//#endregion
-//#region ../packages/core/src/signals/untracked.ts
-/**
-* Executes a function without tracking any dependencies.
-* @param fn - The function to execute without tracking.
-* @returns The result of the function execution.
-*/
-var untracked = Signal.subtle.untrack;
-//#endregion
 //#region ../packages/core/src/utils/context.util.ts
 /**
 * Tracks identifier scope during run time template function execution
@@ -719,11 +502,11 @@ function createAnchor(label, parentNode, context, referenceNode = null) {
 function _for(parentNode, parentContext, condition, trackExpression, forFn) {
 	const anchor = createAnchor("for", parentNode, parentContext);
 	let entries = /* @__PURE__ */ new Map();
-	const unlistener = effect(() => {
+	const unlistener = require_signals.effect(() => {
 		const items = condition();
 		const newKeys = items.map((item) => trackExpression(item));
 		const newKeySet = new Set(newKeys);
-		untracked(() => {
+		require_signals.untracked(() => {
 			const newEntries = /* @__PURE__ */ new Map();
 			for (const [key, entry] of entries) if (!newKeySet.has(key)) {
 				entry.context.unlisten();
@@ -769,11 +552,11 @@ function _for(parentNode, parentContext, condition, trackExpression, forFn) {
 * @returns A handle exposing the resolved variables and an `update` function.
 */
 function _iterationVariables(context, items, index, itemName, aliases) {
-	const $index = signal(index);
-	const $first = signal(index === 0);
-	const $last = signal(index === items.length - 1);
-	const $even = signal(index % 2 === 0);
-	const $odd = signal(index % 2 !== 0);
+	const $index = require_signals.signal(index);
+	const $first = require_signals.signal(index === 0);
+	const $last = require_signals.signal(index === items.length - 1);
+	const $even = require_signals.signal(index % 2 === 0);
+	const $odd = require_signals.signal(index % 2 !== 0);
 	const retVal = {
 		vars: {
 			[itemName]: items[index],
@@ -831,7 +614,7 @@ function _if(parentNode, parentContext, blocks) {
 			break;
 		default: fn = (state) => handleIfElseIf(parentNode, parentContext, blocks, state, anchor);
 	}
-	const unlistener = effect(() => state = fn(state));
+	const unlistener = require_signals.effect(() => state = fn(state));
 	parentContext.listen(unlistener);
 }
 /**
@@ -915,7 +698,7 @@ function checkAndUpdateState(parentNode, parentContext, state, newState, conditi
 		state.context.unlisten();
 		parentContext.removeChild(state.context);
 	}
-	const context = untracked(() => conditionalBlockFn(parentNode, parentContext, anchor));
+	const context = require_signals.untracked(() => conditionalBlockFn(parentNode, parentContext, anchor));
 	parentContext.addChild(context);
 	return {
 		activeBranch: newState,
@@ -962,8 +745,8 @@ function _renderElement(parentNode, context, anchor, tagName, attributes, events
 	const element = context.createElement(tagName);
 	mountNode(element, parentNode, context, anchor);
 	for (let i = 0; i < attributes.length; i++) {
-		const { name, value, literal } = attributes[i];
-		literal ? element.setAttribute(name, String(value())) : context.listen(effect(() => element.setAttribute(name, String(value()))));
+		const { name, value, reactive } = attributes[i];
+		reactive ? context.listen(require_signals.effect(() => element.setAttribute(name, String(value())))) : element.setAttribute(name, String(value()));
 	}
 	for (let i = 0; i < events.length; i++) {
 		const event = events[i];
@@ -1017,7 +800,7 @@ function createMATHMLElement(tagName) {
 function _renderText(parentNode, context, textFn) {
 	const node = document.createTextNode(textFn());
 	mountNode(node, parentNode, context);
-	context.listen(effect(() => node.textContent = textFn()));
+	context.listen(require_signals.effect(() => node.textContent = textFn()));
 }
 /**
 * Creates a static (non-reactive) text node with a literal string value.
@@ -1065,4 +848,25 @@ function _switch(parentNode, parentContext, expression, blocks) {
 	})));
 }
 //#endregion
-export { BaseWebComponent, Context, Event, Property, WebComponent, _for, _if, _iterationVariables, _renderElement, _renderLiteralText, _renderText, _switch, computed, createAnchor, createElement, createMATHMLElement, createSVGElement, effect, input, mountNode, signal, untracked };
+exports.BaseWebComponent = BaseWebComponent;
+exports.Context = Context;
+exports.Event = Event;
+exports.Property = Property;
+exports.WebComponent = WebComponent;
+exports._for = _for;
+exports._if = _if;
+exports._iterationVariables = _iterationVariables;
+exports._renderElement = _renderElement;
+exports._renderLiteralText = _renderLiteralText;
+exports._renderText = _renderText;
+exports._switch = _switch;
+exports.computed = require_signals.computed;
+exports.createAnchor = createAnchor;
+exports.createElement = createElement;
+exports.createMATHMLElement = createMATHMLElement;
+exports.createSVGElement = createSVGElement;
+exports.effect = require_signals.effect;
+exports.input = require_signals.input;
+exports.mountNode = mountNode;
+exports.signal = require_signals.signal;
+exports.untracked = require_signals.untracked;

package/package.json

@@ -1,22 +1,28 @@
 {
   "name": "@xaendar/core",
-  "version": "0.9.18",
+  "version": "0.9.22",
   "description": "A library containing core utils such as webcomponent base classes and theming support",
   "sideEffects": false,
   "type": "module",
-  "main": "./dist/xaendar-core.es.js",
-  "module": "./dist/xaendar-core.es.js",
-  "types": "./dist/xaendar-core.es.d.ts",
+  "main": "./dist/xaendar-core.js",
+  "module": "./dist/xaendar-core.js",
+  "types": "./dist/xaendar-core.d.ts",
   "exports": {
     ".": {
       "import": {
-        "types": "./dist/xaendar-core.es.d.ts",
-        "default": "./dist/xaendar-core.es.js"
+        "types": "./dist/xaendar-core.d.ts",
+        "default": "./dist/xaendar-core.js"
+      }
+    },
+    "signals": {
+      "import": {
+        "types": "./dist/signals.d.ts",
+        "default": "./dist/signals.js"
       }
     }
   },
   "dependencies": {
-    "@xaendar/signals": "0.9.18",
-    "@xaendar/types": "0.9.18"
+    "@xaendar/signals": "0.9.22",
+    "@xaendar/types": "0.9.22"
   }
 }