npm - edges-svelte - Versions diffs - 2.2.0 → 2.2.1 - Mend

edges-svelte 2.2.0 → 2.2.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (20) hide show

package/README.md +1 -1
package/dist/client/NavigationSync.svelte.js +1 -8
package/dist/plugin/EdgesAutoHandlePlugin.d.ts +0 -62
package/dist/plugin/EdgesAutoHandlePlugin.js +1 -64
package/dist/provider/Provider.d.ts +0 -38
package/dist/provider/Provider.js +3 -21
package/dist/server/AutoWrapHandle.js +0 -4
package/dist/server/EdgesHandle.d.ts +0 -3
package/dist/server/EdgesHandle.js +0 -4
package/dist/server/EdgesHandleSimplified.d.ts +0 -8
package/dist/server/EdgesHandleSimplified.js +0 -8
package/dist/store/State.svelte.js +0 -17
package/dist/types.d.ts +0 -80
package/dist/utils/batch.d.ts +0 -21
package/dist/utils/batch.js +0 -40
package/dist/utils/dev.d.ts +0 -21
package/dist/utils/dev.js +2 -29
package/dist/utils/environment.d.ts +0 -4
package/dist/utils/environment.js +0 -4
package/package.json +1 -4

package/README.md CHANGED Viewed

@@ -130,7 +130,7 @@ const doubled = createDerivedState([count], ([$n]) => $n * 2);
 $doubled;
 ```
-> Like Svelte’s `derived`.
+> Like Svelte’s `derived`. On the server side will not subscribe to store like derived, just reads initial value, on client side works like derived.
 ---

package/dist/client/NavigationSync.svelte.js CHANGED Viewed

@@ -159,18 +159,13 @@ if (browser) {
         return interceptEdgesStateFromResponse(response);
     };
     if (typeof MutationObserver !== 'undefined') {
-        // Optimized: Only observe <body> instead of entire document tree
-        // This reduces CPU usage by 30-50% on pages with frequent DOM updates
         const observer = new MutationObserver((mutations) => {
             for (const mutation of mutations) {
                 if (mutation.type === 'childList') {
                     for (const node of mutation.addedNodes) {
-                        // Filter early: only process script elements
                         if (node instanceof HTMLScriptElement) {
                             const text = node.textContent || '';
-                            // Quick check for our state markers
                             if (text.includes('__SAFE_SSR_STATE__') && text.includes('__EDGES_REVIVER__')) {
-                                // Use microtask instead of setTimeout(0) for better performance
                                 queueMicrotask(() => {
                                     if (window.__SAFE_SSR_STATE__) {
                                         for (const [key, value] of window.__SAFE_SSR_STATE__) {
@@ -187,11 +182,9 @@ if (browser) {
                 }
             }
         });
-        // Optimized: Observe only <body> with subtree: false to reduce overhead
-        // State scripts are always injected into body, not head
         observer.observe(document.body || document.documentElement, {
             childList: true,
-            subtree: false // Only direct children, not entire subtree
+            subtree: false
         });
         if (typeof window !== 'undefined') {
             window.addEventListener('beforeunload', () => observer.disconnect());

package/dist/plugin/EdgesAutoHandlePlugin.d.ts CHANGED Viewed

@@ -1,24 +1,9 @@
 import type { Plugin } from 'vite';
 export interface EdgesPluginOptions {
-    /**
-     * State compression options
-     */
     compression?: {
-        /**
-         * Enable compression for large state objects
-         * @default false
-         */
         enabled?: boolean;
-        /**
-         * Minimum size in bytes before compression is applied
-         * @default 1024 (1KB)
-         */
         threshold?: number;
     };
-    /**
-     * Silence Chrome DevTools requests
-     * @default true
-     */
     silentChromeDevtools?: boolean;
 }
 /**
@@ -26,7 +11,6 @@ export interface EdgesPluginOptions {
  *
  * Use this when:
  * - Creating a wrapper package that re-exports edges-svelte functionality
- * - Developing the package itself (use `$lib/server` as serverPath)
  *
  * @param packageName - The name that will be used in generated imports (e.g., 'edges-svelte', 'my-wrapper')
  * @param serverPath - The import path to the server module (e.g., 'edges-svelte/server', '$lib/server')
@@ -38,25 +22,11 @@ export interface EdgesPluginOptions {
  *
  * export const myWrapperPlugin = createEdgesPluginFactory('my-wrapper', 'my-wrapper/server');
  * ```
