synapse-storage 3.0.19 → 4.0.0

package/dist/core/storage/modules/singleton/models.js

@@ -0,0 +1,60 @@
+/**
+ * @example
+ * ```typescript
+ * // Строгая проверка - выбросит ошибку при любых различиях
+ * const storage1 = new MemoryStorage({
+ *   name: 'user',
+ *   singleton: {
+ *     enabled: true,
+ *     mergeStrategy: ConfigMergeStrategy.STRICT
+ *   },
+ *   initialState: { name: 'John' }
+ * })
+ *
+ * // Глубокое слияние - объединит объекты
+ * const storage2 = new MemoryStorage({
+ *   name: 'settings',
+ *   singleton: {
+ *     enabled: true,
+ *     mergeStrategy: ConfigMergeStrategy.DEEP_MERGE
+ *   },
+ *   initialState: { theme: 'dark', notifications: { email: true } }
+ * })
+ * ```
+ */ var models_ConfigMergeStrategy = /*#__PURE__*/ function(ConfigMergeStrategy) {
+    /**
+   * Строгая проверка - выбрасывает ошибку при любых отличиях в конфигурации
+   *
+   * Используйте когда требуется абсолютная идентичность конфигураций
+   * для обеспечения предсказуемого поведения
+   */ ConfigMergeStrategy["STRICT"] = "strict";
+    /**
+   * Первая конфигурация побеждает - игнорирует последующие конфигурации
+   *
+   * **По умолчанию**. Безопасная стратегия, которая использует настройки
+   * первого созданного экземпляра и игнорирует все последующие
+   */ ConfigMergeStrategy["FIRST_WINS"] = "first_wins";
+    /**
+   * Глубокое слияние объектов - рекурсивно объединяет initialState
+   *
+   * Полезно когда разные компоненты должны дополнять начальное состояние.
+   * Примитивные значения из первой конфигурации сохраняются
+   */ ConfigMergeStrategy["DEEP_MERGE"] = "deep_merge";
+    /**
+   * Последняя конфигурация перезаписывает предыдущие (кроме name)
+   *
+   * **Осторожно!** Может привести к непредсказуемому поведению,
+   * так как результат зависит от порядка создания компонентов
+   */ ConfigMergeStrategy["OVERRIDE"] = "override";
+    /**
+   * Предупреждение в консоли + использование первой конфигурации
+   *
+   * Как FIRST_WINS, но с подробными предупреждениями в консоли
+   * о конфликтующих настройках. Полезно для отладки
+   */ ConfigMergeStrategy["WARN_AND_USE_FIRST"] = "warn_and_use_first";
+    return ConfigMergeStrategy;
+}({});
+
+export { models_ConfigMergeStrategy as ConfigMergeStrategy };
+
+//# sourceMappingURL=models.js.map

package/dist/core/storage/modules/singleton/models.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"core/storage/modules/singleton/models.js","sources":["../../../../../src/core/storage/modules/singleton/models.ts"],"sourcesContent":["/**\n * @example\n * ```typescript\n * // Строгая проверка - выбросит ошибку при любых различиях\n * const storage1 = new MemoryStorage({\n *   name: 'user',\n *   singleton: {\n *     enabled: true,\n *     mergeStrategy: ConfigMergeStrategy.STRICT\n *   },\n *   initialState: { name: 'John' }\n * })\n *\n * // Глубокое слияние - объединит объекты\n * const storage2 = new MemoryStorage({\n *   name: 'settings',\n *   singleton: {\n *     enabled: true,\n *     mergeStrategy: ConfigMergeStrategy.DEEP_MERGE\n *   },\n *   initialState: { theme: 'dark', notifications: { email: true } }\n * })\n * ```\n */\nexport enum ConfigMergeStrategy {\n  /**\n   * Строгая проверка - выбрасывает ошибку при любых отличиях в конфигурации\n   *\n   * Используйте когда требуется абсолютная идентичность конфигураций\n   * для обеспечения предсказуемого поведения\n   */\n  STRICT = 'strict',\n\n  /**\n   * Первая конфигурация побеждает - игнорирует последующие конфигурации\n   *\n   * **По умолчанию**. Безопасная стратегия, которая использует настройки\n   * первого созданного экземпляра и игнорирует все последующие\n   */\n  FIRST_WINS = 'first_wins',\n\n  /**\n   * Глубокое слияние объектов - рекурсивно объединяет initialState\n   *\n   * Полезно когда разные компоненты должны дополнять начальное состояние.\n   * Примитивные значения из первой конфигурации сохраняются\n   */\n  DEEP_MERGE = 'deep_merge',\n\n  /**\n   * Последняя конфигурация перезаписывает предыдущие (кроме name)\n   *\n   * **Осторожно!** Может привести к непредсказуемому поведению,\n   * так как результат зависит от порядка создания компонентов\n   */\n  OVERRIDE = 'override',\n\n  /**\n   * Предупреждение в консоли + использование первой конфигурации\n   *\n   * Как FIRST_WINS, но с подробными предупреждениями в консоли\n   * о конфликтующих настройках. Полезно для отладки\n   */\n  WARN_AND_USE_FIRST = 'warn_and_use_first',\n}\n\n/**\n * Позволяет переиспользовать экземпляры хранилищ между компонентами\n * по имени, что особенно полезно в React при частых ре-рендерах\n *\n * @example\n * ```typescript\n * // Базовое использование\n * const storage = new MemoryStorage({\n *   name: 'user-preferences',\n *   singleton: { enabled: true },\n *   initialState: { theme: 'light' }\n * })\n *\n * // Продвинутые настройки\n * const storage = new MemoryStorage({\n *   name: 'shared-state',\n *   singleton: {\n *     enabled: true,\n *     mergeStrategy: ConfigMergeStrategy.DEEP_MERGE,\n *     warnOnConflict: true,\n *     key: 'custom-singleton-key'\n *   },\n *   initialState: { user: null, settings: {} }\n * })\n * ```\n *\n * @see {@link ConfigMergeStrategy} для стратегий разрешения конфликтов\n */\nexport interface SingletonOptions {\n  /**\n   * Включить Singleton Pattern для данного хранилища\n   *\n   * При `true` хранилища с одинаковым именем (или ключом) будут\n   * возвращать один и тот же экземпляр вместо создания нового\n   *\n   * @default false\n   */\n  enabled: boolean\n\n  /**\n   * Стратегия разрешения конфликтов при различающихся конфигурациях\n   *\n   * Определяет как поступать, когда singleton с тем же именем\n   * создается с отличающимися параметрами (initialState, middlewares и т.д.)\n   *\n   * @default ConfigMergeStrategy.FIRST_WINS\n   * @see {@link ConfigMergeStrategy}\n   */\n  mergeStrategy?: ConfigMergeStrategy\n\n  /**\n   * Выводить предупреждения при обнаружении конфликтов конфигурации\n   *\n   * При `true` будет логировать в консоль информацию о различиях\n   * в конфигурациях между экземплярами singleton (кроме стратегии STRICT)\n   *\n   * @default true\n   */\n  warnOnConflict?: boolean\n\n  /**\n   * Кастомный ключ для идентификации singleton экземпляра\n   *\n   * По умолчанию используется комбинация `{StorageType}_{name}`,\n   * но можно задать собственный ключ для более тонкого контроля\n   *\n   * @example\n   * ```typescript\n   * // Разные хранилища с одним именем, но разными ключами\n   * const userCache = new MemoryStorage({\n   *   name: 'user',\n   *   singleton: { enabled: true, key: 'user-cache' }\n   * })\n   *\n   * const userSettings = new LocalStorage({\n   *   name: 'user', // То же имя!\n   *   singleton: { enabled: true, key: 'user-settings' } // Но разный ключ\n   * })\n   * ```\n   *\n   * @default `${StorageType}_${name}`\n   */\n  key?: string\n}\n"],"names":["ConfigMergeStrategy"],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;CAuBC,GACM,IAAKA,0BAAmBA,0BAAnBA;IACV;;;;;GAKC;IAGD;;;;;GAKC;IAGD;;;;;GAKC;IAGD;;;;;GAKC;IAGD;;;;;GAKC;WAtCSA;MAwCX"}

