synapse-storage 3.0.19 → 4.0.1

package/dist/core/storage/middlewares/broadcast.middleware.js

@@ -0,0 +1,197 @@
+import { handleCallbackError, logError } from "../../../_utils/error-handling.util.js";
+import { StorageEvents } from "../storage.interface.js";
+import { SyncBroadcastChannel } from "../utils/broadcast.util.js";
+
+
+
+
+
+
+
+// Обработка сообщений для MemoryStorage
+async function handleMemoryStorageMessage(api, type, payload) {
+    switch(type){
+        case 'set':
+            if (payload?.key !== undefined && payload?.value !== undefined) {
+                await api.storage.doSet(payload.key, payload.value);
+                api.storage.notifySubscribers(payload.key, payload.value);
+            }
+            break;
+        case 'update':
+            if (Array.isArray(payload?.value)) {
+                await api.storage.doUpdate(payload.value);
+                //@ts-ignore
+                payload.value.forEach(({ key, value })=>{
+                    //@ts-ignore
+                    api.storage.notifySubscribers(key, value);
+                });
+            }
+            break;
+        case 'delete':
+            if (payload?.key !== undefined) {
+                await api.storage.doDelete(payload.key);
+                api.storage.notifySubscribers(payload.key, undefined);
+            }
+            break;
+        case 'clear':
+            await api.storage.doClear();
+            api.storage.notifySubscribers('*', {
+                type: StorageEvents.STORAGE_UPDATE,
+                value: {},
+                source: 'broadcast'
+            });
+            break;
+    }
+    // Уведомляем глобальных подписчиков
+    api.storage.notifySubscribers('*', {
+        type: StorageEvents.STORAGE_UPDATE,
+        key: payload?.key,
+        value: payload?.value,
+        source: 'broadcast'
+    });
+}
+// Обработка сообщений для LocalStorage и IndexedDB
+async function handlePersistentStorageMessage(api, type, payload) {
+    // Для LocalStorage и IndexedDB данные уже синхронизированы браузером
+    // Нужно только получить актуальные данные и уведомить подписчиков
+    switch(type){
+        case 'set':
+            if (payload?.key !== undefined) {
+                // Получаем актуальное значение из хранилища
+                const currentValue = await api.storage.doGet(payload.key);
+                api.storage.notifySubscribers(payload.key, currentValue);
+            }
+            break;
+        case 'update':
+            if (Array.isArray(payload?.value)) {
+                // Получаем актуальные значения для каждого обновленного ключа
+                for (const { key } of payload.value){
+                    const currentValue = await api.storage.doGet(key);
+                    api.storage.notifySubscribers(key, currentValue);
+                }
+                // Уведомляем об обновлении с актуальными данными
+                api.storage.notifySubscribers('*', {
+                    type: StorageEvents.STORAGE_UPDATE,
+                    //@ts-ignore
+                    key: payload.value.map(({ key })=>key),
+                    value: payload.value,
+                    source: 'broadcast'
+                });
+            }
+            break;
+        case 'delete':
+            if (payload?.key !== undefined) {
+                api.storage.notifySubscribers(payload.key, undefined);
+            }
+            break;
+        case 'clear':
+            // При очистке уведомляем всех подписчиков
+            api.storage.notifySubscribers('*', {
+                type: StorageEvents.STORAGE_UPDATE,
+                value: {},
+                source: 'broadcast'
+            });
+            break;
+    }
+    // Общее уведомление для глобальных подписчиков
+    if (type !== 'update') {
+        // Для update уже отправили выше
+        api.storage.notifySubscribers('*', {
+            type: StorageEvents.STORAGE_UPDATE,
+            key: payload?.key,
+            value: type === 'delete' ? undefined : payload?.value,
+            source: 'broadcast'
+        });
+    }
+}
+const broadcastMiddleware = (props)=>{
+    const { storageName, storageType } = props;
+    const channelName = `${storageType}-${storageName}`;
+    const channel = new SyncBroadcastChannel(channelName, {
+        debug: true
+    });
+    return {
+        name: 'broadcast',
+        setup: (api)=>{
+            // Настройка синхронизации для MemoryStorage
+            if (storageType === 'memory') {
+                channel.setSyncHandler(async ()=>{
+                    const state = await api.getState();
+                    const updates = Object.entries(state).map(([key, value])=>({
+                            key,
+                            value
+                        }));
+                    const action = {
+                        type: 'update',
+                        key: '*',
+                        value: updates,
+                        metadata: {
+                            batchUpdate: true,
+                            timestamp: Date.now()
+                        }
+                    };
+                    return action;
+                });
+                // Запрашиваем начальную синхронизацию для MemoryStorage
+                channel.requestSync().then(async (action)=>{
+                    if (action?.type === 'update' && Array.isArray(action.value)) {
+                        try {
+                            const validUpdates = action.value.every((update)=>update && typeof update === 'object' && 'key' in update && 'value' in update);
+                            if (!validUpdates) {
+                                logError('broadcastMiddleware: invalid sync response updates structure', action.value);
+                                return;
+                            }
+                            await api.storage.doUpdate(action.value);
+                            // Уведомляем подписчиков о каждом обновленном значении
+                            action.value.forEach(({ key, value })=>{
+                                api.storage.notifySubscribers(key, value);
+                            });
+                            // Уведомляем глобальных подписчиков
+                            api.storage.notifySubscribers('*', {
+                                type: StorageEvents.STORAGE_UPDATE,
+                                value: action.value,
+                                source: 'broadcast'
+                            });
+                        } catch (error) {
+                            handleCallbackError('broadcastMiddleware: error applying sync updates', error);
+                        }
+                    }
+                }).catch((error)=>{
+                    logError('broadcastMiddleware: initial sync failed', error, null, 'warn');
+                });
+            }
+            // Подписка на сообщения от других вкладок
+            return channel.subscribe(async (message)=>{
+                const { type, payload } = message;
+                if (storageType === 'memory') {
+                    // Для MemoryStorage обновляем данные и уведомляем подписчиков
+                    await handleMemoryStorageMessage(api, type, payload);
+                } else {
+                    // Для LocalStorage и IndexedDB только уведомляем подписчиков
+                    await handlePersistentStorageMessage(api, type, payload);
+                }
+            });
+        },
+        reducer: (api)=>(next)=>async (action)=>{
+                    const result = await next(action);
+                    // Отправляем сообщение другим вкладкам для всех типов операций
+                    // Текущая вкладка уже получила уведомления через обычный flow BaseStorage
+                    if ([
+                        'set',
+                        'delete',
+                        'clear',
+                        'update'
+                    ].includes(action.type)) {
+                        channel.broadcast(action.type, action);
+                    }
+                    return result;
+                },
+        cleanup: ()=>{
+            channel.close();
+        }
+    };
+};
+
+export { broadcastMiddleware };
+
+//# sourceMappingURL=broadcast.middleware.js.map

