@bromscandium/core 1.0.0 → 1.0.2

package/LICENSE

@@ -1,21 +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
+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

@@ -1,59 +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
+# @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/package.json

@@ -1,38 +1,38 @@
-{
-  "name": "@bromscandium/core",
-  "version": "1.0.0",
-  "description": "BromiumJS core reactivity system",
-  "author": "bromscandium",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/bromscandium/bromiumjs.git",
-    "directory": "packages/core"
-  },
-  "homepage": "https://github.com/bromscandium/bromiumjs#readme",
-  "bugs": {
-    "url": "https://github.com/bromscandium/bromiumjs/issues"
-  },
-  "keywords": ["bromium", "bromiumjs", "reactivity", "proxy", "signals"],
-  "type": "module",
-  "main": "./dist/index.js",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    ".": {
-      "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
-    }
-  },
-  "files": [
-    "dist",
-    "src"
-  ],
-  "scripts": {
-    "build": "tsc",
-    "dev": "tsc --watch"
-  },
-  "devDependencies": {
-    "typescript": "^5.9.3"
-  }
-}
+{
+  "name": "@bromscandium/core",
+  "version": "1.0.2",
+  "description": "BromiumJS core reactivity system",
+  "author": "bromscandium",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bromscandium/bromiumjs.git",
+    "directory": "packages/core"
+  },
+  "homepage": "https://github.com/bromscandium/bromiumjs#readme",
+  "bugs": {
+    "url": "https://github.com/bromscandium/bromiumjs/issues"
+  },
+  "keywords": ["bromium", "bromiumjs", "reactivity", "proxy", "signals"],
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch"
+  },
+  "devDependencies": {
+    "typescript": "^5.9.3"
+  }
+}

package/src/dep.ts

@@ -1,148 +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();
-}
+/**
+ * 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();
+}