@bromscandium/core 1.0.0

package/src/dep.js

@@ -0,0 +1,119 @@
+/**
+ * Dependency tracking system for reactive state management.
+ * Uses WeakMap for automatic garbage collection of unused dependencies.
+ * @module
+ */
+const targetMap = new WeakMap();
+let activeEffect = null;
+const effectStack = [];
+/**
+ * Returns the currently executing effect, if any.
+ *
+ * @returns The active effect function or null if no effect is running
+ */
+export function getActiveEffect() {
+    return activeEffect;
+}
+/**
+ * Sets the currently active effect.
+ *
+ * @param effect - The effect to set as active, or null to clear
+ */
+export function setActiveEffect(effect) {
+    activeEffect = effect;
+}
+/**
+ * Pushes an effect onto the effect stack and sets it as active.
+ * Used internally when running nested effects.
+ *
+ * @param effect - The effect to push onto the stack
+ */
+export function pushEffect(effect) {
+    effectStack.push(effect);
+    activeEffect = effect;
+}
+/**
+ * Pops the current effect from the stack and restores the previous active effect.
+ * Used internally when a nested effect completes.
+ */
+export function popEffect() {
+    effectStack.pop();
+    activeEffect = effectStack[effectStack.length - 1] || null;
+}
+/**
+ * Tracks a dependency between the currently active effect and a reactive property.
+ * Called automatically when a reactive property is accessed during effect execution.
+ *
+ * @param target - The reactive object being accessed
+ * @param key - The property key being accessed
+ *
+ * @example
+ * ```ts
+ * // Typically called internally by reactive proxies
+ * track(state, 'count');
+ * ```
+ */
+export function track(target, key) {
+    if (!activeEffect)
+        return;
+    let depsMap = targetMap.get(target);
+    if (!depsMap) {
+        targetMap.set(target, (depsMap = new Map()));
+    }
+    let deps = depsMap.get(key);
+    if (!deps) {
+        depsMap.set(key, (deps = new Set()));
+    }
+    if (!deps.has(activeEffect)) {
+        deps.add(activeEffect);
+        activeEffect.deps.add(deps);
+    }
+}
+/**
+ * Triggers all effects that depend on a reactive property.
+ * Called automatically when a reactive property is modified.
+ *
+ * @param target - The reactive object being modified
+ * @param key - The property key being modified
+ *
+ * @example
+ * ```ts
+ * // Typically called internally by reactive proxies
+ * trigger(state, 'count');
+ * ```
+ */
+export function trigger(target, key) {
+    const depsMap = targetMap.get(target);
+    if (!depsMap)
+        return;
+    const deps = depsMap.get(key);
+    if (!deps)
+        return;
+    const effectsToRun = new Set();
+    deps.forEach(effect => {
+        if (effect !== activeEffect) {
+            effectsToRun.add(effect);
+        }
+    });
+    effectsToRun.forEach(effect => {
+        if (effect.options?.scheduler) {
+            effect.options.scheduler(effect);
+        }
+        else {
+            effect();
+        }
+    });
+}
+/**
+ * Removes an effect from all its dependency sets.
+ * Called before re-running an effect to ensure fresh dependency tracking.
+ *
+ * @param effect - The effect to clean up
+ */
+export function cleanup(effect) {
+    effect.deps.forEach(deps => {
+        deps.delete(effect);
+    });
+    effect.deps.clear();
+}
+//# sourceMappingURL=dep.js.map

package/src/dep.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dep.js","sourceRoot":"","sources":["dep.ts"],"names":[],"mappings":"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"}

package/src/dep.ts

