@bromscandium/core 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 bromscandium
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,59 @@
+# @bromscandium/core
+
+Core reactivity system for BromiumJS - a Vue 3-inspired proxy-based reactive system.
+
+## Installation
+
+```bash
+npm install @bromscandium/core
+```
+
+## Usage
+
+```ts
+import { ref, reactive, computed, watch, watchEffect } from '@bromscandium/core';
+
+// Primitive values
+const count = ref(0);
+count.value++; // Triggers reactive updates
+
+// Objects
+const state = reactive({ name: 'John', items: [] });
+state.name = 'Jane'; // Deeply reactive
+
+// Computed values
+const doubled = computed(() => count.value * 2);
+
+// Watchers
+watch(() => count.value, (newVal, oldVal) => {
+  console.log(`Changed from ${oldVal} to ${newVal}`);
+});
+
+watchEffect(() => {
+  console.log(`Count is: ${count.value}`);
+});
+```
+
+## API
+
+| Export | Description |
+|--------|-------------|
+| `ref(value)` | Create a reactive reference for primitives |
+| `reactive(object)` | Create a deeply reactive object |
+| `computed(getter)` | Create a computed value |
+| `effect(fn)` | Create a reactive effect |
+| `watch(source, callback)` | Watch reactive sources |
+| `watchEffect(effect)` | Auto-tracking effect |
+| `isRef(value)` | Check if value is a Ref |
+| `isReactive(value)` | Check if value is reactive |
+| `unref(value)` | Unwrap a Ref |
+| `toRef(object, key)` | Create a Ref from object property |
+| `toRefs(object)` | Convert reactive object to Refs |
+| `toRaw(proxy)` | Get raw object from reactive proxy |
+| `shallowRef(value)` | Create a shallow reactive Ref |
+| `triggerRef(ref)` | Manually trigger ref updates |
+| `markRaw(object)` | Mark object as non-reactive |
+
+## License
+
+MIT

package/dist/dep.d.ts

@@ -0,0 +1,81 @@
+/**
+ * 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;
+}
+/**
+ * Returns the currently executing effect, if any.
+ *
+ * @returns The active effect function or null if no effect is running
+ */
+export declare function getActiveEffect(): EffectFn | null;
+/**
+ * Sets the currently active effect.
+ *
+ * @param effect - The effect to set as active, or null to clear
+ */
+export declare function setActiveEffect(effect: EffectFn | null): void;
+/**
+ * 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 declare function pushEffect(effect: EffectFn): void;
+/**
+ * Pops the current effect from the stack and restores the previous active effect.
+ * Used internally when a nested effect completes.
+ */
+export declare function popEffect(): void;
+/**
+ * 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 declare function track(target: object, key: string | symbol): void;
+/**
+ * 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 declare function trigger(target: object, key: string | symbol): void;
+/**
+ * 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 declare function cleanup(effect: EffectFn): void;
+//# sourceMappingURL=dep.d.ts.map

package/dist/dep.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dep.d.ts","sourceRoot":"","sources":["../src/dep.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;GAEG;AACH,MAAM,MAAM,QAAQ,GAAG,CAAC,MAAM,IAAI,CAAC,GAAG;IACpC,IAAI,EAAE,GAAG,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC;IACzB,OAAO,CAAC,EAAE,aAAa,CAAC;CACzB,CAAC;AAEF;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,iEAAiE;IACjE,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,gEAAgE;IAChE,SAAS,CAAC,EAAE,CAAC,EAAE,EAAE,QAAQ,KAAK,IAAI,CAAC;CACpC;AAOD;;;;GAIG;AACH,wBAAgB,eAAe,IAAI,QAAQ,GAAG,IAAI,CAEjD;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,QAAQ,GAAG,IAAI,GAAG,IAAI,CAE7D;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,QAAQ,GAAG,IAAI,CAGjD;AAED;;;GAGG;AACH,wBAAgB,SAAS,IAAI,IAAI,CAGhC;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAiBhE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAsBlE;AAED;;;;;GAKG;AACH,wBAAgB,OAAO,CAAC,MAAM,EAAE,QAAQ,GAAG,IAAI,CAK9C"}

package/dist/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/dist/dep.js.map

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

package/dist/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/dist/effect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"effect.d.ts","sourceRoot":"","sources":["../src/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/dist/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/dist/effect.js.map

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

package/dist/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/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/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/dist/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/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/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"}