package/dist/core/storage/middlewares/broadcast.middleware.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"core/storage/middlewares/broadcast.middleware.js","sources":["../../../../src/core/storage/middlewares/broadcast.middleware.ts"],"sourcesContent":["import { handleCallbackError, logError } from '../../../_utils/error-handling.util'\nimport { StorageEvents, StorageType } from '../storage.interface'\nimport { SyncBroadcastChannel } from '../utils/broadcast.util'\nimport { Middleware, MiddlewareAPI, NextFunction, StorageAction } from '../utils/middleware-module'\n\ninterface SharedStateMiddlewareProps {\n  storageType: StorageType\n  storageName: string\n}\n\n// Обработка сообщений для MemoryStorage\nasync function handleMemoryStorageMessage(api: MiddlewareAPI, type: string, payload: any): Promise<void> {\n  switch (type) {\n    case 'set':\n      if (payload?.key !== undefined && payload?.value !== undefined) {\n        await api.storage.doSet(payload.key, payload.value)\n        api.storage.notifySubscribers(payload.key, payload.value)\n      }\n      break\n\n    case 'update':\n      if (Array.isArray(payload?.value)) {\n        await api.storage.doUpdate(payload.value)\n        //@ts-ignore\n        payload.value.forEach(({ key, value }) => {\n          //@ts-ignore\n          api.storage.notifySubscribers(key, value)\n        })\n      }\n      break\n\n    case 'delete':\n      if (payload?.key !== undefined) {\n        await api.storage.doDelete(payload.key)\n        api.storage.notifySubscribers(payload.key, undefined)\n      }\n      break\n\n    case 'clear':\n      await api.storage.doClear()\n      api.storage.notifySubscribers('*', {\n        type: StorageEvents.STORAGE_UPDATE,\n        value: {},\n        source: 'broadcast',\n      })\n      break\n  }\n\n  // Уведомляем глобальных подписчиков\n  api.storage.notifySubscribers('*', {\n    type: StorageEvents.STORAGE_UPDATE,\n    key: payload?.key,\n    value: payload?.value,\n    source: 'broadcast',\n  })\n}\n\n// Обработка сообщений для LocalStorage и IndexedDB\nasync function handlePersistentStorageMessage(api: MiddlewareAPI, type: string, payload: any): Promise<void> {\n  // Для LocalStorage и IndexedDB данные уже синхронизированы браузером\n  // Нужно только получить актуальные данные и уведомить подписчиков\n\n  switch (type) {\n    case 'set':\n      if (payload?.key !== undefined) {\n        // Получаем актуальное значение из хранилища\n        const currentValue = await api.storage.doGet(payload.key)\n        api.storage.notifySubscribers(payload.key, currentValue)\n      }\n      break\n\n    case 'update':\n      if (Array.isArray(payload?.value)) {\n        // Получаем актуальные значения для каждого обновленного ключа\n        for (const { key } of payload.value) {\n          const currentValue = await api.storage.doGet(key)\n          api.storage.notifySubscribers(key, currentValue)\n        }\n\n        // Уведомляем об обновлении с актуальными данными\n        api.storage.notifySubscribers('*', {\n          type: StorageEvents.STORAGE_UPDATE,\n          //@ts-ignore\n          key: payload.value.map(({ key }) => key),\n          value: payload.value,\n          source: 'broadcast',\n        })\n      }\n      break\n\n    case 'delete':\n      if (payload?.key !== undefined) {\n        api.storage.notifySubscribers(payload.key, undefined)\n      }\n      break\n\n    case 'clear':\n      // При очистке уведомляем всех подписчиков\n      api.storage.notifySubscribers('*', {\n        type: StorageEvents.STORAGE_UPDATE,\n        value: {},\n        source: 'broadcast',\n      })\n      break\n  }\n\n  // Общее уведомление для глобальных подписчиков\n  if (type !== 'update') {\n    // Для update уже отправили выше\n    api.storage.notifySubscribers('*', {\n      type: StorageEvents.STORAGE_UPDATE,\n      key: payload?.key,\n      value: type === 'delete' ? undefined : payload?.value,\n      source: 'broadcast',\n    })\n  }\n}\n\nexport const broadcastMiddleware = (props: SharedStateMiddlewareProps): Middleware => {\n  const { storageName, storageType } = props\n  const channelName = `${storageType}-${storageName}`\n  const channel = new SyncBroadcastChannel<StorageAction>(channelName, { debug: true })\n\n  return {\n    name: 'broadcast',\n    setup: (api: MiddlewareAPI) => {\n      // Настройка синхронизации для MemoryStorage\n      if (storageType === 'memory') {\n        channel.setSyncHandler(async () => {\n          const state = await api.getState()\n\n          const updates = Object.entries(state).map(([key, value]) => ({\n            key,\n            value,\n          }))\n\n          const action: StorageAction = {\n            type: 'update',\n            key: '*',\n            value: updates,\n            metadata: {\n              batchUpdate: true,\n              timestamp: Date.now(),\n            },\n          }\n          return action\n        })\n\n        // Запрашиваем начальную синхронизацию для MemoryStorage\n        channel\n          .requestSync()\n          .then(async (action) => {\n            if (action?.type === 'update' && Array.isArray(action.value)) {\n              try {\n                const validUpdates = action.value.every((update) => update && typeof update === 'object' && 'key' in update && 'value' in update)\n\n                if (!validUpdates) {\n                  logError('broadcastMiddleware: invalid sync response updates structure', action.value)\n                  return\n                }\n\n                await api.storage.doUpdate(action.value)\n\n                // Уведомляем подписчиков о каждом обновленном значении\n                action.value.forEach(({ key, value }) => {\n                  api.storage.notifySubscribers(key, value)\n                })\n\n                // Уведомляем глобальных подписчиков\n                api.storage.notifySubscribers('*', {\n                  type: StorageEvents.STORAGE_UPDATE,\n                  value: action.value,\n                  source: 'broadcast',\n                })\n              } catch (error) {\n                handleCallbackError('broadcastMiddleware: error applying sync updates', error)\n              }\n            }\n          })\n          .catch((error) => {\n            logError('broadcastMiddleware: initial sync failed', error, null, 'warn')\n          })\n      }\n\n      // Подписка на сообщения от других вкладок\n      return channel.subscribe(async (message) => {\n        const { type, payload } = message\n\n        if (storageType === 'memory') {\n          // Для MemoryStorage обновляем данные и уведомляем подписчиков\n          await handleMemoryStorageMessage(api, type, payload)\n        } else {\n          // Для LocalStorage и IndexedDB только уведомляем подписчиков\n          await handlePersistentStorageMessage(api, type, payload)\n        }\n      })\n    },\n\n    reducer: (api: MiddlewareAPI) => (next: NextFunction) => async (action: StorageAction) => {\n      const result = await next(action)\n\n      // Отправляем сообщение другим вкладкам для всех типов операций\n      // Текущая вкладка уже получила уведомления через обычный flow BaseStorage\n      if (['set', 'delete', 'clear', 'update'].includes(action.type)) {\n        channel.broadcast(action.type, action)\n      }\n\n      return result\n    },\n\n    cleanup: () => {\n      channel.close()\n    },\n  }\n}\n"],"names":["handleCallbackError","logError","StorageEvents","SyncBroadcastChannel","handleMemoryStorageMessage","api","type","payload","undefined","Array","key","value","handlePersistentStorageMessage","currentValue","broadcastMiddleware","props","storageName","storageType","channelName","channel","state","updates","Object","action","Date","validUpdates","update","error","message","next","result"],"mappings":"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"}