@@ -0,0 +1,148 @@
+/**
+ * Dependency tracking system for reactive state management.
+ * Uses WeakMap for automatic garbage collection of unused dependencies.
+ * @module
+ */
+
+/**
+ * An effect function that can be tracked and re-executed when dependencies change.
+ */
+export type EffectFn = (() => void) & {
+  deps: Set<Set<EffectFn>>;
+  options?: EffectOptions;
+};
+
+/**
+ * Configuration options for reactive effects.
+ */
+export interface EffectOptions {
+  /** If true, the effect will not run immediately upon creation */
+  lazy?: boolean;
+  /** Custom scheduler function to control when the effect runs */
+  scheduler?: (fn: EffectFn) => void;
+}
+
+const targetMap = new WeakMap<object, Map<string | symbol, Set<EffectFn>>>();
+
+let activeEffect: EffectFn | null = null;
+const effectStack: EffectFn[] = [];
+
+/**
+ * Returns the currently executing effect, if any.
+ *
+ * @returns The active effect function or null if no effect is running
+ */
+export function getActiveEffect(): EffectFn | null {
+  return activeEffect;
+}
+
+/**
+ * Sets the currently active effect.
+ *
+ * @param effect - The effect to set as active, or null to clear
+ */
+export function setActiveEffect(effect: EffectFn | null): void {
+  activeEffect = effect;
+}
+
+/**
+ * Pushes an effect onto the effect stack and sets it as active.
+ * Used internally when running nested effects.
+ *
+ * @param effect - The effect to push onto the stack
+ */
+export function pushEffect(effect: EffectFn): void {
+  effectStack.push(effect);
+  activeEffect = effect;
+}
+
+/**
+ * Pops the current effect from the stack and restores the previous active effect.
+ * Used internally when a nested effect completes.
+ */
+export function popEffect(): void {
+  effectStack.pop();
+  activeEffect = effectStack[effectStack.length - 1] || null;
+}
+
+/**
+ * Tracks a dependency between the currently active effect and a reactive property.
+ * Called automatically when a reactive property is accessed during effect execution.
+ *
+ * @param target - The reactive object being accessed
+ * @param key - The property key being accessed
+ *
+ * @example
+ * ```ts
+ * // Typically called internally by reactive proxies
+ * track(state, 'count');
+ * ```
+ */
+export function track(target: object, key: string | symbol): void {
+  if (!activeEffect) return;
+
+  let depsMap = targetMap.get(target);
+  if (!depsMap) {
+    targetMap.set(target, (depsMap = new Map()));
+  }
+
+  let deps = depsMap.get(key);
+  if (!deps) {
+    depsMap.set(key, (deps = new Set()));
+  }
+
+  if (!deps.has(activeEffect)) {
+    deps.add(activeEffect);
+    activeEffect.deps.add(deps);
+  }
+}
+
+/**
+ * Triggers all effects that depend on a reactive property.
+ * Called automatically when a reactive property is modified.
+ *
+ * @param target - The reactive object being modified
+ * @param key - The property key being modified
+ *
+ * @example
+ * ```ts
+ * // Typically called internally by reactive proxies
+ * trigger(state, 'count');
+ * ```
+ */
+export function trigger(target: object, key: string | symbol): void {
+  const depsMap = targetMap.get(target);
+  if (!depsMap) return;
+
+  const deps = depsMap.get(key);
+  if (!deps) return;
+
+  const effectsToRun = new Set<EffectFn>();
+
+  deps.forEach(effect => {
+    if (effect !== activeEffect) {
+      effectsToRun.add(effect);
+    }
+  });
+
+  effectsToRun.forEach(effect => {
+    if (effect.options?.scheduler) {
+      effect.options.scheduler(effect);
+    } else {
+      effect();
+    }
+  });
+}
+
+/**
+ * Removes an effect from all its dependency sets.
+ * Called before re-running an effect to ensure fresh dependency tracking.
+ *
+ * @param effect - The effect to clean up
+ */
+export function cleanup(effect: EffectFn): void {
+  effect.deps.forEach(deps => {
+    deps.delete(effect);
+  });
+  effect.deps.clear();
+}

package/src/effect.d.ts