package/dist/core/storage/modules/singleton/singleton.util.d.ts

@@ -0,0 +1,36 @@
+import { BaseStorageConfig, ILogger, StorageType } from '../../storage.interface';
+interface SingletonResult<T> {
+    instance: T;
+    isNewInstance: boolean;
+    appliedConfig: BaseStorageConfig;
+    conflicts?: string[];
+}
+export declare class SingletonManager {
+    private static instances;
+    private static configs;
+    private static logger?;
+    static setLogger(logger: ILogger): void;
+    static getOrCreate<T>(key: string, config: BaseStorageConfig, factory: (finalConfig: BaseStorageConfig) => T): SingletonResult<T>;
+    static exists(key: string): boolean;
+    static getConfig(key: string): BaseStorageConfig | undefined;
+    static remove(key: string): boolean;
+    static clear(): void;
+    static getStats(): {
+        instanceCount: number;
+        instances: string[];
+    };
+    private static mergeConfigurations;
+    private static strictMerge;
+    private static firstWinsMerge;
+    private static deepMerge;
+    private static overrideMerge;
+    private static warnAndUseFirst;
+    private static findConflicts;
+    private static findObjectConflicts;
+    private static deepMergeObjects;
+}
+export declare class SingletonKeyGenerator {
+    static generate(config: BaseStorageConfig, storageType: StorageType): string;
+}
+export {};
+//# sourceMappingURL=singleton.util.d.ts.map

package/dist/core/storage/modules/singleton/singleton.util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"singleton.util.d.ts","sourceRoot":"","sources":["../../../../../src/core/storage/modules/singleton/singleton.util.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAA;AAGjF,UAAU,eAAe,CAAC,CAAC;IACzB,QAAQ,EAAE,CAAC,CAAA;IACX,aAAa,EAAE,OAAO,CAAA;IACtB,aAAa,EAAE,iBAAiB,CAAA;IAChC,SAAS,CAAC,EAAE,MAAM,EAAE,CAAA;CACrB;AAED,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,MAAM,CAAC,SAAS,CAAyB;IACjD,OAAO,CAAC,MAAM,CAAC,OAAO,CAAuC;IAC7D,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,CAAS;IAE/B,MAAM,CAAC,SAAS,CAAC,MAAM,EAAE,OAAO,GAAG,IAAI;IAKvC,MAAM,CAAC,WAAW,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,iBAAiB,EAAE,OAAO,EAAE,CAAC,WAAW,EAAE,iBAAiB,KAAK,CAAC,GAAG,eAAe,CAAC,CAAC,CAAC;IAgCjI,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAKnC,MAAM,CAAC,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,iBAAiB,GAAG,SAAS;IAK5D,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAenC,MAAM,CAAC,KAAK,IAAI,IAAI;IAQpB,MAAM,CAAC,QAAQ,IAAI;QACjB,aAAa,EAAE,MAAM,CAAA;QACrB,SAAS,EAAE,MAAM,EAAE,CAAA;KACpB;IAOD,OAAO,CAAC,MAAM,CAAC,mBAAmB;IAyBlC,OAAO,CAAC,MAAM,CAAC,WAAW;IAU1B,OAAO,CAAC,MAAM,CAAC,cAAc;IAW7B,OAAO,CAAC,MAAM,CAAC,SAAS;IAaxB,OAAO,CAAC,MAAM,CAAC,aAAa;IAa5B,OAAO,CAAC,MAAM,CAAC,eAAe;IAa9B,OAAO,CAAC,MAAM,CAAC,aAAa;IAqB5B,OAAO,CAAC,MAAM,CAAC,mBAAmB;IA0BlC,OAAO,CAAC,MAAM,CAAC,gBAAgB;CAahC;AAGD,qBAAa,qBAAqB;IAChC,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,iBAAiB,EAAE,WAAW,EAAE,WAAW,GAAG,MAAM;CAS7E"}

package/dist/core/storage/modules/singleton/singleton.util.js