package/dist/core/storage/middlewares/index.d.ts

@@ -0,0 +1,9 @@
+export { broadcastMiddleware } from './broadcast.middleware';
+export type { BatchingMiddlewareOptions } from './storage-batching.middleware';
+export type { ShallowCompareMiddlewareOptions } from './storage-shallow-compare.middleware';
+export { syncBroadcastMiddleware } from './sync-broadcast.middleware';
+export type { SyncBatchingMiddlewareOptions } from './sync-storage-batching.middleware';
+export { syncBatchingMiddleware } from './sync-storage-batching.middleware';
+export type { SyncShallowCompareMiddlewareOptions } from './sync-storage-shallow-compare.middleware';
+export { syncShallowCompareMiddleware } from './sync-storage-shallow-compare.middleware';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/storage/middlewares/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/core/storage/middlewares/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAA;AAC5D,YAAY,EAAE,yBAAyB,EAAE,MAAM,+BAA+B,CAAA;AAC9E,YAAY,EAAE,+BAA+B,EAAE,MAAM,sCAAsC,CAAA;AAG3F,OAAO,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAA;AACrE,YAAY,EAAE,6BAA6B,EAAE,MAAM,oCAAoC,CAAA;AACvF,OAAO,EAAE,sBAAsB,EAAE,MAAM,oCAAoC,CAAA;AAC3E,YAAY,EAAE,mCAAmC,EAAE,MAAM,2CAA2C,CAAA;AACpG,OAAO,EAAE,4BAA4B,EAAE,MAAM,2CAA2C,CAAA"}

