@soffinal/stream 0.2.4 → 0.3.0

package/dist/transformers/merge/merge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge.d.ts","sourceRoot":"","sources":["../../../src/transformers/merge/merge.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAEzC,wBAAgB,KAAK,CAAC,KAAK,EAAE,OAAO,SAAS,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,GAAG,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,EAC1E,GAAG,OAAO,EAAE,OAAO,GAClB,MAAM,CAAC,WAAW,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC,KAAK,GAAG,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CA0BpF"}

package/dist/transformers/state/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./state";
+//# sourceMappingURL=index.d.ts.map

package/dist/transformers/state/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/transformers/state/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC"}

package/dist/transformers/state/state.d.ts

@@ -0,0 +1,35 @@
+import { Stream } from "../../stream";
+/**
+ * Stream with reactive state management via getter/setter.
+ *
+ * @template T - The type of values in the stream
+ */
+export type State<T> = Stream<T> & {
+    state: {
+        value: T;
+    };
+};
+/**
+ * Adds `.state.value` getter/setter to a stream for reactive state management.
+ *
+ * @template T - The type of values in the stream
+ * @param initialValue - Initial state value
+ * @returns Transformer that adds state behavior
+ *
+ * @example
+ * ```typescript
+ * const counter = new Stream<number>().pipe(state(0));
+ * counter.listen(n => console.log(n));
+ * counter.state.value = 5; // Triggers listener
+ * console.log(counter.state.value); // 5
+ * ```
+ *
+ * @example
+ * ```typescript
+ * const source = new Stream<number>();
+ * const stateful = source.pipe(state(0));
+ * source.push(10); // Updates stateful.state.value to 10
+ * ```
+ */
+export declare function state<T>(initialValue: T): Stream.Transformer<Stream<T>, Stream<T>>;
+//# sourceMappingURL=state.d.ts.map

package/dist/transformers/state/state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../../src/transformers/state/state.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAEtC;;;;GAIG;AACH,MAAM,MAAM,KAAK,CAAC,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,GAAG;IACjC,KAAK,EAAE;QACL,KAAK,EAAE,CAAC,CAAC;KACV,CAAC;CACH,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,GAAG,MAAM,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,CA0BlF"}

package/package.json

@@ -1,9 +1,13 @@
 {
   "name": "@soffinal/stream",
+  "version": "0.3.0",
+  "author": "Soffinal <smari.sofiane@gmail.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/soffinal/stream.git"
+  },
+  "main": "./dist/index.js",
   "module": "./dist/index.js",
-  "version": "0.2.4",
-  "description": "Type-safe event emitters that scale",
-  "type": "module",
   "devDependencies": {
     "@types/bun": "latest"
   },
@@ -16,6 +20,12 @@
       "types": "./dist/index.d.ts"
     }
   },
+  "description": "Composable reactive primitives for TypeScript",
+  "files": [
+    "dist",
+    "src/transformers/*.md",
+    "README.md"
+  ],
   "keywords": [
     "reactive",
     "streams",
@@ -26,19 +36,7 @@
     "emitter",
     "adaptive constraints"
   ],
-  "author": "Soffinal <smari.sofiane@gmail.com>",
   "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/soffinal/stream.git"
-  },
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "files": [
-    "dist",
-    "src/transformers/*.md",
-    "README.md",
-    "CHANGELOG.md",
-    "LICENSE"
-  ]
+  "type": "module",
+  "types": "./dist/index.d.ts"
 }

package/dist/reactive/index.d.ts

@@ -1,5 +0,0 @@
-export * from "./list.ts";
-export * from "./map.ts";
-export * from "./set.ts";
-export * from "./state.ts";
-//# sourceMappingURL=index.d.ts.map

package/dist/reactive/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/reactive/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC"}

package/dist/reactive/list.d.ts

