edges-svelte 1.2.0 → 1.3.0

package/README.md

@@ -47,8 +47,7 @@ export default defineConfig({
 
 ```ts
 import { createStore } from 'edges-svelte';
-// First argument is a unique name. Each store must havew a unique name.
-const myStore = createStore('MyStore', ({ createState, createDerivedState }) => {
+const myStore = createStore(({ 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
@@ -88,7 +87,7 @@ const myStore = createStore('MyStore', ({ createState, createDerivedState }) =>
 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 myCachedStore = createStore('MyCachedStore', ({ createState }) => {
+const myCachedStore = createStore(({ createState }) => {
 	const data = createState(() => 'cached data');
 	return { data };
 });
@@ -148,12 +147,12 @@ counter.value += 1;
 
 ## Dependency Injection
 
-You can inject dependencies into providers with `createStoreFactory`:
+You can inject dependencies into stores with `createStoreFactory`:
 
 ```ts
 const withDeps = createStoreFactory({ user: getUserFromSession });
 
-const useUserStore = withDeps('UserStore', ({ user, createState }) => {
+const useUserStore = withDeps(({ user, createState }) => {
 	const userState = createState(user);
 	return { userState };
 });

package/dist/client/NavigationSync.svelte.js

@@ -1,5 +1,18 @@
 import { browser } from '$app/environment';
 const stateUpdateCallbacks = new Map();
+const UNDEFINED_MARKER = '__EDGES_UNDEFINED__';
+const NULL_MARKER = '__EDGES_NULL__';
+const safeReviver = (key, value) => {
+    if (value && typeof value === 'object') {
+        if (UNDEFINED_MARKER in value) {
+            return undefined;
+        }
+        if (NULL_MARKER in value) {
+            return null;
+        }
+    }
+    return value;
+};
 export function registerStateUpdate(key, callback) {
     if (browser) {
         stateUpdateCallbacks.set(key, callback);
@@ -13,31 +26,90 @@ export function processEdgesState(edgesState) {
         window.__SAFE_SSR_STATE__ = new Map();
     }
     for (const [key, value] of Object.entries(edgesState)) {
-        window.__SAFE_SSR_STATE__.set(key, value);
+        let processedValue = value;
+        if (typeof value === 'string') {
+            try {
+                processedValue = JSON.parse(value, safeReviver);
+            }
+            catch {
+                // If not JSON then use without handling
+            }
+        }
+        window.__SAFE_SSR_STATE__.set(key, processedValue);
         const callback = stateUpdateCallbacks.get(key);
         if (callback) {
-            callback(value);
+            callback(processedValue);
         }
     }
 }
 if (browser) {
     const originalFetch = window.fetch;
+    let processingResponse = false;
     window.fetch = async function (...args) {
         const response = await originalFetch.apply(this, args);
-        const clonedResponse = response.clone();
-        try {
-            const contentType = clonedResponse.headers.get('content-type');
+        if (processingResponse) {
+            return response;
+        }
+        const [input, init] = args;
+        const url = typeof input === 'string' ? input : input instanceof Request ? input.url : '';
+        const isSvelteKitGet = init.__sveltekit_fetch__ || url.includes('__data.json');
+        const isSvelteKitPost = input instanceof URL && input.search.startsWith('?/');
+        if (isSvelteKitGet || isSvelteKitPost) {
+            const contentType = response.headers.get('content-type');
             if (contentType?.includes('application/json')) {
-                const json = await clonedResponse.json();
-                if (json && typeof json === 'object' && '__edges_state__' in json) {
-                    const edgesState = json.__edges_state__;
-                    processEdgesState(edgesState);
+                processingResponse = true;
+                try {
+                    const cloned = response.clone();
+                    const text = await cloned.text();
+                    if (text) {
+                        try {
+                            const json = JSON.parse(text);
+                            if (json && typeof json === 'object' && '__edges_state__' in json) {
+                                processEdgesState(json.__edges_state__);
+                            }
+                        }
+                        catch {
+                            // ignore no JSON or parse Errors
+                        }
+                    }
+                }
+                catch {
+                    // Ошибка клонирования или чтения - игнорируем
+                }
+                finally {
+                    processingResponse = false;
                 }
             }
         }
-        catch {
-            // Ignore JSON parsing errors
-        }
         return response;
     };
+    if (typeof MutationObserver !== 'undefined') {
+        const observer = new MutationObserver((mutations) => {
+            for (const mutation of mutations) {
+                if (mutation.type === 'childList') {
+                    for (const node of mutation.addedNodes) {
+                        if (node instanceof HTMLScriptElement) {
+                            const text = node.textContent || '';
+                            if (text.includes('__SAFE_SSR_STATE__') && text.includes('__EDGES_REVIVER__')) {
+                                setTimeout(() => {
+                                    if (window.__SAFE_SSR_STATE__) {
+                                        for (const [key, value] of window.__SAFE_SSR_STATE__) {
+                                            const callback = stateUpdateCallbacks.get(key);
+                                            if (callback) {
+                                                callback(value);
+                                            }
+                                        }
+                                    }
+                                }, 0);
+                            }
+                        }
+                    }
+                }
+            }
+        });
+        observer.observe(document.documentElement, {
+            childList: true,
+            subtree: true
+        });
+    }
 }

package/dist/context/Context.d.ts

@@ -4,8 +4,8 @@ export interface ContextData {
     symbol?: symbol;
     data: {
         providers?: Map<string, unknown>;
-        [p: string]: unknown;
-    };
+        boundary?: Map<string, unknown>;
+    } & App.ContextDataExtended;
 }
 declare const _default: {
     current(): ContextData;

package/dist/context/Context.js

@@ -2,7 +2,7 @@ import { browser } from '$app/environment';
 export default {
     current() {
         if (!browser) {
-            throw new Error('AsyncLocalStorage has not been initialized');
+            throw new Error('[edges] AsyncLocalStorage not initialized');
         }
         return { data: {} };
     }

package/dist/provider/Provider.d.ts

@@ -4,7 +4,6 @@ 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;
@@ -12,8 +11,30 @@ type StoreDeps = {
     createState: <T>(initial: T | (() => T)) => Writable<T>;
     createDerivedState: typeof BaseCreateDerivedState;
 };
-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;
+/**
+ * Creates store without name needed
+ * @example
+ * export const useUserStore = createStore(({ createState }) => {
+ *   const user = createState(null);
+ *   return { user };
+ * });
+ */
+export declare function createStore<T, I extends Record<string, unknown> = Record<string, unknown>>(factory: (args: StoreDeps & NoConflict<I, StoreDeps>) => T, inject?: I): () => T;
+export declare function createNamedStore<T, I extends Record<string, unknown> = Record<string, unknown>>(name: string, factory: (args: StoreDeps & NoConflict<I, StoreDeps>) => T, inject?: I): () => T;
+/**
+ * Store factory
+ */
+export declare const createStoreFactory: <I extends Record<string, unknown>>(inject: I) => <T>(factory: (args: StoreDeps & NoConflict<I, StoreDeps>) => T) => () => T;
+/**
+ * Presenter without name needed
+ */
+export declare function createPresenter<T, I extends Record<string, unknown> = Record<string, unknown>>(factory: (args: I) => T, inject?: I): () => T;
+/**
+ * Named presenter
+ */
+export declare function createNamedPresenter<T, I extends Record<string, unknown> = Record<string, unknown>>(name: string, factory: (args: I) => T, inject?: I): () => T;
+/**
+ * Presenter factory
+ */
+export declare const createPresenterFactory: <I extends Record<string, unknown>>(inject: I) => <T>(factory: (args: I) => T) => () => T;
 export {};

package/dist/provider/Provider.js

@@ -1,7 +1,37 @@
 import { createState as BaseCreateState, createDerivedState as BaseCreateDerivedState, createRawState as BaseCreateRawState } from '../store/index.js';
 import { RequestContext } from '../context/index.js';
 import { browser } from '$app/environment';
+// Global client cache
 const globalClientCache = new Map();
+// Key auto-generate
+class AutoKeyGenerator {
+    static cache = new WeakMap();
+    static counters = new Map();
+    static generate(factory) {
+        if (this.cache.has(factory)) {
+            return this.cache.get(factory);
+        }
+        const fnString = factory.toString();
+        let hash = 0;
+        for (let i = 0; i < fnString.length; i++) {
+            const char = fnString.charCodeAt(i);
+            hash = (hash << 5) - hash + char;
+            hash = hash & hash;
+        }
+        const baseKey = `store_${Math.abs(hash).toString(36)}`;
+        let finalKey = baseKey;
+        if (this.counters.has(baseKey)) {
+            const count = this.counters.get(baseKey) + 1;
+            this.counters.set(baseKey, count);
+            finalKey = `${baseKey}_${count}`;
+        }
+        else {
+            this.counters.set(baseKey, 0);
+        }
+        this.cache.set(factory, finalKey);
+        return finalKey;
+    }
+}
 export const clearCache = (pattern) => {
     if (browser) {
         if (pattern) {
@@ -16,21 +46,25 @@ export const clearCache = (pattern) => {
         }
     }
 };
-export const createUiProvider = (name, factory, dependencies, inject) => {
-    const cacheKey = name;
+const createUiProvider = (cacheKey, factory, dependencies, inject) => {
     return () => {
         let contextMap;
         if (browser) {
             contextMap = globalClientCache;
         }
         else {
-            const context = RequestContext.current();
-            if (!context.data.providers) {
-                context.data.providers = new Map();
+            try {
+                const context = RequestContext.current();
+                if (!context.data.providers) {
+                    context.data.providers = new Map();
+                }
+                contextMap = context.data.providers;
+            }
+            catch {
+                contextMap = new Map();
             }
-            contextMap = context.data.providers;
         }
-        if (cacheKey && contextMap.has(cacheKey)) {
+        if (contextMap.has(cacheKey)) {
             const cached = contextMap.get(cacheKey);
             if (cached !== undefined) {
                 return cached;
@@ -41,13 +75,39 @@ export const createUiProvider = (name, factory, dependencies, inject) => {
             ...inject
         };
         const instance = factory(deps);
-        if (cacheKey) {
-            contextMap.set(cacheKey, instance);
-        }
+        contextMap.set(cacheKey, instance);
         return instance;
     };
 };
-export const createStore = (name, factory, inject) => {
+/**
+ * Creates store without name needed
+ * @example
+ * export const useUserStore = createStore(({ createState }) => {
+ *   const user = createState(null);
+ *   return { user };
+ * });
+ */
+export function createStore(factory, inject) {
+    const cacheKey = AutoKeyGenerator.generate(factory);
+    return createUiProvider(cacheKey, factory, (key) => {
+        let stateCounter = 0;
+        return {
+            createState: (initial) => {
+                const stateKey = `${key}::state::${stateCounter++}`;
+                const initFn = typeof initial === 'function' ? initial : () => initial;
+                return BaseCreateState(stateKey, initFn);
+            },
+            createRawState: (initial) => {
+                const stateKey = `${key}::rawstate::${stateCounter++}`;
+                const initFn = typeof initial === 'function' ? initial : () => initial;
+                return BaseCreateRawState(stateKey, initFn);
+            },
+            createDerivedState: BaseCreateDerivedState
+        };
+    }, inject);
+}
+// Creates store with nmame
+export function createNamedStore(name, factory, inject) {
     return createUiProvider(name, factory, (cacheKey) => {
         let stateCounter = 0;
         return {
@@ -64,17 +124,33 @@ export const createStore = (name, factory, inject) => {
             createDerivedState: BaseCreateDerivedState
         };
     }, inject);
-};
+}
+/**
+ * Store factory
+ */
 export const createStoreFactory = (inject) => {
-    return function createInjectedStore(name, factory) {
-        return createStore(name, factory, inject);
+    return function (factory) {
+        return createStore(factory, inject);
     };
 };
-export const createPresenter = (name, factory, inject) => {
+/**
+ * Presenter without name needed
+ */
+export function createPresenter(factory, inject) {
+    const cacheKey = AutoKeyGenerator.generate(factory);
+    return createUiProvider(cacheKey, factory, {}, inject);
+}
+/**
+ * Named presenter
+ */
+export function createNamedPresenter(name, factory, inject) {
     return createUiProvider(name, factory, {}, inject);
-};
+}
+/**
+ * Presenter factory
+ */
 export const createPresenterFactory = (inject) => {
-    return function createInjectedStore(name, factory) {
-        return createPresenter(name, factory, inject);
+    return function (factory) {
+        return createPresenter(factory, inject);
     };
 };

package/dist/server/EdgesHandle.d.ts

@@ -4,15 +4,7 @@ type EdgesHandle = (event: RequestEvent, callback: (params: {
     serialize: (html: string) => string;
 }) => Promise<Response> | Response, silentChromeDevtools?: boolean) => Promise<Response>;
 /**
- * Wraps request handling in an AsyncLocalStorage context and provides a `serialize` function
- * for injecting state into the HTML response.
- *
- * @param event - The SvelteKit RequestEvent for the current request.
- * @param callback - A function that receives the event and a serialize function,
- *   and returns a Response or a Promise of one.
- * @param silentChromeDevtools - If true, intercepts requests to
- *   `/.well-known/appspecific/com.chrome.devtools.json` (triggered by Chrome DevTools)
- *   and returns a 204 No Content response instead of a 404 error.
+ * Wraps request handling in an AsyncLocalStorage context
  */
 export declare const edgesHandle: EdgesHandle;
 export {};

package/dist/server/EdgesHandle.js

@@ -1,21 +1,32 @@
 import { stateSerialize, getStateMap } from '../store/State.svelte.js';
-import { AsyncLocalStorage } from 'async_hooks';
+import { AsyncLocalStorage } from 'node:async_hooks';
 import RequestContext, {} from '../context/Context.js';
 const storage = new AsyncLocalStorage();
 const textEncoder = new TextEncoder();
+// Маркеры для специальных значений
+const UNDEFINED_MARKER = '__EDGES_UNDEFINED__';
+const NULL_MARKER = '__EDGES_NULL__';
+// Безопасный replacer для JSON
+const safeReplacer = (key, value) => {
+    if (value === undefined) {
+        return { [UNDEFINED_MARKER]: true };
+    }
+    if (value === null) {
+        return { [NULL_MARKER]: true };
+    }
+    return value;
+};
 /**
- * Wraps request handling in an AsyncLocalStorage context and provides a `serialize` function
- * for injecting state into the HTML response.
- *
- * @param event - The SvelteKit RequestEvent for the current request.
- * @param callback - A function that receives the event and a serialize function,
- *   and returns a Response or a Promise of one.
- * @param silentChromeDevtools - If true, intercepts requests to
- *   `/.well-known/appspecific/com.chrome.devtools.json` (triggered by Chrome DevTools)
- *   and returns a 204 No Content response instead of a 404 error.
+ * Wraps request handling in an AsyncLocalStorage context
  */
 export const edgesHandle = async (event, callback, silentChromeDevtools = false) => {
-    return await storage.run({ event: event, symbol: Symbol(), data: { providers: new Map() } }, async () => {
+    const requestSymbol = Symbol('request');
+    return await storage.run({
+        event: event,
+        symbol: requestSymbol,
+        data: { providers: new Map() }
+    }, async () => {
+        // Настраиваем RequestContext
         RequestContext.current = () => {
             const context = storage.getStore();
             if (context === undefined) {
@@ -31,33 +42,46 @@ export const edgesHandle = async (event, callback, silentChromeDevtools = false)
             }
             return context;
         };
+        // Chrome DevTools handling
         if (silentChromeDevtools && event.url.pathname === '/.well-known/appspecific/com.chrome.devtools.json') {
             return new Response(null, { status: 204 });
         }
+        // Выполняем основной callback
         const response = await callback({
             edgesEvent: event,
             serialize: (html) => {
                 if (!html)
                     return html ?? '';
-                return html.replace('</body>', `${stateSerialize()}</body>`);
+                // Вставляем сериализованное состояние перед </body>
+                const serialized = stateSerialize();
+                if (!serialized)
+                    return html;
+                return html.replace('</body>', `${serialized}</body>`);
             }
         });
+        // Проверяем, нужно ли инжектить состояние в JSON
         const contentType = response.headers.get('content-type');
         if (contentType?.includes('application/json')) {
-            try {
-                const clonedResponse = response.clone();
-                const json = await clonedResponse.json();
-                const stateMap = getStateMap();
-                if (stateMap && stateMap.size > 0) {
+            const stateMap = getStateMap();
+            // Если есть состояние для передачи
+            if (stateMap && stateMap.size > 0) {
+                try {
+                    // Клонируем response для чтения
+                    const clonedResponse = response.clone();
+                    const json = await clonedResponse.json();
+                    // Подготавливаем состояние для передачи
                     const stateObj = {};
                     for (const [key, value] of stateMap) {
-                        stateObj[key] = value;
+                        // Сериализуем каждое значение отдельно с поддержкой undefined
+                        stateObj[key] = JSON.stringify(value, safeReplacer);
                     }
+                    // Добавляем состояние в JSON
                     const modifiedJson = {
                         ...json,
                         __edges_state__: stateObj
                     };
                     const modifiedBody = JSON.stringify(modifiedJson);
+                    // Создаем новые заголовки с правильной длиной
                     const newHeaders = new Headers(response.headers);
                     newHeaders.set('content-length', String(textEncoder.encode(modifiedBody).length));
                     return new Response(modifiedBody, {
@@ -66,9 +90,11 @@ export const edgesHandle = async (event, callback, silentChromeDevtools = false)
                         headers: newHeaders
                     });
                 }
-            }
-            catch {
-                // Failed to inject state - return original response
+                catch (e) {
+                    console.error('[edges] Failed to inject state into JSON response:', e);
+                    // При ошибке возвращаем оригинальный response
+                    return response;
+                }
             }
         }
         return response;

package/dist/store/State.svelte.js

@@ -1,21 +1,49 @@
 import RequestContext from '../context/Context.js';
-import { uneval } from 'devalue';
 import { browser } from '$app/environment';
 import { derived, writable } from 'svelte/store';
 import { registerStateUpdate } from '../client/NavigationSync.svelte.js';
 const RequestStores = new WeakMap();
+const UNDEFINED_MARKER = '__EDGES_UNDEFINED__';
+const NULL_MARKER = '__EDGES_NULL__';
+const safeReplacer = (key, value) => {
+    if (value === undefined) {
+        return { [UNDEFINED_MARKER]: true };
+    }
+    if (value === null) {
+        return { [NULL_MARKER]: true };
+    }
+    if (typeof value === 'function' || typeof value === 'symbol') {
+        return undefined;
+    }
+    return value;
+};
+// const safeReviver = (key: string, value: unknown): unknown => {
+// 	if (value && typeof value === 'object') {
+// 		if (UNDEFINED_MARKER in value) {
+// 			return undefined;
+// 		}
+// 		if (NULL_MARKER in value) {
+// 			return null;
+// 		}
+// 	}
+// 	return value;
+// };
 export const stateSerialize = () => {
     const map = getRequestContext();
     if (!map || map.size === 0)
         return '';
     const entries = [];
     for (const [key, value] of map) {
-        entries.push(`window.__SAFE_SSR_STATE__.set(${uneval(key)},${uneval(value)})`);
+        const serialized = JSON.stringify(value, safeReplacer);
+        const escaped = serialized.replace(/'/g, "\\'").replace(/\\/g, '\\\\');
+        entries.push(`window.__SAFE_SSR_STATE__.set('${key}',JSON.parse('${escaped}',window.__EDGES_REVIVER__))`);
     }
-    return `<script>window.__SAFE_SSR_STATE__=new Map();${entries.join(';')}</script>`;
+    const reviverCode = `window.__EDGES_REVIVER__=function(k,v){if(v&&typeof v==='object'){if('${UNDEFINED_MARKER}' in v)return undefined;if('${NULL_MARKER}' in v)return null}return v};`;
+    return `<script>${reviverCode}window.__SAFE_SSR_STATE__=new Map();${entries.join(';')}</script>`;
 };
 const getRequestContext = () => {
-    const sym = RequestContext.current().symbol;
+    const context = RequestContext.current();
+    const sym = context.symbol;
     if (sym) {
         if (!RequestStores.has(sym)) {
             RequestStores.set(sym, new Map());
@@ -32,9 +60,13 @@ export const getStateMap = () => {
     }
 };
 const getBrowserState = (key, initial) => {
-    const state = window.__SAFE_SSR_STATE__?.get(key);
-    if (state)
+    if (!window.__SAFE_SSR_STATE__) {
+        return initial;
+    }
+    const state = window.__SAFE_SSR_STATE__.get(key);
+    if (window.__SAFE_SSR_STATE__.has(key)) {
         return state;
+    }
     return initial;
 };
 export const createRawState = (key, initial) => {
@@ -44,45 +76,90 @@ export const createRawState = (key, initial) => {
             state = newValue;
         };
         registerStateUpdate(key, callback);
+        const updateWindowState = (val) => {
+            if (!window.__SAFE_SSR_STATE__) {
+                window.__SAFE_SSR_STATE__ = new Map();
+            }
+            window.__SAFE_SSR_STATE__.set(key, val);
+        };
         return {
             get value() {
                 return state;
             },
             set value(val) {
                 state = val;
+                updateWindowState(val);
             }
         };
     }
     const map = getRequestContext();
+    if (!map) {
+        const val = initial();
+        return {
+            get value() {
+                return val;
+            },
+            set value(_) {
+                /* noop */
+            }
+        };
+    }
     return {
         get value() {
-            if (!map)
-                return initial();
-            if (!map.has(key))
-                map.set(key, structuredClone(initial()));
+            if (!map.has(key)) {
+                map.set(key, initial());
+            }
             return map.get(key);
         },
         set value(val) {
-            if (map) {
-                map.set(key, val);
-            }
+            map.set(key, val);
         }
     };
 };
 export const createState = (key, initial) => {
     if (browser) {
-        const state = writable(getBrowserState(key, initial()));
+        const initialValue = getBrowserState(key, initial());
+        const state = writable(initialValue);
         const callback = (newValue) => {
             state.set(newValue);
         };
         registerStateUpdate(key, callback);
+        const originalSet = state.set;
+        const originalUpdate = state.update;
+        state.set = (value) => {
+            originalSet(value);
+            if (!window.__SAFE_SSR_STATE__) {
+                window.__SAFE_SSR_STATE__ = new Map();
+            }
+            window.__SAFE_SSR_STATE__.set(key, value);
+        };
+        state.update = (updater) => {
+            originalUpdate((current) => {
+                const newValue = updater(current);
+                if (!window.__SAFE_SSR_STATE__) {
+                    window.__SAFE_SSR_STATE__ = new Map();
+                }
+                window.__SAFE_SSR_STATE__.set(key, newValue);
+                return newValue;
+            });
+        };
         return state;
     }
     const map = getRequestContext();
-    if (!map)
-        throw new Error('No RequestContext available');
-    if (!map.has(key))
-        map.set(key, structuredClone(initial()));
+    if (!map) {
+        const val = initial();
+        return {
+            subscribe(run) {
+                run(val);
+                return () => { };
+            },
+            set() { },
+            update() { }
+        };
+    }
+    if (!map.has(key)) {
+        map.set(key, initial());
+    }
     return {
         subscribe(run) {
             run(map.get(key));
@@ -95,7 +172,6 @@ export const createState = (key, initial) => {
             const oldVal = map.get(key);
             const newVal = updater(oldVal);
             map.set(key, newVal);
-            //subscribers.forEach((fn) => fn(newVal));
         }
     };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "edges-svelte",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "license": "MIT",
   "author": "Pixel1917",
   "description": "A blazing-fast, extremely lightweight and SSR-friendly store for Svelte",
@@ -37,10 +37,6 @@
       "types": "./dist/server/index.d.ts",
       "svelte": "./dist/server/index.js"
     },
-    "./client": {
-      "types": "./dist/client/index.d.ts",
-      "svelte": "./dist/client/index.js"
-    },
     "./context": {
       "types": "./dist/context/index.d.ts",
       "svelte": "./dist/context/index.js"

package/dist/client/index.d.ts

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

package/dist/client/index.js

@@ -1 +0,0 @@
-"use strict";