@bromscandium/core 1.0.0

package/src/effect.ts

@@ -0,0 +1,263 @@
+/**
+ * Effect system for reactive side effects, computed values, and watchers.
+ * @module
+ */
+
+import {
+  EffectFn,
+  EffectOptions,
+  cleanup,
+  pushEffect,
+  popEffect,
+  track,
+  trigger,
+  getActiveEffect,
+} from './dep.js';
+import { Ref, isRef, ComputedRef, RefFlag } from './ref.js';
+
+function trackComputed(computed: any): void {
+  if (getActiveEffect()) {
+    track(computed, 'value');
+  }
+}
+
+function triggerComputed(computed: any): void {
+  trigger(computed, 'value');
+}
+
+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 function effect(fn: () => void, options?: EffectOptions): EffectFn;
+export function effect<T>(fn: () => T, options?: EffectOptions): ReactiveEffect<T>;
+export function effect(fn: () => any, options?: EffectOptions): EffectFn {
+  const effectFn: 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<T> {
+  private _value!: T;
+  private _dirty = true;
+  private _effect: ReactiveEffect<T>;
+  public readonly [RefFlag] = true;
+
+  constructor(getter: () => T) {
+    this._effect = effect(getter, {
+      lazy: true,
+      scheduler: () => {
+        if (!this._dirty) {
+          this._dirty = true;
+          triggerComputed(this);
+        }
+      },
+    }) as ReactiveEffect<T>;
+  }
+
+  get value(): T {
+    trackComputed(this);
+    if (this._dirty) {
+      this._value = this._effect();
+      this._dirty = false;
+    }
+    return this._value;
+  }
+}
+
+/**
+ * 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<T>(getter: () => T): ComputedRef<T> {
+  return new ComputedRefImpl(getter) as 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 function watch<T>(
+  source: WatchSource<T>,
+  callback: WatchCallback<T>,
+  options?: WatchOptions
+): () => void {
+  let getter: () => T;
+
+  if (isRef(source)) {
+    getter = () => source.value;
+  } else if (typeof source === 'function') {
+    getter = source;
+  } else {
+    getter = () => source;
+  }
+
+  let oldValue: T | undefined;
+
+  const job = () => {
+    const newValue = runEffect() as T;
+    callback(newValue, oldValue);
+    oldValue = newValue;
+  };
+
+  const runEffect = effect(getter, {
+    lazy: true,
+    scheduler: job,
+  }) as ReactiveEffect<T>;
+
+  if (options?.immediate) {
+    job();
+  } else {
+    oldValue = runEffect() as T;
+  }
+
+  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: () => void): () => void {
+  const effectFn = effect(fn);
+  return () => cleanup(effectFn);
+}
+
+let isFlushing = false;
+const pendingJobs: Set<EffectFn> = 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: EffectFn): void {
+  pendingJobs.add(job);
+  if (!isFlushing) {
+    isFlushing = true;
+    Promise.resolve().then(flushJobs);
+  }
+}
+
+function flushJobs(): void {
+  pendingJobs.forEach(job => job());
+  pendingJobs.clear();
+  isFlushing = false;
+}

package/src/index.d.ts

@@ -0,0 +1,5 @@
+export { track, trigger, cleanup, type EffectFn, type EffectOptions, } from './dep.js';
+export { reactive, isReactive, toRaw, markRaw, ReactiveFlags, } from './reactive.js';
+export { ref, isRef, unref, toRef, toRefs, shallowRef, triggerRef, type Ref, type ComputedRef, type ShallowRef, } from './ref.js';
+export { effect, computed, watch, watchEffect, queueJob, } from './effect.js';
+//# sourceMappingURL=index.d.ts.map

package/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,EACL,OAAO,EACP,OAAO,EACP,KAAK,QAAQ,EACb,KAAK,aAAa,GACnB,MAAM,UAAU,CAAC;AAElB,OAAO,EACL,QAAQ,EACR,UAAU,EACV,KAAK,EACL,OAAO,EACP,aAAa,GACd,MAAM,eAAe,CAAC;AAEvB,OAAO,EACL,GAAG,EACH,KAAK,EACL,KAAK,EACL,KAAK,EACL,MAAM,EACN,UAAU,EACV,UAAU,EACV,KAAK,GAAG,EACR,KAAK,WAAW,EAChB,KAAK,UAAU,GAChB,MAAM,UAAU,CAAC;AAElB,OAAO,EACL,MAAM,EACN,QAAQ,EACR,KAAK,EACL,WAAW,EACX,QAAQ,GACT,MAAM,aAAa,CAAC"}

package/src/index.js

@@ -0,0 +1,6 @@
+// Core package exports
+export { track, trigger, cleanup, } from './dep.js';
+export { reactive, isReactive, toRaw, markRaw, ReactiveFlags, } from './reactive.js';
+export { ref, isRef, unref, toRef, toRefs, shallowRef, triggerRef, } from './ref.js';
+export { effect, computed, watch, watchEffect, queueJob, } from './effect.js';
+//# sourceMappingURL=index.js.map

package/src/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AAAA,uBAAuB;AAEvB,OAAO,EACL,KAAK,EACL,OAAO,EACP,OAAO,GAGR,MAAM,UAAU,CAAC;AAElB,OAAO,EACL,QAAQ,EACR,UAAU,EACV,KAAK,EACL,OAAO,EACP,aAAa,GACd,MAAM,eAAe,CAAC;AAEvB,OAAO,EACL,GAAG,EACH,KAAK,EACL,KAAK,EACL,KAAK,EACL,MAAM,EACN,UAAU,EACV,UAAU,GAIX,MAAM,UAAU,CAAC;AAElB,OAAO,EACL,MAAM,EACN,QAAQ,EACR,KAAK,EACL,WAAW,EACX,QAAQ,GACT,MAAM,aAAa,CAAC"}

package/src/index.ts

@@ -0,0 +1,38 @@
+// Core package exports
+
+export {
+  track,
+  trigger,
+  cleanup,
+  type EffectFn,
+  type EffectOptions,
+} from './dep.js';
+
+export {
+  reactive,
+  isReactive,
+  toRaw,
+  markRaw,
+  ReactiveFlags,
+} from './reactive.js';
+
+export {
+  ref,
+  isRef,
+  unref,
+  toRef,
+  toRefs,
+  shallowRef,
+  triggerRef,
+  type Ref,
+  type ComputedRef,
+  type ShallowRef,
+} from './ref.js';
+
+export {
+  effect,
+  computed,
+  watch,
+  watchEffect,
+  queueJob,
+} from './effect.js';

package/src/reactive.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Proxy-based reactivity system for deep reactive state management.
+ * @module
+ */
+/**
+ * Internal flags used to identify reactive objects.
+ */
+export declare const ReactiveFlags: {
+    readonly IS_REACTIVE: "__b_isReactive";
+    readonly RAW: "__b_raw";
+};
+/**
+ * Creates a deeply reactive proxy of an object.
+ * Changes to the object or its nested properties will automatically trigger effects.
+ *
+ * @param target - The object to make reactive
+ * @returns A reactive proxy of the target object
+ *
+ * @example
+ * ```ts
+ * const state = reactive({ count: 0, nested: { value: 1 } });
+ * state.count++; // Triggers effects tracking 'count'
+ * state.nested.value++; // Triggers effects tracking nested 'value'
+ * ```
+ */
+export declare function reactive<T extends object>(target: T): T;
+/**
+ * Checks if a value is a reactive proxy created by `reactive()`.
+ *
+ * @param value - The value to check
+ * @returns True if the value is a reactive proxy
+ *
+ * @example
+ * ```ts
+ * const state = reactive({ count: 0 });
+ * isReactive(state); // true
+ * isReactive({ count: 0 }); // false
+ * ```
+ */
+export declare function isReactive(value: unknown): boolean;
+/**
+ * Returns the raw, non-reactive version of a reactive object.
+ * Useful when you need to read values without triggering dependency tracking.
+ *
+ * @param observed - The reactive object to unwrap
+ * @returns The original non-reactive object
+ *
+ * @example
+ * ```ts
+ * const state = reactive({ count: 0 });
+ * const raw = toRaw(state);
+ * raw === state; // false
+ * isReactive(raw); // false
+ * ```
+ */
+export declare function toRaw<T>(observed: T): T;
+/**
+ * Marks an object so it will never be converted to a reactive proxy.
+ * Useful for values that should not be made reactive, like third-party class instances.
+ *
+ * @param value - The object to mark as non-reactive
+ * @returns The same object, marked as raw
+ *
+ * @example
+ * ```ts
+ * const obj = markRaw({ count: 0 });
+ * const state = reactive({ data: obj });
+ * isReactive(state.data); // false - obj was marked raw
+ * ```
+ */
+export declare function markRaw<T extends object>(value: T): T;
+//# sourceMappingURL=reactive.d.ts.map

package/src/reactive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reactive.d.ts","sourceRoot":"","sources":["reactive.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAOH;;GAEG;AACH,eAAO,MAAM,aAAa;;;CAGhB,CAAC;AAEX;;;;;;;;;;;;;GAaG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,MAAM,EAAE,MAAM,EAAE,CAAC,GAAG,CAAC,CAqEvD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAElD;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,GAAG,CAAC,CAGvC;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,OAAO,CAAC,CAAC,SAAS,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,CAOrD"}

package/src/reactive.js

@@ -0,0 +1,138 @@
+/**
+ * Proxy-based reactivity system for deep reactive state management.
+ * @module
+ */
+import { track, trigger } from './dep.js';
+const reactiveMap = new WeakMap();
+const rawMap = new WeakMap();
+/**
+ * Internal flags used to identify reactive objects.
+ */
+export const ReactiveFlags = {
+    IS_REACTIVE: '__b_isReactive',
+    RAW: '__b_raw',
+};
+/**
+ * Creates a deeply reactive proxy of an object.
+ * Changes to the object or its nested properties will automatically trigger effects.
+ *
+ * @param target - The object to make reactive
+ * @returns A reactive proxy of the target object
+ *
+ * @example
+ * ```ts
+ * const state = reactive({ count: 0, nested: { value: 1 } });
+ * state.count++; // Triggers effects tracking 'count'
+ * state.nested.value++; // Triggers effects tracking nested 'value'
+ * ```
+ */
+export function reactive(target) {
+    if (reactiveMap.has(target)) {
+        return reactiveMap.get(target);
+    }
+    if (target[ReactiveFlags.IS_REACTIVE]) {
+        return target;
+    }
+    const proxy = new Proxy(target, {
+        get(target, key, receiver) {
+            if (key === ReactiveFlags.IS_REACTIVE) {
+                return true;
+            }
+            if (key === ReactiveFlags.RAW) {
+                return target;
+            }
+            const result = Reflect.get(target, key, receiver);
+            track(target, key);
+            if (typeof result === 'object' && result !== null) {
+                return reactive(result);
+            }
+            return result;
+        },
+        set(target, key, value, receiver) {
+            const oldValue = Reflect.get(target, key, receiver);
+            const newValue = value?.[ReactiveFlags.RAW] || value;
+            const result = Reflect.set(target, key, newValue, receiver);
+            if (!Object.is(oldValue, newValue)) {
+                trigger(target, key);
+            }
+            return result;
+        },
+        deleteProperty(target, key) {
+            const hadKey = Reflect.has(target, key);
+            const result = Reflect.deleteProperty(target, key);
+            if (hadKey && result) {
+                trigger(target, key);
+            }
+            return result;
+        },
+        has(target, key) {
+            track(target, key);
+            return Reflect.has(target, key);
+        },
+        ownKeys(target) {
+            track(target, Symbol('iterate'));
+            return Reflect.ownKeys(target);
+        },
+    });
+    reactiveMap.set(target, proxy);
+    rawMap.set(proxy, target);
+    return proxy;
+}
+/**
+ * Checks if a value is a reactive proxy created by `reactive()`.
+ *
+ * @param value - The value to check
+ * @returns True if the value is a reactive proxy
+ *
+ * @example
+ * ```ts
+ * const state = reactive({ count: 0 });
+ * isReactive(state); // true
+ * isReactive({ count: 0 }); // false
+ * ```
+ */
+export function isReactive(value) {
+    return !!(value && value[ReactiveFlags.IS_REACTIVE]);
+}
+/**
+ * Returns the raw, non-reactive version of a reactive object.
+ * Useful when you need to read values without triggering dependency tracking.
+ *
+ * @param observed - The reactive object to unwrap
+ * @returns The original non-reactive object
+ *
+ * @example
+ * ```ts
+ * const state = reactive({ count: 0 });
+ * const raw = toRaw(state);
+ * raw === state; // false
+ * isReactive(raw); // false
+ * ```
+ */
+export function toRaw(observed) {
+    const raw = observed?.[ReactiveFlags.RAW];
+    return raw ? toRaw(raw) : observed;
+}
+/**
+ * Marks an object so it will never be converted to a reactive proxy.
+ * Useful for values that should not be made reactive, like third-party class instances.
+ *
+ * @param value - The object to mark as non-reactive
+ * @returns The same object, marked as raw
+ *
+ * @example
+ * ```ts
+ * const obj = markRaw({ count: 0 });
+ * const state = reactive({ data: obj });
+ * isReactive(state.data); // false - obj was marked raw
+ * ```
+ */
+export function markRaw(value) {
+    Object.defineProperty(value, ReactiveFlags.IS_REACTIVE, {
+        configurable: true,
+        enumerable: false,
+        value: false,
+    });
+    return value;
+}
+//# sourceMappingURL=reactive.js.map

package/src/reactive.js.map

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

package/src/reactive.ts

@@ -0,0 +1,162 @@
+/**
+ * Proxy-based reactivity system for deep reactive state management.
+ * @module
+ */
+
+import { track, trigger } from './dep.js';
+
+const reactiveMap = new WeakMap<object, object>();
+const rawMap = new WeakMap<object, object>();
+
+/**
+ * Internal flags used to identify reactive objects.
+ */
+export const ReactiveFlags = {
+  IS_REACTIVE: '__b_isReactive',
+  RAW: '__b_raw',
+} as const;
+
+/**
+ * Creates a deeply reactive proxy of an object.
+ * Changes to the object or its nested properties will automatically trigger effects.
+ *
+ * @param target - The object to make reactive
+ * @returns A reactive proxy of the target object
+ *
+ * @example
+ * ```ts
+ * const state = reactive({ count: 0, nested: { value: 1 } });
+ * state.count++; // Triggers effects tracking 'count'
+ * state.nested.value++; // Triggers effects tracking nested 'value'
+ * ```
+ */
+export function reactive<T extends object>(target: T): T {
+  if (reactiveMap.has(target)) {
+    return reactiveMap.get(target) as T;
+  }
+
+  if ((target as any)[ReactiveFlags.IS_REACTIVE]) {
+    return target;
+  }
+
+  const proxy = new Proxy(target, {
+    get(target, key, receiver) {
+      if (key === ReactiveFlags.IS_REACTIVE) {
+        return true;
+      }
+      if (key === ReactiveFlags.RAW) {
+        return target;
+      }
+
+      const result = Reflect.get(target, key, receiver);
+
+      track(target, key);
+
+      if (typeof result === 'object' && result !== null) {
+        return reactive(result);
+      }
+
+      return result;
+    },
+
+    set(target, key, value, receiver) {
+      const oldValue = Reflect.get(target, key, receiver);
+
+      const newValue = (value as any)?.[ReactiveFlags.RAW] || value;
+
+      const result = Reflect.set(target, key, newValue, receiver);
+
+      if (!Object.is(oldValue, newValue)) {
+        trigger(target, key);
+      }
+
+      return result;
+    },
+
+    deleteProperty(target, key) {
+      const hadKey = Reflect.has(target, key);
+      const result = Reflect.deleteProperty(target, key);
+
+      if (hadKey && result) {
+        trigger(target, key);
+      }
+
+      return result;
+    },
+
+    has(target, key) {
+      track(target, key);
+      return Reflect.has(target, key);
+    },
+
+    ownKeys(target) {
+      track(target, Symbol('iterate'));
+      return Reflect.ownKeys(target);
+    },
+  });
+
+  reactiveMap.set(target, proxy);
+  rawMap.set(proxy, target);
+
+  return proxy as T;
+}
+
+/**
+ * Checks if a value is a reactive proxy created by `reactive()`.
+ *
+ * @param value - The value to check
+ * @returns True if the value is a reactive proxy
+ *
+ * @example
+ * ```ts
+ * const state = reactive({ count: 0 });
+ * isReactive(state); // true
+ * isReactive({ count: 0 }); // false
+ * ```
+ */
+export function isReactive(value: unknown): boolean {
+  return !!(value && (value as any)[ReactiveFlags.IS_REACTIVE]);
+}
+
+/**
+ * Returns the raw, non-reactive version of a reactive object.
+ * Useful when you need to read values without triggering dependency tracking.
+ *
+ * @param observed - The reactive object to unwrap
+ * @returns The original non-reactive object
+ *
+ * @example
+ * ```ts
+ * const state = reactive({ count: 0 });
+ * const raw = toRaw(state);
+ * raw === state; // false
+ * isReactive(raw); // false
+ * ```
+ */
+export function toRaw<T>(observed: T): T {
+  const raw = (observed as any)?.[ReactiveFlags.RAW];
+  return raw ? toRaw(raw) : observed;
+}
+
+/**
+ * Marks an object so it will never be converted to a reactive proxy.
+ * Useful for values that should not be made reactive, like third-party class instances.
+ *
+ * @param value - The object to mark as non-reactive
+ * @returns The same object, marked as raw
+ *
+ * @example
+ * ```ts
+ * const obj = markRaw({ count: 0 });
+ * const state = reactive({ data: obj });
+ * isReactive(state.data); // false - obj was marked raw
+ * ```
+ */
+export function markRaw<T extends object>(value: T): T {
+  Object.defineProperty(value, ReactiveFlags.IS_REACTIVE, {
+    configurable: true,
+    enumerable: false,
+    value: false,
+  });
+  return value;
+}