@@ -1,171 +0,0 @@
-import { Stream } from "../stream.ts";
-/**
- * A reactive List that provides array-like functionality with stream-based mutation events.
- * Emits events when items are inserted, deleted, or the list is cleared.
- * Supports negative indexing with modulo wrapping.
- * @template VALUE - The type of values stored in the list
- *
- * @see {@link Stream} - Complete copy-paste transformers library
- *
- * @example
- * ```typescript
- * const todos = new List<string>();
- *
- * // Listen to insertions
- * todos.insert.listen(([index, item]) => {
- *   console.log(`Added "${item}" at index ${index}`);
- * });
- *
- * // Listen to deletions
- * todos.delete.listen(([index, item]) => {
- *   console.log(`Removed "${item}" from index ${index}`);
- * });
- *
- * todos.insert(0, "Buy milk"); //Added "Buy milk" at index 0
- * todos.insert(1, "Walk dog"); //Added "Walk dog" at index 1
- * todos.insert(-1, "kechma haja"); //Added "kechma haja" at index 2
- * todos[0] = "Buy organic milk"; // Added "Buy organic milk" at index 0
- * ```
- */
-export declare class List<VALUE> implements Iterable<VALUE> {
-    private _items;
-    private _insertStream?;
-    private _deleteStream?;
-    private _clearStream?;
-    [index: number]: VALUE | undefined;
-    /**
-     * Inserts a value at the specified index and emits the insertion event.
-     * Negative indices are handled specially for insertion positioning.
-     *
-     * @see {@link Stream} - Complete copy-paste transformers library
-     *
-     * @example
-     * ```typescript
-     * const list = new List([1, 2, 3]);
-     * list.insert.listen(([index, value]) => console.log(`Inserted ${value} at ${index}`));
-     *
-     * list.insert(1, 99); // Inserted 99 at 1 → [1, 99, 2, 3]
-     * list.insert(-1, 88); // Insert at end → [1, 99, 2, 3, 88]
-     * ```
-     */
-    insert: ((index: number, value: VALUE) => this) & Stream<[number, VALUE]>;
-    /**
-     * Deletes a value at the specified index and emits the deletion event.
-     * Returns the deleted value or undefined if index is invalid.
-     *
-     * @see {@link Stream} - Complete copy-paste transformers library
-     *
-     * @example
-     * ```typescript
-     * const list = new List(['a', 'b', 'c']);
-     * list.delete.listen(([index, value]) => console.log(`Deleted ${value} from ${index}`));
-     *
-     * const deleted = list.delete(1); // Deleted b from 1
-     * console.log(deleted); // 'b'
-     * ```
-     */
-    delete: ((index: number) => VALUE | undefined) & Stream<[number, VALUE]>;
-    /**
-     * Clears all items from the list and emits the clear event.
-     * Only emits if the list was not already empty.
-     *
-     * @see {@link Stream} - Complete copy-paste transformers library
-     *
-     * @example
-     * ```typescript
-     * const list = new List([1, 2, 3]);
-     * list.clear.listen(() => console.log('List cleared'));
-     *
-     * list.clear(); // List cleared
-     * list.clear(); // No emission (already empty)
-     * ```
-     */
-    clear: (() => void) & Stream<void>;
-    /**
-     * Creates a new reactive List.
-     *
-     * @param items - Optional iterable of initial items
-     *
-     * @see {@link Stream} - Complete copy-paste transformers library
-     *
-     * @example
-     * ```typescript
-     * // Empty list
-     * const list = new List<number>();
-     *
-     * // With initial items
-     * const todos = new List(['Buy milk', 'Walk dog']);
-     *
-     * // Listen to changes
-     * todos.insert.listen(([index, item]) => updateUI(index, item));
-     * todos.delete.listen(([index, item]) => removeFromUI(index));
-     *
-     * // Index access with modulo wrapping
-     * console.log(todos[0]);  // 'Buy milk'
-     * console.log(todos[-1]); // 'Walk dog' (last item)
-     * ```
-     */
-    constructor(items?: Iterable<VALUE>);
-    /**
-     * Gets the value at the specified index without modulo wrapping.
-     *
-     * @param index - The index to access
-     * @returns The value at the index or undefined
-     *
-     * @see {@link Stream} - Complete copy-paste transformers library
-     *
-     * @example
-     * ```typescript
-     * const list = new List([10, 20, 30]);
-     * console.log(list.get(1)); // 20
-     * console.log(list.get(5)); // undefined
-     * ```
-     */
-    get(index: number): VALUE | undefined;
-    /**
-     * Gets the current length of the list.
-     *
-     * @see {@link Stream} - Complete copy-paste transformers library
-     *
-     * @example
-     * ```typescript
-     * const list = new List([1, 2, 3]);
-     * console.log(list.length); // 3
-     *
-     * list.insert(0, 0);
-     * console.log(list.length); // 4
-     * ```
-     */
-    get length(): number;
-    /**
-     * Returns an iterator for the list values.
-     *
-     * @see {@link Stream} - Complete copy-paste transformers library
-     *
-     * @example
-     * ```typescript
-     * const list = new List([1, 2, 3]);
-     * for (const value of list.values()) {
-     *   console.log(value); // 1, 2, 3
-     * }
-     * ```
-     */
-    values(): IterableIterator<VALUE>;
-    /**
-     * Makes the list iterable.
-     *
-     * @see {@link Stream} - Complete copy-paste transformers library
-     *
-     * @example
-     * ```typescript
-     * const list = new List(['a', 'b', 'c']);
-     * for (const item of list) {
-     *   console.log(item); // 'a', 'b', 'c'
-     * }
-     *
-     * const array = [...list]; // ['a', 'b', 'c']
-     * ```
-     */
-    [Symbol.iterator](): IterableIterator<VALUE>;
-}
-//# sourceMappingURL=list.d.ts.map