package/dist/core/storage/middlewares/index.js

@@ -0,0 +1,17 @@
+
+
+
+
+// Async middlewares (existing)
+
+// Sync middlewares
+
+
+
+
+export { broadcastMiddleware } from "./broadcast.middleware.js";
+export { syncBroadcastMiddleware } from "./sync-broadcast.middleware.js";
+export { syncBatchingMiddleware } from "./sync-storage-batching.middleware.js";
+export { syncShallowCompareMiddleware } from "./sync-storage-shallow-compare.middleware.js";
+
+//# sourceMappingURL=index.js.map

package/dist/core/storage/middlewares/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"core/storage/middlewares/index.js","sources":["../../../../src/core/storage/middlewares/index.ts"],"sourcesContent":["// Async middlewares (existing)\nexport { broadcastMiddleware } from './broadcast.middleware'\nexport type { BatchingMiddlewareOptions } from './storage-batching.middleware'\nexport type { ShallowCompareMiddlewareOptions } from './storage-shallow-compare.middleware'\n\n// Sync middlewares\nexport { syncBroadcastMiddleware } from './sync-broadcast.middleware'\nexport type { SyncBatchingMiddlewareOptions } from './sync-storage-batching.middleware'\nexport { syncBatchingMiddleware } from './sync-storage-batching.middleware'\nexport type { SyncShallowCompareMiddlewareOptions } from './sync-storage-shallow-compare.middleware'\nexport { syncShallowCompareMiddleware } from './sync-storage-shallow-compare.middleware'\n"],"names":["broadcastMiddleware","syncBroadcastMiddleware","syncBatchingMiddleware","syncShallowCompareMiddleware"],"mappings":";;;;AAAA,+BAA+B;AAC6B;AAI5D,mBAAmB;AACkD;AAEM;AAEa"}

package/dist/core/storage/middlewares/storage-batching.middleware.d.ts

@@ -0,0 +1,7 @@
+import { Middleware } from '../utils/middleware-module';
+export interface BatchingMiddlewareOptions {
+    batchSize?: number;
+    batchDelay?: number;
+}
+export declare const batchingMiddleware: (options?: BatchingMiddlewareOptions) => Middleware;
+//# sourceMappingURL=storage-batching.middleware.d.ts.map

package/dist/core/storage/middlewares/storage-batching.middleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-batching.middleware.d.ts","sourceRoot":"","sources":["../../../../src/core/storage/middlewares/storage-batching.middleware.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAA8C,MAAM,4BAA4B,CAAA;AAEnG,MAAM,WAAW,yBAAyB;IACxC,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB;AASD,eAAO,MAAM,kBAAkB,GAAI,UAAS,yBAA8B,KAAG,UA0H5E,CAAA"}

package/dist/core/storage/middlewares/storage-batching.middleware.js

