dalila 1.3.1 → 1.3.2

package/dist/core/scope.js

@@ -1,3 +1,27 @@
+/** Tracks disposed scopes without mutating the public interface. */
+const disposedScopes = new WeakSet();
+const scopeCreateListeners = new Set();
+const scopeDisposeListeners = new Set();
+/**
+ * Subscribe to scope creation events.
+ * Returns an unsubscribe function.
+ */
+export function onScopeCreate(fn) {
+    scopeCreateListeners.add(fn);
+    return () => scopeCreateListeners.delete(fn);
+}
+/**
+ * Subscribe to scope disposal events.
+ * Returns an unsubscribe function.
+ */
+export function onScopeDispose(fn) {
+    scopeDisposeListeners.add(fn);
+    return () => scopeDisposeListeners.delete(fn);
+}
+/** Returns true if the given scope has been disposed. */
+export function isScopeDisposed(scope) {
+    return disposedScopes.has(scope);
+}
 /**
  * Creates a new Scope instance.
  *
@@ -7,13 +31,13 @@
  *   in the same dispose pass (because we snapshot via `splice(0)`).
  * - Parent is captured from the current scope context (set by withScope).
  */
-export function createScope() {
+export function createScope(parentOverride) {
     const cleanups = [];
-    const parent = currentScope;
-    let disposed = false;
+    const parent = parentOverride === undefined ? currentScope : parentOverride === null ? null : parentOverride;
     const runCleanupSafely = (fn) => {
         try {
-            return fn();
+            fn();
+            return undefined;
         }
         catch (err) {
             return err;
@@ -21,7 +45,7 @@ export function createScope() {
     };
     const scope = {
         onCleanup(fn) {
-            if (disposed) {
+            if (isScopeDisposed(scope)) {
                 const error = runCleanupSafely(fn);
                 if (error) {
                     console.error('[Dalila] cleanup registered after dispose() threw:', error);
@@ -31,9 +55,9 @@ export function createScope() {
             cleanups.push(fn);
         },
         dispose() {
-            if (disposed)
+            if (isScopeDisposed(scope))
                 return;
-            disposed = true;
+            disposedScopes.add(scope);
             const snapshot = cleanups.splice(0);
             const errors = [];
             for (const fn of snapshot) {
@@ -44,12 +68,28 @@ export function createScope() {
             if (errors.length > 0) {
                 console.error('[Dalila] scope.dispose() had cleanup errors:', errors);
             }
+            for (const listener of scopeDisposeListeners) {
+                try {
+                    listener(scope);
+                }
+                catch (err) {
+                    console.error('[Dalila] scope.dispose() listener threw:', err);
+                }
+            }
         },
         parent,
     };
     if (parent) {
         parent.onCleanup(() => scope.dispose());
     }
+    for (const listener of scopeCreateListeners) {
+        try {
+            listener(scope);
+        }
+        catch (err) {
+            console.error('[Dalila] scope.create() listener threw:', err);
+        }
+    }
     return scope;
 }
 /**
@@ -61,6 +101,18 @@ let currentScope = null;
 export function getCurrentScope() {
     return currentScope;
 }
+/**
+ * Returns the current scope hierarchy, from current scope up to the root.
+ */
+export function getCurrentScopeHierarchy() {
+    const scopes = [];
+    let current = currentScope;
+    while (current) {
+        scopes.push(current);
+        current = current.parent;
+    }
+    return scopes;
+}
 /**
  * Sets the current active scope.
  * Prefer using `withScope()` unless you are implementing low-level internals.
@@ -76,6 +128,9 @@ export function setCurrentScope(scope) {
  * - `effect()` can auto-dispose when the scope ends
  */
 export function withScope(scope, fn) {
+    if (isScopeDisposed(scope)) {
+        throw new Error('[Dalila] withScope() cannot enter a disposed scope.');
+    }
     const prevScope = currentScope;
     currentScope = scope;
     try {

package/dist/core/signal.d.ts

@@ -5,9 +5,16 @@
  */
 export declare function setEffectErrorHandler(handler: (error: Error, source: string) => void): void;
 export interface Signal<T> {
+    /** Read the current value (with dependency tracking if inside an effect). */
     (): T;
+    /** Set a new value and notify subscribers. */
     set(value: T): void;
+    /** Update the value using a function. */
     update(fn: (v: T) => T): void;
+    /** Read the current value without creating a dependency (no tracking). */
+    peek(): T;
+    /** Subscribe to value changes manually (outside of effects). Returns unsubscribe function. */
+    on(callback: (value: T) => void): () => void;
 }
 /**
  * Create a signal: a mutable value with automatic dependency tracking.
@@ -64,3 +71,18 @@ export declare function computed<T>(fn: () => T): Signal<T>;
  * - when disposed, aborts the current run and stops future scheduling
  */
 export declare function effectAsync(fn: (signal: AbortSignal) => void): () => void;
+/**
+ * Run a function without tracking any signal reads as dependencies.
+ *
+ * Use this inside an effect when you want to read a signal's value
+ * without creating a dependency on it.
+ *
+ * Example:
+ * ```ts
+ * effect(() => {
+ *   const tracked = count();        // This read is tracked
+ *   const untracked = untrack(() => other()); // This read is NOT tracked
+ * });
+ * ```
+ */
+export declare function untrack<T>(fn: () => T): T;

package/dist/core/signal.js

@@ -158,6 +158,26 @@ export function signal(initialValue) {
     read.update = (fn) => {
         read.set(fn(value));
     };
+    read.peek = () => value;
+    read.on = (callback) => {
+        // Create a lightweight effect-like subscriber for manual subscriptions
+        const subscriber = (() => {
+            if (subscriber.disposed)
+                return;
+            callback(value);
+        });
+        subscriber.disposed = false;
+        subscribers.add(subscriber);
+        (subscriber.deps ?? (subscriber.deps = new Set())).add(subscribers);
+        // Return unsubscribe function
+        return () => {
+            if (subscriber.disposed)
+                return;
+            subscriber.disposed = true;
+            subscribers.delete(subscriber);
+            subscriber.deps?.delete(subscribers);
+        };
+    };
     return read;
 }
 /**
@@ -306,6 +326,45 @@ export function computed(fn) {
     read.update = () => {
         throw new Error('Cannot update a computed signal directly. Computed signals are derived from other signals.');
     };
+    read.peek = () => {
+        // For computed, peek still needs to compute if dirty, but without tracking
+        if (dirty) {
+            cleanupDeps();
+            const prevEffect = activeEffect;
+            const prevScope = activeScope;
+            activeEffect = markDirty;
+            activeScope = null;
+            try {
+                value = fn();
+                dirty = false;
+                if (markDirty.deps)
+                    trackedDeps = new Set(markDirty.deps);
+            }
+            finally {
+                activeEffect = prevEffect;
+                activeScope = prevScope;
+            }
+        }
+        return value;
+    };
+    read.on = (callback) => {
+        const subscriber = (() => {
+            if (subscriber.disposed)
+                return;
+            // For computed, we need to get the latest value
+            callback(read.peek());
+        });
+        subscriber.disposed = false;
+        subscribers.add(subscriber);
+        (subscriber.deps ?? (subscriber.deps = new Set())).add(subscribers);
+        return () => {
+            if (subscriber.disposed)
+                return;
+            subscriber.disposed = true;
+            subscribers.delete(subscriber);
+            subscriber.deps?.delete(subscribers);
+        };
+    };
     return read;
 }
 /**
@@ -363,3 +422,30 @@ export function effectAsync(fn) {
         owningScope.onCleanup(dispose);
     return dispose;
 }
+/**
+ * Run a function without tracking any signal reads as dependencies.
+ *
+ * Use this inside an effect when you want to read a signal's value
+ * without creating a dependency on it.
+ *
+ * Example:
+ * ```ts
+ * effect(() => {
+ *   const tracked = count();        // This read is tracked
+ *   const untracked = untrack(() => other()); // This read is NOT tracked
+ * });
+ * ```
+ */
+export function untrack(fn) {
+    const prevEffect = activeEffect;
+    const prevScope = activeScope;
+    activeEffect = null;
+    activeScope = null;
+    try {
+        return fn();
+    }
+    finally {
+        activeEffect = prevEffect;
+        activeScope = prevScope;
+    }
+}

package/dist/core/when.js

@@ -1,5 +1,5 @@
 import { effect } from './signal.js';
-import { createScope, getCurrentScope, withScope } from './scope.js';
+import { createScope, getCurrentScope, isScopeDisposed, withScope } from './scope.js';
 import { scheduleMicrotask } from './scheduler.js';
 /**
  * Conditional DOM rendering with per-branch lifetime.
@@ -38,6 +38,13 @@ export function when(test, thenFn, elseFn) {
     let pendingCond = undefined;
     /** Disposal guard to prevent orphan microtasks from touching dead DOM. */
     let disposed = false;
+    /** Parent scope captured at creation time (if any). */
+    const parentScope = getCurrentScope();
+    const resolveParentScope = () => {
+        if (!parentScope)
+            return null;
+        return isScopeDisposed(parentScope) ? null : parentScope;
+    };
     /** Removes mounted nodes and disposes their branch scope. */
     const clear = () => {
         branchScope?.dispose();
@@ -56,7 +63,7 @@ export function when(test, thenFn, elseFn) {
     /** Clears old branch and mounts the branch for `cond`. */
     const swap = (cond) => {
         clear();
-        const nextScope = createScope();
+        const nextScope = createScope(resolveParentScope());
         try {
             // Render inside an isolated scope so branch resources are tied to that branch.
             const result = withScope(nextScope, () => (cond ? thenFn() : elseFn?.()));
@@ -107,7 +114,6 @@ export function when(test, thenFn, elseFn) {
         });
     });
     // If `when()` is created inside a parent scope, dispose branch resources with it.
-    const parentScope = getCurrentScope();
     if (parentScope) {
         parentScope.onCleanup(() => {
             disposed = true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dalila",
-  "version": "1.3.1",
+  "version": "1.3.2",
   "description": "DOM-first reactive framework based on signals",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",