package/dist/reactive/list.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"list.d.ts","sourceRoot":"","sources":["../../src/reactive/list.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAEtC;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,qBAAa,IAAI,CAAC,KAAK,CAAE,YAAW,QAAQ,CAAC,KAAK,CAAC;IACjD,OAAO,CAAC,MAAM,CAAe;IAC7B,OAAO,CAAC,aAAa,CAAC,CAA0B;IAChD,OAAO,CAAC,aAAa,CAAC,CAA0B;IAChD,OAAO,CAAC,YAAY,CAAC,CAAe;IAEpC,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,GAAG,SAAS,CAAC;IAEnC;;;;;;;;;;;;;;OAcG;IACK,MAAM,EAAE,CAAC,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC,GAAG,MAAM,CAAC,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC;IAElF;;;;;;;;;;;;;;OAcG;IACK,MAAM,EAAE,CAAC,CAAC,KAAK,EAAE,MAAM,KAAK,KAAK,GAAG,SAAS,CAAC,GAAG,MAAM,CAAC,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC;IAEjF;;;;;;;;;;;;;;OAcG;IACK,KAAK,EAAE,CAAC,MAAM,IAAI,CAAC,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC;IAE3C;;;;;;;;;;;;;;;;;;;;;;;OAuBG;gBACS,KAAK,CAAC,EAAE,QAAQ,CAAC,KAAK,CAAC;IAiGnC;;;;;;;;;;;;;;OAcG;IACH,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,GAAG,SAAS;IAIrC;;;;;;;;;;;;;OAaG;IACH,IAAI,MAAM,IAAI,MAAM,CAEnB;IACD;;;;;;;;;;;;OAYG;IACH,MAAM,IAAI,gBAAgB,CAAC,KAAK,CAAC;IAGjC;;;;;;;;;;;;;;OAcG;IACH,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,gBAAgB,CAAC,KAAK,CAAC;CAG7C"}

package/dist/reactive/map.d.ts