@@ -0,0 +1,108 @@
+// storage-batching.middleware.ts - ИСПРАВЛЕННАЯ ВЕРСИЯ
+const batchingMiddleware = (options = {})=>{
+    const batchSize = options.batchSize ?? 10;
+    const batchDelay = options.batchDelay ?? 10 // Уменьшил для более быстрого батчинга
+    ;
+    const queues = new Map();
+    const timeouts = new Map();
+    const shouldBatch = (action)=>{
+        return action.type === 'set' || action.type === 'update';
+    };
+    const getSegmentKey = (action)=>{
+        return `${action.type}_${action.key?.toString() || 'default'}`;
+    };
+    const mergeActions = (actions)=>{
+        const merged = new Map();
+        // Группируем по ключу и оставляем только последнее значение
+        for (const action of actions){
+            const key = `${action.type}_${action.key?.toString() || 'default'}`;
+            merged.set(key, action); // Последнее действие перезаписывает предыдущие
+        }
+        return Array.from(merged.values());
+    };
+    const clearTimeout = (segment)=>{
+        const timeout = timeouts.get(segment);
+        if (timeout) {
+            globalThis.clearTimeout(timeout);
+            timeouts.delete(segment);
+        }
+    };
+    const setTimeout = (segment, callback)=>{
+        const timeout = globalThis.setTimeout(callback, batchDelay);
+        timeouts.set(segment, timeout);
+    };
+    const processBatch = async (segment, api, next)=>{
+        const queue = queues.get(segment);
+        if (!queue || queue.length === 0) return;
+        // Очищаем очередь и таймер
+        queues.delete(segment);
+        clearTimeout(segment);
+        try {
+            // Объединяем действия
+            const actions = queue.map((item)=>item.action);
+            const mergedActions = mergeActions(actions);
+            // Выполняем только merged actions
+            for (const mergedAction of mergedActions){
+                try {
+                    // Выполняем merged действие
+                    const result = await next(mergedAction);
+                    // Находим все queue items, которые соответствуют этому merged action
+                    const matchingItems = queue.filter((item)=>item.action.type === mergedAction.type && item.action.key?.toString() === mergedAction.key?.toString());
+                    // Все соответствующие items получают результат merged операции
+                    matchingItems.forEach((item)=>item.resolve(result));
+                } catch (error) {
+                    // В случае ошибки отклоняем соответствующие промисы
+                    const matchingItems = queue.filter((item)=>item.action.type === mergedAction.type && item.action.key?.toString() === mergedAction.key?.toString());
+                    matchingItems.forEach((item)=>item.reject(error));
+                }
+            }
+        } catch (error) {
+            // В случае общей ошибки отклоняем все промисы
+            queue.forEach((item)=>item.reject(error));
+        }
+    };
+    const addToQueue = async (action, api, next)=>{
+        return new Promise((resolve, reject)=>{
+            const segment = getSegmentKey(action);
+            let queue = queues.get(segment);
+            if (!queue) {
+                queue = [];
+                queues.set(segment, queue);
+            }
+            queue.push({
+                action,
+                resolve,
+                reject,
+                timestamp: Date.now()
+            });
+            clearTimeout(segment);
+            if (queue.length >= batchSize) {
+                // Немедленно обрабатываем батч
+                queueMicrotask(()=>processBatch(segment, api, next));
+            } else {
+                // Устанавливаем таймер
+                setTimeout(segment, ()=>processBatch(segment, api, next));
+            }
+        });
+    };
+    return {
+        name: 'batching',
+        setup: ()=>{},
+        cleanup: async ()=>{
+            // Очищаем таймеры
+            timeouts.forEach((timeout)=>globalThis.clearTimeout(timeout));
+            timeouts.clear();
+            queues.clear();
+        },
+        reducer: (api)=>(next)=>async (action)=>{
+                    if (!shouldBatch(action)) {
+                        return next(action);
+                    }
+                    return addToQueue(action, api, next);
+                }
+    };
+};
+
+export { batchingMiddleware };
+
+//# sourceMappingURL=storage-batching.middleware.js.map