@@ -0,0 +1,216 @@
+import { ConfigMergeStrategy } from "./models.js";
+
+
+
+class SingletonManager {
+    static instances = new Map();
+    static configs = new Map();
+    static logger;
+    static setLogger(logger) {
+        this.logger = logger;
+    }
+    // Основной метод для создания/получения singleton
+    static getOrCreate(key, config, factory) {
+        const existingConfig = this.configs.get(key);
+        const existingInstance = this.instances.get(key);
+        // Если экземпляр уже существует
+        if (existingInstance && existingConfig) {
+            const mergeResult = this.mergeConfigurations(existingConfig, config);
+            return {
+                instance: existingInstance,
+                isNewInstance: false,
+                appliedConfig: mergeResult.finalConfig,
+                conflicts: mergeResult.conflicts
+            };
+        }
+        // Создаем новый экземпляр
+        const instance = factory(config);
+        this.instances.set(key, instance);
+        this.configs.set(key, {
+            ...config
+        });
+        this.logger?.debug(`Created new singleton instance: ${key}`);
+        return {
+            instance,
+            isNewInstance: true,
+            appliedConfig: config,
+            conflicts: []
+        };
+    }
+    // Проверка существования singleton
+    static exists(key) {
+        return this.instances.has(key);
+    }
+    // Получение конфигурации singleton
+    static getConfig(key) {
+        return this.configs.get(key);
+    }
+    // Удаление singleton из реестра (без вызова destroy)
+    static remove(key) {
+        const existed = this.instances.has(key);
+        if (existed) {
+            this.instances.delete(key);
+            this.configs.delete(key);
+            this.logger?.debug(`Removed singleton instance: ${key}`);
+            return true;
+        }
+        return false;
+    }
+    // Очистка реестра singleton (без вызова destroy)
+    static clear() {
+        this.instances.clear();
+        this.configs.clear();
+        this.logger?.debug('Cleared all singleton instances');
+    }
+    // Получение статистики
+    static getStats() {
+        return {
+            instanceCount: this.instances.size,
+            instances: Array.from(this.instances.keys())
+        };
+    }
+    static mergeConfigurations(existing, incoming) {
+        const strategy = incoming.singleton?.mergeStrategy || ConfigMergeStrategy.FIRST_WINS;
+        const warnOnConflict = incoming.singleton?.warnOnConflict ?? true;
+        switch(strategy){
+            case ConfigMergeStrategy.STRICT:
+                return this.strictMerge(existing, incoming);
+            case ConfigMergeStrategy.FIRST_WINS:
+                return this.firstWinsMerge(existing, incoming, warnOnConflict);
+            case ConfigMergeStrategy.DEEP_MERGE:
+                return this.deepMerge(existing, incoming);
+            case ConfigMergeStrategy.OVERRIDE:
+                return this.overrideMerge(existing, incoming);
+            case ConfigMergeStrategy.WARN_AND_USE_FIRST:
+                return this.warnAndUseFirst(existing, incoming);
+            default:
+                return this.firstWinsMerge(existing, incoming, warnOnConflict);
+        }
+    }
+    static strictMerge(existing, incoming) {
+        const conflicts = this.findConflicts(existing, incoming);
+        if (conflicts.length > 0) {
+            throw new Error(`Strict singleton validation failed for "${existing.name}". Conflicts: ${conflicts.join(', ')}`);
+        }
+        return {
+            finalConfig: existing,
+            conflicts: []
+        };
+    }
+    static firstWinsMerge(existing, incoming, warn) {
+        const conflicts = this.findConflicts(existing, incoming);
+        if (warn && conflicts.length > 0) {
+            this.logger?.warn(`Singleton config conflicts for "${existing.name}":`, conflicts);
+            this.logger?.warn('Using existing configuration');
+        }
+        return {
+            finalConfig: existing,
+            conflicts
+        };
+    }
+    static deepMerge(existing, incoming) {
+        const conflicts = this.findConflicts(existing, incoming);
+        const mergedConfig = {
+            ...existing,
+            initialState: this.deepMergeObjects(existing.initialState || {}, incoming.initialState || {})
+        };
+        this.logger?.debug(`Deep merged singleton config for "${existing.name}"`);
+        return {
+            finalConfig: mergedConfig,
+            conflicts
+        };
+    }
+    static overrideMerge(existing, incoming) {
+        const conflicts = this.findConflicts(existing, incoming);
+        const mergedConfig = {
+            ...incoming,
+            name: existing.name
+        };
+        this.logger?.warn(`Overriding singleton config for "${existing.name}"`);
+        return {
+            finalConfig: mergedConfig,
+            conflicts
+        };
+    }
+    static warnAndUseFirst(existing, incoming) {
+        const conflicts = this.findConflicts(existing, incoming);
+        if (conflicts.length > 0) {
+            this.logger?.warn(`Configuration conflicts detected for singleton "${existing.name}":`);
+            this.logger?.warn('Existing config:', existing);
+            this.logger?.warn('Incoming config:', incoming);
+            this.logger?.warn('Using existing configuration');
+        }
+        return {
+            finalConfig: existing,
+            conflicts
+        };
+    }
+    static findConflicts(config1, config2) {
+        const conflicts = [];
+        // Проверяем initialState
+        if (config1.initialState && config2.initialState) {
+            const stateConflicts = this.findObjectConflicts(config1.initialState, config2.initialState, 'initialState');
+            conflicts.push(...stateConflicts);
+        } else if (config1.initialState !== config2.initialState) {
+            conflicts.push('initialState: one is undefined');
+        }
+        // Проверяем middlewares (базовая проверка — поле живёт в SyncStorageConfig/AsyncStorageConfig)
+        const c1 = config1;
+        const c2 = config2;
+        if (!!c1.middlewares !== !!c2.middlewares) {
+            conflicts.push('middlewares: configuration differs');
+        }
+        return conflicts;
+    }
+    static findObjectConflicts(obj1, obj2, path) {
+        const conflicts = [];
+        const allKeys = new Set([
+            ...Object.keys(obj1 || {}),
+            ...Object.keys(obj2 || {})
+        ]);
+        for (const key of allKeys){
+            const currentPath = `${path}.${key}`;
+            const val1 = obj1?.[key];
+            const val2 = obj2?.[key];
+            if (val1 === val2) continue;
+            if (val1 === undefined || val2 === undefined) {
+                conflicts.push(`${currentPath}: missing in one config`);
+            } else if (typeof val1 !== typeof val2) {
+                conflicts.push(`${currentPath}: type mismatch (${typeof val1} vs ${typeof val2})`);
+            } else if (typeof val1 === 'object' && val1 !== null && val2 !== null) {
+                conflicts.push(...this.findObjectConflicts(val1, val2, currentPath));
+            } else {
+                conflicts.push(`${currentPath}: value mismatch (${val1} vs ${val2})`);
+            }
+        }
+        return conflicts;
+    }
+    static deepMergeObjects(target, source) {
+        const result = {
+            ...target
+        };
+        for(const key in source){
+            if (source[key] !== null && typeof source[key] === 'object' && !Array.isArray(source[key])) {
+                result[key] = this.deepMergeObjects(target[key] || {}, source[key]);
+            } else {
+                result[key] = source[key];
+            }
+        }
+        return result;
+    }
+}
+// Хелпер для генерации ключа singleton
+class SingletonKeyGenerator {
+    static generate(config, storageType) {
+        // Если указан кастомный ключ
+        if (config.singleton?.key) {
+            return config.singleton.key;
+        }
+        // Стандартный ключ: тип + имя
+        return `${storageType}_${config.name}`;
+    }
+}
+
+export { SingletonKeyGenerator, SingletonManager };
+
+//# sourceMappingURL=singleton.util.js.map