@@ -1,107 +0,0 @@
-import { Stream } from "../stream.ts";
-/**
- * A reactive Map that extends the native Map with stream-based mutation events.
- * Emits events when entries are set, deleted, or the map is cleared.
- *
- * @template KEY - The type of keys in the map
- * @template VALUE - The type of values in the map
- *
- * @see {@link Stream} - Complete copy-paste transformers library
- *
- * @example
- * ```typescript
- * const cache = new Map<string, any>();
- *
- * // Listen to cache updates
- * cache.set.listen(([key, value]) => {
- *   console.log(`Cache updated: ${key} = ${value}`);
- * });
- *
- * // Listen to cache evictions
- * cache.delete.listen(([key, value]) => {
- *   console.log(`Cache evicted: ${key}`);
- * });
- *
- * cache.set('user:123', { name: 'John' });
- * cache.delete('user:123');
- * ```
- */
-export declare class Map<KEY, VALUE> extends globalThis.Map<KEY, VALUE> {
-    protected _setStream?: Stream<[KEY, VALUE]>;
-    protected _deleteStream?: Stream<[KEY, VALUE]>;
-    protected _clearStream?: Stream<void>;
-    /**
-     * Sets a key-value pair in the map and emits the entry to listeners.
-     * Only emits if the value actually changes (not same key-value pair).
-     *
-     * @see {@link Stream} - Complete copy-paste transformers library
-     *
-     * @example
-     * ```typescript
-     * const config = new Map<string, string>();
-     * config.set.listen(([key, value]) => console.log(`Set: ${key}=${value}`));
-     *
-     * config.set('theme', 'dark'); // Set: theme=dark
-     * config.set('theme', 'dark'); // No emission (same value)
-     * config.set('theme', 'light'); // Set: theme=light
-     * ```
-     */
-    set: ((key: KEY, value: VALUE) => this) & Stream<[KEY, VALUE]>;
-    /**
-     * Deletes a key from the map and emits the deleted entry to listeners.
-     * Only emits if the key was actually deleted (existed in map).
-     *
-     * @see {@link Stream} - Complete copy-paste transformers library
-     *
-     * @example
-     * ```typescript
-     * const users = new Map([['alice', { age: 30 }], ['bob', { age: 25 }]]);
-     * users.delete.listen(([key, value]) => console.log(`Removed: ${key}`));
-     *
-     * users.delete('alice'); // Removed: alice
-     * users.delete('charlie'); // No emission (didn't exist)
-     * ```
-     */
-    delete: ((key: KEY) => boolean) & Stream<[KEY, VALUE]>;
-    /**
-     * Clears all entries from the map and emits to listeners.
-     * Only emits if the map was not already empty.
-     *
-     * @see {@link Stream} - Complete copy-paste transformers library
-     *
-     * @example
-     * ```typescript
-     * const store = new Map([['a', 1], ['b', 2]]);
-     * store.clear.listen(() => console.log('Store cleared'));
-     *
-     * store.clear(); // Store cleared
-     * store.clear(); // No emission (already empty)
-     * ```
-     */
-    clear: (() => void) & Stream<void>;
-    /**
-     * Creates a new reactive Map.
-     *
-     * @param entries - Optional iterable of initial key-value pairs
-     *
-     * @see {@link Stream} - Complete copy-paste transformers library
-     *
-     * @example
-     * ```typescript
-     * // Empty map
-     * const cache = new Map<string, any>();
-     *
-     * // With initial entries
-     * const config = new Map([
-     *   ['theme', 'dark'],
-     *   ['lang', 'en']
-     * ]);
-     *
-     * // Listen to changes
-     * config.set.listen(([key, value]) => saveConfig(key, value));
-     * config.delete.listen(([key]) => removeConfig(key));
-     * ```
-     */
-    constructor(entries?: Iterable<[KEY, VALUE]>);
-}
-//# sourceMappingURL=map.d.ts.map

package/dist/reactive/map.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"map.d.ts","sourceRoot":"","sources":["../../src/reactive/map.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAEtC;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,qBAAa,GAAG,CAAC,GAAG,EAAE,KAAK,CAAE,SAAQ,UAAU,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC;IAC7D,SAAS,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC,CAAC;IAC5C,SAAS,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC,CAAC;IAC/C,SAAS,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC,IAAI,CAAC,CAAC;IAEtC;;;;;;;;;;;;;;;OAeG;IACK,GAAG,EAAE,CAAC,CAAC,GAAG,EAAE,GAAG,EAAE,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC,GAAG,MAAM,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC,CAAC;IAEvE;;;;;;;;;;;;;;OAcG;IACK,MAAM,EAAE,CAAC,CAAC,GAAG,EAAE,GAAG,KAAK,OAAO,CAAC,GAAG,MAAM,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC,CAAC;IAE/D;;;;;;;;;;;;;;OAcG;IACK,KAAK,EAAE,CAAC,MAAM,IAAI,CAAC,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC;IAE3C;;;;;;;;;;;;;;;;;;;;;;OAsBG;gBACS,OAAO,CAAC,EAAE,QAAQ,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;CAuD7C"}