package/dist/core/storage/middlewares/storage-batching.middleware.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"core/storage/middlewares/storage-batching.middleware.js","sources":["../../../../src/core/storage/middlewares/storage-batching.middleware.ts"],"sourcesContent":["// storage-batching.middleware.ts - ИСПРАВЛЕННАЯ ВЕРСИЯ\nimport { Middleware, MiddlewareAPI, NextFunction, StorageAction } from '../utils/middleware-module'\n\nexport interface BatchingMiddlewareOptions {\n  batchSize?: number\n  batchDelay?: number\n}\n\ninterface BatchItem {\n  action: StorageAction\n  resolve: (value: any) => void\n  reject: (error: any) => void\n  timestamp: number\n}\n\nexport const batchingMiddleware = (options: BatchingMiddlewareOptions = {}): Middleware => {\n  const batchSize = options.batchSize ?? 10\n  const batchDelay = options.batchDelay ?? 10 // Уменьшил для более быстрого батчинга\n\n  const queues = new Map<string, BatchItem[]>()\n  const timeouts = new Map<string, NodeJS.Timeout>()\n\n  const shouldBatch = (action: StorageAction): boolean => {\n    return action.type === 'set' || action.type === 'update'\n  }\n\n  const getSegmentKey = (action: StorageAction): string => {\n    return `${action.type}_${action.key?.toString() || 'default'}`\n  }\n\n  const mergeActions = (actions: StorageAction[]): StorageAction[] => {\n    const merged = new Map<string, StorageAction>()\n\n    // Группируем по ключу и оставляем только последнее значение\n    for (const action of actions) {\n      const key = `${action.type}_${action.key?.toString() || 'default'}`\n      merged.set(key, action) // Последнее действие перезаписывает предыдущие\n    }\n\n    return Array.from(merged.values())\n  }\n\n  const clearTimeout = (segment: string): void => {\n    const timeout = timeouts.get(segment)\n    if (timeout) {\n      globalThis.clearTimeout(timeout)\n      timeouts.delete(segment)\n    }\n  }\n\n  const setTimeout = (segment: string, callback: () => void): void => {\n    const timeout = globalThis.setTimeout(callback, batchDelay)\n    timeouts.set(segment, timeout)\n  }\n\n  const processBatch = async (segment: string, api: MiddlewareAPI, next: NextFunction): Promise<void> => {\n    const queue = queues.get(segment)\n    if (!queue || queue.length === 0) return\n\n    // Очищаем очередь и таймер\n    queues.delete(segment)\n    clearTimeout(segment)\n\n    try {\n      // Объединяем действия\n      const actions = queue.map((item) => item.action)\n      const mergedActions = mergeActions(actions)\n\n      // Выполняем только merged actions\n      for (const mergedAction of mergedActions) {\n        try {\n          // Выполняем merged действие\n          const result = await next(mergedAction)\n\n          // Находим все queue items, которые соответствуют этому merged action\n          const matchingItems = queue.filter((item) => item.action.type === mergedAction.type && item.action.key?.toString() === mergedAction.key?.toString())\n\n          // Все соответствующие items получают результат merged операции\n          matchingItems.forEach((item) => item.resolve(result))\n        } catch (error) {\n          // В случае ошибки отклоняем соответствующие промисы\n          const matchingItems = queue.filter((item) => item.action.type === mergedAction.type && item.action.key?.toString() === mergedAction.key?.toString())\n          matchingItems.forEach((item) => item.reject(error))\n        }\n      }\n    } catch (error) {\n      // В случае общей ошибки отклоняем все промисы\n      queue.forEach((item) => item.reject(error))\n    }\n  }\n\n  const addToQueue = async (action: StorageAction, api: MiddlewareAPI, next: NextFunction): Promise<any> => {\n    return new Promise((resolve, reject) => {\n      const segment = getSegmentKey(action)\n\n      let queue = queues.get(segment)\n      if (!queue) {\n        queue = []\n        queues.set(segment, queue)\n      }\n\n      queue.push({\n        action,\n        resolve,\n        reject,\n        timestamp: Date.now(),\n      })\n\n      clearTimeout(segment)\n\n      if (queue.length >= batchSize) {\n        // Немедленно обрабатываем батч\n        queueMicrotask(() => processBatch(segment, api, next))\n      } else {\n        // Устанавливаем таймер\n        setTimeout(segment, () => processBatch(segment, api, next))\n      }\n    })\n  }\n\n  return {\n    name: 'batching',\n    setup: () => {},\n    cleanup: async () => {\n      // Очищаем таймеры\n      timeouts.forEach((timeout) => globalThis.clearTimeout(timeout))\n      timeouts.clear()\n      queues.clear()\n    },\n    reducer: (api: MiddlewareAPI) => (next: NextFunction) => async (action: StorageAction) => {\n      if (!shouldBatch(action)) {\n        return next(action)\n      }\n\n      return addToQueue(action, api, next)\n    },\n  }\n}\n"],"names":["batchingMiddleware","options","batchSize","batchDelay","queues","Map","timeouts","shouldBatch","action","getSegmentKey","mergeActions","actions","merged","key","Array","clearTimeout","segment","timeout","globalThis","setTimeout","callback","processBatch","api","next","queue","item","mergedActions","mergedAction","result","matchingItems","error","addToQueue","Promise","resolve","reject","Date","queueMicrotask"],"mappings":"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"}