- *
- * @example
- * ```ts
- * // For package development (testing the package itself)
- * import { createEdgesPluginFactory } from './src/lib/plugin/index.js';
- *
- * const edgesPluginDev = createEdgesPluginFactory('edges-svelte', '$lib/server');
- *
- * export default defineConfig({
- *   plugins: [sveltekit(), edgesPluginDev()]
- * });
- * ```
  */
 export declare function createEdgesPluginFactory(packageName: string, serverPath: string): (options?: EdgesPluginOptions) => Plugin;
 /**
- * Default edges-svelte plugin for end users.
  *
  * This plugin automatically wraps the SvelteKit handle hook with edgesHandle,
- * eliminating the need to manually wrap your handle function.
  *
  * @example
  * ```ts
@@ -69,37 +39,5 @@ export declare function createEdgesPluginFactory(packageName: string, serverPath
  *   plugins: [sveltekit(), edgesPlugin()]
  * });
  * ```
- *
- * @example
- * ```ts
- * // vite.config.ts - With compression
- * export default defineConfig({
- *   plugins: [
- *     sveltekit(),
- *     edgesPlugin({
- *       compression: {
- *         enabled: true,
- *         threshold: 2048  // Compress states larger than 2KB
- *       }
- *     })
- *   ]
- * });
- * ```
- *
- * After adding the plugin, you can write your hooks.server.ts normally:
- *
- * @example
- * ```ts
- * // hooks.server.ts - No manual wrapping needed!
- *
- * // Option 1: No handle defined - plugin creates default
- * // (nothing to write, it just works)
- *
- * // Option 2: Custom handle - plugin automatically wraps it
- * export const handle = async ({ event, resolve }) => {
- *   console.log('My custom middleware');
- *   return resolve(event);
- * };
- * ```
  */
 export declare const edgesPlugin: (options?: EdgesPluginOptions) => Plugin;

package/dist/plugin/EdgesAutoHandlePlugin.js CHANGED Viewed

@@ -3,7 +3,6 @@
  *
  * Use this when:
  * - Creating a wrapper package that re-exports edges-svelte functionality
- * - Developing the package itself (use `$lib/server` as serverPath)
  *
  * @param packageName - The name that will be used in generated imports (e.g., 'edges-svelte', 'my-wrapper')
  * @param serverPath - The import path to the server module (e.g., 'edges-svelte/server', '$lib/server')
@@ -15,18 +14,6 @@
  *
  * export const myWrapperPlugin = createEdgesPluginFactory('my-wrapper', 'my-wrapper/server');
  * ```
- *
- * @example
- * ```ts
- * // For package development (testing the package itself)
- * import { createEdgesPluginFactory } from './src/lib/plugin/index.js';
- *
- * const edgesPluginDev = createEdgesPluginFactory('edges-svelte', '$lib/server');
- *
- * export default defineConfig({
- *   plugins: [sveltekit(), edgesPluginDev()]
- * });
- * ```
  */
 export function createEdgesPluginFactory(packageName, serverPath) {
     // Compile regex patterns once per factory (performance optimization)
@@ -37,46 +24,31 @@ export function createEdgesPluginFactory(packageName, serverPath) {
         const { compression = {}, silentChromeDevtools = true } = options || {};
         return {
             name: `${packageName}-auto-handle`,
-            enforce: 'pre', // Run before SvelteKit
+            enforce: 'pre',
             transform(code, id) {
-                // Only transform hooks.server.ts
                 if (!id.includes('hooks.server.ts'))
                     return null;
-                // If already wrapped by the plugin, skip
                 if (code.includes('__EDGES_AUTO_WRAPPED__'))
                     return null;
-                // If user is manually using the package, skip auto-wrapping
-                // Optimized: Use pre-compiled regex pattern
                 if (MANUAL_IMPORT_PATTERN.test(code)) {
                     return null;
                 }
-                // Check if user defined a handle export
-                // Optimized: Use pre-compiled regex pattern
                 const hasHandleExport = HANDLE_EXPORT_PATTERN.test(code);
-                // Build compression options string
                 const compressionOptions = compression.enabled ? `, { compress: true, compressionThreshold: ${compression.threshold || 1024} }` : '';
-                // Build silent devtools option
                 const silentOption = silentChromeDevtools ? '' : `, false`;
-                // Find the position after the last import statement to preserve import order
-                // Optimized: Use regex instead of line-by-line parsing for 20x performance improvement
                 const findImportInsertPosition = (sourceCode) => {
-                    // Match all import/export statements
                     const importRegex = /(?:^|\n)((?:import|export)\s+(?:type\s+)?(?:\{[^}]*\}|\*|\w+)(?:\s+from)?\s+['"][^'"]+['"];?)/gm;
                     let lastMatch = null;
                     let match;
-                    // Find the last import/export statement
                     while ((match = importRegex.exec(sourceCode)) !== null) {
                         lastMatch = match;
                     }
                     if (!lastMatch) {
-                        // No imports found, insert at the beginning
                         return 0;
                     }
-                    // Return position after the last import
                     return lastMatch.index + lastMatch[0].length;
                 };
                 if (!hasHandleExport) {
-                    // No handle defined - create default with compression options
                     const insertPos = findImportInsertPosition(code);
                     const beforeImports = code.slice(0, insertPos);
                     const afterImports = code.slice(insertPos);
@@ -91,7 +63,6 @@ export function createEdgesPluginFactory(packageName, serverPath) {
                         map: null
                     };
                 }
-                // User defined a handle - wrap it with options
                 const insertPos = findImportInsertPosition(code);
                 const beforeImports = code.slice(0, insertPos);
                 const afterImports = code.slice(insertPos);
@@ -112,10 +83,8 @@ export function createEdgesPluginFactory(packageName, serverPath) {
     };
 }
 /**
- * Default edges-svelte plugin for end users.
  *
  * This plugin automatically wraps the SvelteKit handle hook with edgesHandle,
- * eliminating the need to manually wrap your handle function.
  *
  * @example
  * ```ts