package/dist/core/storage/modules/singleton/singleton.util.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"core/storage/modules/singleton/singleton.util.js","sources":["../../../../../src/core/storage/modules/singleton/singleton.util.ts"],"sourcesContent":["import { BaseStorageConfig, ILogger, StorageType } from '../../storage.interface'\nimport { ConfigMergeStrategy } from './models'\n\ninterface SingletonResult<T> {\n  instance: T\n  isNewInstance: boolean\n  appliedConfig: BaseStorageConfig\n  conflicts?: string[]\n}\n\nexport class SingletonManager {\n  private static instances = new Map<string, any>()\n  private static configs = new Map<string, BaseStorageConfig>()\n  private static logger?: ILogger\n\n  static setLogger(logger: ILogger): void {\n    this.logger = logger\n  }\n\n  // Основной метод для создания/получения singleton\n  static getOrCreate<T>(key: string, config: BaseStorageConfig, factory: (finalConfig: BaseStorageConfig) => T): SingletonResult<T> {\n    const existingConfig = this.configs.get(key)\n    const existingInstance = this.instances.get(key)\n\n    // Если экземпляр уже существует\n    if (existingInstance && existingConfig) {\n      const mergeResult = this.mergeConfigurations(existingConfig, config)\n\n      return {\n        instance: existingInstance,\n        isNewInstance: false,\n        appliedConfig: mergeResult.finalConfig,\n        conflicts: mergeResult.conflicts,\n      }\n    }\n\n    // Создаем новый экземпляр\n    const instance = factory(config)\n    this.instances.set(key, instance)\n    this.configs.set(key, { ...config })\n\n    this.logger?.debug(`Created new singleton instance: ${key}`)\n\n    return {\n      instance,\n      isNewInstance: true,\n      appliedConfig: config,\n      conflicts: [],\n    }\n  }\n\n  // Проверка существования singleton\n  static exists(key: string): boolean {\n    return this.instances.has(key)\n  }\n\n  // Получение конфигурации singleton\n  static getConfig(key: string): BaseStorageConfig | undefined {\n    return this.configs.get(key)\n  }\n\n  // Удаление singleton из реестра (без вызова destroy)\n  static remove(key: string): boolean {\n    const existed = this.instances.has(key)\n\n    if (existed) {\n      this.instances.delete(key)\n      this.configs.delete(key)\n\n      this.logger?.debug(`Removed singleton instance: ${key}`)\n      return true\n    }\n\n    return false\n  }\n\n  // Очистка реестра singleton (без вызова destroy)\n  static clear(): void {\n    this.instances.clear()\n    this.configs.clear()\n\n    this.logger?.debug('Cleared all singleton instances')\n  }\n\n  // Получение статистики\n  static getStats(): {\n    instanceCount: number\n    instances: string[]\n  } {\n    return {\n      instanceCount: this.instances.size,\n      instances: Array.from(this.instances.keys()),\n    }\n  }\n\n  private static mergeConfigurations(existing: BaseStorageConfig, incoming: BaseStorageConfig): { finalConfig: BaseStorageConfig; conflicts: string[] } {\n    const strategy = incoming.singleton?.mergeStrategy || ConfigMergeStrategy.FIRST_WINS\n    const warnOnConflict = incoming.singleton?.warnOnConflict ?? true\n\n    switch (strategy) {\n      case ConfigMergeStrategy.STRICT:\n        return this.strictMerge(existing, incoming)\n\n      case ConfigMergeStrategy.FIRST_WINS:\n        return this.firstWinsMerge(existing, incoming, warnOnConflict)\n\n      case ConfigMergeStrategy.DEEP_MERGE:\n        return this.deepMerge(existing, incoming)\n\n      case ConfigMergeStrategy.OVERRIDE:\n        return this.overrideMerge(existing, incoming)\n\n      case ConfigMergeStrategy.WARN_AND_USE_FIRST:\n        return this.warnAndUseFirst(existing, incoming)\n\n      default:\n        return this.firstWinsMerge(existing, incoming, warnOnConflict)\n    }\n  }\n\n  private static strictMerge(existing: BaseStorageConfig, incoming: BaseStorageConfig): { finalConfig: BaseStorageConfig; conflicts: string[] } {\n    const conflicts = this.findConflicts(existing, incoming)\n\n    if (conflicts.length > 0) {\n      throw new Error(`Strict singleton validation failed for \"${existing.name}\". Conflicts: ${conflicts.join(', ')}`)\n    }\n\n    return { finalConfig: existing, conflicts: [] }\n  }\n\n  private static firstWinsMerge(existing: BaseStorageConfig, incoming: BaseStorageConfig, warn: boolean): { finalConfig: BaseStorageConfig; conflicts: string[] } {\n    const conflicts = this.findConflicts(existing, incoming)\n\n    if (warn && conflicts.length > 0) {\n      this.logger?.warn(`Singleton config conflicts for \"${existing.name}\":`, conflicts)\n      this.logger?.warn('Using existing configuration')\n    }\n\n    return { finalConfig: existing, conflicts }\n  }\n\n  private static deepMerge(existing: BaseStorageConfig, incoming: BaseStorageConfig): { finalConfig: BaseStorageConfig; conflicts: string[] } {\n    const conflicts = this.findConflicts(existing, incoming)\n\n    const mergedConfig: BaseStorageConfig = {\n      ...existing,\n      initialState: this.deepMergeObjects(existing.initialState || {}, incoming.initialState || {}),\n    }\n\n    this.logger?.debug(`Deep merged singleton config for \"${existing.name}\"`)\n\n    return { finalConfig: mergedConfig, conflicts }\n  }\n\n  private static overrideMerge(existing: BaseStorageConfig, incoming: BaseStorageConfig): { finalConfig: BaseStorageConfig; conflicts: string[] } {\n    const conflicts = this.findConflicts(existing, incoming)\n\n    const mergedConfig: BaseStorageConfig = {\n      ...incoming,\n      name: existing.name, // name никогда не перезаписываем\n    }\n\n    this.logger?.warn(`Overriding singleton config for \"${existing.name}\"`)\n\n    return { finalConfig: mergedConfig, conflicts }\n  }\n\n  private static warnAndUseFirst(existing: BaseStorageConfig, incoming: BaseStorageConfig): { finalConfig: BaseStorageConfig; conflicts: string[] } {\n    const conflicts = this.findConflicts(existing, incoming)\n\n    if (conflicts.length > 0) {\n      this.logger?.warn(`Configuration conflicts detected for singleton \"${existing.name}\":`)\n      this.logger?.warn('Existing config:', existing)\n      this.logger?.warn('Incoming config:', incoming)\n      this.logger?.warn('Using existing configuration')\n    }\n\n    return { finalConfig: existing, conflicts }\n  }\n\n  private static findConflicts(config1: BaseStorageConfig, config2: BaseStorageConfig): string[] {\n    const conflicts: string[] = []\n\n    // Проверяем initialState\n    if (config1.initialState && config2.initialState) {\n      const stateConflicts = this.findObjectConflicts(config1.initialState, config2.initialState, 'initialState')\n      conflicts.push(...stateConflicts)\n    } else if (config1.initialState !== config2.initialState) {\n      conflicts.push('initialState: one is undefined')\n    }\n\n    // Проверяем middlewares (базовая проверка — поле живёт в SyncStorageConfig/AsyncStorageConfig)\n    const c1 = config1 as Record<string, any>\n    const c2 = config2 as Record<string, any>\n    if (!!c1.middlewares !== !!c2.middlewares) {\n      conflicts.push('middlewares: configuration differs')\n    }\n\n    return conflicts\n  }\n\n  private static findObjectConflicts(obj1: any, obj2: any, path: string): string[] {\n    const conflicts: string[] = []\n\n    const allKeys = new Set([...Object.keys(obj1 || {}), ...Object.keys(obj2 || {})])\n\n    for (const key of allKeys) {\n      const currentPath = `${path}.${key}`\n      const val1 = obj1?.[key]\n      const val2 = obj2?.[key]\n\n      if (val1 === val2) continue\n\n      if (val1 === undefined || val2 === undefined) {\n        conflicts.push(`${currentPath}: missing in one config`)\n      } else if (typeof val1 !== typeof val2) {\n        conflicts.push(`${currentPath}: type mismatch (${typeof val1} vs ${typeof val2})`)\n      } else if (typeof val1 === 'object' && val1 !== null && val2 !== null) {\n        conflicts.push(...this.findObjectConflicts(val1, val2, currentPath))\n      } else {\n        conflicts.push(`${currentPath}: value mismatch (${val1} vs ${val2})`)\n      }\n    }\n\n    return conflicts\n  }\n\n  private static deepMergeObjects(target: any, source: any): any {\n    const result = { ...target }\n\n    for (const key in source) {\n      if (source[key] !== null && typeof source[key] === 'object' && !Array.isArray(source[key])) {\n        result[key] = this.deepMergeObjects(target[key] || {}, source[key])\n      } else {\n        result[key] = source[key]\n      }\n    }\n\n    return result\n  }\n}\n\n// Хелпер для генерации ключа singleton\nexport class SingletonKeyGenerator {\n  static generate(config: BaseStorageConfig, storageType: StorageType): string {\n    // Если указан кастомный ключ\n    if (config.singleton?.key) {\n      return config.singleton.key\n    }\n\n    // Стандартный ключ: тип + имя\n    return `${storageType}_${config.name}`\n  }\n}\n"],"names":["ConfigMergeStrategy","SingletonManager","Map","logger","key","config","factory","existingConfig","existingInstance","mergeResult","instance","existed","Array","existing","incoming","strategy","warnOnConflict","conflicts","Error","warn","mergedConfig","config1","config2","stateConflicts","c1","c2","obj1","obj2","path","allKeys","Set","Object","currentPath","val1","val2","undefined","target","source","result","SingletonKeyGenerator","storageType"],"mappings":"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"}