@@ -0,0 +1,131 @@
+/**
+ * Effect system for reactive side effects, computed values, and watchers.
+ * @module
+ */
+import { EffectFn, EffectOptions } from './dep.js';
+import { Ref, ComputedRef } from './ref.js';
+interface ReactiveEffect<T = any> extends EffectFn {
+    (): T;
+}
+/**
+ * Creates a reactive effect that automatically tracks dependencies and re-runs when they change.
+ *
+ * @param fn - The effect function to run
+ * @param options - Configuration options for the effect
+ * @returns The effect function, which can be called manually or used for cleanup
+ *
+ * @example
+ * ```ts
+ * const count = ref(0);
+ *
+ * // Runs immediately and re-runs when count changes
+ * effect(() => {
+ *   console.log('Count is:', count.value);
+ * });
+ *
+ * // Lazy effect with custom scheduler
+ * const runner = effect(() => count.value * 2, {
+ *   lazy: true,
+ *   scheduler: (fn) => queueMicrotask(fn)
+ * });
+ * ```
+ */
+export declare function effect(fn: () => void, options?: EffectOptions): EffectFn;
+export declare function effect<T>(fn: () => T, options?: EffectOptions): ReactiveEffect<T>;
+/**
+ * Creates a computed ref that derives its value from other reactive state.
+ * The value is lazily evaluated and cached until dependencies change.
+ *
+ * @param getter - A function that computes the value from reactive sources
+ * @returns A read-only ref containing the computed value
+ *
+ * @example
+ * ```ts
+ * const count = ref(0);
+ * const doubled = computed(() => count.value * 2);
+ *
+ * console.log(doubled.value); // 0
+ * count.value = 5;
+ * console.log(doubled.value); // 10
+ * ```
+ */
+export declare function computed<T>(getter: () => T): ComputedRef<T>;
+/** A watch source can be either a ref or a getter function */
+type WatchSource<T> = Ref<T> | (() => T);
+/** Callback invoked when a watched source changes */
+type WatchCallback<T> = (newValue: T, oldValue: T | undefined) => void;
+/**
+ * Configuration options for the watch function.
+ */
+interface WatchOptions {
+    /** If true, the callback is invoked immediately with the current value */
+    immediate?: boolean;
+    /** If true, deeply watches nested object properties (not yet implemented) */
+    deep?: boolean;
+}
+/**
+ * Watches a reactive source and invokes a callback when it changes.
+ *
+ * @param source - A ref or getter function to watch
+ * @param callback - Function called with new and old values when the source changes
+ * @param options - Configuration options
+ * @returns A function to stop watching
+ *
+ * @example
+ * ```ts
+ * const count = ref(0);
+ *
+ * // Watch a ref
+ * const stop = watch(count, (newVal, oldVal) => {
+ *   console.log(`Changed from ${oldVal} to ${newVal}`);
+ * });
+ *
+ * // Watch a getter
+ * watch(() => state.nested.value, (newVal) => {
+ *   console.log('Nested value changed:', newVal);
+ * });
+ *
+ * // With immediate option
+ * watch(count, callback, { immediate: true });
+ *
+ * stop(); // Stop watching
+ * ```
+ */
+export declare function watch<T>(source: WatchSource<T>, callback: WatchCallback<T>, options?: WatchOptions): () => void;
+/**
+ * Runs a function immediately and re-runs it whenever its reactive dependencies change.
+ * Similar to `effect()` but returns a cleanup function instead of the effect.
+ *
+ * @param fn - The effect function to run
+ * @returns A function to stop the effect
+ *
+ * @example
+ * ```ts
+ * const count = ref(0);
+ *
+ * const stop = watchEffect(() => {
+ *   console.log('Count:', count.value);
+ * });
+ *
+ * count.value++; // Logs: "Count: 1"
+ * stop(); // Stop watching
+ * count.value++; // No log
+ * ```
+ */
+export declare function watchEffect(fn: () => void): () => void;
+/**
+ * Queues an effect to run in the next microtask, batching multiple updates.
+ * Effects queued multiple times before flush will only run once.
+ *
+ * @param job - The effect function to queue
+ *
+ * @example
+ * ```ts
+ * const updateEffect = effect(() => render(), {
+ *   scheduler: queueJob
+ * });
+ * ```
+ */
+export declare function queueJob(job: EffectFn): void;
+export {};
+//# sourceMappingURL=effect.d.ts.map

package/src/effect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"effect.d.ts","sourceRoot":"","sources":["effect.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACL,QAAQ,EACR,aAAa,EAOd,MAAM,UAAU,CAAC;AAClB,OAAO,EAAE,GAAG,EAAS,WAAW,EAAW,MAAM,UAAU,CAAC;AAY5D,UAAU,cAAc,CAAC,CAAC,GAAG,GAAG,CAAE,SAAQ,QAAQ;IAChD,IAAI,CAAC,CAAC;CACP;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,MAAM,CAAC,EAAE,EAAE,MAAM,IAAI,EAAE,OAAO,CAAC,EAAE,aAAa,GAAG,QAAQ,CAAC;AAC1E,wBAAgB,MAAM,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,EAAE,OAAO,CAAC,EAAE,aAAa,GAAG,cAAc,CAAC,CAAC,CAAC,CAAC;AAkDnF;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,CAE3D;AAED,8DAA8D;AAC9D,KAAK,WAAW,CAAC,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;AAEzC,qDAAqD;AACrD,KAAK,aAAa,CAAC,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,GAAG,SAAS,KAAK,IAAI,CAAC;AAEvE;;GAEG;AACH,UAAU,YAAY;IACpB,0EAA0E;IAC1E,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,6EAA6E;IAC7E,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,KAAK,CAAC,CAAC,EACrB,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC,EACtB,QAAQ,EAAE,aAAa,CAAC,CAAC,CAAC,EAC1B,OAAO,CAAC,EAAE,YAAY,GACrB,MAAM,IAAI,CAiCZ;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,WAAW,CAAC,EAAE,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAGtD;AAKD;;;;;;;;;;;;GAYG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,QAAQ,GAAG,IAAI,CAM5C"}

package/src/effect.js