@@ -128,37 +97,5 @@ export function createEdgesPluginFactory(packageName, serverPath) {
  *   plugins: [sveltekit(), edgesPlugin()]
  * });
  * ```
- *
- * @example
- * ```ts
- * // vite.config.ts - With compression
- * export default defineConfig({
- *   plugins: [
- *     sveltekit(),
- *     edgesPlugin({
- *       compression: {
- *         enabled: true,
- *         threshold: 2048  // Compress states larger than 2KB
- *       }
- *     })
- *   ]
- * });
- * ```
- *
- * After adding the plugin, you can write your hooks.server.ts normally:
- *
- * @example
- * ```ts
- * // hooks.server.ts - No manual wrapping needed!
- *
- * // Option 1: No handle defined - plugin creates default
- * // (nothing to write, it just works)
- *
- * // Option 2: Custom handle - plugin automatically wraps it
- * export const handle = async ({ event, resolve }) => {
- *   console.log('My custom middleware');
- *   return resolve(event);
- * };
- * ```
  */
 export const edgesPlugin = createEdgesPluginFactory('edges-svelte', 'edges-svelte/server');

package/dist/provider/Provider.d.ts CHANGED Viewed

@@ -11,52 +11,14 @@ type StoreDeps = {
     createState: <T>(initial: T | (() => T)) => Writable<T>;
     createDerivedState: typeof BaseCreateDerivedState;
 };
-/**
- * Creates store with optional name
- * @example
- * // Without key (auto-generated)
- * export const useUserStore = createStore(({ createState }) => {
- *   const user = createState(null);
- *   return { user };
- * });
- *
- * @example
- * // With explicit key (recommended for production)
- * export const useUserStore = createStore('user-store', ({ 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 createStore<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;
     <T>(name: string, factory: (args: StoreDeps & NoConflict<I, StoreDeps>) => T): () => T;
 };
-/**
- * Creates presenter with optional name
- * @example
- * // Without key (auto-generated)
- * export const useAuthPresenter = createPresenter(() => {
- *   const login = async () => { ... };
- *   return { login };
- * });
- *
- * @example
- * // With explicit key
- * export const useAuthPresenter = createPresenter('auth-presenter', () => {
- *   const login = async () => { ... };
- *   return { login };
- * });
- */
 export declare function createPresenter<T, I extends Record<string, unknown> = Record<string, unknown>>(factory: (args: I) => T, inject?: I): () => T;
 export declare function createPresenter<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;
     <T>(name: string, factory: (args: I) => T): () => T;

package/dist/provider/Provider.js CHANGED Viewed

@@ -2,9 +2,7 @@ import { createState as BaseCreateState, createDerivedState as BaseCreateDerived
 import { RequestContext } from '../context/index.js';
 import { browser } from '../utils/environment.js';
 import { DevTools } from '../utils/dev.js';
-// Global client cache
 const globalClientCache = new Map();
-// Key auto-generate
 class AutoKeyGenerator {
     static cache = new WeakMap();
     static counters = new Map();
@@ -30,9 +28,6 @@ class AutoKeyGenerator {
         }
         if (cache.has(factory))
             return cache.get(factory);
-        // Use multiple sources for stable key generation
-        // Priority: displayName > name > toString
-        // This ensures stability even with minification
         const fnIdentifier = factory.__storeKey__ || factory.displayName || factory.name || factory.toString();
         const hash = this.hash(fnIdentifier);
         const baseKey = `store_${Math.abs(hash).toString(36)}`;
@@ -46,17 +41,14 @@ class AutoKeyGenerator {
             counters.set(baseKey, 0);
         }
         cache.set(factory, finalKey);
-        // Dev mode validation
         DevTools.validateFactoryUniqueness(factory, finalKey);
         return finalKey;
     }
     static hash(str) {
-        // FNV-1a hash algorithm - better distribution than simple sum hash
-        // Provides 50% fewer collisions for typical factory names
-        let hash = 2166136261; // FNV offset basis (32-bit)
+        let hash = 2166136261;
         for (let i = 0; i < str.length; i++) {
-            hash = (hash ^ str.charCodeAt(i)) * 16777619; // FNV prime
-            hash = hash >>> 0; // Convert to unsigned 32-bit integer
+            hash = (hash ^ str.charCodeAt(i)) * 16777619;
+            hash = hash >>> 0;
         }
         return hash;
     }
@@ -109,12 +101,10 @@ const createUiProvider = (cacheKey, factory, dependencies, inject) => {
     };
 };
 export function createStore(nameOrFactory, factoryOrInject, inject) {
-    // Handle overloads
     const isNameProvided = typeof nameOrFactory === 'string';
     const name = isNameProvided ? nameOrFactory : undefined;
     const factory = isNameProvided ? factoryOrInject : nameOrFactory;
     const injections = isNameProvided ? inject : factoryOrInject;
-    // Use provided name or auto-generate
     const cacheKey = name || AutoKeyGenerator.generate(factory);
     return createUiProvider(cacheKey, factory, (key) => {
         let stateCounter = 0;
@@ -133,9 +123,6 @@ export function createStore(nameOrFactory, factoryOrInject, inject) {
         };
     }, injections);
 }
-/**
- * Store factory
- */
 export const createStoreFactory = (inject) => {
     function storeFactory(nameOrFactory, factory) {
         if (typeof nameOrFactory === 'string') {
@@ -148,18 +135,13 @@ export const createStoreFactory = (inject) => {
     return storeFactory;
 };
 export function createPresenter(nameOrFactory, factoryOrInject, inject) {
-    // Handle overloads
     const isNameProvided = typeof nameOrFactory === 'string';
     const name = isNameProvided ? nameOrFactory : undefined;
     const factory = isNameProvided ? factoryOrInject : nameOrFactory;
     const injections = isNameProvided ? inject : factoryOrInject;
-    // Use provided name or auto-generate
     const cacheKey = name || AutoKeyGenerator.generate(factory);
     return createUiProvider(cacheKey, factory, {}, injections);
 }
-/**
- * Presenter factory
- */
 export const createPresenterFactory = (inject) => {
     function presenterFactory(nameOrFactory, factory) {
         if (typeof nameOrFactory === 'string') {

package/dist/server/AutoWrapHandle.js CHANGED Viewed

@@ -12,21 +12,17 @@ import { edgesHandle } from './EdgesHandleSimplified.js';
  */
 export function __autoWrapHandle(userHandle, compressionOptions, silentChromeDevtools = true) {
     if (!userHandle) {
-        // No user handle - return default edgesHandle with compression options
         return edgesHandle(({ serialize, edgesEvent, resolve }) => resolve(edgesEvent, {
             transformPageChunk: ({ html }) => serialize(html, compressionOptions)
         }), silentChromeDevtools);
     }
-    // Wrap user's handle with edgesHandle
     return edgesHandle(({ serialize, edgesEvent, resolve }) => {
         return userHandle({
             event: edgesEvent,
             resolve: (e, opts) => resolve(e, {
                 ...opts,
                 transformPageChunk: ({ html, done }) => {
-                    // Apply user's transform first (if any)
                     const userTransformed = opts?.transformPageChunk?.({ html, done }) ?? html;
-                    // Then apply edges serialization with compression options
                     return typeof userTransformed === 'string' ? serialize(userTransformed, compressionOptions) : userTransformed;
                 }
             })

package/dist/server/EdgesHandle.d.ts CHANGED Viewed

@@ -7,8 +7,5 @@ type EdgesHandle = (event: RequestEvent, callback: (params: {
     edgesEvent: RequestEvent;
     serialize: (html: string, options?: SerializeOptions) => string;
 }) => Promise<Response> | Response, silentChromeDevtools?: boolean) => Promise<Response>;
-/**
- * Wraps request handling in an AsyncLocalStorage context
- */
 export declare const edgesHandle: EdgesHandle;
 export {};

package/dist/server/EdgesHandle.js CHANGED Viewed

@@ -14,9 +14,6 @@ const safeReplacer = (key, value) => {
     }
     return value;
 };
-/**
- * Wraps request handling in an AsyncLocalStorage context
- */
 export const edgesHandle = async (event, callback, silentChromeDevtools = false) => {
     const requestSymbol = Symbol('request');
     return await storage.run({
@@ -89,7 +86,6 @@ export const edgesHandle = async (event, callback, silentChromeDevtools = false)
                 }
                 catch (e) {
                     console.error('[edges] Failed to inject state into JSON response:', e);
-                    // Original response
                     return response;
                 }
             }

package/dist/server/EdgesHandleSimplified.d.ts CHANGED Viewed

@@ -9,16 +9,8 @@ type SimplifiedCallback = (params: {
     resolve: (event: RequestEvent, opts?: ResolveOptions) => Response | Promise<Response>;
 }) => Response | Promise<Response>;
 /**
- * Simplified wrapper around edgesHandle that provides a more convenient API.
- *
  * @example
  * ```ts
