@marianmeres/fetch-store 2.12.0 → 3.0.3

package/README.md

@@ -1,83 +1,318 @@
 # @marianmeres/fetch-store
 
-[Store](https://github.com/marianmeres/store) utility for collecting results and meta info
-of any type of async work. Typically used for http requests.
+A reactive [store](https://github.com/marianmeres/store) utility for managing async fetch
+operations with built-in state tracking for loading, errors, and success counts. Designed
+for Svelte-compatible reactivity but works with any framework.
 
 ## Install
 
 ```shell
-$ npm i @marianmeres/fetch-store
+deno add jsr:@marianmeres/fetch-store
 ```
 
-## Basic example
+```shell
+npm i @marianmeres/fetch-store
+```
+
+## Basic Example
 
-```javascript
-// foo-store.js
-const foo = createFetchStore(async () => {
-	const r = await fetch('foo.json');
-	if (!r.ok) throw new Error('Not OK!');
-	return await r.json();
+```typescript
+// user-store.ts
+import { createFetchStore } from "@marianmeres/fetch-store";
+
+const userStore = createFetchStore(async (userId: string) => {
+    const response = await fetch(`/api/users/${userId}`);
+    if (!response.ok) throw new Error("Failed to fetch user");
+    return await response.json();
 });
+
+// Fetch user data
+await userStore.fetch("123");
+
+// Access current state
+const { data, isFetching, lastFetchError } = userStore.get();
 ```
 
-```sveltehtml
-<!--FooComponent.svelte-->
+### Svelte Integration
+
+```svelte
+<!-- UserProfile.svelte -->
 <script>
-    onMount(foo.fetch)
+    import { onMount } from 'svelte';
+    import { userStore } from './user-store.ts';
+
+    export let userId;
+    onMount(() => userStore.fetch(userId));
 </script>
 
-{#if $foo.isFetching}
+{#if $userStore.isFetching}
     <Spinner />
-{:else if $foo.lastFetchError}
-    <Error error={$foo.lastFetchError} />
+{:else if $userStore.lastFetchError}
+    <Error error={$userStore.lastFetchError} />
 {:else}
-    <Foo foo={$foo.data} />
+    <UserCard user={$userStore.data} />
 {/if}
 ```
 
-## Api
+## Features
+
+- **Reactive state management** - Subscribe to loading, error, and data states
+- **Silent fetching** - Update data without triggering loading indicators
+- **Fetch-once with caching** - Prevent redundant fetches within a time threshold
+- **Polling support** - Built-in recursive fetching for real-time updates
+- **Request deduplication** - Optionally return in-flight promises for concurrent calls
+- **Abort support** - Cancel in-flight requests with AbortController integration
+- **Stream support** - Handle SSE, WebSocket, or push-based data sources
+
+## Abortable Requests
+
+Enable automatic request cancellation when a new fetch starts:
+
+```typescript
+import { createFetchStore } from "@marianmeres/fetch-store";
+
+const searchStore = createFetchStore(
+    async (query: string, signal: AbortSignal) => {
+        const response = await fetch(`/api/search?q=${query}`, { signal });
+        if (!response.ok) throw new Error("Search failed");
+        return await response.json();
+    },
+    null,
+    null,
+    { abortable: true }
+);
+
+// Rapid calls - each new fetch aborts the previous one
+searchStore.fetch("h");      // Aborted
+searchStore.fetch("he");     // Aborted
+searchStore.fetch("hel");    // Aborted
+searchStore.fetch("hello");  // This one completes
+
+// Manual abort
+searchStore.abort();
+```
+
+## Request Deduplication
+
+Prevent duplicate requests when multiple calls happen while one is in-flight:
 
 ```typescript
-const store = createFetchStore<T>(
-    // the async worker
-    fetchWorker: (...args) => Promise<any>,
-    // optional, initial `data` value of the store
-    initial?: T = null,
-    // optional, used to modify data returned by fetchWorker... (usefull for various
-    // data update strategies, like merge/deepmerge/set etc)
-    dataFactory?: (raw: any, old?: any) => T = null,
-    // options (see source)
-    options? = null
+const userStore = createFetchStore(
+    async (userId) => fetch(`/api/users/${userId}`).then(r => r.json()),
+    null,
+    null,
+    { dedupeInflight: true }
 );
 
-// subscription
-store.subscribe((v) => {
-    // main result
-    // v.data: T;
-
-    // meta
-    // v.isFetching: boolean;
-    // v.lastFetchStart: Date;
-    // v.lastFetchEnd: Date;
-    // v.lastFetchError: Date;
-    // v.successCounter: number;
+// These all return the same promise (only one HTTP request is made)
+const p1 = userStore.fetch("123");
+const p2 = userStore.fetch("123");
+const p3 = userStore.fetch("123");
+
+p1 === p2 && p2 === p3; // true
+```
+
+## Streaming Data
+
+For streaming data sources, use `createFetchStreamStore`:
+
+```typescript
+import { createFetchStreamStore } from "@marianmeres/fetch-store";
+
+const sseStore = createFetchStreamStore((emit, url) => {
+    const eventSource = new EventSource(url);
+
+    eventSource.onmessage = (event) => {
+        emit("data", JSON.parse(event.data));
+    };
+
+    eventSource.onerror = (error) => {
+        emit("error", error);
+    };
+
+    // Return cleanup function
+    return () => {
+        eventSource.close();
+        emit("end");
+    };
 });
 
-// instance api
+// Start streaming (with optional auto-restart after 5s delay)
+const stop = sseStore.fetchStream(["/api/events"], 5000);
+
+// Later: stop the stream
+stop();
+```
+
+## Breaking Changes (v3.0.0)
+
+This major release includes the following breaking changes:
+
+### Simplified Generic Types
+
+The `FetchStore<T>` and `FetchStreamStore<T>` interfaces have been simplified from a
+two-generic pattern to a single generic:
+
+```typescript
+// Before (v2.x)
+interface FetchStore<T, V = T extends FetchStoreValue<infer D> ? D : T> { ... }
+
+// After (v3.x)
+interface FetchStore<T> extends StoreReadable<FetchStoreValue<T>> { ... }
+```
+
+**Migration:** If you were using explicit generic parameters, simply use the data type
+directly: `FetchStore<User>` instead of `FetchStore<FetchStoreValue<User>, User>`.
+
+### Simplified API Signature
 
-// do the async work
-store.fetch(...args): Promise<T>;
+The `createFetchStore` and `createFetchStreamStore` functions now have a simpler signature.
+The `dataFactory` parameter has been moved into the `options` object:
 
-// do the async work, but do not update meta
-store.fetchSilent(...args): Promise<T>;
+```typescript
+// Before (v2.x)
+createFetchStore(fetchWorker, initial, dataFactory, options)
 
-// do the async work only once (if within threshold since last)
-store.fetchOnce(args: any[], thresholdMs: number): Promise<void>;
+// After (v3.x)
+createFetchStore(fetchWorker, initial, options)
+// dataFactory is now in options: { dataFactory: (data, old) => transformedData }
+```
 
-// to reset internal meta store
-store.reset();
-store.resetError();
+**Migration:** Move your `dataFactory` from the third parameter into the options object:
 
-// for manual hackings
-store.getInternalDataStore();
+```typescript
+// Before
+const store = createFetchStore(
+    async () => fetchData(),
+    null,
+    (data, old) => ({ ...old, ...data }),
+    { dedupeInflight: true }
+);
+
+// After
+const store = createFetchStore(
+    async () => fetchData(),
+    null,
+    {
+        dataFactory: (data, old) => ({ ...old, ...data }),
+        dedupeInflight: true
+    }
+);
 ```
+
+### DataFactory Type Change
+
+The `DataFactory<T>` type now receives properly typed data instead of `unknown`:
+
+```typescript
+// Before (v2.x)
+type DataFactory<T> = (raw: any, old?: T) => T;
+
+// After (v3.x)
+type DataFactory<T> = (data: T, old?: T) => T;
+```
+
+The `fetchWorker` must now return `Promise<T>` directly, making the types consistent
+throughout the API.
+
+
+## API Reference
+
+### `createFetchStore<T>(fetchWorker, initial?, options?)`
+
+Creates a reactive store for async fetch operations.
+
+**Parameters:**
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `fetchWorker` | `(...args) => Promise<T>` | required | Async function performing the fetch. Must return data of type T. When `abortable: true`, receives `AbortSignal` as the last argument. |
+| `initial` | `T \| null` | `null` | Initial data value |
+| `options` | `FetchStoreOptions<T>` | `{}` | Configuration options |
+
+**Options:**
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `fetchOnceDefaultThresholdMs` | `number` | `300000` | Default threshold (5 min) for `fetchOnce` before allowing re-fetch |
+| `dedupeInflight` | `boolean` | `false` | If true, concurrent `fetch()` calls return the same promise |
+| `abortable` | `boolean` | `false` | If true, creates AbortController for each fetch, aborting previous requests |
+| `dataFactory` | `(data: T, old?: T) => T` | - | Transform fetched data (useful for merge strategies) |
+| `onReset` | `() => void` | - | Callback invoked when `reset()` is called |
+
+**Returns:** `FetchStore<T>`
+
+### FetchStore Methods
+
+| Method | Signature | Description |
+|--------|-----------|-------------|
+| `subscribe` | `(fn: (value) => void) => () => void` | Subscribe to store changes (Svelte-compatible) |
+| `get` | `() => FetchStoreValue<T>` | Get current store value |
+| `fetch` | `(...args) => Promise<T \| null>` | Execute fetch, sets `isFetching` to true |
+| `fetchSilent` | `(...args) => Promise<T \| null>` | Execute fetch without updating `isFetching` |
+| `fetchOnce` | `(args?, thresholdMs?) => Promise<T \| null>` | Fetch only if not already fetched or threshold passed |
+| `fetchOnceSilent` | `(args?, thresholdMs?) => Promise<T \| null>` | Silent version of `fetchOnce` |
+| `fetchRecursive` | `(args?, delayMs?) => () => void` | Start polling, returns cancel function |
+| `reset` | `() => void` | Reset store to initial state |
+| `resetError` | `() => void` | Clear `lastFetchError` only |
+| `touch` | `(data?: T) => void` | Update timestamps (tricks `fetchOnce`), optionally set data |
+| `abort` | `() => void` | Abort in-flight requests (requires `abortable: true`) |
+| `getInternalDataStore` | `() => StoreLike<T>` | Access internal data store |
+
+### FetchStoreValue Properties
+
+The store value contains both data and metadata:
+
+| Property | Type | Description |
+|----------|------|-------------|
+| `data` | `T \| null` | The fetched data (null before first fetch or after reset) |
+| `isFetching` | `boolean` | Whether a fetch is in progress |
+| `lastFetchStart` | `Date \| null` | When the last fetch started |
+| `lastFetchEnd` | `Date \| null` | When the last fetch completed |
+| `lastFetchError` | `Error \| null` | Error from the last fetch, if any |
+| `lastFetchSilentError` | `Error \| null` | Error from the last silent fetch, if any |
+| `successCounter` | `number` | Number of successful fetches |
+
+### `createFetchStreamStore<T>(fetchStreamWorker, initial?, options?)`
+
+Creates a reactive store for streaming data sources.
+
+**Parameters:**
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `fetchStreamWorker` | `(emit, ...args) => (() => void) \| void` | required | Worker receiving emit callback for events. Emit receives data of type T. Should return cleanup function. |
+| `initial` | `T \| null` | `null` | Initial data value |
+| `options` | `FetchStreamStoreOptions<T>` | `{}` | Configuration options |
+
+**Options:**
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `dataFactory` | `(data: T, old?: T) => T` | - | Transform received data (useful for merge strategies) |
+| `onReset` | `() => void` | - | Callback invoked when `reset()` is called |
+
+**Emit Events:**
+- `emit("data", value)` - Push new data
+- `emit("error", error)` - Report an error
+- `emit("end")` - Signal stream completion
+
+**Returns:** `FetchStreamStore<T>`
+
+### FetchStreamStore Methods
+
+| Method | Signature | Description |
+|--------|-----------|-------------|
+| `subscribe` | `(fn: (value) => void) => () => void` | Subscribe to store changes |
+| `get` | `() => FetchStreamStoreValue<T>` | Get current store value |
+| `fetchStream` | `(args?, recursiveDelayMs?) => () => void` | Start stream, returns stop function. If `recursiveDelayMs > 0`, restarts after "end" event. |
+| `reset` | `() => void` | Reset store to initial state |
+| `resetError` | `() => void` | Clear `lastFetchError` only |
+| `getInternalDataStore` | `() => StoreLike<T>` | Access internal data store |
+
+## Package Identity
+
+- **Name:** @marianmeres/fetch-store
+- **Author:** Marian Meres
+- **Repository:** https://github.com/marianmeres/fetch-store
+- **License:** MIT

package/dist/fetch-store.d.ts

@@ -0,0 +1,33 @@
+export type { DataFactory, FetchStore, FetchStoreMeta, FetchStoreOptions, FetchStoreValue, } from "./types.js";
+export { createFetchStreamStore } from "./fetch-stream-store.js";
+import type { FetchStore, FetchStoreOptions } from "./types.js";
+/**
+ * Creates a reactive store for managing async fetch operations with built-in
+ * state tracking for loading, errors, and success counts.
+ *
+ * @template T - The type of data the store will hold
+ * @param fetchWorker - Async function that performs the actual fetch operation.
+ *   Must return data of type T. When `abortable: true`, receives AbortSignal as the last argument.
+ * @param initial - Initial data value (default: null)
+ * @param options - Configuration options including optional dataFactory for merge strategies
+ * @returns A FetchStore instance with reactive subscription and fetch methods
+ *
+ * @example
+ * ```ts
+ * const userStore = createFetchStore(
+ *   async (userId: string) => {
+ *     const res = await fetch(`/api/users/${userId}`);
+ *     return res.json() as Promise<User>;
+ *   },
+ *   null,
+ *   { fetchOnceDefaultThresholdMs: 60000 }
+ * );
+ *
+ * userStore.subscribe(({ data, isFetching, lastFetchError }) => {
+ *   console.log({ data, isFetching, lastFetchError });
+ * });
+ *
+ * await userStore.fetch("123");
+ * ```
+ */
+export declare const createFetchStore: <T>(fetchWorker: (...args: unknown[]) => Promise<T>, initial?: T | null, options?: Partial<FetchStoreOptions<T>>) => FetchStore<T>;

package/dist/fetch-store.js

@@ -0,0 +1,280 @@
+import { createDerivedStore, createStore } from "@marianmeres/store";
+// Re-export stream store for backwards compatibility
+export { createFetchStreamStore } from "./fetch-stream-store.js";
+const DEFAULT_OPTIONS = {
+    fetchOnceDefaultThresholdMs: 300_000, // 5 minutes
+    dedupeInflight: false,
+    abortable: false,
+};
+/**
+ * Creates a reactive store for managing async fetch operations with built-in
+ * state tracking for loading, errors, and success counts.
+ *
+ * @template T - The type of data the store will hold
+ * @param fetchWorker - Async function that performs the actual fetch operation.
+ *   Must return data of type T. When `abortable: true`, receives AbortSignal as the last argument.
+ * @param initial - Initial data value (default: null)
+ * @param options - Configuration options including optional dataFactory for merge strategies
+ * @returns A FetchStore instance with reactive subscription and fetch methods
+ *
+ * @example
+ * ```ts
+ * const userStore = createFetchStore(
+ *   async (userId: string) => {
+ *     const res = await fetch(`/api/users/${userId}`);
+ *     return res.json() as Promise<User>;
+ *   },
+ *   null,
+ *   { fetchOnceDefaultThresholdMs: 60000 }
+ * );
+ *
+ * userStore.subscribe(({ data, isFetching, lastFetchError }) => {
+ *   console.log({ data, isFetching, lastFetchError });
+ * });
+ *
+ * await userStore.fetch("123");
+ * ```
+ */
+export const createFetchStore = (fetchWorker, initial = null, options = {}) => {
+    const mergedOptions = { ...DEFAULT_OPTIONS, ...options };
+    const { fetchOnceDefaultThresholdMs, dedupeInflight, abortable } = mergedOptions;
+    const dataFactory = options.dataFactory;
+    // Use factory for data transformation strategies (merge/deepmerge/set/...)
+    const _createData = (data, old) => typeof dataFactory === "function" ? dataFactory(data, old ?? undefined) : data;
+    const _createMetaObj = () => ({
+        isFetching: false,
+        lastFetchStart: null,
+        lastFetchEnd: null,
+        lastFetchError: null,
+        successCounter: 0,
+        lastFetchSilentError: null,
+    });
+    const _dataStore = createStore(initial);
+    const _metaStore = createStore(_createMetaObj());
+    const { subscribe, get } = createDerivedStore([_dataStore, _metaStore], ([data, meta]) => ({ data, ...meta }));
+    // In-flight promise for deduplication
+    let _inflightPromise = null;
+    let _inflightSilentPromise = null;
+    // AbortController for cancellation
+    let _abortController = null;
+    let _abortControllerSilent = null;
+    const abort = () => {
+        if (_abortController) {
+            _abortController.abort();
+            _abortController = null;
+        }
+        if (_abortControllerSilent) {
+            _abortControllerSilent.abort();
+            _abortControllerSilent = null;
+        }
+    };
+    const fetch = (...rest) => {
+        // If deduplication is enabled and there's an in-flight request, return it
+        if (dedupeInflight && _inflightPromise) {
+            return _inflightPromise;
+        }
+        // If abortable, abort any previous request and create new controller
+        if (abortable) {
+            if (_abortController) {
+                _abortController.abort();
+            }
+            _abortController = new AbortController();
+        }
+        const currentController = _abortController;
+        const doFetch = async () => {
+            _metaStore.set({
+                ..._metaStore.get(),
+                isFetching: true,
+                lastFetchStart: new Date(),
+                lastFetchEnd: null,
+                lastFetchError: null,
+            });
+            let error = null;
+            let newSuccessCounter = _metaStore.get().successCounter;
+            try {
+                // Pass signal as the last argument if abortable
+                const args = abortable && currentController
+                    ? [...rest, currentController.signal]
+                    : rest;
+                _dataStore.set(_createData(await fetchWorker(...args), _dataStore.get()));
+                newSuccessCounter++;
+            }
+            catch (e) {
+                // Don't treat abort as an error that should be stored
+                if (e instanceof DOMException && e.name === "AbortError") {
+                    // Request was aborted, don't update meta
+                    return _dataStore.get();
+                }
+                error = e instanceof Error ? e : new Error(String(e));
+            }
+            _metaStore.set({
+                ..._metaStore.get(),
+                isFetching: false,
+                lastFetchEnd: new Date(),
+                lastFetchError: error,
+                successCounter: newSuccessCounter,
+            });
+            // Return fetched (or last) data (for non-subscribe consumption)
+            return _metaStore.get().lastFetchError ? null : _dataStore.get();
+        };
+        if (dedupeInflight) {
+            _inflightPromise = doFetch().finally(() => {
+                _inflightPromise = null;
+                if (currentController === _abortController) {
+                    _abortController = null;
+                }
+            });
+            return _inflightPromise;
+        }
+        return doFetch().finally(() => {
+            if (currentController === _abortController) {
+                _abortController = null;
+            }
+        });
+    };
+    // Similar to fetch, but does not touch meta.isFetching, allowing data updates
+    // without triggering loading spinners
+    const fetchSilent = (...rest) => {
+        // If deduplication is enabled and there's an in-flight request, return it
+        if (dedupeInflight && _inflightSilentPromise) {
+            return _inflightSilentPromise;
+        }
+        // If abortable, abort any previous silent request and create new controller
+        if (abortable) {
+            if (_abortControllerSilent) {
+                _abortControllerSilent.abort();
+            }
+            _abortControllerSilent = new AbortController();
+        }
+        const currentController = _abortControllerSilent;
+        const doFetchSilent = async () => {
+            const currentMeta = _metaStore.get();
+            if (currentMeta.lastFetchSilentError) {
+                _metaStore.set({ ...currentMeta, lastFetchSilentError: null });
+            }
+            let error = null;
+            try {
+                // Pass signal as the last argument if abortable
+                const args = abortable && currentController
+                    ? [...rest, currentController.signal]
+                    : rest;
+                _dataStore.set(_createData(await fetchWorker(...args), _dataStore.get()));
+            }
+            catch (e) {
+                // Don't treat abort as an error that should be stored
+                if (e instanceof DOMException && e.name === "AbortError") {
+                    return _dataStore.get();
+                }
+                error = e instanceof Error ? e : new Error(String(e));
+            }
+            if (error) {
+                _metaStore.set({ ..._metaStore.get(), lastFetchSilentError: error });
+            }
+            // Return fetched (or last) data (for non-subscribe consumption)
+            return _metaStore.get().lastFetchSilentError ? null : _dataStore.get();
+        };
+        if (dedupeInflight) {
+            _inflightSilentPromise = doFetchSilent().finally(() => {
+                _inflightSilentPromise = null;
+                if (currentController === _abortControllerSilent) {
+                    _abortControllerSilent = null;
+                }
+            });
+            return _inflightSilentPromise;
+        }
+        return doFetchSilent().finally(() => {
+            if (currentController === _abortControllerSilent) {
+                _abortControllerSilent = null;
+            }
+        });
+    };
+    // Sets internal timestamps to now, tricking fetchOnce into thinking data was just fetched.
+    // Useful for external cache invalidation.
+    const touch = (data) => {
+        if (data !== undefined) {
+            _dataStore.set(data);
+        }
+        const currentMeta = _metaStore.get();
+        const now = new Date();
+        _metaStore.set({
+            ...currentMeta,
+            lastFetchStart: now,
+            lastFetchEnd: now,
+            successCounter: currentMeta.successCounter + 1,
+        });
+    };
+    const _fetchOnce = async (isSilent, fetchArgs = [], thresholdMs = fetchOnceDefaultThresholdMs) => {
+        const { successCounter, isFetching, lastFetchStart } = _metaStore.get();
+        const args = Array.isArray(fetchArgs) ? fetchArgs : [fetchArgs];
+        if (!successCounter && !isFetching) {
+            return isSilent ? await fetchSilent(...args) : await fetch(...args);
+        }
+        // Expired threshold?
+        if (thresholdMs &&
+            !isFetching &&
+            lastFetchStart &&
+            Date.now() - lastFetchStart.valueOf() > thresholdMs) {
+            return isSilent ? await fetchSilent(...args) : await fetch(...args);
+        }
+        return _dataStore.get();
+    };
+    // Use falsy threshold (0) to skip threshold check
+    const fetchOnce = async (fetchArgs = [], thresholdMs = fetchOnceDefaultThresholdMs) => {
+        return await _fetchOnce(false, fetchArgs, thresholdMs);
+    };
+    const fetchOnceSilent = async (fetchArgs = [], thresholdMs = fetchOnceDefaultThresholdMs) => {
+        return await _fetchOnce(true, fetchArgs, thresholdMs);
+    };
+    // Recursive polling (whether it's "long" or "short" polling depends on the server)
+    const fetchRecursive = (fetchArgs = [], delayMs = 500) => {
+        let _timer;
+        let _aborted = false;
+        const _fetchRecursive = (args = [], delay = 500) => {
+            const normalizedArgs = Array.isArray(args) ? args : [args];
+            const resolvedDelay = typeof delay === "function" ? delay() : delay;
+            fetchSilent(...normalizedArgs).then(() => {
+                if (_timer)
+                    clearTimeout(_timer);
+                if (resolvedDelay > 0 && !_aborted) {
+                    _timer = setTimeout(() => !_aborted && _fetchRecursive(normalizedArgs, delay), resolvedDelay);
+                }
+            });
+            // Return a "cancel" (or "stop") control fn
+            return () => {
+                if (_timer)
+                    clearTimeout(_timer);
+                _aborted = true;
+            };
+        };
+        return _fetchRecursive(fetchArgs, delayMs);
+    };
+    // Resets the store to initial state; useful for cache invalidation
+    const reset = () => {
+        abort();
+        _dataStore.set(initial);
+        _metaStore.set(_createMetaObj());
+        _inflightPromise = null;
+        _inflightSilentPromise = null;
+        if (typeof mergedOptions.onReset === "function")
+            mergedOptions.onReset();
+    };
+    const resetError = () => {
+        _metaStore.update((old) => ({ ...old, lastFetchError: null }));
+    };
+    return {
+        subscribe,
+        get,
+        fetch,
+        fetchSilent,
+        fetchOnce,
+        fetchOnceSilent,
+        fetchRecursive,
+        reset,
+        resetError,
+        getInternalDataStore: () => _dataStore,
+        touch,
+        abort,
+        // Expose raw worker as well
+        fetchWorker,
+    };
+};

package/dist/fetch-stream-store.d.ts

@@ -1,30 +1,28 @@
-import { CreateStoreOptions, StoreLike, StoreReadable } from '@marianmeres/store';
-import { DataFactory, FetchStoreValue } from './index.js';
-export interface FetchStreamStoreMeta {
-    isFetching: boolean;
-    lastFetchStart: Date | null;
-    lastFetchEnd: Date | null;
-    lastFetchError: Error | null;
-}
-interface FetchStreamStoreOptions<T> extends CreateStoreOptions<T> {
-    onReset: () => void;
-}
-type FetchStreamEventName = 'data' | 'error' | 'end';
-type FetchStreamEventEmitFn = (eventName: FetchStreamEventName, eventData: any) => () => void;
-export interface FetchStreamStore<T, V> extends StoreReadable<T> {
-    fetchStream: (args?: any[], recursiveDelayMs?: number | (() => number)) => () => void;
-    fetchStreamWorker: (emit: FetchStreamEventEmitFn, ...args: any[]) => any;
-    reset: () => void;
-    resetError: () => void;
-    getInternalDataStore: () => StoreLike<V>;
-}
-export declare const createFetchStreamStore: <T>(fetchStreamWorker: (...args: any[]) => () => void, initial?: T | null, dataFactory?: DataFactory<T> | null, options?: Partial<FetchStreamStoreOptions<T>>) => {
-    subscribe: (cb: import("@marianmeres/store").Subscribe<FetchStoreValue<T>>) => import("@marianmeres/store").Unsubscribe;
-    get: () => FetchStoreValue<T>;
-    fetchStream: (fetchArgs?: any[], recursiveDelayMs?: number | (() => number)) => () => void;
-    reset: () => void;
-    resetError: () => void;
-    getInternalDataStore: () => StoreLike<T>;
-    fetchStreamWorker: (...args: any[]) => () => void;
-};
-export {};
+export type { FetchStreamEventEmitFn, FetchStreamEventName, FetchStreamStore, FetchStreamStoreMeta, FetchStreamStoreOptions, FetchStreamStoreValue, } from "./types.js";
+import type { FetchStreamEventName, FetchStreamStore, FetchStreamStoreOptions } from "./types.js";
+/**
+ * Creates a reactive store for handling streaming data sources like SSE, WebSocket,
+ * or any push-based data pattern.
+ *
+ * @template T - The type of data the store will hold
+ * @param fetchStreamWorker - Worker function that receives an emit callback for sending events.
+ *   The emit callback receives data of type T. Should return a cleanup/abort function, or void
+ *   if no cleanup is needed.
+ * @param initial - Initial data value (default: null)
+ * @param options - Configuration options including optional dataFactory for merge strategies
+ * @returns A FetchStreamStore instance with reactive subscription and stream control
+ *
+ * @example
+ * ```ts
+ * const sseStore = createFetchStreamStore<Message>((emit, url) => {
+ *   const eventSource = new EventSource(url);
+ *   eventSource.onmessage = (e) => emit("data", JSON.parse(e.data));
+ *   eventSource.onerror = (e) => emit("error", e);
+ *   return () => eventSource.close();
+ * });
+ *
+ * const stop = sseStore.fetchStream(["/api/events"]);
+ * // Later: stop() to close the connection
+ * ```
+ */
+export declare const createFetchStreamStore: <T>(fetchStreamWorker: (emit: (eventName: FetchStreamEventName, eventData?: T | Error) => void, ...args: unknown[]) => (() => void) | void, initial?: T | null, options?: Partial<FetchStreamStoreOptions<T>>) => FetchStreamStore<T>;

package/dist/fetch-stream-store.js

@@ -0,0 +1,129 @@
+import { createDerivedStore, createStore } from "@marianmeres/store";
+const DEFAULT_OPTIONS = {};
+/**
+ * Creates a reactive store for handling streaming data sources like SSE, WebSocket,
+ * or any push-based data pattern.
+ *
+ * @template T - The type of data the store will hold
+ * @param fetchStreamWorker - Worker function that receives an emit callback for sending events.
+ *   The emit callback receives data of type T. Should return a cleanup/abort function, or void
+ *   if no cleanup is needed.
+ * @param initial - Initial data value (default: null)
+ * @param options - Configuration options including optional dataFactory for merge strategies
+ * @returns A FetchStreamStore instance with reactive subscription and stream control
+ *
+ * @example
+ * ```ts
+ * const sseStore = createFetchStreamStore<Message>((emit, url) => {
+ *   const eventSource = new EventSource(url);
+ *   eventSource.onmessage = (e) => emit("data", JSON.parse(e.data));
+ *   eventSource.onerror = (e) => emit("error", e);
+ *   return () => eventSource.close();
+ * });
+ *
+ * const stop = sseStore.fetchStream(["/api/events"]);
+ * // Later: stop() to close the connection
+ * ```
+ */
+export const createFetchStreamStore = (fetchStreamWorker, initial = null, options = {}) => {
+    const mergedOptions = { ...DEFAULT_OPTIONS, ...options };
+    const dataFactory = options.dataFactory;
+    // Use factory for data transformation strategies (merge/deepmerge/set/...)
+    const _createData = (data, old) => typeof dataFactory === "function" ? dataFactory(data, old ?? undefined) : data;
+    const _createMetaObj = () => ({
+        isFetching: false,
+        lastFetchStart: null,
+        lastFetchEnd: null,
+        lastFetchError: null,
+    });
+    const _dataStore = createStore(initial);
+    const _metaStore = createStore(_createMetaObj());
+    const { subscribe, get } = createDerivedStore([_dataStore, _metaStore], ([data, meta]) => ({ data, ...meta }));
+    const fetchStream = (fetchArgs = [], recursiveDelayMs = 0) => {
+        let _timer;
+        let _aborted = false;
+        let _abortFn;
+        // Must be hoisted so recursive calls can be cancelled properly
+        let _abort = () => {
+            if (typeof _abortFn === "function") {
+                _abortFn();
+            }
+            else {
+                console.warn("`abort` is a noop (the fetchStreamWorker did not return a function).");
+            }
+            if (_timer)
+                clearTimeout(_timer);
+            _aborted = true;
+        };
+        // Inner worker (maybe recursive)
+        const _fetchStream = (args = [], delayMs = 0) => {
+            const normalizedArgs = Array.isArray(args) ? args : [args];
+            const delay = typeof delayMs === "function" ? delayMs() : delayMs;
+            _metaStore.set({
+                ..._metaStore.get(),
+                isFetching: true,
+                lastFetchStart: new Date(),
+                lastFetchEnd: null,
+                lastFetchError: null,
+            });
+            try {
+                _abortFn = fetchStreamWorker((eventName, eventData) => {
+                    if (_metaStore.get().lastFetchError) {
+                        _metaStore.set({ ..._metaStore.get(), lastFetchError: null });
+                    }
+                    if (eventName === "data" && eventData !== undefined && !(eventData instanceof Error)) {
+                        _dataStore.set(_createData(eventData, _dataStore.get()));
+                    }
+                    else if (eventName === "error") {
+                        const error = eventData instanceof Error
+                            ? eventData
+                            : new Error(String(eventData));
+                        _metaStore.set({ ..._metaStore.get(), lastFetchError: error });
+                    }
+                    else if (eventName === "end") {
+                        _metaStore.set({
+                            ..._metaStore.get(),
+                            isFetching: false,
+                            lastFetchEnd: new Date(),
+                        });
+                        // Maybe recursive?
+                        if (delay > 0 && !_aborted) {
+                            if (_timer)
+                                clearTimeout(_timer);
+                            _timer = setTimeout(() => {
+                                if (!_aborted) {
+                                    _abort = _fetchStream(normalizedArgs, delayMs);
+                                }
+                            }, delay);
+                        }
+                    }
+                }, ...normalizedArgs);
+            }
+            catch (e) {
+                const error = e instanceof Error ? e : new Error(String(e));
+                _metaStore.set({ ..._metaStore.get(), lastFetchError: error });
+            }
+            return _abort;
+        };
+        return _fetchStream(fetchArgs, recursiveDelayMs);
+    };
+    const reset = () => {
+        _dataStore.set(initial);
+        _metaStore.set(_createMetaObj());
+        if (typeof mergedOptions.onReset === "function")
+            mergedOptions.onReset();
+    };
+    const resetError = () => {
+        _metaStore.update((old) => ({ ...old, lastFetchError: null }));
+    };
+    return {
+        subscribe,
+        get,
+        fetchStream,
+        reset,
+        resetError,
+        getInternalDataStore: () => _dataStore,
+        // Expose raw worker as well
+        fetchStreamWorker,
+    };
+};

package/dist/mod.d.ts

@@ -0,0 +1,3 @@
+export * from "./types.js";
+export * from "./fetch-store.js";
+export * from "./fetch-stream-store.js";

package/dist/mod.js

@@ -0,0 +1,3 @@
+export * from "./types.js";
+export * from "./fetch-store.js";
+export * from "./fetch-stream-store.js";

package/dist/types.d.ts

@@ -0,0 +1,208 @@
+import type { CreateStoreOptions, StoreLike, StoreReadable } from "@marianmeres/store";
+/**
+ * Factory function that transforms fetched data, useful for merge strategies.
+ * Receives the new data and optionally the previous value.
+ *
+ * @template T - The data type
+ * @param data - New data from the fetch worker
+ * @param old - Previous data value (optional, for merge strategies)
+ * @returns Transformed data of type T
+ */
+export type DataFactory<T> = (data: T, old?: T) => T;
+/**
+ * Base metadata interface shared by all fetch stores.
+ * Contains common fields for tracking fetch operation state.
+ */
+export interface FetchMetaBase {
+    /** Whether a fetch operation is currently in progress */
+    isFetching: boolean;
+    /** Timestamp when the last fetch operation started */
+    lastFetchStart: Date | null;
+    /** Timestamp when the last fetch operation completed */
+    lastFetchEnd: Date | null;
+    /** Error from the last fetch operation, if any */
+    lastFetchError: Error | null;
+}
+/**
+ * Extended metadata for FetchStore including success tracking and silent fetch errors.
+ */
+export interface FetchStoreMeta extends FetchMetaBase {
+    /** Count of successful fetch operations (incremented on each success) */
+    successCounter: number;
+    /** Error from the last silent fetch operation, if any */
+    lastFetchSilentError: Error | null;
+}
+/**
+ * Metadata for FetchStreamStore (uses base meta fields only).
+ */
+export interface FetchStreamStoreMeta extends FetchMetaBase {
+}
+/**
+ * Combined value type for FetchStore containing both data and metadata.
+ * This is the shape of the value returned by `get()` and passed to subscribers.
+ *
+ * @template T - The data type stored in the fetch store
+ */
+export interface FetchStoreValue<T> extends FetchStoreMeta {
+    /** The fetched data (null before first successful fetch or after reset) */
+    data: T | null;
+}
+/**
+ * Combined value type for FetchStreamStore containing both data and metadata.
+ * This is the shape of the value returned by `get()` and passed to subscribers.
+ *
+ * @template T - The data type stored in the stream store
+ */
+export interface FetchStreamStoreValue<T> extends FetchStreamStoreMeta {
+    /** The streamed data (null before first data or after reset) */
+    data: T | null;
+}
+/**
+ * Main FetchStore interface providing reactive state management for async fetch operations.
+ * Extends StoreReadable for Svelte-compatible subscribe functionality.
+ *
+ * @template T - The data type stored in the fetch store
+ */
+export interface FetchStore<T> extends StoreReadable<FetchStoreValue<T>> {
+    /**
+     * Executes the fetch worker and updates store state.
+     * Sets `isFetching` to true during the operation.
+     * @param args - Arguments passed to the fetch worker
+     * @returns Promise resolving to fetched data or null on error
+     */
+    fetch: (...args: unknown[]) => Promise<T | null>;
+    /**
+     * Like `fetch`, but does not set `isFetching` to true.
+     * Useful for background refreshes without showing loading spinners.
+     * @param args - Arguments passed to the fetch worker
+     * @returns Promise resolving to fetched data or null on error
+     */
+    fetchSilent: (...args: unknown[]) => Promise<T | null>;
+    /**
+     * Fetches data only if not already fetched or if the threshold has passed.
+     * Useful for caching scenarios where you want to avoid redundant fetches.
+     * @param args - Arguments passed to the fetch worker
+     * @param thresholdMs - Time in ms before re-fetching is allowed (default from options)
+     * @returns Promise resolving to fetched data or null on error
+     */
+    fetchOnce: (args?: unknown[], thresholdMs?: number) => Promise<T | null>;
+    /**
+     * Like `fetchOnce`, but uses silent fetching (no `isFetching` state change).
+     * @param args - Arguments passed to the fetch worker
+     * @param thresholdMs - Time in ms before re-fetching is allowed (default from options)
+     * @returns Promise resolving to fetched data or null on error
+     */
+    fetchOnceSilent: (args?: unknown[], thresholdMs?: number) => Promise<T | null>;
+    /**
+     * Starts recursive polling using silent fetch.
+     * Each fetch waits for the previous one to complete before scheduling the next.
+     * @param args - Arguments passed to the fetch worker
+     * @param delayMs - Delay between fetches in ms, or function returning delay
+     * @returns Cancel function to stop the polling
+     */
+    fetchRecursive: (args?: unknown[], delayMs?: number | (() => number)) => () => void;
+    /**
+     * Resets the store to its initial state, clearing all data and metadata.
+     * Also aborts any in-flight requests if abortable is enabled.
+     */
+    reset: () => void;
+    /**
+     * Clears only the `lastFetchError` field without resetting other state.
+     */
+    resetError: () => void;
+    /**
+     * Returns the internal data store for direct manipulation.
+     * Use with caution as it bypasses the fetch store's state management.
+     */
+    getInternalDataStore: () => StoreLike<T | null>;
+    /**
+     * The raw fetch worker function passed to createFetchStore.
+     */
+    fetchWorker: (...args: unknown[]) => Promise<unknown>;
+    /**
+     * Updates internal timestamps to trick `fetchOnce` into thinking data was just fetched.
+     * Optionally sets new data. Useful for external cache invalidation.
+     * @param data - Optional new data to set
+     */
+    touch: (data?: T) => void;
+    /**
+     * Aborts any in-flight fetch requests.
+     * Only effective when `abortable: true` option is set.
+     */
+    abort: () => void;
+}
+/**
+ * Event names that can be emitted by the stream worker.
+ * - `data`: New data chunk received
+ * - `error`: An error occurred
+ * - `end`: Stream has completed
+ */
+export type FetchStreamEventName = "data" | "error" | "end";
+/**
+ * Emit function passed to the stream worker for sending events.
+ * @param eventName - The type of event being emitted
+ * @param eventData - The event payload (data chunk or error)
+ */
+export type FetchStreamEventEmitFn = (eventName: FetchStreamEventName, eventData?: unknown) => void;
+/**
+ * FetchStreamStore interface for handling streaming data sources.
+ * Useful for SSE, WebSocket, or any streaming data pattern.
+ *
+ * @template T - The data type stored in the stream store
+ */
+export interface FetchStreamStore<T> extends StoreReadable<FetchStreamStoreValue<T>> {
+    /**
+     * Starts the stream and optionally restarts it after completion.
+     * @param args - Arguments passed to the stream worker
+     * @param recursiveDelayMs - Delay before restarting stream after "end" event (0 = no restart)
+     * @returns Cancel function to stop the stream
+     */
+    fetchStream: (args?: unknown[], recursiveDelayMs?: number | (() => number)) => () => void;
+    /**
+     * The raw stream worker function passed to createFetchStreamStore.
+     */
+    fetchStreamWorker: (emit: FetchStreamEventEmitFn, ...args: unknown[]) => unknown;
+    /**
+     * Resets the store to its initial state, clearing all data and metadata.
+     */
+    reset: () => void;
+    /**
+     * Clears only the `lastFetchError` field without resetting other state.
+     */
+    resetError: () => void;
+    /**
+     * Returns the internal data store for direct manipulation.
+     * Use with caution as it bypasses the stream store's state management.
+     */
+    getInternalDataStore: () => StoreLike<T | null>;
+}
+/**
+ * Configuration options for createFetchStore.
+ * Extends CreateStoreOptions from @marianmeres/store.
+ *
+ * @template T - The data type stored in the fetch store
+ */
+export interface FetchStoreOptions<T> extends CreateStoreOptions<T> {
+    /** Default threshold in ms for fetchOnce before allowing re-fetch (default: 300000 = 5 min) */
+    fetchOnceDefaultThresholdMs: number;
+    /** Callback invoked when reset() is called */
+    onReset: () => void;
+    /** If true, subsequent fetch() calls while one is in-flight return the existing promise */
+    dedupeInflight: boolean;
+    /** If true, creates AbortController for each fetch, passing signal to worker and aborting previous requests */
+    abortable: boolean;
+    /** Optional factory function to transform fetched data (useful for merge strategies) */
+    dataFactory: DataFactory<T>;
+}
+/**
+ * Configuration options for createFetchStreamStore.
+ * Extends CreateStoreOptions from @marianmeres/store.
+ *
+ * @template T - The data type stored in the stream store
+ */
+export interface FetchStreamStoreOptions<T> extends CreateStoreOptions<T> {
+    /** Callback invoked when reset() is called */
+    onReset: () => void;
+    /** Optional factory function to transform streamed data (useful for merge strategies) */
+    dataFactory: DataFactory<T>;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,62 +1,20 @@
 {
 	"name": "@marianmeres/fetch-store",
-	"version": "2.12.0",
-	"description": "",
+	"version": "3.0.3",
 	"type": "module",
-	"main": "./dist/index.cjs",
-	"module": "./dist/index.js",
-	"browser": "./dist/index.umd.js",
-	"exports": {
-		"require": "./dist/index.cjs",
-		"import": "./dist/index.js"
-	},
-	"files": [
-		"dist"
-	],
-	"types": "./dist/index.d.ts",
-	"scripts": {
-		"clean": "rimraf dist/*",
-		"prettier": "prettier --write \"{src,tests}/**/*.{js,ts,json}\"",
-		"release": "release -v minor",
-		"release:patch": "release -v patch",
-		"test": "node --loader ts-node/esm tests/index.ts",
-		"test:watch": "nodemon --delay 0.5 -q -w \"src/**/*.*\" -w \"tests/**/*.*\" -x \"node --loader ts-node/esm tests/index.ts\" --",
-		"build": "npm run clean && rollup -c",
-		"dev": "npm run clean && rollup -c -w"
-	},
+	"main": "dist/mod.js",
+	"types": "dist/mod.d.ts",
+	"author": "Marian Meres",
+	"license": "MIT",
 	"repository": {
 		"type": "git",
 		"url": "git+https://github.com/marianmeres/fetch-store.git"
 	},
-	"keywords": [
-		"interval"
-	],
-	"author": "Marian Meres <marian@meres.sk>",
-	"license": "MIT",
 	"bugs": {
 		"url": "https://github.com/marianmeres/fetch-store/issues"
 	},
-	"homepage": "https://github.com/marianmeres/fetch-store#readme",
-	"devDependencies": {
-		"@marianmeres/clog": "^1.0.0",
-		"@marianmeres/release": "^1.0.0",
-		"@marianmeres/test-runner": "^2.0.15",
-		"@rollup/plugin-commonjs": "^24.0.1",
-		"@rollup/plugin-node-resolve": "^15.0.1",
-		"@rollup/plugin-terser": "^0.4.0",
-		"@rollup/plugin-typescript": "^11.0.0",
-		"@types/node": "^18.15.1",
-		"mkdirp": "^2.1.5",
-		"nodemon": "^3.0.2",
-		"prettier": "^2.8.4",
-		"rimraf": "^4.4.0",
-		"rollup": "^3.19.1",
-		"ts-node": "^10.9.1",
-		"tslib": "^2.5.0",
-		"typescript": "^4.9.5"
-	},
 	"dependencies": {
-		"@marianmeres/pubsub": "^1.1.0",
-		"@marianmeres/store": "^1.6.0"
+		"@marianmeres/pubsub": "^2.4.1",
+		"@marianmeres/store": "^2.3.0"
 	}
 }

package/dist/index.cjs

@@ -1 +0,0 @@
-"use strict";const t=t=>"function"==typeof t,e=(e,r="")=>{if(!t(e))throw new TypeError(`${r} Expecting function arg`.trim())},r=e=>t(e.subscribe),n=(r,n=null)=>{const s=e=>t(null==n?void 0:n.persist)&&n.persist(e);let c=(()=>{const t=new Map,e=e=>(t.has(e)||t.set(e,new Set),t.get(e)),r=(t,r)=>{if(!t)throw new TypeError("Expecting valid event name.");if("function"!=typeof r)throw new TypeError("Expecting valid callback function.");return e(t).add(r),()=>e(t).delete(r)};return{publish:(t,r)=>{e(t).forEach(t=>t(r))},subscribe:r,subscribeOnce:(t,e)=>{const n=r(t,t=>{e(t),n()});return n},unsubscribe:(t,r)=>{e(t).delete(r)},unsubscribeAll:e=>t.delete(e)}})(),l=r;s(l);const a=()=>l,u=t=>{l!==t&&(l=t,s(l),c.publish("change",l))};return{set:u,get:a,update:t=>{e(t,"[update]"),u(t(a()))},subscribe:t=>(e(t,"[subscribe]"),t(l),c.subscribe("change",t))}},s=(s,c,l=null)=>{const a=e=>t(null==l?void 0:l.persist)&&l.persist(e),u=n(null==l?void 0:l.initialValue),o=[];if(s.forEach(t=>{if(!r(t))throw new TypeError("Expecting array of StoreLike objects");t.subscribe(t=>o.push(t))()}),!t(c))throw new TypeError("Expecting second argument to be the derivative function");if(!c.length||c.length>2)throw new TypeError("Expecting the derivative function to have exactly 1 or 2 arguments");let i=0,h=[];const F=t=>{e(t,"[derived.subscribe]"),i++||s.forEach((t,e)=>{h.push(t.subscribe(t=>{o[e]=t,1===c.length?(u.set(c(o)),a(u.get())):c(o,t=>{u.set(t),a(u.get())})}))});const r=u.subscribe(t);return()=>{--i||(h.forEach(t=>t()),h=[]),r()}};return{get:()=>{let t;return F(e=>t=e)(),t},subscribe:F}},c=t=>"function"==typeof t,l={},a={fetchOnceDefaultThresholdMs:3e5},u=t=>"function"==typeof t;exports.createFetchStore=(t,e=null,r=null,c={})=>{const{fetchOnceDefaultThresholdMs:l}={...a,...c||{}},o=(t,e)=>u(r)?r?.(t,e):t,i=n(o(e),c),h=n({isFetching:!1,lastFetchStart:null,lastFetchEnd:null,lastFetchError:null,successCounter:0,lastFetchSilentError:null}),{subscribe:F,get:g}=s([i,h],([t,e])=>({data:t,...e})),E=async(...e)=>{let r=h.get();r.isFetching=!0,r.lastFetchStart=new Date,r.lastFetchEnd=null,r.lastFetchError=null,h.set({...r});try{i.set(o(await t(...e),i.get())),r.successCounter++}catch(t){r.lastFetchError=t}finally{r.isFetching=!1,r.lastFetchEnd=new Date}return h.set({...r}),h.get().lastFetchError?null:i.get()},f=async(...e)=>{let r=h.get(),n=0;r.lastFetchSilentError&&(h.set({...r,lastFetchSilentError:null}),n++);try{i.set(o(await t(...e),i.get()))}catch(t){r.lastFetchSilentError=t,n++}return n&&h.set({...r}),h.get().lastFetchSilentError?null:i.get()},d=async(t,e=[],r=l)=>{const{successCounter:n,isFetching:s,lastFetchStart:c}=h.get();return Array.isArray(e)||(e=[e]),n||s?r&&!s&&c&&Date.now()-new Date(c).valueOf()>r?t?await f(...e):await E(...e):i.get():t?await f(...e):await E(...e)},b=(t=[],e=500)=>{let r,n=!1;return((t=[],e=500)=>{Array.isArray(t)||(t=[t]);const s=u(e)?e():e;return f(...t).then(()=>{r&&clearTimeout(r),s>0&&!n&&(r=setTimeout(()=>!n&&b(t,e),s))}),()=>{r&&clearTimeout(r),n=!0}})(t,e)};return{subscribe:F,get:g,fetch:E,fetchSilent:f,fetchOnce:async(t=[],e=l)=>await d(!1,t,e),fetchOnceSilent:async(t=[],e=l)=>await d(!0,t,e),fetchRecursive:b,reset:()=>{i.set(o(e)),h.set({isFetching:!1,lastFetchStart:null,lastFetchEnd:null,lastFetchError:null,successCounter:0,lastFetchSilentError:null}),"function"==typeof c.onReset&&c.onReset()},resetError:()=>h.update(t=>({...t,lastFetchError:null})),getInternalDataStore:()=>i,touch:t=>{t&&i.set(t);let e=h.get();const r=new Date;h.set({...e,lastFetchStart:r,lastFetchEnd:r,successCounter:e.successCounter+1})},fetchWorker:t}},exports.createFetchStreamStore=(t,e=null,r=null,a={})=>{a={...l,...a||{}};const u=(t,e)=>c(r)?r?.(t,e):t,o=n(u(e),a),i=n({isFetching:!1,lastFetchStart:null,lastFetchEnd:null,lastFetchError:null}),{subscribe:h,get:F}=s([o,i],([t,e])=>({data:t,...e}));return{subscribe:h,get:F,fetchStream:(e=[],r=0)=>{let n,s,l=!1,a=()=>{"function"==typeof s?s():console.warn("`abort` is a noop (the fetchStreamWorker did not return a function)."),n&&clearTimeout(n),l=!0};const h=(e=[],r=0)=>{Array.isArray(e)||(e=[e]);const F=c(r)?r():r;i.update(t=>({...t,isFetching:!0,lastFetchStart:new Date,lastFetchEnd:null,lastFetchError:null}));try{s=t((t,s)=>{i.get().lastFetchError&&i.update(t=>({...t,lastFetchError:null})),"data"===t?o.set(u(s,o.get())):"error"===t?i.update(t=>({...t,lastFetchError:s})):"end"===t&&(i.update(t=>({...t,isFetching:!1,lastFetchEnd:new Date})),F>0&&!l&&(n&&clearTimeout(n),n=setTimeout(()=>{l||(a=h(e,r))},F)))},...e)}catch(t){i.update(e=>({...e,lastFetchError:t}))}return a};return h(e,r)},reset:()=>{o.set(u(e)),i.set({isFetching:!1,lastFetchStart:null,lastFetchEnd:null,lastFetchError:null}),"function"==typeof a.onReset&&a.onReset()},resetError:()=>i.update(t=>({...t,lastFetchError:null})),getInternalDataStore:()=>o,fetchStreamWorker:t}};

package/dist/index.d.ts

@@ -1,31 +0,0 @@
-import { CreateStoreOptions, StoreLike, StoreReadable } from '@marianmeres/store';
-export { createFetchStreamStore } from './fetch-stream-store.js';
-export interface FetchStoreMeta {
-    isFetching: boolean;
-    lastFetchStart: Date | null;
-    lastFetchEnd: Date | null;
-    lastFetchError: Error | null;
-    successCounter: number;
-    lastFetchSilentError: Error | null;
-}
-export interface FetchStoreValue<T> extends FetchStoreMeta {
-    data: T;
-}
-export interface FetchStore<T, V> extends StoreReadable<T> {
-    fetch: (...args: any[]) => Promise<V | null>;
-    fetchSilent: (...args: any[]) => Promise<V | null>;
-    fetchOnce: (args?: any[], thresholdMs?: number) => Promise<V | null>;
-    fetchOnceSilent: (args?: any[], thresholdMs?: number) => Promise<V | null>;
-    fetchRecursive: (args?: any[], delayMs?: number) => () => void;
-    reset: () => void;
-    resetError: () => void;
-    getInternalDataStore: () => StoreLike<V>;
-    fetchWorker: (...args: any[]) => Promise<any>;
-    touch: (data?: V) => void;
-}
-interface FetchStoreOptions<T> extends CreateStoreOptions<T> {
-    fetchOnceDefaultThresholdMs: number;
-    onReset: () => void;
-}
-export type DataFactory<T> = (raw: any, old?: any) => T;
-export declare const createFetchStore: <T>(fetchWorker: (...args: any[]) => Promise<any>, initial?: T | null, dataFactory?: DataFactory<T> | null, options?: Partial<FetchStoreOptions<T>>) => FetchStore<FetchStoreValue<T>, T>;

package/dist/index.js

@@ -1 +0,0 @@
-const t=t=>"function"==typeof t,e=(e,r="")=>{if(!t(e))throw new TypeError(`${r} Expecting function arg`.trim())},r=e=>t(e.subscribe),n=(r,n=null)=>{const s=e=>t(null==n?void 0:n.persist)&&n.persist(e);let c=(()=>{const t=new Map,e=e=>(t.has(e)||t.set(e,new Set),t.get(e)),r=(t,r)=>{if(!t)throw new TypeError("Expecting valid event name.");if("function"!=typeof r)throw new TypeError("Expecting valid callback function.");return e(t).add(r),()=>e(t).delete(r)};return{publish:(t,r)=>{e(t).forEach(t=>t(r))},subscribe:r,subscribeOnce:(t,e)=>{const n=r(t,t=>{e(t),n()});return n},unsubscribe:(t,r)=>{e(t).delete(r)},unsubscribeAll:e=>t.delete(e)}})(),l=r;s(l);const a=()=>l,u=t=>{l!==t&&(l=t,s(l),c.publish("change",l))};return{set:u,get:a,update:t=>{e(t,"[update]"),u(t(a()))},subscribe:t=>(e(t,"[subscribe]"),t(l),c.subscribe("change",t))}},s=(s,c,l=null)=>{const a=e=>t(null==l?void 0:l.persist)&&l.persist(e),u=n(null==l?void 0:l.initialValue),o=[];if(s.forEach(t=>{if(!r(t))throw new TypeError("Expecting array of StoreLike objects");t.subscribe(t=>o.push(t))()}),!t(c))throw new TypeError("Expecting second argument to be the derivative function");if(!c.length||c.length>2)throw new TypeError("Expecting the derivative function to have exactly 1 or 2 arguments");let i=0,h=[];const g=t=>{e(t,"[derived.subscribe]"),i++||s.forEach((t,e)=>{h.push(t.subscribe(t=>{o[e]=t,1===c.length?(u.set(c(o)),a(u.get())):c(o,t=>{u.set(t),a(u.get())})}))});const r=u.subscribe(t);return()=>{--i||(h.forEach(t=>t()),h=[]),r()}};return{get:()=>{let t;return g(e=>t=e)(),t},subscribe:g}},c=t=>"function"==typeof t,l={},a=(t,e=null,r=null,a={})=>{a={...l,...a||{}};const u=(t,e)=>c(r)?r?.(t,e):t,o=n(u(e),a),i=n({isFetching:!1,lastFetchStart:null,lastFetchEnd:null,lastFetchError:null}),{subscribe:h,get:g}=s([o,i],([t,e])=>({data:t,...e}));return{subscribe:h,get:g,fetchStream:(e=[],r=0)=>{let n,s,l=!1,a=()=>{"function"==typeof s?s():console.warn("`abort` is a noop (the fetchStreamWorker did not return a function)."),n&&clearTimeout(n),l=!0};const h=(e=[],r=0)=>{Array.isArray(e)||(e=[e]);const g=c(r)?r():r;i.update(t=>({...t,isFetching:!0,lastFetchStart:new Date,lastFetchEnd:null,lastFetchError:null}));try{s=t((t,s)=>{i.get().lastFetchError&&i.update(t=>({...t,lastFetchError:null})),"data"===t?o.set(u(s,o.get())):"error"===t?i.update(t=>({...t,lastFetchError:s})):"end"===t&&(i.update(t=>({...t,isFetching:!1,lastFetchEnd:new Date})),g>0&&!l&&(n&&clearTimeout(n),n=setTimeout(()=>{l||(a=h(e,r))},g)))},...e)}catch(t){i.update(e=>({...e,lastFetchError:t}))}return a};return h(e,r)},reset:()=>{o.set(u(e)),i.set({isFetching:!1,lastFetchStart:null,lastFetchEnd:null,lastFetchError:null}),"function"==typeof a.onReset&&a.onReset()},resetError:()=>i.update(t=>({...t,lastFetchError:null})),getInternalDataStore:()=>o,fetchStreamWorker:t}},u={fetchOnceDefaultThresholdMs:3e5},o=t=>"function"==typeof t,i=(t,e=null,r=null,c={})=>{const{fetchOnceDefaultThresholdMs:l}={...u,...c||{}},a=(t,e)=>o(r)?r?.(t,e):t,i=n(a(e),c),h=n({isFetching:!1,lastFetchStart:null,lastFetchEnd:null,lastFetchError:null,successCounter:0,lastFetchSilentError:null}),{subscribe:g,get:E}=s([i,h],([t,e])=>({data:t,...e})),F=async(...e)=>{let r=h.get();r.isFetching=!0,r.lastFetchStart=new Date,r.lastFetchEnd=null,r.lastFetchError=null,h.set({...r});try{i.set(a(await t(...e),i.get())),r.successCounter++}catch(t){r.lastFetchError=t}finally{r.isFetching=!1,r.lastFetchEnd=new Date}return h.set({...r}),h.get().lastFetchError?null:i.get()},f=async(...e)=>{let r=h.get(),n=0;r.lastFetchSilentError&&(h.set({...r,lastFetchSilentError:null}),n++);try{i.set(a(await t(...e),i.get()))}catch(t){r.lastFetchSilentError=t,n++}return n&&h.set({...r}),h.get().lastFetchSilentError?null:i.get()},d=async(t,e=[],r=l)=>{const{successCounter:n,isFetching:s,lastFetchStart:c}=h.get();return Array.isArray(e)||(e=[e]),n||s?r&&!s&&c&&Date.now()-new Date(c).valueOf()>r?t?await f(...e):await F(...e):i.get():t?await f(...e):await F(...e)},b=(t=[],e=500)=>{let r,n=!1;return((t=[],e=500)=>{Array.isArray(t)||(t=[t]);const s=o(e)?e():e;return f(...t).then(()=>{r&&clearTimeout(r),s>0&&!n&&(r=setTimeout(()=>!n&&b(t,e),s))}),()=>{r&&clearTimeout(r),n=!0}})(t,e)};return{subscribe:g,get:E,fetch:F,fetchSilent:f,fetchOnce:async(t=[],e=l)=>await d(!1,t,e),fetchOnceSilent:async(t=[],e=l)=>await d(!0,t,e),fetchRecursive:b,reset:()=>{i.set(a(e)),h.set({isFetching:!1,lastFetchStart:null,lastFetchEnd:null,lastFetchError:null,successCounter:0,lastFetchSilentError:null}),"function"==typeof c.onReset&&c.onReset()},resetError:()=>h.update(t=>({...t,lastFetchError:null})),getInternalDataStore:()=>i,touch:t=>{t&&i.set(t);let e=h.get();const r=new Date;h.set({...e,lastFetchStart:r,lastFetchEnd:r,successCounter:e.successCounter+1})},fetchWorker:t}};export{i as createFetchStore,a as createFetchStreamStore};

package/dist/index.umd.js

@@ -1 +0,0 @@
-!function(t,e){"object"==typeof exports&&"undefined"!=typeof module?e(exports):"function"==typeof define&&define.amd?define(["exports"],e):e((t="undefined"!=typeof globalThis?globalThis:t||self)["fetch-store"]={})}(this,function(t){"use strict";const e=t=>"function"==typeof t,r=(t,r="")=>{if(!e(t))throw new TypeError(`${r} Expecting function arg`.trim())},n=t=>e(t.subscribe),s=(t,n=null)=>{const s=t=>e(null==n?void 0:n.persist)&&n.persist(t);let c=(()=>{const t=new Map,e=e=>(t.has(e)||t.set(e,new Set),t.get(e)),r=(t,r)=>{if(!t)throw new TypeError("Expecting valid event name.");if("function"!=typeof r)throw new TypeError("Expecting valid callback function.");return e(t).add(r),()=>e(t).delete(r)};return{publish:(t,r)=>{e(t).forEach(t=>t(r))},subscribe:r,subscribeOnce:(t,e)=>{const n=r(t,t=>{e(t),n()});return n},unsubscribe:(t,r)=>{e(t).delete(r)},unsubscribeAll:e=>t.delete(e)}})(),l=t;s(l);const a=()=>l,o=t=>{l!==t&&(l=t,s(l),c.publish("change",l))};return{set:o,get:a,update:t=>{r(t,"[update]"),o(t(a()))},subscribe:t=>(r(t,"[subscribe]"),t(l),c.subscribe("change",t))}},c=(t,c,l=null)=>{const a=t=>e(null==l?void 0:l.persist)&&l.persist(t),o=s(null==l?void 0:l.initialValue),u=[];if(t.forEach(t=>{if(!n(t))throw new TypeError("Expecting array of StoreLike objects");t.subscribe(t=>u.push(t))()}),!e(c))throw new TypeError("Expecting second argument to be the derivative function");if(!c.length||c.length>2)throw new TypeError("Expecting the derivative function to have exactly 1 or 2 arguments");let i=0,h=[];const f=e=>{r(e,"[derived.subscribe]"),i++||t.forEach((t,e)=>{h.push(t.subscribe(t=>{u[e]=t,1===c.length?(o.set(c(u)),a(o.get())):c(u,t=>{o.set(t),a(o.get())})}))});const n=o.subscribe(e);return()=>{--i||(h.forEach(t=>t()),h=[]),n()}};return{get:()=>{let t;return f(e=>t=e)(),t},subscribe:f}},l=t=>"function"==typeof t,a={},o={fetchOnceDefaultThresholdMs:3e5},u=t=>"function"==typeof t;t.createFetchStore=(t,e=null,r=null,n={})=>{const{fetchOnceDefaultThresholdMs:l}={...o,...n||{}},a=(t,e)=>u(r)?r?.(t,e):t,i=s(a(e),n),h=s({isFetching:!1,lastFetchStart:null,lastFetchEnd:null,lastFetchError:null,successCounter:0,lastFetchSilentError:null}),{subscribe:f,get:d}=c([i,h],([t,e])=>({data:t,...e})),g=async(...e)=>{let r=h.get();r.isFetching=!0,r.lastFetchStart=new Date,r.lastFetchEnd=null,r.lastFetchError=null,h.set({...r});try{i.set(a(await t(...e),i.get())),r.successCounter++}catch(t){r.lastFetchError=t}finally{r.isFetching=!1,r.lastFetchEnd=new Date}return h.set({...r}),h.get().lastFetchError?null:i.get()},F=async(...e)=>{let r=h.get(),n=0;r.lastFetchSilentError&&(h.set({...r,lastFetchSilentError:null}),n++);try{i.set(a(await t(...e),i.get()))}catch(t){r.lastFetchSilentError=t,n++}return n&&h.set({...r}),h.get().lastFetchSilentError?null:i.get()},E=async(t,e=[],r=l)=>{const{successCounter:n,isFetching:s,lastFetchStart:c}=h.get();return Array.isArray(e)||(e=[e]),n||s?r&&!s&&c&&Date.now()-new Date(c).valueOf()>r?t?await F(...e):await g(...e):i.get():t?await F(...e):await g(...e)},p=(t=[],e=500)=>{let r,n=!1;return((t=[],e=500)=>{Array.isArray(t)||(t=[t]);const s=u(e)?e():e;return F(...t).then(()=>{r&&clearTimeout(r),s>0&&!n&&(r=setTimeout(()=>!n&&p(t,e),s))}),()=>{r&&clearTimeout(r),n=!0}})(t,e)};return{subscribe:f,get:d,fetch:g,fetchSilent:F,fetchOnce:async(t=[],e=l)=>await E(!1,t,e),fetchOnceSilent:async(t=[],e=l)=>await E(!0,t,e),fetchRecursive:p,reset:()=>{i.set(a(e)),h.set({isFetching:!1,lastFetchStart:null,lastFetchEnd:null,lastFetchError:null,successCounter:0,lastFetchSilentError:null}),"function"==typeof n.onReset&&n.onReset()},resetError:()=>h.update(t=>({...t,lastFetchError:null})),getInternalDataStore:()=>i,touch:t=>{t&&i.set(t);let e=h.get();const r=new Date;h.set({...e,lastFetchStart:r,lastFetchEnd:r,successCounter:e.successCounter+1})},fetchWorker:t}},t.createFetchStreamStore=(t,e=null,r=null,n={})=>{n={...a,...n||{}};const o=(t,e)=>l(r)?r?.(t,e):t,u=s(o(e),n),i=s({isFetching:!1,lastFetchStart:null,lastFetchEnd:null,lastFetchError:null}),{subscribe:h,get:f}=c([u,i],([t,e])=>({data:t,...e}));return{subscribe:h,get:f,fetchStream:(e=[],r=0)=>{let n,s,c=!1,a=()=>{"function"==typeof s?s():console.warn("`abort` is a noop (the fetchStreamWorker did not return a function)."),n&&clearTimeout(n),c=!0};const h=(e=[],r=0)=>{Array.isArray(e)||(e=[e]);const f=l(r)?r():r;i.update(t=>({...t,isFetching:!0,lastFetchStart:new Date,lastFetchEnd:null,lastFetchError:null}));try{s=t((t,s)=>{i.get().lastFetchError&&i.update(t=>({...t,lastFetchError:null})),"data"===t?u.set(o(s,u.get())):"error"===t?i.update(t=>({...t,lastFetchError:s})):"end"===t&&(i.update(t=>({...t,isFetching:!1,lastFetchEnd:new Date})),f>0&&!c&&(n&&clearTimeout(n),n=setTimeout(()=>{c||(a=h(e,r))},f)))},...e)}catch(t){i.update(e=>({...e,lastFetchError:t}))}return a};return h(e,r)},reset:()=>{u.set(o(e)),i.set({isFetching:!1,lastFetchStart:null,lastFetchEnd:null,lastFetchError:null}),"function"==typeof n.onReset&&n.onReset()},resetError:()=>i.update(t=>({...t,lastFetchError:null})),getInternalDataStore:()=>u,fetchStreamWorker:t}}});