package/dist/core/storage/middlewares/storage-shallow-compare.middleware.d.ts

@@ -0,0 +1,7 @@
+import { Middleware } from '../utils/middleware-module';
+export interface ShallowCompareMiddlewareOptions {
+    segments?: string[];
+    comparator?: <T>(prev: T, next: T) => boolean;
+}
+export declare const shallowCompareMiddleware: (options?: ShallowCompareMiddlewareOptions) => Middleware;
+//# sourceMappingURL=storage-shallow-compare.middleware.d.ts.map

package/dist/core/storage/middlewares/storage-shallow-compare.middleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-shallow-compare.middleware.d.ts","sourceRoot":"","sources":["../../../../src/core/storage/middlewares/storage-shallow-compare.middleware.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAiE,MAAM,4BAA4B,CAAA;AAGtH,MAAM,WAAW,+BAA+B;IAC9C,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;IACnB,UAAU,CAAC,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,KAAK,OAAO,CAAA;CAC9C;AAED,eAAO,MAAM,wBAAwB,GAAI,UAAS,+BAAoC,KAAG,UA8CxF,CAAA"}

package/dist/core/storage/middlewares/storage-shallow-compare.middleware.js

@@ -0,0 +1,43 @@
+import { VALUE_NOT_CHANGED } from "../utils/middleware-module.js";
+
+
+
+const shallowCompareMiddleware = (options = {})=>{
+    const { comparator = (prev, next)=>{
+        if (prev === next) return true;
+        if (typeof prev !== 'object' || typeof next !== 'object' || prev === null || next === null) {
+            return prev === next;
+        }
+        const keysA = Object.keys(prev);
+        const keysB = Object.keys(next);
+        if (keysA.length !== keysB.length) return false;
+        return keysA.every((key)=>Object.prototype.hasOwnProperty.call(next, key) && prev[key] === next[key]);
+    }, segments = [] } = options;
+    // Кэш последних значений
+    const valueCache = new Map();
+    return {
+        name: 'shallow-compare',
+        setup: (api)=>{},
+        reducer: (api)=>(next)=>async (action)=>{
+                    // Пропускаем действия кроме set
+                    if (action.type !== 'set' || segments.length && !segments.includes(action.metadata?.segment ?? 'default')) {
+                        return next(action);
+                    }
+                    const cacheKey = action.key;
+                    const prevValue = valueCache.get(cacheKey);
+                    const nextValue = action.value;
+                    // Если значения равны, возвращаем sentinel — не модифицируем значение
+                    if (prevValue !== undefined && comparator(prevValue, nextValue)) {
+                        return VALUE_NOT_CHANGED;
+                    }
+                    // Иначе обновляем кэш и продолжаем
+                    const result = await next(action);
+                    valueCache.set(cacheKey, result !== undefined ? result : nextValue);
+                    return result;
+                }
+    };
+};
+
+export { shallowCompareMiddleware };
+
+//# sourceMappingURL=storage-shallow-compare.middleware.js.map