package/dist/core/storage/storage.interface.d.ts

@@ -0,0 +1,168 @@
+import { IndexedDBConfig } from './adapters/indexed-DB.service';
+import { BatchingMiddlewareOptions, ShallowCompareMiddlewareOptions } from './middlewares';
+import { SingletonOptions } from './modules/singleton/models';
+import { AsyncMiddleware, AsyncMiddlewareAPI, AsyncNextFunction, Middleware, MiddlewareAPI, NextFunction, StorageAction, SyncMiddleware, SyncMiddlewareAPI, SyncNextFunction } from './utils/middleware-module';
+import { StorageKeyType } from './utils/storage-key';
+export declare enum StorageStatus {
+    IDLE = "idle",
+    LOADING = "loading",
+    READY = "ready",
+    ERROR = "error"
+}
+export interface StorageInitStatus {
+    status: StorageStatus;
+    error?: Error;
+}
+export declare enum StorageEvents {
+    STORAGE_UPDATE = "storage:update",
+    STORAGE_DELETE = "storage:delete",
+    STORAGE_PATCH = "storage:patch",
+    STORAGE_SELECT = "storage:select",
+    STORAGE_CLEAR = "storage:clear",
+    STORAGE_DESTROY = "storage:destroy"
+}
+export interface StorageEvent<T = any> {
+    type: string;
+    payload?: T;
+    metadata?: Record<string, any>;
+}
+export interface IEventEmitter {
+    emit(event: StorageEvent): Promise<void>;
+}
+export interface ILogger {
+    debug(message: string, meta?: Record<string, any>): void;
+    info(message: string, meta?: Record<string, any>): void;
+    warn(message: string, meta?: Record<string, any>): void;
+    error(message: string, meta?: Record<string, any>): void;
+}
+export type { AsyncMiddleware, AsyncMiddlewareAPI, AsyncNextFunction, Middleware, MiddlewareAPI, NextFunction, StorageAction, SyncMiddleware, SyncMiddlewareAPI, SyncNextFunction };
+/**
+ * Базовый интерфейс для всех хранилищ.
+ * Содержит lifecycle, sync-доступ к кешу, подписки и метаданные.
+ */
+export interface IStorageBase<T extends Record<string, any> = any> {
+    /** Имя хранилища */
+    readonly name: string;
+    /** Тип хранилища */
+    readonly type: StorageType;
+    /** Инициализация хранилища (всегда async — загрузка данных, миграции и т.д.) */
+    initialize(): Promise<this>;
+    /** Уничтожение хранилища */
+    destroy(): Promise<void>;
+    /** Ожидание готовности хранилища */
+    waitForReady(): Promise<this>;
+    /** Синхронное получение состояния из кеша (доступно для всех типов хранилищ) */
+    getStateSync(): T;
+    /** Подписка на изменение конкретного ключа */
+    subscribe(key: StorageKeyType, callback: (value: any) => void): VoidFunction;
+    /** Подписка через path-selector */
+    subscribe<R>(pathSelector: (state: T) => R, callback: (value: R) => void): VoidFunction;
+    /** Подписка на все изменения хранилища */
+    subscribeToAll(callback: (event: {
+        type: string;
+        changedPaths?: string[];
+        key?: StorageKeyType[] | StorageKeyType;
+        value?: any;
+    }) => void): VoidFunction;
+    /** Текущий статус инициализации */
+    readonly initStatus: StorageInitStatus;
+    /** Подписка на изменение статуса инициализации */
+    onStatusChange(callback: (status: StorageInitStatus) => void): VoidFunction;
+}
+/**
+ * Синхронное хранилище.
+ * Memory и LocalStorage реализуют этот интерфейс.
+ * Все операции чтения/записи выполняются синхронно.
+ */
+export interface ISyncStorage<T extends Record<string, any> = any> extends IStorageBase<T> {
+    get<R>(key: StorageKeyType): R | undefined;
+    set<R>(key: StorageKeyType, value: R): void;
+    update(updater: (state: T) => void): void;
+    remove(key: StorageKeyType): void;
+    has(key: StorageKeyType): boolean;
+    clear(): void;
+    /** Сброс состояния к initialState (или к {} если initialState не задан) */
+    reset(): void;
+    keys(): string[];
+    getState(): T;
+}
+/**
+ * Асинхронное хранилище.
+ * IndexedDB реализует этот интерфейс.
+ * Все операции чтения/записи возвращают Promise.
+ */
+export interface IAsyncStorage<T extends Record<string, any> = any> extends IStorageBase<T> {
+    get<R>(key: StorageKeyType): Promise<R | undefined>;
+    set<R>(key: StorageKeyType, value: R): Promise<void>;
+    update(updater: (state: T) => void): Promise<void>;
+    remove(key: StorageKeyType): Promise<void>;
+    has(key: StorageKeyType): Promise<boolean>;
+    clear(): Promise<void>;
+    /** Сброс состояния к initialState (или к {} если initialState не задан) */
+    reset(): Promise<void>;
+    keys(): Promise<string[]>;
+    getState(): Promise<T>;
+}
+/**
+ * Union type — любое хранилище.
+ * Используется когда тип хранилища неизвестен на этапе компиляции.
+ */
+export type IStorage<T extends Record<string, any> = any> = ISyncStorage<T> | IAsyncStorage<T>;
+export type StorageType = 'memory' | 'localStorage' | 'indexedDB';
+export interface SyncDefaultMiddlewares {
+    batching: (options?: BatchingMiddlewareOptions) => SyncMiddleware;
+    shallowCompare: (options?: ShallowCompareMiddlewareOptions) => SyncMiddleware;
+}
+export interface AsyncDefaultMiddlewares {
+    batching: (options?: BatchingMiddlewareOptions) => AsyncMiddleware;
+    shallowCompare: (options?: ShallowCompareMiddlewareOptions) => AsyncMiddleware;
+}
+/** @deprecated Use SyncDefaultMiddlewares or AsyncDefaultMiddlewares */
+export type DefaultMiddlewares = AsyncDefaultMiddlewares;
+export type GetSyncDefaultMiddleware = () => SyncDefaultMiddlewares;
+export type GetAsyncDefaultMiddleware = () => AsyncDefaultMiddlewares;
+/** @deprecated Use GetAsyncDefaultMiddleware */
+export type GetDefaultMiddleware = GetAsyncDefaultMiddleware;
+export type ConfigureSyncMiddlewares = (getDefaultMiddleware: GetSyncDefaultMiddleware) => SyncMiddleware[];
+export type ConfigureAsyncMiddlewares = (getDefaultMiddleware: GetAsyncDefaultMiddleware) => AsyncMiddleware[];
+/** @deprecated Use ConfigureAsyncMiddlewares */
+export type ConfigureMiddlewares = ConfigureAsyncMiddlewares;
+/** Базовая конфигурация хранилища (общие поля) */
+export interface BaseStorageConfig<T extends Record<string, any> = Record<string, any>> {
+    name: string;
+    initialState?: T;
+    singleton?: SingletonOptions;
+}
+/** Конфигурация для sync-хранилищ (Memory, LocalStorage) */
+export interface SyncStorageConfig<T extends Record<string, any> = Record<string, any>> extends BaseStorageConfig<T> {
+    middlewares?: ConfigureSyncMiddlewares;
+}
+/** Конфигурация для async-хранилищ (IndexedDB) */
+export interface AsyncStorageConfig<T extends Record<string, any> = Record<string, any>> extends BaseStorageConfig<T> {
+    middlewares?: ConfigureAsyncMiddlewares;
+}
+/**
+ * @deprecated Use SyncStorageConfig or AsyncStorageConfig
+ * Обратная совместимость — общий StorageConfig
+ */
+export interface StorageConfig<T extends Record<string, any> = Record<string, any>> {
+    name: string;
+    initialState?: T;
+    middlewares?: ConfigureMiddlewares;
+}
+/** @deprecated Use SyncStorageConfig */
+export interface StorageSingletonConfig<T extends Record<string, any> = Record<string, any>> extends StorageConfig<T> {
+    singleton?: SingletonOptions;
+}
+export type MemoryStorageConfig<T extends Record<string, any> = Record<string, any>> = SyncStorageConfig<T>;
+export type LocalStorageConfig<T extends Record<string, any> = Record<string, any>> = SyncStorageConfig<T>;
+export interface IndexedDBStorageConfig<T extends Record<string, any> = Record<string, any>> extends AsyncStorageConfig<T> {
+    options: IndexedDBConfig;
+}
+/** Для универсальных методов (factory) — конфиг с явным типом */
+export interface UniversalStorageConfig<T extends Record<string, any> = Record<string, any>> extends BaseStorageConfig<T> {
+    type: StorageType;
+    middlewares?: ConfigureSyncMiddlewares | ConfigureAsyncMiddlewares;
+    options?: IndexedDBConfig;
+}
+//# sourceMappingURL=storage.interface.d.ts.map

