event-emission 0.1.0 → 0.2.1

package/README.md

@@ -1,12 +1,15 @@
 # Event Emission
 
+**Event Emission** is a high-performance, type-safe event primitive designed to bridge the gap between three worlds: DOM `EventTarget`, TC39 `Observable`, and `AsyncIterator`. While standard event emitters often force you into a single consumption pattern, **Event Emission** gives you the freedom to dispatch once and consume however your logic demands—whether that's standard callbacks, reactive pipelines via RxJS, or clean `for await...of` loops. By treating events as a first-class, composable primitive rather than just a side-effect, it eliminates race conditions and shared mutable state, providing a unified, zero-dependency foundation for building resilient, concurrent applications in modern JavaScript and TypeScript environments.
+
 A lightweight, zero-dependency, type-safe event system with DOM EventTarget ergonomics and TC39 Observable interoperability. Use one event source with callbacks, async iterators, and RxJS without losing TypeScript safety.
 
 ## Tasting notes
 
 - **Typed events** - Event maps keep payloads and event names in sync
+- **DOM compatible** - `EmissionEvent` is a superset of the built-in `Event`
 - **Familiar API** - `addEventListener`, `removeEventListener`, `dispatchEvent`
-- **Observable-ready** - Works with RxJS and other TC39 Observable libraries
+- **TC39 Observable** - Fully compliant `Observable` implementation (passes all `es-observable-tests`)
 - **Async iteration** - `for await...of` over events with backpressure options
 - **Wildcard listeners** - Listen to `*` or namespaced `user:*` patterns
 - **Observable state** - Proxy any object and emit change events automatically
