edges-svelte 1.0.2 → 1.0.4

package/dist/provider/Provider.d.ts

@@ -10,6 +10,7 @@ type StoreDeps = {
 type NoConflict<I> = {
     [K in keyof I]: K extends keyof StoreDeps ? never : I[K];
 };
+export declare const clearProviderCache: (pattern?: string) => void;
 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 {};

package/dist/provider/Provider.js

@@ -2,6 +2,20 @@ import { createState as BaseCreateState, createDerivedState as BaseCreateDerived
 import { RequestContext } from '../context/index.js';
 import { browser } from '$app/environment';
 const globalClientCache = new Map();
+export const clearProviderCache = (pattern) => {
+    if (browser) {
+        if (pattern) {
+            for (const [key] of globalClientCache) {
+                if (key.includes(pattern)) {
+                    globalClientCache.delete(key);
+                }
+            }
+        }
+        else {
+            globalClientCache.clear();
+        }
+    }
+};
 export const createProvider = (name, factory, inject) => {
     const cacheKey = name;
     return () => {
@@ -17,7 +31,10 @@ 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;
+            }
         }
         let stateCounter = 0;
         const autoKeyDeps = {

package/dist/store/State.svelte.d.ts

@@ -9,4 +9,9 @@ export declare const createRawState: <T>(key: string, initial: () => T) => {
     value: T;
 };
 export declare const createState: <T>(key: string, initial: () => T) => Writable<T>;
-export declare const createDerivedState: <T, D>(stores: Readable<T>[] | [Readable<T>], deriveFn: (values: [T] | T[]) => D) => Readable<D>;
+type Stores = [Readable<unknown>, ...Array<Readable<unknown>>] | Array<Readable<unknown>>;
+type StoresValues<T> = T extends Readable<infer U> ? U : {
+    [K in keyof T]: T[K] extends Readable<infer U> ? U : never;
+};
+export declare const createDerivedState: <T extends Stores, D>(stores: T, deriveFn: (values: StoresValues<T>) => D) => Readable<D>;
+export {};

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.2",
+  "version": "1.0.4",
   "license": "MIT",
   "author": "Pixel1917",
   "description": "A blazing-fast, extremely lightweight and SSR-friendly store for Svelte",