package/dist/core/storage/storage.interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.interface.d.ts","sourceRoot":"","sources":["../../../src/core/storage/storage.interface.ts"],"names":[],"mappings":"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"}

package/dist/core/storage/storage.interface.js

@@ -0,0 +1,23 @@
+// storage.interface.ts
+// ─── Storage Status ────────────────────────────────────────────────────────────
+var storage_interface_StorageStatus = /*#__PURE__*/ function(StorageStatus) {
+    StorageStatus["IDLE"] = "idle";
+    StorageStatus["LOADING"] = "loading";
+    StorageStatus["READY"] = "ready";
+    StorageStatus["ERROR"] = "error";
+    return StorageStatus;
+}({});
+// ─── Storage Events ────────────────────────────────────────────────────────────
+var storage_interface_StorageEvents = /*#__PURE__*/ function(StorageEvents) {
+    StorageEvents["STORAGE_UPDATE"] = "storage:update";
+    StorageEvents["STORAGE_DELETE"] = "storage:delete";
+    StorageEvents["STORAGE_PATCH"] = "storage:patch";
+    StorageEvents["STORAGE_SELECT"] = "storage:select";
+    StorageEvents["STORAGE_CLEAR"] = "storage:clear";
+    StorageEvents["STORAGE_DESTROY"] = "storage:destroy";
+    return StorageEvents;
+}({});
+
+export { storage_interface_StorageEvents as StorageEvents, storage_interface_StorageStatus as StorageStatus };
+
+//# sourceMappingURL=storage.interface.js.map