- * // Simple usage with default behavior
- * export const handle = edgesHandle(({ serialize, edgesEvent, resolve }) =>
- *   resolve(edgesEvent, { transformPageChunk: ({ html }) => serialize(html) })
- * );
- *
- * // You can still access resolve for custom logic
  * export const handle = edgesHandle(({ serialize, edgesEvent, resolve }) => {
  *   // Custom logic here
  *   return resolve(edgesEvent, { transformPageChunk: ({ html }) => serialize(html) });

package/dist/server/EdgesHandleSimplified.js CHANGED Viewed

@@ -1,15 +1,7 @@
 import { edgesHandle as originalEdgesHandle } from './EdgesHandle.js';
 /**
- * Simplified wrapper around edgesHandle that provides a more convenient API.
- *
  * @example
  * ```ts
- * // Simple usage with default behavior
- * export const handle = edgesHandle(({ serialize, edgesEvent, resolve }) =>
- *   resolve(edgesEvent, { transformPageChunk: ({ html }) => serialize(html) })
- * );
- *
- * // You can still access resolve for custom logic
  * export const handle = edgesHandle(({ serialize, edgesEvent, resolve }) => {
  *   // Custom logic here
  *   return resolve(edgesEvent, { transformPageChunk: ({ html }) => serialize(html) });

package/dist/store/State.svelte.js CHANGED Viewed

@@ -5,7 +5,6 @@ import { registerStateUpdate } from '../client/NavigationSync.svelte.js';
 const RequestStores = new WeakMap();
 const UNDEFINED_MARKER = '__EDGES_UNDEFINED__';
 const NULL_MARKER = '__EDGES_NULL__';
-// Pre-compiled reviver code for better performance (cached once instead of regenerated per request)
 const REVIVER_CODE = `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};`;
 const safeReplacer = (key, value) => {
     if (value === undefined) {
@@ -19,17 +18,6 @@ const safeReplacer = (key, value) => {
     }
     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 = (options) => {
     const map = getRequestContext();
     if (!map || map.size === 0)
@@ -39,10 +27,7 @@ export const stateSerialize = (options) => {
     const threshold = options?.threshold ?? 1024; // 1KB default
     for (const [key, value] of map) {
         const serialized = JSON.stringify(value, safeReplacer);
-        // Check if we should compress this entry
         if (shouldCompress && serialized.length > threshold) {
-            // For large values, use base64 encoding as a simple compression
-            // Optimized: Use Array.from instead of reduce for 10x performance improvement
             const bytes = new TextEncoder().encode(serialized);
             const binary = Array.from(bytes, (byte) => String.fromCharCode(byte)).join('');
             const encoded = btoa(binary);
@@ -55,12 +40,10 @@ export const stateSerialize = (options) => {
 			}`);
         }
         else {
-            // Optimized: Single-pass escape instead of two separate replace calls
             const escaped = serialized.replace(/[\\']/g, (ch) => '\\' + ch);
             entries.push(`window.__SAFE_SSR_STATE__.set('${key}',JSON.parse('${escaped}',window.__EDGES_REVIVER__))`);
         }
     }
-    // Use pre-compiled reviver code for better performance
     return `<script>${REVIVER_CODE}window.__SAFE_SSR_STATE__=new Map();${entries.join(';')}</script>`;
 };
 const getRequestContext = () => {

package/dist/types.d.ts CHANGED Viewed

@@ -1,25 +1,8 @@
 import type { Writable, Readable } from 'svelte/store';
-/**
- * Configuration for store creation with minification resistance
- */
 export interface StoreConfig {
-    /**
-     * Explicit key for the store to avoid minification issues
-     * @example
-     * ```ts
-     * const factory = (deps) => { ... };
-     * factory.__storeKey__ = 'userStore';
-     * ```
-     */
     __storeKey__?: string;
-    /**
-     * Display name for debugging
-     */
     displayName?: string;
 }
-/**
- * Store factory function with configuration
- */
 export type StoreFactory<T, I = Record<string, unknown>> = ((args: {
     createState: <T>(initial: T | (() => T)) => Writable<T>;
     createRawState: <T>(initial: T | (() => T)) => {
@@ -27,89 +10,26 @@ export type StoreFactory<T, I = Record<string, unknown>> = ((args: {
     };
     createDerivedState: <T extends Readable<unknown>[], D>(stores: T, deriveFn: (values: unknown[]) => D) => Readable<D>;
 } & I) => T) & StoreConfig;
-/**
- * Presenter factory function with configuration
- */
 export type PresenterFactory<T, I = Record<string, unknown>> = ((args: I) => T) & StoreConfig;
-/**
- * Options for batched state updates
- */
 export interface BatchOptions {
-    /**
-     * Whether to defer DOM updates to the next microtask
-     * @default true
-     */
     defer?: boolean;
-    /**
-     * Callback when batch completes
-     */
     onComplete?: () => void;
 }
-/**
- * Compression options for state serialization
- */
 export interface CompressionOptions {
-    /**
-     * Enable compression for large state objects
-     * @default false
-     */
     enabled?: boolean;
-    /**
-     * Minimum size in bytes before compression is applied
-     * @default 1024 (1KB)
-     */
     threshold?: number;
-    /**
-     * Compression algorithm to use
-     * @default 'base64'
-     */
     algorithm?: 'base64' | 'gzip' | 'brotli';
 }
-/**
- * Development tools configuration
- */
 export interface DevToolsConfig {
-    /**
-     * Enable development mode validations
-     * @default true in dev, false in production
-     */
     enabled?: boolean;
-    /**
-     * Warn about large state objects
-     * @default true
-     */
     warnLargeState?: boolean;
-    /**
-     * Size threshold for large state warnings (in bytes)
-     * @default 50000 (50KB)
-     */
     largeStateThreshold?: number;
-    /**
-     * Check for direct state mutations
-     * @default true
-     */
     checkMutations?: boolean;
-    /**
-     * Log performance metrics
-     * @default false
-     */
     logPerformance?: boolean;
 }
-/**
- * Global configuration for edges-svelte
- */
 export interface EdgesConfig {
-    /**
-     * Development tools configuration
-     */
     devTools?: DevToolsConfig;
-    /**
-     * Default compression options for state serialization
-     */
     compression?: CompressionOptions;
-    /**
-     * Default batch options
-     */
     batch?: BatchOptions;
 }
 export type UnknownFunc = {

package/dist/utils/batch.d.ts CHANGED Viewed

@@ -1,25 +1,4 @@
-/**
- * Batch multiple state updates to avoid unnecessary re-renders
- *
- * @example
- * ```ts
- * batch(() => {
- *   store1.set(value1);
- *   store2.set(value2);
- *   store3.set(value3);
- * });
- * ```
- */
 export declare const batch: (fn: () => void) => void;
-/**
- * Queue an update for batching (internal use)
- */
 export declare const queueUpdate: (key: string, value: unknown, callback?: (value: unknown) => void) => void;
-/**
- * Register a callback for batch completion (internal use)
- */
 export declare const onBatchComplete: (callback: () => void) => void;
-/**
- * Transaction-like API for complex state updates
- */
 export declare const transaction: <T>(fn: () => Promise<T>) => Promise<T>;

package/dist/utils/batch.js CHANGED Viewed

@@ -3,16 +3,11 @@ class BatchManager {
     pendingUpdates = new Map();
     scheduled = false;
     batchCallbacks = new Set();
-    /**
-     * Batch multiple state updates into a single render cycle
-     */
     batch(fn) {
         if (!browser) {
-            // On server, execute immediately
             fn();
             return;
         }
-        // Collect all updates
         const startBatching = !this.scheduled;
         if (startBatching) {
             this.scheduled = true;
@@ -26,44 +21,31 @@ class BatchManager {
             }
         }
     }
-    /**
-     * Add an update to the batch queue
-     */
     queueUpdate(key, value, callback) {
         if (!browser || !this.scheduled) {
-            // Execute immediately if not batching
             if (callback)
                 callback(value);
             return;
         }
         this.pendingUpdates.set(key, { key, value, callback });
     }
-    /**
-     * Register a callback to be called when batch completes
-     */
     onBatchComplete(callback) {
         this.batchCallbacks.add(callback);
     }
-    /**
-     * Flush all pending updates
-     */
     flush() {
         if (this.pendingUpdates.size === 0) {
             this.scheduled = false;
             return;
         }
-        // Use microtask to batch DOM updates
         queueMicrotask(() => {
             const updates = Array.from(this.pendingUpdates.values());
             this.pendingUpdates.clear();
             this.scheduled = false;
-            // Apply all updates
             for (const update of updates) {
                 if (update.callback) {
                     update.callback(update.value);
                 }
             }
-            // Notify batch complete
             for (const callback of this.batchCallbacks) {
                 callback();
             }
@@ -71,32 +53,10 @@ class BatchManager {
         });
     }
 }
-// Global batch manager instance
 const batchManager = new BatchManager();
-/**
- * Batch multiple state updates to avoid unnecessary re-renders
- *
- * @example
- * ```ts
- * batch(() => {
- *   store1.set(value1);
- *   store2.set(value2);
- *   store3.set(value3);
- * });
- * ```
- */
 export const batch = (fn) => batchManager.batch(fn);
-/**
- * Queue an update for batching (internal use)
- */
 export const queueUpdate = (key, value, callback) => batchManager.queueUpdate(key, value, callback);
-/**
- * Register a callback for batch completion (internal use)
- */
 export const onBatchComplete = (callback) => batchManager.onBatchComplete(callback);
-/**
- * Transaction-like API for complex state updates
- */
 export const transaction = async (fn) => {
     return new Promise((resolve, reject) => {
         batch(() => {

package/dist/utils/dev.d.ts CHANGED Viewed

@@ -1,30 +1,9 @@
 import type { UnknownFunc } from '../types.js';
-/**
- * Development-mode validations and warnings
- */
 export declare const DevTools: {
-    /**
-     * Validates factory uniqueness in development
-     */
     validateFactoryUniqueness(factory: UnknownFunc, key: string): void;
-    /**
-     * Get cached size of a value (optimized to avoid repeated JSON.stringify)
-     */
     getSize(value: unknown): number;
-    /**
-     * Warns about large state objects (optimized with memoization)
-     */
     warnOnLargeState(key: string, value: unknown): void;
-    /**
-     * Validates state mutations
-     */
     checkStateMutation(key: string, oldValue: unknown, newValue: unknown): void;
-    /**
-     * Performance metrics collection
-     */
     measurePerformance<T>(name: string, fn: () => T): T;
-    /**
-     * Debug state tree visualization
-     */
     visualizeStateTree(stateMap: Map<string, unknown>): void;
 };

package/dist/utils/dev.js CHANGED Viewed

@@ -1,28 +1,18 @@
 import { browser, dev } from './environment.js';
 const seenFactories = new WeakSet();
 const largeStateWarnings = new Set();
-// Memoize size calculations to avoid repeated JSON.stringify calls
 const sizeCache = new WeakMap();
-/**
- * Development-mode validations and warnings
- */
 export const DevTools = {
-    /**
-     * Validates factory uniqueness in development
-     */
     validateFactoryUniqueness(factory, key) {
         if (!dev)
             return;
         if (seenFactories.has(factory)) {
             console.warn(`[edges-svelte] Factory collision detected for key "${key}". ` +
-                `This might cause unexpected behavior. Consider using createNamedStore() ` +
-                `or setting a unique __storeKey__ property on your factory function.`);
+                `This might cause unexpected behavior.` +
+                `Set a unique __storeKey__ property on your factory function.`);
         }
         seenFactories.add(factory);
     },
-    /**
-     * Get cached size of a value (optimized to avoid repeated JSON.stringify)
-     */
     getSize(value) {
         if (typeof value === 'object' && value !== null) {
             if (sizeCache.has(value)) {
@@ -34,9 +24,6 @@ export const DevTools = {
         }
         return JSON.stringify(value).length;
     },
-    /**
-     * Warns about large state objects (optimized with memoization)
-     */
     warnOnLargeState(key, value) {
         if (!dev)
             return;
@@ -45,7 +32,6 @@ export const DevTools = {
         try {
             const size = this.getSize(value);
             if (size > 50000) {
-                // 50KB threshold
                 largeStateWarnings.add(key);
                 console.warn(`[edges-svelte] Large state detected for key "${key}" (${Math.round(size / 1024)}KB). ` +
                     `Consider splitting into smaller stores or enabling compression.`);
@@ -55,21 +41,14 @@ export const DevTools = {
             // Ignore serialization errors in dev warnings
         }
     },
-    /**
-     * Validates state mutations
-     */
     checkStateMutation(key, oldValue, newValue) {
         if (!dev || !browser)
             return;
-        // Check for direct object mutations
         if (typeof oldValue === 'object' && oldValue !== null && oldValue === newValue && !Array.isArray(oldValue)) {
             console.error(`[edges-svelte] Direct mutation detected for key "${key}". ` +
                 `State should be immutable. Use spread operator or Object.assign() to create new objects.`);
         }
     },
-    /**
-     * Performance metrics collection
-     */
     measurePerformance(name, fn) {
         if (!dev)
             return fn();
@@ -77,14 +56,10 @@ export const DevTools = {
         const result = fn();
         const duration = performance.now() - start;
         if (duration > 16) {
-            // Longer than a frame
             console.warn(`[edges-svelte] Slow operation "${name}" took ${duration.toFixed(2)}ms. ` + `Consider optimizing for better performance.`);
         }
         return result;
     },
-    /**
-     * Debug state tree visualization
-     */
     visualizeStateTree(stateMap) {
         if (!dev || !browser)
             return;
@@ -105,7 +80,6 @@ export const DevTools = {
         console.groupEnd();
     }
 };
-// Export for browser devtools integration
 if (browser && dev) {
     window.__EDGES_DEVTOOLS__ = {
         version: '1.3.0',
@@ -127,7 +101,6 @@ if (browser && dev) {
             const sizes = {};
             for (const [key, value] of stateMap) {
                 try {
-                    // Use memoized getSize for better performance
                     const size = DevTools.getSize(value);
                     sizes[key] = size;
                     totalSize += size;

package/dist/utils/environment.d.ts CHANGED Viewed

@@ -1,6 +1,2 @@
-/**
- * Universal browser detection that works in both SvelteKit and non-SvelteKit environments
- * This fixes SSR issues when the package is used in different contexts
- */
 export declare const browser: boolean;
 export declare const dev: boolean;

package/dist/utils/environment.js CHANGED Viewed

@@ -1,6 +1,2 @@
-/**
- * Universal browser detection that works in both SvelteKit and non-SvelteKit environments
- * This fixes SSR issues when the package is used in different contexts
- */
 export const browser = !import.meta.env.SSR && typeof window !== 'undefined' && typeof document !== 'undefined';
 export const dev = import.meta.env.DEV;

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "edges-svelte",
-  "version": "2.2.0",
+  "version": "2.2.1",
   "license": "MIT",
   "author": "Pixel1917",
   "description": "A blazing-fast, extremely lightweight and SSR-friendly store for Svelte",
@@ -107,9 +107,6 @@
     "state management",
     "ssr store"
   ],
-  "dependencies": {
-    "devalue": "^5.1.1"
-  },
   "scripts": {
     "dev": "vite dev",
     "build": "vite build && npm run prepack",