package/dist/core/storage/middlewares/storage-shallow-compare.middleware.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"core/storage/middlewares/storage-shallow-compare.middleware.js","sources":["../../../../src/core/storage/middlewares/storage-shallow-compare.middleware.ts"],"sourcesContent":["import { Middleware, MiddlewareAPI, NextFunction, StorageAction, VALUE_NOT_CHANGED } from '../utils/middleware-module'\nimport { StorageKeyType } from '../utils/storage-key'\n\nexport interface ShallowCompareMiddlewareOptions {\n  segments?: string[]\n  comparator?: <T>(prev: T, next: T) => boolean\n}\n\nexport const shallowCompareMiddleware = (options: ShallowCompareMiddlewareOptions = {}): Middleware => {\n  const {\n    comparator = (prev: any, next: any) => {\n      if (prev === next) return true\n\n      if (typeof prev !== 'object' || typeof next !== 'object' || prev === null || next === null) {\n        return prev === next\n      }\n\n      const keysA = Object.keys(prev)\n      const keysB = Object.keys(next)\n\n      if (keysA.length !== keysB.length) return false\n\n      return keysA.every((key) => Object.prototype.hasOwnProperty.call(next, key) && prev[key] === next[key])\n    },\n    segments = [],\n  } = options\n\n  // Кэш последних значений\n  const valueCache = new Map<StorageKeyType, any>()\n\n  return {\n    name: 'shallow-compare',\n    setup: (api: MiddlewareAPI) => {},\n    reducer: (api: MiddlewareAPI) => (next: NextFunction) => async (action: StorageAction) => {\n      // Пропускаем действия кроме set\n      if (action.type !== 'set' || (segments.length && !segments.includes(action.metadata?.segment ?? 'default'))) {\n        return next(action)\n      }\n\n      const cacheKey = action.key!\n      const prevValue = valueCache.get(cacheKey)\n      const nextValue = action.value\n\n      // Если значения равны, возвращаем sentinel — не модифицируем значение\n      if (prevValue !== undefined && comparator(prevValue, nextValue)) {\n        return VALUE_NOT_CHANGED\n      }\n\n      // Иначе обновляем кэш и продолжаем\n      const result = await next(action)\n      valueCache.set(cacheKey, result !== undefined ? result : nextValue)\n      return result\n    },\n  }\n}\n"],"names":["VALUE_NOT_CHANGED","shallowCompareMiddleware","options","comparator","prev","next","keysA","Object","keysB","key","segments","valueCache","Map","api","action","cacheKey","prevValue","nextValue","undefined","result"],"mappings":";;;AAAsH;AAQ/G,MAAMC,wBAAwBA,GAAG,CAACC,UAA2C,CAAC,CAAC;IACpF,MAAM,EACJC,aAAa,CAACC,MAAWC;QACvB,IAAID,SAASC,MAAM,OAAO;QAE1B,IAAI,OAAOD,SAAS,YAAY,OAAOC,SAAS,YAAYD,SAAS,QAAQC,SAAS,MAAM;YAC1F,OAAOD,SAASC;QAClB;QAEA,MAAMC,QAAQC,OAAO,IAAI,CAACH;QAC1B,MAAMI,QAAQD,OAAO,IAAI,CAACF;QAE1B,IAAIC,MAAM,MAAM,KAAKE,MAAM,MAAM,EAAE,OAAO;QAE1C,OAAOF,MAAM,KAAK,CAAC,CAACG,MAAQF,OAAO,SAAS,CAAC,cAAc,CAAC,IAAI,CAACF,MAAMI,QAAQL,IAAI,CAACK,IAAI,KAAKJ,IAAI,CAACI,IAAI;IACxG,CAAC,EACDC,WAAW,EAAE,EACd,GAAGR;IAEJ,yBAAyB;IACzB,MAAMS,aAAa,IAAIC;IAEvB,OAAO;QACL,MAAM;QACN,OAAO,CAACC,OAAwB;QAChC,SAAS,CAACA,MAAuB,CAACR,OAAuB,OAAOS;oBAC9D,gCAAgC;oBAChC,IAAIA,OAAO,IAAI,KAAK,SAAUJ,SAAS,MAAM,IAAI,CAACA,SAAS,QAAQ,CAACI,OAAO,QAAQ,EAAE,WAAW,YAAa;wBAC3G,OAAOT,KAAKS;oBACd;oBAEA,MAAMC,WAAWD,OAAO,GAAG;oBAC3B,MAAME,YAAYL,WAAW,GAAG,CAACI;oBACjC,MAAME,YAAYH,OAAO,KAAK;oBAE9B,sEAAsE;oBACtE,IAAIE,cAAcE,aAAaf,WAAWa,WAAWC,YAAY;wBAC/D,OAAOjB,iBAAiBA;oBAC1B;oBAEA,mCAAmC;oBACnC,MAAMmB,SAAS,MAAMd,KAAKS;oBAC1BH,WAAW,GAAG,CAACI,UAAUI,WAAWD,YAAYC,SAASF;oBACzD,OAAOE;gBACT;IACF;AACF,EAAC"}

package/dist/core/storage/middlewares/sync-broadcast.middleware.d.ts

@@ -0,0 +1,9 @@
+import { StorageType } from '../storage.interface';
+import { SyncMiddleware } from '../utils/middleware-module';
+interface SyncSharedStateMiddlewareProps {
+    storageType: StorageType;
+    storageName: string;
+}
+export declare const syncBroadcastMiddleware: (props: SyncSharedStateMiddlewareProps) => SyncMiddleware;
+export {};
+//# sourceMappingURL=sync-broadcast.middleware.d.ts.map

package/dist/core/storage/middlewares/sync-broadcast.middleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync-broadcast.middleware.d.ts","sourceRoot":"","sources":["../../../../src/core/storage/middlewares/sync-broadcast.middleware.ts"],"names":[],"mappings":"AACA,OAAO,EAAiB,WAAW,EAAE,MAAM,sBAAsB,CAAA;AAEjE,OAAO,EAAiB,cAAc,EAAuC,MAAM,4BAA4B,CAAA;AAE/G,UAAU,8BAA8B;IACtC,WAAW,EAAE,WAAW,CAAA;IACxB,WAAW,EAAE,MAAM,CAAA;CACpB;AA+FD,eAAO,MAAM,uBAAuB,GAAI,OAAO,8BAA8B,KAAG,cA0F/E,CAAA"}