package/dist/core/storage/storage.interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"core/storage/storage.interface.js","sources":["../../../src/core/storage/storage.interface.ts"],"sourcesContent":["// storage.interface.ts\nimport { IndexedDBConfig } from './adapters/indexed-DB.service'\nimport { BatchingMiddlewareOptions, ShallowCompareMiddlewareOptions } from './middlewares'\nimport { SingletonOptions } from './modules/singleton/models'\nimport {\n  AsyncMiddleware,\n  AsyncMiddlewareAPI,\n  AsyncNextFunction,\n  Middleware,\n  MiddlewareAPI,\n  NextFunction,\n  StorageAction,\n  SyncMiddleware,\n  SyncMiddlewareAPI,\n  SyncNextFunction,\n} from './utils/middleware-module'\nimport { StorageKeyType } from './utils/storage-key'\n\n// ─── Storage Status ────────────────────────────────────────────────────────────\n\nexport enum StorageStatus {\n  IDLE = 'idle',\n  LOADING = 'loading',\n  READY = 'ready',\n  ERROR = 'error',\n}\n\nexport interface StorageInitStatus {\n  status: StorageStatus\n  error?: Error\n}\n\n// ─── Storage Events ────────────────────────────────────────────────────────────\n\nexport enum StorageEvents {\n  STORAGE_UPDATE = 'storage:update',\n  STORAGE_DELETE = 'storage:delete',\n  STORAGE_PATCH = 'storage:patch',\n  STORAGE_SELECT = 'storage:select',\n  STORAGE_CLEAR = 'storage:clear',\n  STORAGE_DESTROY = 'storage:destroy',\n}\n\nexport interface StorageEvent<T = any> {\n  type: string\n  payload?: T\n  metadata?: Record<string, any>\n}\n\n// ─── Utility Interfaces ────────────────────────────────────────────────────────\n\nexport interface IEventEmitter {\n  emit(event: StorageEvent): Promise<void>\n}\n\nexport interface ILogger {\n  debug(message: string, meta?: Record<string, any>): void\n  info(message: string, meta?: Record<string, any>): void\n  warn(message: string, meta?: Record<string, any>): void\n  error(message: string, meta?: Record<string, any>): void\n}\n\n// ─── Middleware Types (re-exported from middleware-module) ─────────────────────\n\nexport type { AsyncMiddleware, AsyncMiddlewareAPI, AsyncNextFunction, Middleware, MiddlewareAPI, NextFunction, StorageAction, SyncMiddleware, SyncMiddlewareAPI, SyncNextFunction }\n\n// ─── Storage Interfaces ────────────────────────────────────────────────────────\n\n/**\n * Базовый интерфейс для всех хранилищ.\n * Содержит lifecycle, sync-доступ к кешу, подписки и метаданные.\n */\nexport interface IStorageBase<T extends Record<string, any> = any> {\n  /** Имя хранилища */\n  readonly name: string\n\n  /** Тип хранилища */\n  readonly type: StorageType\n\n  // ─── Lifecycle ─────────────────────────────────────────────────────────────\n\n  /** Инициализация хранилища (всегда async — загрузка данных, миграции и т.д.) */\n  initialize(): Promise<this>\n\n  /** Уничтожение хранилища */\n  destroy(): Promise<void>\n\n  /** Ожидание готовности хранилища */\n  waitForReady(): Promise<this>\n\n  // ─── Sync-доступ к кешу ────────────────────────────────────────────────────\n\n  /** Синхронное получение состояния из кеша (доступно для всех типов хранилищ) */\n  getStateSync(): T\n\n  // ─── Подписки ──────────────────────────────────────────────────────────────\n\n  /** Подписка на изменение конкретного ключа */\n  subscribe(key: StorageKeyType, callback: (value: any) => void): VoidFunction\n\n  /** Подписка через path-selector */\n  subscribe<R>(pathSelector: (state: T) => R, callback: (value: R) => void): VoidFunction\n\n  /** Подписка на все изменения хранилища */\n  subscribeToAll(callback: (event: { type: string; changedPaths?: string[]; key?: StorageKeyType[] | StorageKeyType; value?: any }) => void): VoidFunction\n\n  /** Текущий статус инициализации */\n  readonly initStatus: StorageInitStatus\n\n  /** Подписка на изменение статуса инициализации */\n  onStatusChange(callback: (status: StorageInitStatus) => void): VoidFunction\n}\n\n/**\n * Синхронное хранилище.\n * Memory и LocalStorage реализуют этот интерфейс.\n * Все операции чтения/записи выполняются синхронно.\n */\nexport interface ISyncStorage<T extends Record<string, any> = any> extends IStorageBase<T> {\n  get<R>(key: StorageKeyType): R | undefined\n  set<R>(key: StorageKeyType, value: R): void\n  update(updater: (state: T) => void): void\n  remove(key: StorageKeyType): void\n  has(key: StorageKeyType): boolean\n  clear(): void\n  /** Сброс состояния к initialState (или к {} если initialState не задан) */\n  reset(): void\n  keys(): string[]\n  getState(): T\n}\n\n/**\n * Асинхронное хранилище.\n * IndexedDB реализует этот интерфейс.\n * Все операции чтения/записи возвращают Promise.\n */\nexport interface IAsyncStorage<T extends Record<string, any> = any> extends IStorageBase<T> {\n  get<R>(key: StorageKeyType): Promise<R | undefined>\n  set<R>(key: StorageKeyType, value: R): Promise<void>\n  update(updater: (state: T) => void): Promise<void>\n  remove(key: StorageKeyType): Promise<void>\n  has(key: StorageKeyType): Promise<boolean>\n  clear(): Promise<void>\n  /** Сброс состояния к initialState (или к {} если initialState не задан) */\n  reset(): Promise<void>\n  keys(): Promise<string[]>\n  getState(): Promise<T>\n}\n\n/**\n * Union type — любое хранилище.\n * Используется когда тип хранилища неизвестен на этапе компиляции.\n */\nexport type IStorage<T extends Record<string, any> = any> = ISyncStorage<T> | IAsyncStorage<T>\n\n// ─── Config Types ──────────────────────────────────────────────────────────────\n\nexport type StorageType = 'memory' | 'localStorage' | 'indexedDB'\n\n// --- Default middleware helpers ---\n\nexport interface SyncDefaultMiddlewares {\n  batching: (options?: BatchingMiddlewareOptions) => SyncMiddleware\n  shallowCompare: (options?: ShallowCompareMiddlewareOptions) => SyncMiddleware\n}\n\nexport interface AsyncDefaultMiddlewares {\n  batching: (options?: BatchingMiddlewareOptions) => AsyncMiddleware\n  shallowCompare: (options?: ShallowCompareMiddlewareOptions) => AsyncMiddleware\n}\n\n/** @deprecated Use SyncDefaultMiddlewares or AsyncDefaultMiddlewares */\nexport type DefaultMiddlewares = AsyncDefaultMiddlewares\n\nexport type GetSyncDefaultMiddleware = () => SyncDefaultMiddlewares\nexport type GetAsyncDefaultMiddleware = () => AsyncDefaultMiddlewares\n\n/** @deprecated Use GetAsyncDefaultMiddleware */\nexport type GetDefaultMiddleware = GetAsyncDefaultMiddleware\n\nexport type ConfigureSyncMiddlewares = (getDefaultMiddleware: GetSyncDefaultMiddleware) => SyncMiddleware[]\nexport type ConfigureAsyncMiddlewares = (getDefaultMiddleware: GetAsyncDefaultMiddleware) => AsyncMiddleware[]\n\n/** @deprecated Use ConfigureAsyncMiddlewares */\nexport type ConfigureMiddlewares = ConfigureAsyncMiddlewares\n\n// --- Storage configs ---\n\n/** Базовая конфигурация хранилища (общие поля) */\nexport interface BaseStorageConfig<T extends Record<string, any> = Record<string, any>> {\n  name: string\n  initialState?: T\n  singleton?: SingletonOptions\n}\n\n/** Конфигурация для sync-хранилищ (Memory, LocalStorage) */\nexport interface SyncStorageConfig<T extends Record<string, any> = Record<string, any>> extends BaseStorageConfig<T> {\n  middlewares?: ConfigureSyncMiddlewares\n}\n\n/** Конфигурация для async-хранилищ (IndexedDB) */\nexport interface AsyncStorageConfig<T extends Record<string, any> = Record<string, any>> extends BaseStorageConfig<T> {\n  middlewares?: ConfigureAsyncMiddlewares\n}\n\n/**\n * @deprecated Use SyncStorageConfig or AsyncStorageConfig\n * Обратная совместимость — общий StorageConfig\n */\nexport interface StorageConfig<T extends Record<string, any> = Record<string, any>> {\n  name: string\n  initialState?: T\n  middlewares?: ConfigureMiddlewares\n}\n\n/** @deprecated Use SyncStorageConfig */\nexport interface StorageSingletonConfig<T extends Record<string, any> = Record<string, any>> extends StorageConfig<T> {\n  singleton?: SingletonOptions\n}\n\n// --- Specific storage configs ---\n\nexport type MemoryStorageConfig<T extends Record<string, any> = Record<string, any>> = SyncStorageConfig<T>\n\nexport type LocalStorageConfig<T extends Record<string, any> = Record<string, any>> = SyncStorageConfig<T>\n\nexport interface IndexedDBStorageConfig<T extends Record<string, any> = Record<string, any>> extends AsyncStorageConfig<T> {\n  options: IndexedDBConfig\n}\n\n/** Для универсальных методов (factory) — конфиг с явным типом */\nexport interface UniversalStorageConfig<T extends Record<string, any> = Record<string, any>> extends BaseStorageConfig<T> {\n  type: StorageType\n  middlewares?: ConfigureSyncMiddlewares | ConfigureAsyncMiddlewares\n  options?: IndexedDBConfig\n}\n"],"names":["StorageStatus","StorageEvents"],"mappings":"AAAA,uBAAuB;AAkBvB,kFAAkF;AAE3E,IAAKA,+BAAaA,0BAAbA;;;;;WAAAA;MAKX;AAOD,kFAAkF;AAE3E,IAAKC,+BAAaA,0BAAbA;;;;;;;WAAAA;MAOX"}