package/dist/reactive/set.d.ts

@@ -1,102 +0,0 @@
-import { Stream } from "../stream.ts";
-/**
- * A reactive Set that extends the native Set with stream-based mutation events.
- * Emits events when items are added, deleted, or the set is cleared.
- *
- * @template VALUE - The type of values stored in the set
- *
- * @see {@link Stream} - Complete copy-paste transformers library
- *
- * @example
- * ```typescript
- * const activeUsers = new Set<string>();
- *
- * // Listen to additions
- * activeUsers.add.listen(userId => {
- *   console.log(`User ${userId} came online`);
- * });
- *
- * // Listen to deletions
- * activeUsers.delete.listen(userId => {
- *   console.log(`User ${userId} went offline`);
- * });
- *
- * activeUsers.add('alice'); // User alice came online
- * activeUsers.delete('alice'); // User alice went offline
- * ```
- */
-export declare class Set<VALUE> extends globalThis.Set<VALUE> {
-    protected _addStream?: Stream<VALUE>;
-    protected _deleteStream?: Stream<VALUE>;
-    protected _clearStream?: Stream<void>;
-    /**
-     * Adds a value to the set and emits the value to listeners.
-     * Only emits if the value is actually added (not a duplicate).
-     *
-     * @see {@link Stream} - Complete copy-paste transformers library
-     *
-     * @example
-     * ```typescript
-     * const tags = new Set<string>();
-     * tags.add.listen(tag => console.log('Added:', tag));
-     *
-     * tags.add('javascript'); // Added: javascript
-     * tags.add('javascript'); // No emission (duplicate)
-     * ```
-     */
-    add: ((value: VALUE) => this) & Stream<VALUE>;
-    /**
-     * Deletes a value from the set and emits the value to listeners.
-     * Only emits if the value was actually deleted (existed in set).
-     *
-     * @see {@link Stream} - Complete copy-paste transformers library
-     *
-     * @example
-     * ```typescript
-     * const items = new Set(['a', 'b', 'c']);
-     * items.delete.listen(item => console.log('Removed:', item));
-     *
-     * items.delete('b'); // Removed: b
-     * items.delete('x'); // No emission (didn't exist)
-     * ```
-     */
-    delete: ((value: VALUE) => boolean) & Stream<VALUE>;
-    /**
-     * Clears all values from the set and emits to listeners.
-     * Only emits if the set was not already empty.
-     *
-     * @see {@link Stream} - Complete copy-paste transformers library
-     *
-     * @example
-     * ```typescript
-     * const cache = new Set([1, 2, 3]);
-     * cache.clear.listen(() => console.log('Cache cleared'));
-     *
-     * cache.clear(); // Cache cleared
-     * cache.clear(); // No emission (already empty)
-     * ```
-     */
-    clear: (() => void) & Stream<void>;
-    /**
-     * Creates a new reactive Set.
-     *
-     * @param values - Optional iterable of initial values
-     *
-     * @see {@link Stream} - Complete copy-paste transformers library
-     *
-     * @example
-     * ```typescript
-     * // Empty set
-     * const tags = new Set<string>();
-     *
-     * // With initial values
-     * const colors = new Set(['red', 'green', 'blue']);
-     *
-     * // Listen to changes
-     * colors.add.listen(color => updateUI(color));
-     * colors.delete.listen(color => removeFromUI(color));
-     * ```
-     */
-    constructor(values?: Iterable<VALUE>);
-}
-//# sourceMappingURL=set.d.ts.map

