Spearwolf Signalize Signalize Utilities

Signalize Utilities

Overview

batch() - Deferred Effect Execution

Combine multiple signal updates into one effect run:

import {batch, createSignal, createEffect} from '@spearwolf/signalize';

const firstName = createSignal('');
const lastName = createSignal('');

createEffect(() => {
  console.log(`${firstName.get()} ${lastName.get()}`);
});

// Without batch: effect runs TWICE
firstName.set('John'); // Effect runs
lastName.set('Doe'); // Effect runs again

// With batch: effect runs ONCE
batch(() => {
  firstName.set('Jane');
  lastName.set('Smith');
}); // Effect runs once here with final values

Key Behaviors

• Signal values update immediately inside batch (readable)
• Effects are deferred until batch ends
• Nested batches are flattened - only outermost batch triggers effects
• Effects run in priority order (higher priority first)

Priority Ordering

Within a batch, effects execute in priority order:

createEffect(low, {priority: -100}); // Runs last
createEffect(high, {priority: 1000}); // Runs first
createEffect(normal); // Default priority 0

batch(() => {
  signal.set(newValue);
});
// Execution order: high → normal → low

Default priorities:

This ensures memos compute before effects that depend on them.

Nested Batches

batch(() => {
  a.set(1);

  batch(() => {
    b.set(2);
    c.set(3);
  });
  // Inner batch doesn't trigger effects yet

  d.set(4);
});
// ALL effects run once here

Reading Values in Batch

batch(() => {
  firstName.set('John');
  console.log(firstName.get()); // 'John' - value is immediate

  // But effects haven't run yet
});

beQuiet() - Suppress Dependency Tracking

Read signals without creating dependencies:

import {beQuiet, isQuiet} from '@spearwolf/signalize';

createEffect(() => {
  const tracked = signalA.get(); // Creates dependency

  beQuiet(() => {
    const untracked = signalB.get(); // NO dependency created
    console.log(untracked);
  });

  // Effect only re-runs when signalA changes, not signalB
});

Use Cases

One-time configuration reads:

createEffect(() => {
  const data = dataSignal.get(); // Track this

  beQuiet(() => {
    const config = configSignal.get(); // Don't track config
    process(data, config);
  });
});

Logging without subscribing:

createEffect(() => {
  performAction(signal.get());

  beQuiet(() => {
    console.log('Debug - other value:', otherSignal.get());
  });
});

Conditional non-tracking:

createEffect(() => {
  if (shouldTrack.get()) {
    return trackedSignal.get();
  } else {
    return beQuiet(() => untrackedSignal.get());
  }
});

Check Quiet State

if (isQuiet()) {
  // Currently inside beQuiet() context
}

hibernate() - Complete Context Isolation

Temporarily exit all reactive contexts:

import {hibernate} from '@spearwolf/signalize';

createEffect(() => {
  const val = signal.get(); // Tracked

  hibernate(() => {
    // No current effect context
    // No batch context
    // No beQuiet context

    otherSignal.set(val); // Triggers effects IMMEDIATELY

    // Can create independent effects
    createEffect(() => {
      /* Not nested in outer effect */
    });
  });
});

What hibernate() Clears

All contexts are restored after hibernate callback completes.

Use Cases

Escape batch for immediate effect:

batch(() => {
  a.set(1);

  hibernate(() => {
    // This triggers effects immediately, not batched
    criticalSignal.set(urgent);
  });

  b.set(2); // Back in batch
});

Create independent effects:

createEffect(() => {
  trigger.get();

  hibernate(() => {
    // This effect is NOT a child of the outer effect
    createEffect(() => {
      independent.get();
    });
  });
});

Read without any context:

batch(() => {
  beQuiet(() => {
    createEffect(() => {
      // Deeply nested contexts

      hibernate(() => {
        // Clean slate - no batch, no quiet, no effect
        const value = signal.get(); // Would track if in effect
      });
    });
  });
});

Exception Safety

Contexts are properly restored even if an exception is thrown:

try {
  hibernate(() => {
    throw new Error('oops');
  });
} catch (e) {
  // Contexts are restored here
}

Comparison Table

Combining Utilities

batch + beQuiet

batch(() => {
  // Multiple updates, one effect run
  a.set(1);
  b.set(2);

  // Read without tracking (inside the batch)
  beQuiet(() => {
    console.log('Current c:', c.get());
  });
});

Effect with selective tracking

createEffect(() => {
  // Track these
  const important = importantSignal.get();

  // Don't track these
  beQuiet(() => {
    const config = configSignal.get();
    const debug = debugSignal.get();
  });

  process(important, config, debug);
});

Pitfalls

1. beQuiet doesn't prevent writes

beQuiet(() => {
  signal.set(newValue); // Still notifies dependents!
});

2. hibernate flushes batches

batch(() => {
  a.set(1);

  hibernate(() => {
    // Batch was FLUSHED - effects for a.set(1) already ran!
  });
});

3. Nested beQuiet is redundant

beQuiet(() => {
  beQuiet(() => {
    // Still quiet, but redundant nesting
  });
});

See Also

• Developer Guide - Comprehensive guide to all features
• Full API Reference - Complete API documentation
• Cheat Sheet - Quick reference

Converted and distributed by TomeVault — claim your Tome and manage your conversions.