@@ -0,0 +1,188 @@
+/**
+ * Effect system for reactive side effects, computed values, and watchers.
+ * @module
+ */
+var _a;
+import { cleanup, pushEffect, popEffect, track, trigger, getActiveEffect, } from './dep.js';
+import { isRef, RefFlag } from './ref.js';
+function trackComputed(computed) {
+    if (getActiveEffect()) {
+        track(computed, 'value');
+    }
+}
+function triggerComputed(computed) {
+    trigger(computed, 'value');
+}
+export function effect(fn, options) {
+    const effectFn = () => {
+        cleanup(effectFn);
+        pushEffect(effectFn);
+        try {
+            return fn();
+        }
+        finally {
+            popEffect();
+        }
+    };
+    effectFn.deps = new Set();
+    effectFn.options = options;
+    if (!options?.lazy) {
+        effectFn();
+    }
+    return effectFn;
+}
+class ComputedRefImpl {
+    constructor(getter) {
+        this._dirty = true;
+        this[_a] = true;
+        this._effect = effect(getter, {
+            lazy: true,
+            scheduler: () => {
+                if (!this._dirty) {
+                    this._dirty = true;
+                    triggerComputed(this);
+                }
+            },
+        });
+    }
+    get value() {
+        trackComputed(this);
+        if (this._dirty) {
+            this._value = this._effect();
+            this._dirty = false;
+        }
+        return this._value;
+    }
+}
+_a = RefFlag;
+/**
+ * Creates a computed ref that derives its value from other reactive state.
+ * The value is lazily evaluated and cached until dependencies change.
+ *
+ * @param getter - A function that computes the value from reactive sources
+ * @returns A read-only ref containing the computed value
+ *
+ * @example
+ * ```ts
+ * const count = ref(0);
+ * const doubled = computed(() => count.value * 2);
+ *
+ * console.log(doubled.value); // 0
+ * count.value = 5;
+ * console.log(doubled.value); // 10
+ * ```
+ */
+export function computed(getter) {
+    return new ComputedRefImpl(getter);
+}
+/**
+ * Watches a reactive source and invokes a callback when it changes.
+ *
+ * @param source - A ref or getter function to watch
+ * @param callback - Function called with new and old values when the source changes
+ * @param options - Configuration options
+ * @returns A function to stop watching
+ *
+ * @example
+ * ```ts
+ * const count = ref(0);
+ *
+ * // Watch a ref
+ * const stop = watch(count, (newVal, oldVal) => {
+ *   console.log(`Changed from ${oldVal} to ${newVal}`);
+ * });
+ *
+ * // Watch a getter
+ * watch(() => state.nested.value, (newVal) => {
+ *   console.log('Nested value changed:', newVal);
+ * });
+ *
+ * // With immediate option
+ * watch(count, callback, { immediate: true });
+ *
+ * stop(); // Stop watching
+ * ```
+ */
+export function watch(source, callback, options) {
+    let getter;
+    if (isRef(source)) {
+        getter = () => source.value;
+    }
+    else if (typeof source === 'function') {
+        getter = source;
+    }
+    else {
+        getter = () => source;
+    }
+    let oldValue;
+    const job = () => {
+        const newValue = runEffect();
+        callback(newValue, oldValue);
+        oldValue = newValue;
+    };
+    const runEffect = effect(getter, {
+        lazy: true,
+        scheduler: job,
+    });
+    if (options?.immediate) {
+        job();
+    }
+    else {
+        oldValue = runEffect();
+    }
+    return () => {
+        cleanup(runEffect);
+    };
+}
+/**
+ * Runs a function immediately and re-runs it whenever its reactive dependencies change.
+ * Similar to `effect()` but returns a cleanup function instead of the effect.
+ *
+ * @param fn - The effect function to run
+ * @returns A function to stop the effect
+ *
+ * @example
+ * ```ts
+ * const count = ref(0);
+ *
+ * const stop = watchEffect(() => {
+ *   console.log('Count:', count.value);
+ * });
+ *
+ * count.value++; // Logs: "Count: 1"
+ * stop(); // Stop watching
+ * count.value++; // No log
+ * ```
+ */
+export function watchEffect(fn) {
+    const effectFn = effect(fn);
+    return () => cleanup(effectFn);
+}
+let isFlushing = false;
+const pendingJobs = new Set();
+/**
+ * Queues an effect to run in the next microtask, batching multiple updates.
+ * Effects queued multiple times before flush will only run once.
+ *
+ * @param job - The effect function to queue
+ *
+ * @example
+ * ```ts
+ * const updateEffect = effect(() => render(), {
+ *   scheduler: queueJob
+ * });
+ * ```
+ */
+export function queueJob(job) {
+    pendingJobs.add(job);
+    if (!isFlushing) {
+        isFlushing = true;
+        Promise.resolve().then(flushJobs);
+    }
+}
+function flushJobs() {
+    pendingJobs.forEach(job => job());
+    pendingJobs.clear();
+    isFlushing = false;
+}
+//# sourceMappingURL=effect.js.map

package/src/effect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"effect.js","sourceRoot":"","sources":["effect.ts"],"names":[],"mappings":"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"}