package/dist/reactive/set.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"set.d.ts","sourceRoot":"","sources":["../../src/reactive/set.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAEtC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,qBAAa,GAAG,CAAC,KAAK,CAAE,SAAQ,UAAU,CAAC,GAAG,CAAC,KAAK,CAAC;IACnD,SAAS,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;IACrC,SAAS,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;IACxC,SAAS,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC,IAAI,CAAC,CAAC;IAEtC;;;;;;;;;;;;;;OAcG;IACK,GAAG,EAAE,CAAC,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;IAEtD;;;;;;;;;;;;;;OAcG;IACK,MAAM,EAAE,CAAC,CAAC,KAAK,EAAE,KAAK,KAAK,OAAO,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;IAE5D;;;;;;;;;;;;;;OAcG;IACK,KAAK,EAAE,CAAC,MAAM,IAAI,CAAC,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC;IAE3C;;;;;;;;;;;;;;;;;;;OAmBG;gBACS,MAAM,CAAC,EAAE,QAAQ,CAAC,KAAK,CAAC;CAqDrC"}

package/dist/reactive/state.d.ts

@@ -1,79 +0,0 @@
-import { Stream } from "../stream.ts";
-/**
- * A reactive state container that extends Stream to provide stateful value management.
- *
- * @template VALUE - The type of the state value
- *
- * @see {@link Stream} - Complete copy-paste transformers library
- *
- * @example
- * ```typescript
- * // Basic state
- * const counter = new State(0);
- * counter.listen(value => console.log('Counter:', value));
- * counter.value = 5; // Counter: 5
- *
- * // State from stream
- * const source = new Stream<number>();
- * const state = new State(0, source);
- * state.listen(value => console.log('State:', value));
- * source.push(1, 2, 3); // State: 1, State: 2, State: 3
- *
- * // State from transformed stream
- * const filtered = source.pipe(filter({}, (_, v) => [v > 0, {}]));
- * const derivedState = new State(-1, filtered);
- * ```
- */
-export declare class State<VALUE = unknown> extends Stream<VALUE> {
-    protected _value: VALUE;
-    constructor(initialValue: VALUE);
-    constructor(initialValue: VALUE, stream: Stream.FunctionGenerator<VALUE> | Stream<VALUE>);
-    /**
-     * Updates the state with one or more values sequentially.
-     * Each value triggers listeners and updates the current state.
-     *
-     * @param values - Values to set as state
-     *
-     * @see {@link Stream} - Complete copy-paste transformers library
-     *
-     * @example
-     * ```typescript
-     * const state = new State(0);
-     * state.listen(v => console.log(v));
-     *
-     * state.push(1, 2, 3); // Logs: 1, 2, 3
-     * console.log(state.value); // 3
-     * ```
-     */
-    push(...values: VALUE[]): void;
-    /**
-     * Gets the current state value.
-     *
-     * @see {@link Stream} - Complete copy-paste transformers library
-     *
-     * @example
-     * ```typescript
-     * const state = new State('hello');
-     * console.log(state.value); // 'hello'
-     * ```
-     */
-    get value(): VALUE;
-    /**
-     * Sets the current state value and notifies all listeners.
-     *
-     * @param value - The new state value
-     *
-     * @see {@link Stream} - Complete copy-paste transformers library
-     *
-     * @example
-     * ```typescript
-     * const state = new State(0);
-     * state.listen(v => console.log('New value:', v));
-     *
-     * state.value = 42; // New value: 42
-     * state.value = 100; // New value: 100
-     * ```
-     */
-    set value(value: VALUE);
-}
-//# sourceMappingURL=state.d.ts.map

package/dist/reactive/state.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../src/reactive/state.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAEtC;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,qBAAa,KAAK,CAAC,KAAK,GAAG,OAAO,CAAE,SAAQ,MAAM,CAAC,KAAK,CAAC;IACvD,SAAS,CAAC,MAAM,EAAE,KAAK,CAAC;gBACZ,YAAY,EAAE,KAAK;gBACnB,YAAY,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,iBAAiB,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC;IAmBxF;;;;;;;;;;;;;;;;OAgBG;IACM,IAAI,CAAC,GAAG,MAAM,EAAE,KAAK,EAAE,GAAG,IAAI;IAKvC;;;;;;;;;;OAUG;IACH,IAAI,KAAK,IAAI,KAAK,CAEjB;IACD;;;;;;;;;;;;;;;OAeG;IACH,IAAI,KAAK,CAAC,KAAK,EAAE,KAAK,EAGrB;CACF"}