edges-svelte 1.0.3 → 1.1.0

package/README.md

@@ -10,7 +10,7 @@ No context boilerplate. No hydration headaches. Just drop-in SSR-compatible stat
 - 🧠 Persistent per-request memory via `AsyncLocalStorage`
 - 💧 Tiny API
 - 💥 Instant serialization without magic
-- 🧩 Provider-based dependency injection, zero runtime overhead
+- 🧩 Dependency injection, zero runtime overhead
 
 > Designed for **SvelteKit**.
 
@@ -49,12 +49,12 @@ export const handle: Handle = async ({ event, resolve }) => {
 
 ## Basic usage
 
-### `createProvider` - creates a provider function that can manage states
+### `createStore` - creates a store function that can manage states
 
 ```ts
-import { createProvider } from 'edges-svelte';
-
-const myProvider = createProvider('MyProvider', ({ createState, createDerivedState }) => {
+import { createStore } from 'edges-svelte';
+// First argument is a unique name. Each store must havew a unique name.
+const myStore = createStore('MyStore', ({ createState, createDerivedState }) => {
 	// createState creates a writable, SSR-safe store with a unique key
 	const collection = createState<number[]>([]);
 	// createDerivedState creates a derived store, SSR-safe as well
@@ -70,9 +70,9 @@ const myProvider = createProvider('MyProvider', ({ createState, createDerivedSta
 
 ```svelte
 <script lang="ts">
-	import { myProvider } from 'your-alias';
+	import { myStore } from 'your-alias';
 
-	const { collection, collectionLengthDoubled, updateAction } = myProvider();
+	const { collection, collectionLengthDoubled, updateAction } = myStore();
 </script>
 
 {$collection.join(', ')}
@@ -84,17 +84,17 @@ const myProvider = createProvider('MyProvider', ({ createState, createDerivedSta
 <!-- Will update the state -->
 ```
 
-- 💡 All stores created inside `createProvider` use unique keys automatically and are request-scoped
+- 💡 All stores created inside `createStore` use unique keys automatically and are request-scoped
 - 🛡️ Fully SSR-safe — stores are isolated per request and serialized automatically
 
 ---
 
-## Provider Caching (built-in)
+## Store Caching (built-in)
 
-Providers are cached per request by their unique provider name (cache key). Calling the same provider multiple times in the same request returns the cached instance.
+Stores are cached per request by their unique name (cache key). Calling the same store multiple times in the same request returns the cached instance.
 
 ```ts
-const myCachedProvider = createProvider('MyCachedProvider', ({ createState }) => {
+const myCachedStore = createStore('MyCachedStore', ({ createState }) => {
 	const data = createState(() => 'cached data');
 	return { data };
 });
@@ -108,7 +108,7 @@ const myCachedProvider = createProvider('MyCachedProvider', ({ createState }) =>
 
 State is isolated per request using `AsyncLocalStorage` internally. You never share data between users.
 
-You **must** always create stores inside providers returned by `createProvider`.
+You **must** always create stores inside using `createStore`.
 
 ---
 
@@ -154,10 +154,10 @@ counter.value += 1;
 
 ## Dependency Injection
 
-You can inject dependencies into providers with `createProviderFactory`:
+You can inject dependencies into providers with `createStoreFactory`:
 
 ```ts
-const withDeps = createProviderFactory({ user: getUserFromSession });
+const withDeps = createStoreFactory({ user: getUserFromSession });
 
 const useUserStore = withDeps('UserStore', ({ user, createState }) => {
 	const userState = createState(user);
@@ -167,12 +167,30 @@ const useUserStore = withDeps('UserStore', ({ user, createState }) => {
 
 ---
 
+## createPresenter
+
+A cached provider for UI logic without direct state management primitives. Perfect for separating business logic from state management.
+
+#### When to use
+
+createPresenter is ideal when you want to:
+
+1. Keep state management separate from UI logic
+2. Create reusable business logic that doesn't directly manage state
+3. Build presenters that orchestrate between services and stores
+4. Follow clean architecture patterns with clear separation of concerns
+
+Difference from createStore
+While createStore provides state primitives (createState, createDerivedState, createRawState), createPresenter focuses purely on business logic and coordination. It maintains all the caching and dependency injection features of createStore but without state management utilities.
+
+---
+
 ## Exports summary
 
-| Feature                                   | Import from           |
-| ----------------------------------------- | --------------------- |
-| `createProvider`, `createProviderFactory` | `edges-svelte`        |
-| `edgesHandle`                             | `edges-svelte/server` |
+| Feature                                                                          | Import from           |
+| -------------------------------------------------------------------------------- | --------------------- |
+| `createStore`, `createStoreFactory`, `createPresenter`, `createPresenterFactory` | `edges-svelte`        |
+| `edgesHandle`                                                                    | `edges-svelte/server` |
 
 ---
 

package/dist/provider/Provider.d.ts

@@ -1,5 +1,10 @@
 import { createDerivedState as BaseCreateDerivedState } from '../store/index.js';
 import type { Writable } from 'svelte/store';
+type NoConflict<I, D> = {
+    [K in keyof I]: K extends keyof D ? never : I[K];
+};
+export declare const clearCache: (pattern?: string) => void;
+export declare const createUiProvider: <T, F, D extends Record<string, unknown> | ((cacheKey: string) => Record<string, unknown>), I extends Record<string, unknown> = Record<string, unknown>>(name: string, factory: (deps: F) => T, dependencies: D, inject?: I) => (() => T);
 type StoreDeps = {
     createRawState: <T>(initial: T | (() => T)) => {
         value: T;
@@ -7,9 +12,8 @@ type StoreDeps = {
     createState: <T>(initial: T | (() => T)) => Writable<T>;
     createDerivedState: typeof BaseCreateDerivedState;
 };
-type NoConflict<I> = {
-    [K in keyof I]: K extends keyof StoreDeps ? never : I[K];
-};
-export declare const createProvider: <T, I extends Record<string, unknown> = Record<string, unknown>>(name: string, factory: (args: StoreDeps & NoConflict<I>) => T, inject?: I) => (() => T);
-export declare const createProviderFactory: <I extends Record<string, unknown>>(inject: I) => <T>(name: string, factory: (args: StoreDeps & NoConflict<I>) => T) => () => T;
+export declare const createStore: <T, I extends Record<string, unknown> = Record<string, unknown>>(name: string, factory: (args: StoreDeps & NoConflict<I, StoreDeps>) => T, inject?: I) => (() => T);
+export declare const createStoreFactory: <I extends Record<string, unknown>>(inject: I) => <T>(name: string, factory: (args: StoreDeps & NoConflict<I, StoreDeps>) => T) => () => T;
+export declare const createPresenter: <T, I extends Record<string, unknown> = Record<string, unknown>>(name: string, factory: (args: I) => T, inject?: I) => (() => T);
+export declare const createPresenterFactory: <I extends Record<string, unknown>>(inject: I) => <T>(name: string, factory: (args: I) => T) => () => T;
 export {};

package/dist/provider/Provider.js

@@ -2,7 +2,21 @@ import { createState as BaseCreateState, createDerivedState as BaseCreateDerived
 import { RequestContext } from '../context/index.js';
 import { browser } from '$app/environment';
 const globalClientCache = new Map();
-export const createProvider = (name, factory, inject) => {
+export const clearCache = (pattern) => {
+    if (browser) {
+        if (pattern) {
+            for (const [key] of globalClientCache) {
+                if (key.includes(pattern)) {
+                    globalClientCache.delete(key);
+                }
+            }
+        }
+        else {
+            globalClientCache.clear();
+        }
+    }
+};
+export const createUiProvider = (name, factory, dependencies, inject) => {
     const cacheKey = name;
     return () => {
         let contextMap;
@@ -17,32 +31,50 @@ export const createProvider = (name, factory, inject) => {
             contextMap = context.data.providers;
         }
         if (cacheKey && contextMap.has(cacheKey)) {
-            return contextMap.get(cacheKey);
+            const cached = contextMap.get(cacheKey);
+            if (cached !== undefined) {
+                return cached;
+            }
+        }
+        const deps = {
+            ...(typeof dependencies === 'function' ? dependencies(cacheKey) : dependencies),
+            ...inject
+        };
+        const instance = factory(deps);
+        if (cacheKey) {
+            contextMap.set(cacheKey, instance);
         }
+        return instance;
+    };
+};
+export const createStore = (name, factory, inject) => {
+    return createUiProvider(name, factory, (cacheKey) => {
         let stateCounter = 0;
-        const autoKeyDeps = {
-            ...inject,
+        return {
             createState: (initial) => {
-                const key = `${cacheKey ?? 'provider'}::state::${stateCounter++}`;
+                const key = `${cacheKey}::state::${stateCounter++}`;
                 const initFn = typeof initial === 'function' ? initial : () => initial;
                 return BaseCreateState(key, initFn);
             },
             createRawState: (initial) => {
-                const key = `${cacheKey ?? 'provider'}::rawstate::${stateCounter++}`;
+                const key = `${cacheKey}::rawstate::${stateCounter++}`;
                 const initFn = typeof initial === 'function' ? initial : () => initial;
                 return BaseCreateRawState(key, initFn);
             },
             createDerivedState: BaseCreateDerivedState
         };
-        const instance = factory(autoKeyDeps);
-        if (cacheKey) {
-            contextMap.set(cacheKey, instance);
-        }
-        return instance;
+    }, inject);
+};
+export const createStoreFactory = (inject) => {
+    return function createInjectedStore(name, factory) {
+        return createStore(name, factory, inject);
     };
 };
-export const createProviderFactory = (inject) => {
-    return function createInjectedProvider(name, factory) {
-        return createProvider(name, factory, inject);
+export const createPresenter = (name, factory, inject) => {
+    return createUiProvider(name, factory, {}, inject);
+};
+export const createPresenterFactory = (inject) => {
+    return function createInjectedStore(name, factory) {
+        return createPresenter(name, factory, inject);
     };
 };

package/dist/store/State.svelte.js

@@ -42,7 +42,7 @@ export const createRawState = (key, initial) => {
     return {
         get value() {
             if (!map)
-                return undefined;
+                return initial();
             if (!map.has(key))
                 map.set(key, structuredClone(initial()));
             return map.get(key);
@@ -63,22 +63,22 @@ export const createState = (key, initial) => {
         throw new Error('No RequestContext available');
     if (!map.has(key))
         map.set(key, structuredClone(initial()));
-    const subscribers = new Set();
+    //const subscribers: Set<(val: T) => void> = new Set();
     return {
         subscribe(run) {
             run(map.get(key));
-            subscribers.add(run);
-            return () => subscribers.delete(run);
+            //subscribers.add(run);
+            return () => { };
         },
         set(val) {
             map.set(key, val);
-            subscribers.forEach((fn) => fn(val));
+            //subscribers.forEach((fn) => fn(val));
         },
         update(updater) {
             const oldVal = map.get(key);
             const newVal = updater(oldVal);
             map.set(key, newVal);
-            subscribers.forEach((fn) => fn(newVal));
+            //subscribers.forEach((fn) => fn(newVal));
         }
     };
 };
@@ -90,14 +90,19 @@ export const createDerivedState = (stores, deriveFn) => {
         subscribe(run) {
             const values = new Array(stores.length);
             let initializedCount = 0;
+            let isInitialized = false;
+            const checkAndRun = () => {
+                if (initializedCount >= stores.length && !isInitialized) {
+                    isInitialized = true;
+                    run(deriveFn(values));
+                }
+            };
             const unsubscribers = stores.map((store, i) => store.subscribe((value) => {
                 values[i] = value;
                 if (initializedCount < stores.length) {
                     initializedCount++;
                 }
-                if (initializedCount >= stores.length) {
-                    run(deriveFn(values));
-                }
+                checkAndRun();
             }));
             return () => {
                 unsubscribers.forEach((unsub) => unsub());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "edges-svelte",
-  "version": "1.0.3",
+  "version": "1.1.0",
   "license": "MIT",
   "author": "Pixel1917",
   "description": "A blazing-fast, extremely lightweight and SSR-friendly store for Svelte",