@@ -56,16 +59,38 @@ events.dispatchEvent({
 ## Core concepts
 
 - **Event map**: a TypeScript type that maps event names to payload types.
-- **Event shape**: `{ type: string; detail: Payload }` for all listeners.
+- **Event shape**: `{ type: string; detail: Payload; bubbles?: boolean; cancelable?: boolean; composed?: boolean }` for dispatch.
 - **Unsubscribe**: `addEventListener` returns a function to remove the listener.
 
 ## API overview
 
+Core (`event-emission`):
+
 - `createEventTarget<E>(options?)`
 - `createEventTarget(target, { observe: true, ... })`
-- `Eventful<E>` base class
-- Interop: `fromEventTarget`, `forwardToEventTarget`, `pipe`
-- Utilities: `isObserved`, `getOriginal`
+- `EventEmission<E>` base class
+
+Optional subpaths:
+
+- `Observable<T>` compliant implementation (`event-emission/observable`)
+- Interoperability: `fromEventTarget`, `forwardToEventTarget`, `pipe` (`event-emission/interoperability`)
+- Observe utilities: `isObserved`, `getOriginal`, `setupEventForwarding` (`event-emission/observe`)
+- Types-only exports (`event-emission/types`)
+
+## Subpath exports
+
+To keep the core entrypoint lean, optional features are exposed via subpath exports:
+
+```typescript
+import { Observable } from 'event-emission/observable';
+import { getOriginal, isObserved, setupEventForwarding } from 'event-emission/observe';
+import {
+  forwardToEventTarget,
+  fromEventTarget,
+  pipe,
+} from 'event-emission/interoperability';
+import type { EventTargetLike } from 'event-emission/types';
+```
 
 ## createEventTarget
 
@@ -113,11 +138,29 @@ state.user.name = 'Grace'; // Triggers 'update' and 'update:user.name'
 
 **Observe options:**
 
-| Option          | Type                            | Default  | Description                        |
-| --------------- | ------------------------------- | -------- | ---------------------------------- |
-| `observe`       | `boolean`                       | `false`  | Enable property change observation |
-| `deep`          | `boolean`                       | `true`   | Observe nested objects             |
-| `cloneStrategy` | `'shallow' \| 'deep' \| 'path'` | `'path'` | How to clone previous state        |
+Deep observation is enabled by default.
+
+| Option          | Type                            | Default  | Description                                                        |
+| --------------- | ------------------------------- | -------- | ------------------------------------------------------------------ |
+| `observe`       | `boolean`                       | `false`  | Enable property change observation                                 |
+| `deep`          | `boolean`                       | `true`   | Observe nested objects                                             |
+| `cloneStrategy` | `'shallow' \| 'deep' \| 'path'` | `'path'` | How to clone previous state                                        |
+| `deepClone`     | `<T>(value: T) => T`            | -        | Optional deep clone fallback when `structuredClone` is unavailable |
+
+Note: `cloneStrategy: 'deep'` uses `structuredClone` by default, or `deepClone` if provided.
+
+Example fallback:
+
+```typescript
+const state = createEventTarget(
+  { count: 0, user: { name: 'Ada' } },
+  {
+    observe: true,
+    cloneStrategy: 'deep',
+    deepClone: (value) => JSON.parse(JSON.stringify(value)),
+  },
+);
+```
 
 **Update event details:**
 
@@ -126,6 +169,29 @@ state.user.name = 'Grace'; // Triggers 'update' and 'update:user.name'
 
 ## Event listeners
 
+### `on(type, options?)`
+
+Creates an `Observable` for a specific event type. This follows the `ObservableEventTarget` proposal, allowing for powerful composition.
+
+```typescript
+const clicks = button.on('click', { passive: true });
+
+clicks.subscribe((event) => {
+  console.log('Clicked!', event.detail);
+});
+```
+
+**Options:**
+
+| Option         | Type          | Default | Description                                                                            |
+| -------------- | ------------- | ------- | -------------------------------------------------------------------------------------- |
+| `capture`      | `boolean`     | `false` | If true, listen during the capture phase                                               |
+| `receiveError` | `boolean`     | `false` | If true, listen for "error" events and forward them to the observer's error method     |
+| `handler`      | `Function`    | `null`  | Optional function to run stateful actions (like `preventDefault()`) before dispatching |
+| `once`         | `boolean`     | `false` | If true, the observable completes after the first event is dispatched                  |
+| `passive`      | `boolean`     | `false` | Indicates that the callback will not cancel the event                                  |
+| `signal`       | `AbortSignal` | -       | Abort signal to remove the listener when aborted                                       |
+
 ### `addEventListener(type, listener, options?)`
 
 Adds a listener and returns an unsubscribe function.
@@ -138,18 +204,22 @@ const unsubscribe = events.addEventListener('message', (event) => {
 unsubscribe();
 ```
 
-**Options:**
+**Options:** (or pass `true`/`false` for capture)
+
+| Option    | Type          | Description                                  |
+| --------- | ------------- | -------------------------------------------- |
+| `capture` | `boolean`     | Listen during the capture phase              |
+| `once`    | `boolean`     | Remove listener after first invocation       |
+| `passive` | `boolean`     | Listener will not call `preventDefault()`    |
+| `signal`  | `AbortSignal` | Abort signal to remove listener when aborted |
 
-| Option   | Type          | Description                                  |
-| -------- | ------------- | -------------------------------------------- |
-| `once`   | `boolean`     | Remove listener after first invocation       |
-| `signal` | `AbortSignal` | Abort signal to remove listener when aborted |
+Note: `preventDefault()` only affects events dispatched with `cancelable: true`. `dispatchEvent` returns `false` when a cancelable event is prevented.
 
 ### `once(type, listener, options?)`
 
 Adds a one-time listener.
 
-### `removeEventListener(type, listener)`
+### `removeEventListener(type, listener, options?)`
 
 Removes a specific listener.
 
@@ -173,10 +243,24 @@ Wildcard events include `{ type: pattern, originalType, detail }`.
 
 ## Async iteration
 
+You can use `for await...of` to consume events. This is great for stream-processing events with backpressure.
+
 ```typescript
-for await (const event of events.events('message', { bufferSize: 16 })) {
+// Simple iteration
+for await (const event of events.events('message')) {
   console.log('Received:', event.detail.text);
 }
+
+// With options for backpressure and cleanup
+const iterator = events.events('message', {
+  bufferSize: 16,
+  overflowStrategy: 'drop-oldest',
+  signal: abortController.signal,
+});
+
+for await (const event of iterator) {
+  // ...
+}
 ```
 
 **Iterator options:**
@@ -221,6 +305,26 @@ observable
   .subscribe(console.log);
 ```
 
+### `Observable` class
+
+A fully compliant implementation of the TC39 Observable proposal.
+
+```typescript
+import { Observable } from 'event-emission/observable';
+
+// Create from items
+const numbers = Observable.of(1, 2, 3);
+
+// Create from any iterable or observable-like
+const fromArray = Observable.from([10, 20, 30]);
+
+// Manual creation
+const custom = new Observable((observer) => {
+  observer.next('Hello');
+  observer.complete();
+});
+```
+
 ## Lifecycle
 
 ### `complete()`
@@ -231,14 +335,14 @@ Marks the event target as complete, clears listeners, and ends iterators.
 
 Removes all listeners without marking as complete.
 
-## Eventful base class
+## EventEmission base class
 
-Extend `Eventful` to build typed emitters:
+Extend `EventEmission` to build typed emitters:
 
 ```typescript
-import { Eventful } from 'event-emission';
+import { EventEmission } from 'event-emission';
 
-class UserService extends Eventful<{
+class UserService extends EventEmission<{
   'user:created': { id: string; name: string };
   'user:deleted': { id: string };
   error: Error;
@@ -256,7 +360,7 @@ class UserService extends Eventful<{
 ### `fromEventTarget(domTarget, eventTypes, options?)`
 
 ```typescript
-import { fromEventTarget } from 'event-emission';
+import { fromEventTarget } from 'event-emission/interoperability';
 
 type ButtonEvents = {
   click: MouseEvent;
@@ -276,7 +380,8 @@ events.destroy();
 ### `forwardToEventTarget(source, domTarget, options?)`
 
 ```typescript
-import { createEventTarget, forwardToEventTarget } from 'event-emission';
+import { createEventTarget } from 'event-emission';
+import { forwardToEventTarget } from 'event-emission/interoperability';
 
 const events = createEventTarget<{ custom: { value: number } }>();
 const element = document.getElementById('target');
@@ -291,7 +396,8 @@ unsubscribe();
 ### `pipe(source, target, options?)`
 
 ```typescript
-import { createEventTarget, pipe } from 'event-emission';
+import { createEventTarget } from 'event-emission';
+import { pipe } from 'event-emission/interoperability';
 
 const componentEvents = createEventTarget<{ ready: void }>();
 const appBus = createEventTarget<{ ready: void }>();
@@ -301,7 +407,89 @@ const unsubscribe = pipe(componentEvents, appBus);
 unsubscribe();
 ```
 
-Note: `pipe(source, target)` forwards all events via a wildcard listener. The instance method `events.pipe(target)` only forwards event types that already have listeners when you call it.
+Note: Both `pipe(source, target)` and `events.pipe(target)` forward all events via a wildcard listener. Use a map function to transform events or return `null` to filter.
+
+## React integration
+
+**Event Emission** works beautifully with React's `useSyncExternalStore` for predictable, race-condition-free state synchronization.
+
+### Observing an event emitter
+
+```typescript
+import { useSyncExternalStore } from 'react';
+import { createEventTarget } from 'event-emission';
+
+const bus = createEventTarget<{ log: string }>();
+
+function useBusEvent() {
+  return useSyncExternalStore(
+    (callback) => bus.addEventListener('log', callback),
+    () => getLatestLogValue(), // implementation depends on your needs
+  );
+}
+```
+
+### Syncing with Observable State
+
+The `observe` feature is perfect for building high-performance global stores or local controllers that live outside the React render cycle.
+
+```typescript
+import { useSyncExternalStore } from 'react';
+import { createEventTarget } from 'event-emission';
+
+// 1. Create your store outside of React
+const store = createEventTarget(
+  { count: 0, lastUpdated: new Date() },
+  { observe: true }
+);
+
+// 2. Create a generic hook to sync with any observed target
+export function useObservable<T extends object>(target: T) {
+  return useSyncExternalStore(
+    (onStoreChange) => (target as any).addEventListener('update', onStoreChange),
+    () => target
+  );
+}
+
+// 3. Components re-render only when the store actually mutates
+function Counter() {
+  const state = useObservable(store);
+  return (
+    <button onClick={() => state.count++}>
+      Count is {state.count}
+    </button>
+  );
+}
+```
+
+## Svelte integration
+
+**Event Emission** works naturally with Svelte 5 Runes to create reactive stores that live outside your component tree.
+
+### Creating a Reactive Rune
+
+```typescript
+import { createEventTarget } from 'event-emission';
+
+// 1. Define your external state
+const store = createEventTarget({ count: 0 }, { observe: true });
+
+// 2. Create a generic Rune to sync with any observed target
+export function useObservable<T extends object>(target: T) {
+  let state = $state(target);
+
+  $effect(() => {
+    return (target as any).addEventListener('update', () => {
+      state = target; // Trigger Svelte reactivity
+    });
+  });
+
+  return state;
+}
+
+// 3. Use it in your components
+const state = useObservable(store);
+```
 
 ## Utilities
 
@@ -309,23 +497,36 @@ Note: `pipe(source, target)` forwards all events via a wildcard listener. The in
 
 Checks if an object is an observed proxy.
 
+```typescript
+import { isObserved } from 'event-emission/observe';
+```
+
 ### `getOriginal(proxy)`
 
 Returns the original unproxied object.
 
+```typescript
+import { getOriginal } from 'event-emission/observe';
+```
+
 ## TypeScript types
 
 ```typescript
 import type {
-  EventfulEvent,
+  EmissionEvent,
   EventTargetLike,
   ObservableLike,
   Observer,
   Subscription,
   WildcardEvent,
   AddEventListenerOptionsLike,
+} from 'event-emission/types';
+
+import type {
   ObservableEventMap,
   PropertyChangeDetail,
   ArrayMutationDetail,
-} from 'event-emission';
+} from 'event-emission/observe';
+
+import type { Subscriber, SubscriptionObserver } from 'event-emission/observable';
 ```

package/dist/{eventful.d.ts → event-emission.d.ts}

@@ -1,5 +1,5 @@
 import { SymbolObservable } from './symbols';
-import type { AddEventListenerOptionsLike, EventfulEvent, EventsIteratorOptions, EventTargetLike, ObservableLike, Observer, Subscription, WildcardEvent } from './types';
+import type { AddEventListenerOptionsLike, DispatchEventInput, DOMEventLike, EmissionEvent, EventListenerLike, EventListenerOptionsLike, EventsIteratorOptions, EventTargetLike, ObservableLike, Observer, OnOptions, Subscription, WildcardEvent } from './types';
 /**
  * Abstract base class for typed event emitters with DOM EventTarget
  * and TC39 Observable compatibility.
@@ -7,7 +7,7 @@ import type { AddEventListenerOptionsLike, EventfulEvent, EventsIteratorOptions,
  * Extend this class to create custom event emitters with typed events.
  * The class provides:
  * - DOM EventTarget compatible API (addEventListener, removeEventListener, dispatchEvent)
- * - TC39 Observable interop (subscribe, Symbol.observable)
+ * - TC39 Observable interoperability (subscribe, Symbol.observable)
  * - Async iteration support (events() method)
  * - Wildcard listeners for namespaced events
  * - Lifecycle management (complete(), completed)
@@ -21,7 +21,7 @@ import type { AddEventListenerOptionsLike, EventfulEvent, EventsIteratorOptions,
  * @example Basic usage
  * ```typescript
  * // Define your emitter with typed events
- * class UserService extends Eventful<{
+ * class UserService extends EventEmission<{
  *   'user:created': { id: string; name: string };
  *   'user:deleted': { id: string };
  *   error: Error;
@@ -39,7 +39,7 @@ import type { AddEventListenerOptionsLike, EventfulEvent, EventsIteratorOptions,
  * });
  * ```
  *
- * @example TC39 Observable interop
+ * @example TC39 Observable interoperability
  * ```typescript
  * const service = new UserService();
  *
@@ -64,32 +64,36 @@ import type { AddEventListenerOptionsLike, EventfulEvent, EventsIteratorOptions,
  * }
  * ```
  */
-export declare abstract class Eventful<E extends Record<string, any>> {
+export declare abstract class EventEmission<E extends Record<string, any>> {
     #private;
     /**
-     * Returns this observable for Symbol.observable interop.
+     * Returns this observable for Symbol.observable interoperability.
      */
-    [SymbolObservable]: () => ObservableLike<EventfulEvent<E[keyof E]>>;
+    [SymbolObservable]: () => ObservableLike<EmissionEvent<E[keyof E]>>;
     constructor();
     /**
      * Adds an event listener for the specified event type.
      * Returns an unsubscribe function for convenience.
      */
-    addEventListener<K extends keyof E & string>(type: K, listener: (event: EventfulEvent<E[K]>) => void | Promise<void>, options?: AddEventListenerOptionsLike): () => void;
+    addEventListener<K extends keyof E & string>(type: K, listener: EventListenerLike<EmissionEvent<E[K], K>> | null, options?: AddEventListenerOptionsLike | boolean): () => void;
     /**
      * Removes an event listener for the specified event type.
      */
-    removeEventListener<K extends keyof E & string>(type: K, listener: (event: EventfulEvent<E[K]>) => void | Promise<void>): void;
+    removeEventListener<K extends keyof E & string>(type: K, listener: EventListenerLike<EmissionEvent<E[K], K>> | null, options?: EventListenerOptionsLike | boolean): void;
     /**
      * Dispatches an event to all registered listeners.
      * Returns false if the emitter has been completed, true otherwise.
      */
-    dispatchEvent<K extends keyof E & string>(event: EventfulEvent<E[K]>): boolean;
+    dispatchEvent<K extends keyof E & string>(event: DispatchEventInput<E[K], K> | DOMEventLike): boolean;
+    /**
+     * Returns an observable for the specified event type.
+     */
+    on<K extends keyof E & string>(type: K, options?: OnOptions | boolean): ObservableLike<EmissionEvent<E[K], K>>;
     /**
      * Adds a one-time listener for the specified event type.
      * Returns an unsubscribe function.
      */
-    once<K extends keyof E & string>(type: K, listener: (event: EventfulEvent<E[K]>) => void | Promise<void>, options?: Omit<AddEventListenerOptionsLike, 'once'>): () => void;
+    once<K extends keyof E & string>(type: K, listener: EventListenerLike<EmissionEvent<E[K], K>> | null, options?: Omit<AddEventListenerOptionsLike, 'once'> | boolean): () => void;
     /**
      * Removes all listeners, or those of the specified event type.
      */
@@ -100,10 +104,9 @@ export declare abstract class Eventful<E extends Record<string, any>> {
     clear(): void;
     /**
      * Pipe events from this emitter to another target.
-     * Note: Only forwards events for types that have listeners when pipe() is called.
-     * Events for types registered after piping won't be forwarded automatically.
+     * Forwards all events. If mapFn returns null, the event is skipped.
      */
-    pipe<T extends Record<string, any>>(target: EventTargetLike<T>, mapFn?: <K extends keyof E & string>(event: EventfulEvent<E[K]>) => EventfulEvent<T[keyof T & string]> | null): () => void;
+    pipe<T extends Record<string, any>>(target: EventTargetLike<T>, mapFn?: <K extends keyof E & string>(event: EmissionEvent<E[K], K>) => DispatchEventInput<T[keyof T & string], keyof T & string> | null): () => void;
     /**
      * Adds a wildcard listener that receives events matching the pattern.
      * Use '*' for all events, or 'namespace:*' for namespaced events.
@@ -116,15 +119,15 @@ export declare abstract class Eventful<E extends Record<string, any>> {
     /**
      * Subscribes an observer to all events (untyped).
      */
-    subscribe(observerOrNext: Observer<EventfulEvent<E[keyof E]>> | ((value: EventfulEvent<E[keyof E]>) => void)): Subscription;
+    subscribe(observerOrNext: Observer<EmissionEvent<E[keyof E]>> | ((value: EmissionEvent<E[keyof E]>) => void)): Subscription;
     /**
      * Subscribes an observer to events of a specific type (typed).
      */
-    subscribe<K extends keyof E & string>(type: K, observerOrNext?: Observer<EventfulEvent<E[K]>> | ((value: EventfulEvent<E[K]>) => void), error?: (err: unknown) => void, completeHandler?: () => void): Subscription;
+    subscribe<K extends keyof E & string>(type: K, observerOrNext?: Observer<EmissionEvent<E[K], K>> | ((value: EmissionEvent<E[K], K>) => void), error?: (err: unknown) => void, completeHandler?: () => void): Subscription;
     /**
      * Returns an observable that emits all events.
      */
-    toObservable(): ObservableLike<EventfulEvent<E[keyof E]>>;
+    toObservable(): ObservableLike<EmissionEvent<E[keyof E]>>;
     /**
      * Marks the emitter as complete. Invokes complete() on all observable subscribers,
      * ends all async iterators, and suppresses further emits/dispatches.
@@ -148,6 +151,6 @@ export declare abstract class Eventful<E extends Record<string, any>> {
      * }
      * ```
      */
-    events<K extends keyof E & string>(type: K, options?: EventsIteratorOptions): AsyncIterableIterator<EventfulEvent<E[K]>>;
+    events<K extends keyof E & string>(type: K, options?: EventsIteratorOptions): AsyncIterableIterator<EmissionEvent<E[K], K>>;
 }
-//# sourceMappingURL=eventful.d.ts.map
+//# sourceMappingURL=event-emission.d.ts.map

package/dist/event-emission.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-emission.d.ts","sourceRoot":"","sources":["../src/event-emission.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAC7C,OAAO,KAAK,EACV,2BAA2B,EAC3B,kBAAkB,EAClB,YAAY,EACZ,aAAa,EACb,iBAAiB,EACjB,wBAAwB,EACxB,qBAAqB,EACrB,eAAe,EACf,cAAc,EACd,QAAQ,EACR,SAAS,EACT,YAAY,EACZ,aAAa,EACd,MAAM,SAAS,CAAC;AAEjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DG;AAEH,8BAAsB,aAAa,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;;IA8M/D;;OAEG;IACH,CAAC,gBAAgB,CAAC,QAAI,cAAc,CAAC,aAAa,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;;IAtM/D;;;OAGG;IACH,gBAAgB,CAAC,CAAC,SAAS,MAAM,CAAC,GAAG,MAAM,EACzC,IAAI,EAAE,CAAC,EACP,QAAQ,EAAE,iBAAiB,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,IAAI,EAC1D,OAAO,CAAC,EAAE,2BAA2B,GAAG,OAAO,GAC9C,MAAM,IAAI;IAIb;;OAEG;IACH,mBAAmB,CAAC,CAAC,SAAS,MAAM,CAAC,GAAG,MAAM,EAC5C,IAAI,EAAE,CAAC,EACP,QAAQ,EAAE,iBAAiB,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,IAAI,EAC1D,OAAO,CAAC,EAAE,wBAAwB,GAAG,OAAO,GAC3C,IAAI;IAIP;;;OAGG;IACH,aAAa,CAAC,CAAC,SAAS,MAAM,CAAC,GAAG,MAAM,EACtC,KAAK,EAAE,kBAAkB,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,YAAY,GAChD,OAAO;IAQV;;OAEG;IACH,EAAE,CAAC,CAAC,SAAS,MAAM,CAAC,GAAG,MAAM,EAC3B,IAAI,EAAE,CAAC,EACP,OAAO,CAAC,EAAE,SAAS,GAAG,OAAO,GAC5B,cAAc,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAIzC;;;OAGG;IACH,IAAI,CAAC,CAAC,SAAS,MAAM,CAAC,GAAG,MAAM,EAC7B,IAAI,EAAE,CAAC,EACP,QAAQ,EAAE,iBAAiB,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,IAAI,EAC1D,OAAO,CAAC,EAAE,IAAI,CAAC,2BAA2B,EAAE,MAAM,CAAC,GAAG,OAAO,GAC5D,MAAM,IAAI;IAIb;;OAEG;IACH,kBAAkB,CAAC,CAAC,SAAS,MAAM,CAAC,GAAG,MAAM,EAAE,IAAI,CAAC,EAAE,CAAC,GAAG,IAAI;IAI9D;;OAEG;IACH,KAAK,IAAI,IAAI;IAIb;;;OAGG;IAEH,IAAI,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAChC,MAAM,EAAE,eAAe,CAAC,CAAC,CAAC,EAC1B,KAAK,CAAC,EAAE,CAAC,CAAC,SAAS,MAAM,CAAC,GAAG,MAAM,EACjC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,KAC1B,kBAAkB,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC,EAAE,MAAM,CAAC,GAAG,MAAM,CAAC,GAAG,IAAI,GACpE,MAAM,IAAI;IAQb;;;OAGG;IACH,mBAAmB,CACjB,OAAO,EAAE,GAAG,GAAG,GAAG,MAAM,IAAI,EAC5B,QAAQ,EAAE,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,EAC3D,OAAO,CAAC,EAAE,2BAA2B,GACpC,MAAM,IAAI;IAIb;;OAEG;IACH,sBAAsB,CACpB,OAAO,EAAE,GAAG,GAAG,GAAG,MAAM,IAAI,EAC5B,QAAQ,EAAE,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,GAC1D,IAAI;IAQP;;OAEG;IACH,SAAS,CACP,cAAc,EACV,QAAQ,CAAC,aAAa,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,GACnC,CAAC,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,GAC/C,YAAY;IAEf;;OAEG;IACH,SAAS,CAAC,CAAC,SAAS,MAAM,CAAC,GAAG,MAAM,EAClC,IAAI,EAAE,CAAC,EACP,cAAc,CAAC,EACX,QAAQ,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAChC,CAAC,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,IAAI,CAAC,EAC7C,KAAK,CAAC,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,IAAI,EAC9B,eAAe,CAAC,EAAE,MAAM,IAAI,GAC3B,YAAY;IAoDf;;OAEG;IACH,YAAY,IAAI,cAAc,CAAC,aAAa,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;IAezD;;;;OAIG;IACH,QAAQ,IAAI,IAAI;IAIhB;;OAEG;IACH,IAAI,SAAS,IAAI,OAAO,CAEvB;IAMD;;;;;;;;;;;;OAYG;IACH,MAAM,CAAC,CAAC,SAAS,MAAM,CAAC,GAAG,MAAM,EAC/B,IAAI,EAAE,CAAC,EACP,OAAO,CAAC,EAAE,qBAAqB,GAC9B,qBAAqB,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;CAGjD"}

package/dist/factory.d.ts

@@ -15,7 +15,7 @@ export interface CreateEventTargetOptions {
  * Extends CreateEventTargetOptions with proxy observation settings.
  *
  * @property observe - Must be true to enable observation mode.
- * @property deep - If true, nested objects are also observed (default: false).
+ * @property deep - If true, nested objects are also observed (default: true).
  * @property cloneStrategy - Strategy for cloning previous state: 'shallow', 'deep', or 'path'.
  */
 export interface CreateEventTargetObserveOptions extends CreateEventTargetOptions, ObserveOptions {

package/dist/factory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../src/factory.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,KAAK,kBAAkB,EACvB,KAAK,cAAc,EACpB,MAAM,WAAW,CAAC;AAEnB,OAAO,KAAK,EAGV,eAAe,EAKhB,MAAM,SAAS,CAAC;AAcjB;;;;;GAKG;AACH,MAAM,WAAW,wBAAwB;IACvC,+EAA+E;IAC/E,eAAe,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;CAC1D;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,+BACf,SAAQ,wBAAwB,EAAE,cAAc;IAChD,+CAA+C;IAC/C,OAAO,EAAE,IAAI,CAAC;CACf;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC7D,IAAI,CAAC,EAAE,wBAAwB,GAC9B,eAAe,CAAC,CAAC,CAAC,CAAC;AAEtB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,MAAM,EAChD,MAAM,EAAE,CAAC,EACT,IAAI,EAAE,+BAA+B,GACpC,CAAC,GAAG,eAAe,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC,CAAC"}
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../src/factory.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,kBAAkB,EACvB,KAAK,cAAc,EACpB,MAAM,WAAW,CAAC;AAEnB,OAAO,KAAK,EAIV,eAAe,EAOhB,MAAM,SAAS,CAAC;AAyCjB;;;;;GAKG;AACH,MAAM,WAAW,wBAAwB;IACvC,+EAA+E;IAC/E,eAAe,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;CAC1D;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,+BACf,SAAQ,wBAAwB,EAAE,cAAc;IAChD,+CAA+C;IAC/C,OAAO,EAAE,IAAI,CAAC;CACf;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC7D,IAAI,CAAC,EAAE,wBAAwB,GAC9B,eAAe,CAAC,CAAC,CAAC,CAAC;AAEtB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,MAAM,EAChD,MAAM,EAAE,CAAC,EACT,IAAI,EAAE,+BAA+B,GACpC,CAAC,GAAG,eAAe,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC,CAAC"}