@nemigo/storage 1.5.0 → 1.7.0

package/dist/capacity.d.ts

@@ -0,0 +1,12 @@
+import { RuntimeStorage } from "./runtime.js";
+import type { IStorageSetOptions } from "./types.js";
+export interface ConstructCapacityStorage {
+    capacity: number;
+    ttl_seconds?: number;
+}
+export declare class CapacityStorage extends RuntimeStorage {
+    capacity: number;
+    constructor({ capacity, ttl_seconds }: ConstructCapacityStorage);
+    get<T = any>(key: string): T | undefined;
+    set(key: string, value: any, options?: IStorageSetOptions): void;
+}

package/dist/capacity.js

@@ -0,0 +1,39 @@
+import { RuntimeStorage } from "./runtime.js";
+export class CapacityStorage extends RuntimeStorage {
+    capacity;
+    constructor({ capacity, ttl_seconds }) {
+        super(ttl_seconds);
+        this.capacity = capacity;
+    }
+    get(key) {
+        const entry = super.__get(key);
+        if (!entry)
+            return;
+        // Обновляем порядок использования, чтобы сохранить от LRU-удаления
+        this.__storage.delete(key);
+        this.__storage.set(key, entry);
+        return entry.value;
+    }
+    set(key, value, options) {
+        this.__storage.delete(key);
+        if (this.__storage.size >= this.capacity) {
+            // Удаляем устаревшие элементы
+            for (const existingKey of this.__storage.keys()) {
+                const entry = this.__storage.get(existingKey);
+                if (!entry || this.__isExpired(entry)) {
+                    this.__storage.delete(existingKey);
+                }
+                if (this.__storage.size < this.capacity)
+                    break;
+            }
+            // Если всё ещё переполнен — удаляем LRU
+            if (this.__storage.size >= this.capacity) {
+                const firstKey = this.__storage.keys().next().value;
+                if (firstKey !== undefined) {
+                    this.__storage.delete(firstKey);
+                }
+            }
+        }
+        super.set(key, value, options);
+    }
+}

package/dist/cookie.d.ts

@@ -1,48 +1,42 @@
-import { VeilPrefixStorage } from "./internal/veil.js";
-import type { IStorage, IStorageValue, SetIStorageOptions } from "./types.js";
+import type { ConstructVeilPrefixStorage } from "./internal/veil-prefix.js";
+import { VeilPrefixStorage } from "./internal/veil-prefix.js";
+import type { IStorage, IStorageValue, IStorageSetOptions } from "./types.js";
 import type { SetDocumentCookieOptions } from "@nemigo/helpers/html/cookie";
-/**
- * Серверные readonly-куки для {@link CookieStorage}
- */
-export interface ServerCookie {
-    name: string;
-    value: string;
-}
 /**
  * Опции для {@link CookieStorage.set}
  */
-export interface SetCookieStorageOptions extends SetDocumentCookieOptions, SetIStorageOptions {
+export interface CookieStorageSetOptions extends SetDocumentCookieOptions, IStorageSetOptions {
     prefix?: string;
 }
 /**
  * Опции для {@link CookieStorage.delete}
  */
-export interface DeleteCookieStorageOptions {
+export interface CookieStorageDeleteOptions {
     Path?: string;
     prefix?: string;
 }
-export declare class CookieStorage extends VeilPrefixStorage implements IStorage {
+/**
+ * Серверные readonly-куки для {@link CookieStorage}
+ */
+export interface ServerCookie {
+    name: string;
+    value: string;
+}
+export interface ConstructCookieStorage extends ConstructVeilPrefixStorage {
+    cookies?: ServerCookie[];
+}
+export declare class CookieStorage extends VeilPrefixStorage implements IStorage<void> {
     __server: Map<string, string>;
-    /**
-     * TTL (time-to-live) хранилища
-     */
-    ttl_seconds?: number | null;
-    /**
-     * @remarks `options.ttl_seconds === null` делает хранение сессионным!
-     */
-    constructor({ cookies, prefix, ttl_seconds }: {
-        cookies?: ServerCookie[];
-        prefix?: string;
-        ttl_seconds?: number | null;
-    });
+    constructor(ctx?: ConstructCookieStorage);
     fill(cookies?: ServerCookie[]): void;
     __unveil<T>(value?: string | null): T | undefined;
+    has(name: string): boolean;
     get<T extends IStorageValue>(name: string, prefix?: string): T | undefined;
     /**
-     * @remarks `options.ttl_seconds === null` делает хранение сессионным!
+     * @remarks `options.ttl_seconds === undefined` делает хранение сессионным!
      */
-    set(name: string, value: IStorageValue, options?: SetCookieStorageOptions): void;
-    delete(name: string, options?: DeleteCookieStorageOptions): void;
+    set(name: string, value: IStorageValue, options?: CookieStorageSetOptions): void;
+    delete(name: string, options?: CookieStorageDeleteOptions): void;
     /**
      * Очистка серверных кук
      */

package/dist/cookie.js

@@ -1,20 +1,12 @@
-import { VeilPrefixStorage } from "./internal/veil.js";
+import { VeilPrefixStorage } from "./internal/veil-prefix.js";
 import { isSSR } from "@nemigo/helpers/html";
 import { deleteDocumentCookie, getDocumentCookie, setDocumentCookie } from "@nemigo/helpers/html/cookie";
 import { unveil, veil } from "@nemigo/helpers/veil";
 export class CookieStorage extends VeilPrefixStorage {
     __server = new Map();
-    /**
-     * TTL (time-to-live) хранилища
-     */
-    ttl_seconds;
-    /**
-     * @remarks `options.ttl_seconds === null` делает хранение сессионным!
-     */
-    constructor({ cookies, prefix, ttl_seconds }) {
-        super(prefix);
-        this.fill(cookies);
-        this.ttl_seconds = ttl_seconds;
+    constructor(ctx = {}) {
+        super(ctx);
+        this.fill(ctx.cookies);
     }
     fill(cookies = []) {
         for (const item of cookies)
@@ -24,19 +16,19 @@ export class CookieStorage extends VeilPrefixStorage {
     __unveil(value) {
         return value ? unveil(value) : undefined;
     }
+    has(name) {
+        return this.get(name) !== undefined;
+    }
     get(name, prefix) {
         const key = this.__toKey(name, prefix);
         return this.__unveil(isSSR ? this.__server.get(key) : getDocumentCookie(key));
     }
-    //...
     /**
-     * @remarks `options.ttl_seconds === null` делает хранение сессионным!
+     * @remarks `options.ttl_seconds === undefined` делает хранение сессионным!
      */
     set(name, value, options = {}) {
-        if (isSSR)
-            return;
-        const MaxAge = options.ttl_seconds !== undefined ? options.ttl_seconds : this.ttl_seconds;
-        setDocumentCookie(this.__toKey(name, options.prefix), veil(value), { ...options, MaxAge });
+        if (!isSSR)
+            setDocumentCookie(this.__toKey(name, options.prefix), veil(value), { ...options, MaxAge: options.ttl_seconds });
     }
     delete(name, options = {}) {
         if (!isSSR)

package/dist/derived/vault.d.ts

@@ -0,0 +1,66 @@
+import type { CanBePromise } from "@nemigo/helpers/types";
+import type { IStorage } from "@nemigo/storage/types";
+export interface VaultItem<PayloadData> {
+    /**
+     * Полезная нагрузка
+     */
+    pld: PayloadData;
+    /**
+     * Время создания (timestamp в секундах)
+     */
+    iat: number;
+    /**
+     * Абсолютное время истечения (timestamp в секундах). Если не задано — не устаревает
+     */
+    exp?: number;
+    /**
+     * Абсолютное время, до которого нельзя обновлять (timestamp в секундах)
+     */
+    upd?: number;
+}
+export interface VaultTimings {
+    /**
+     * Срок действия данных (в секундах). Если не задано — данные не устаревают
+     */
+    exp?: number;
+    /**
+     * Минимальный интервал до следующего обновления (в секундах).
+     * Если не задано — обновление разрешено в любой момент
+     */
+    upd?: number;
+}
+export interface VaultRunOptions<PayloadData> extends VaultTimings {
+    /**
+     * Использовать иные данные вместо генерации
+     */
+    overload?: PayloadData;
+    /**
+     * Принудительно перегенерировать, игнорируя тайминги
+     */
+    force?: boolean;
+    /**
+     * TTL в хранилище (в секундах, дельта от текущего момента)
+     */
+    ttl_seconds?: number;
+}
+export interface ConstructVault<PayloadData> extends VaultTimings {
+    /**
+     * Функция генерации полезной нагрузки
+     */
+    generate: (delta: VaultTimings, now_seconds: number) => CanBePromise<PayloadData>;
+    /**
+     * Функция сравнения двух полезных нагрузок на эквивалентность
+     */
+    equal: (a: PayloadData, b: PayloadData) => CanBePromise<boolean>;
+}
+export declare class Vault<PayloadData, Storage extends IStorage = IStorage> {
+    storage: Storage;
+    ctx: ConstructVault<PayloadData>;
+    constructor(storage: Storage, ctx: ConstructVault<PayloadData>);
+    find(key: string): CanBePromise<VaultItem<PayloadData> | undefined>;
+    check(key: string, pld: PayloadData): Promise<boolean>;
+    run(key: string, options?: VaultRunOptions<PayloadData>): Promise<{
+        generate: boolean;
+        item: VaultItem<PayloadData>;
+    }>;
+}

package/dist/derived/vault.js

@@ -0,0 +1,41 @@
+export class Vault {
+    storage;
+    ctx;
+    constructor(storage, ctx) {
+        this.storage = storage;
+        this.ctx = ctx;
+    }
+    find(key) {
+        return this.storage.get(key);
+    }
+    async check(key, pld) {
+        const existed = await this.find(key);
+        if (!existed)
+            return false;
+        return this.ctx.equal(existed.pld, pld);
+    }
+    async run(key, options = {}) {
+        const { ttl_seconds, exp = this.ctx.exp, upd = this.ctx.upd, force = false, overload } = options;
+        // работаем в секундах
+        const nowSec = Math.floor(Date.now() / 1000);
+        const existed = await this.find(key);
+        if (existed && !force) {
+            const expired = existed.exp !== undefined && nowSec > existed.exp;
+            const tooEarlyToUpdate = existed.upd !== undefined && nowSec < existed.upd;
+            if (!expired && !tooEarlyToUpdate) {
+                return { generate: false, item: existed };
+            }
+        }
+        // Вычисляем абсолютные времена для сохранения
+        const newExp = exp !== undefined ? nowSec + exp : undefined;
+        const newUpd = upd !== undefined ? nowSec + upd : undefined;
+        const item = {
+            pld: overload ?? (await this.ctx.generate({ exp, upd }, nowSec)),
+            iat: nowSec,
+            exp: newExp,
+            upd: newUpd,
+        };
+        await this.storage.set(key, item, { ttl_seconds });
+        return { generate: true, item };
+    }
+}

package/dist/internal/veil-prefix.d.ts

@@ -0,0 +1,13 @@
+export interface ConstructVeilPrefixStorage {
+    prefix?: string;
+    ttl_seconds?: number;
+}
+export declare abstract class VeilPrefixStorage {
+    /**
+     * TTL хранилища для быстрого использования
+     */
+    ttl_seconds?: number;
+    prefix: string;
+    constructor({ ttl_seconds, prefix }?: ConstructVeilPrefixStorage);
+    __toKey(name: string, prefix?: string): string;
+}

package/dist/internal/veil-prefix.js

@@ -0,0 +1,16 @@
+import { veil } from "@nemigo/helpers/veil";
+export class VeilPrefixStorage {
+    /**
+     * TTL хранилища для быстрого использования
+     */
+    ttl_seconds;
+    prefix;
+    // noinspection TypeScriptAbstractClassConstructorCanBeMadeProtected
+    constructor({ ttl_seconds, prefix = "" } = {}) {
+        this.prefix = prefix;
+        this.ttl_seconds = ttl_seconds;
+    }
+    __toKey(name, prefix = this.prefix) {
+        return prefix + veil(name);
+    }
+}

package/dist/runtime.d.ts

@@ -1,59 +1,20 @@
-import type { IStorage, IStorageValue, SetIStorageOptions } from "./types.js";
+import type { IStorage, IStorageValue, IStorageSetOptions } from "./types.js";
 import type { Timestamp } from "@nemigo/helpers/types";
-interface InternalValue {
+export interface EntryValue {
     value: IStorageValue;
     expired?: Timestamp;
 }
-/**
- * LRU (Least Recently Used) runtime-хранилище данных, имплементирующее интерфейс {@link IStorage}
- *
- * - Значения удаляются при превышении максимального размера или по истечении заданного TTL
- * - TTL для каждого значения используется из хранилища (если задано), но можно указать и индивидуальное
- *
- * @example
- * ```typescript
- * const storage = new RuntimeStorage({ max: 2, ttl_minutes: 5 });
- * storage.set('one', 1);
- * storage.set('two', 2);
- * storage.set('three', 3); // Если хранилище переполнено, удалится наименее недавно использованное или устаревшее значение
- * console.log(storage.get('one')); // undefined, если значение устарело или удалено
- * console.log(storage.get('two')); // 2
- * ```
- */
-export declare class RuntimeStorage implements IStorage {
-    __storage: Map<string, InternalValue>;
+export declare class RuntimeStorage implements IStorage<boolean> {
+    __storage: Map<string, EntryValue>;
     /**
-     * Максимальное количество значений в хранилище
+     * TTL хранилища для быстрого использования
      */
-    max: number;
-    /**
-     * TTL (time-to-live) хранилища в миллисекундах
-     */
-    ttl?: number | null;
-    /**
-     * @param options - Настройки хранилища
-     * @param [options.max=200] - Максимальное количество значений в хранилище
-     * @param [options.ttl_seconds] - TTL (time-to-live) хранилища в **секундах**
-     */
-    constructor({ max, ttl_seconds }?: {
-        max?: number;
-        ttl_seconds?: number | null;
-    });
-    __isExpired(entry: InternalValue): boolean;
+    ttl_seconds?: number;
+    constructor(ttl_seconds?: number);
+    __isExpired(entry: EntryValue): boolean;
+    __get(key: string): EntryValue | undefined;
+    has(key: string): boolean;
     get<T = any>(key: string): T | undefined;
-    /**
-     * Устанавливает значение в кэш
-     *
-     * - Если индивидуальный TTL в **секундах** не указан, используется TTL хранилища (если задано)
-     * - Если ключ уже существует, его значение обновляется и перемещается в конец
-     * - Если размер хранимых значений превышает максимальное значение, производится очистка устаревших
-     * - Если после очистки хранилище всё ещё переполнено, удаляется наименее недавно использованное значение
-     */
-    set(key: string, value: any, options?: SetIStorageOptions): void;
-    size(): number;
-    shake(): void;
+    set(key: string, value: any, options?: IStorageSetOptions): void;
     delete(key: string): boolean;
-    clear(): void;
-    has(key: string): boolean;
 }
-export {};

package/dist/runtime.js

@@ -1,116 +1,37 @@
-import { getTTL } from "./internal/index.js";
-/**
- * LRU (Least Recently Used) runtime-хранилище данных, имплементирующее интерфейс {@link IStorage}
- *
- * - Значения удаляются при превышении максимального размера или по истечении заданного TTL
- * - TTL для каждого значения используется из хранилища (если задано), но можно указать и индивидуальное
- *
- * @example
- * ```typescript
- * const storage = new RuntimeStorage({ max: 2, ttl_minutes: 5 });
- * storage.set('one', 1);
- * storage.set('two', 2);
- * storage.set('three', 3); // Если хранилище переполнено, удалится наименее недавно использованное или устаревшее значение
- * console.log(storage.get('one')); // undefined, если значение устарело или удалено
- * console.log(storage.get('two')); // 2
- * ```
- */
 export class RuntimeStorage {
     __storage;
     /**
-     * Максимальное количество значений в хранилище
+     * TTL хранилища для быстрого использования
      */
-    max;
-    /**
-     * TTL (time-to-live) хранилища в миллисекундах
-     */
-    ttl;
-    /**
-     * @param options - Настройки хранилища
-     * @param [options.max=200] - Максимальное количество значений в хранилище
-     * @param [options.ttl_seconds] - TTL (time-to-live) хранилища в **секундах**
-     */
-    constructor({ max = 200, ttl_seconds } = {}) {
-        this.max = max;
-        this.ttl = ttl_seconds ? ttl_seconds * 1000 : ttl_seconds;
+    ttl_seconds;
+    constructor(ttl_seconds) {
         this.__storage = new Map();
+        this.ttl_seconds = ttl_seconds;
     }
     __isExpired(entry) {
         return Boolean(entry.expired && Date.now() > entry.expired);
     }
-    get(key) {
+    __get(key) {
         const entry = this.__storage.get(key);
         if (!entry)
-            return undefined;
+            return;
         if (this.__isExpired(entry)) {
             this.__storage.delete(key);
-            return undefined;
-        }
-        // Обновляем порядок использования, чтобы сохранить от LRU-удаления
-        this.__storage.delete(key);
-        this.__storage.set(key, entry);
-        return entry.value;
-    }
-    /**
-     * Устанавливает значение в кэш
-     *
-     * - Если индивидуальный TTL в **секундах** не указан, используется TTL хранилища (если задано)
-     * - Если ключ уже существует, его значение обновляется и перемещается в конец
-     * - Если размер хранимых значений превышает максимальное значение, производится очистка устаревших
-     * - Если после очистки хранилище всё ещё переполнено, удаляется наименее недавно использованное значение
-     */
-    set(key, value, options) {
-        if (this.__storage.has(key)) {
-            this.__storage.delete(key);
         }
         else {
-            if (this.__storage.size >= this.max) {
-                // Удаляем устаревшие элементы
-                for (const existingKey of this.__storage.keys()) {
-                    const entry = this.__storage.get(existingKey);
-                    if (!entry || this.__isExpired(entry)) {
-                        this.__storage.delete(existingKey);
-                    }
-                    if (this.__storage.size < this.max)
-                        break;
-                }
-                // Если всё ещё переполнен — удаляем LRU
-                if (this.__storage.size >= this.max) {
-                    const firstKey = this.__storage.keys().next().value;
-                    if (firstKey !== undefined) {
-                        this.__storage.delete(firstKey);
-                    }
-                }
-            }
+            return entry;
         }
-        const expired = getTTL(options?.ttl_seconds, this.ttl);
-        this.__storage.set(key, expired ? { value, expired } : { value });
     }
-    size() {
-        return this.__storage.size;
+    has(key) {
+        return Boolean(this.__get(key));
+    }
+    get(key) {
+        return this.__get(key)?.value;
     }
-    shake() {
-        for (const existingKey of this.__storage.keys()) {
-            const entry = this.__storage.get(existingKey);
-            if (!entry || this.__isExpired(entry)) {
-                this.__storage.delete(existingKey);
-            }
-        }
+    set(key, value, options) {
+        this.__storage.set(key, options?.ttl_seconds ? { value, expired: options.ttl_seconds * 1000 } : { value });
     }
     delete(key) {
         return this.__storage.delete(key);
     }
-    clear() {
-        this.__storage.clear();
-    }
-    has(key) {
-        const entry = this.__storage.get(key);
-        if (!entry)
-            return false;
-        if (this.__isExpired(entry)) {
-            this.__storage.delete(key);
-            return false;
-        }
-        return true;
-    }
 }

package/dist/types.d.ts

@@ -6,33 +6,53 @@ export type IStorageValue = object | string | boolean | number | null;
 /**
  * Опции для {@link IStorage.set}
  */
-export interface SetIStorageOptions {
+export interface IStorageSetOptions {
     /**
-     * @remarks `null` поведение может отличаться у разных имплементаций!
+     * @remarks `undefined` поведение может быть особым у разных имплементаций!
      */
-    ttl_seconds?: number | null;
+    ttl_seconds?: number;
 }
 /**
  * Интерфейс для синхронных хранилищ данных для полиморфизма
  *
  * Используется только там, где нельзя использовать {@link IStorage}
  */
-export interface ISyncStorage {
-    get<T extends IStorageValue>(key: string): T | undefined;
-    set(key: string, value: IStorageValue, options?: SetIStorageOptions): void;
+export interface ISyncStorage<Delete extends boolean | void = boolean | void> {
+    get<T extends IStorageValue>(name: string): T | undefined;
+    set(name: string, value: IStorageValue, options?: IStorageSetOptions): void;
     /**
-     * @return `true`, если оно существовало. Допускаются имплементации без проверки
+     * @return `true`, если оно существовало. Допускаются имплементации без этого
      */
-    delete(key: string): boolean | void;
+    delete(name: string): Delete;
+    /**
+     * Обычно просто `Boolean(this.get(name))`, но могут быть более производительные способы
+     */
+    has(name: string): boolean;
 }
 /**
  * Интерфейс для всех хранилищ данных для полиморфизма
  */
-export interface IStorage {
-    get<T extends IStorageValue>(key: string): CanBePromise<T | undefined>;
-    set(key: string, value: IStorageValue, options?: SetIStorageOptions): CanBePromise;
+export interface IStorage<Delete extends boolean | void = boolean | void> {
+    get<T extends IStorageValue>(name: string): CanBePromise<T | undefined>;
+    set(name: string, value: IStorageValue, options?: IStorageSetOptions): CanBePromise;
+    /**
+     * @return `true`, если оно существовало. Допускаются имплементации без этого
+     */
+    delete(name: string): CanBePromise<Delete>;
     /**
-     * @return `true`, если оно существовало. Допускаются имплементации без проверки
+     * Обычно просто `Boolean(this.get(name))`, но могут быть более производительные способы
      */
-    delete(key: string): CanBePromise<boolean | void>;
+    has(name: string): CanBePromise<boolean>;
+}
+export interface ISyncStoragePanic<Delete extends boolean | void = boolean | void> {
+    onhas?(err: unknown): boolean | never;
+    onget?<V extends IStorageValue = IStorageValue>(err: unknown): V | undefined | never;
+    ondelete?(err: unknown): Delete | never;
+    onset?(err: unknown): undefined | never;
+}
+export interface IStoragePanic<Delete extends boolean | void = boolean | void> {
+    onhas?(err: unknown): CanBePromise<boolean | never>;
+    onget?<V extends IStorageValue = IStorageValue>(err: unknown): CanBePromise<V | undefined | never>;
+    ondelete?(err: unknown): CanBePromise<Delete | never>;
+    onset?(err: unknown): CanBePromise<undefined | never>;
 }

package/dist/web.d.ts

@@ -1,28 +1,20 @@
-import { VeilPrefixStorage } from "./internal/veil.js";
-import type { IStorage, IStorageValue, SetIStorageOptions } from "./types.js";
+import { VeilPrefixStorage } from "./internal/veil-prefix.js";
+import type { IStorage, IStorageValue, IStorageSetOptions } from "./types.js";
+import type { Timestamp } from "@nemigo/helpers/types";
 export type WebStorageType = "local" | "session";
 export interface WebStorageOptions {
     type?: WebStorageType;
     prefix?: string;
 }
-export declare class WebStorage extends VeilPrefixStorage implements IStorage {
-    /**
-     * TTL (time-to-live) хранилища в миллисекундах
-     */
-    ttl?: number | null;
-    /**
-     * @param options - Настройки хранилища
-     * @param [options.ttl_seconds] - TTL (time-to-live) хранилища в **секундах**
-     */
-    constructor({ ttl_seconds, prefix }?: {
-        prefix?: string;
-        ttl_seconds?: number | null;
-    });
+export interface EntryValue {
+    value: IStorageValue;
+    expired?: Timestamp;
+}
+export declare class WebStorage extends VeilPrefixStorage implements IStorage<void> {
+    __isExpired(entry: EntryValue): boolean;
     __get<T>(storage: Storage, key: string): T | undefined;
+    has(name: string, options?: WebStorageOptions): boolean;
     get<T extends IStorageValue>(name: string, options?: WebStorageOptions): T | undefined;
-    set(name: string, value: IStorageValue, options?: SetIStorageOptions & WebStorageOptions): void;
-    delete(name: string, options?: {
-        type?: WebStorageType;
-        prefix?: string;
-    }): boolean | void;
+    set(name: string, value: IStorageValue, options?: IStorageSetOptions & WebStorageOptions): void;
+    delete(name: string, options?: WebStorageOptions): void;
 }

package/dist/web.js

@@ -1,32 +1,25 @@
-import { getTTL } from "./internal/index.js";
-import { VeilPrefixStorage } from "./internal/veil.js";
+import { VeilPrefixStorage } from "./internal/veil-prefix.js";
 import { isSSR } from "@nemigo/helpers/html";
 import { unveil, veil } from "@nemigo/helpers/veil";
 export class WebStorage extends VeilPrefixStorage {
-    /**
-     * TTL (time-to-live) хранилища в миллисекундах
-     */
-    ttl;
-    /**
-     * @param options - Настройки хранилища
-     * @param [options.ttl_seconds] - TTL (time-to-live) хранилища в **секундах**
-     */
-    constructor({ ttl_seconds, prefix } = {}) {
-        super(prefix);
-        this.ttl = ttl_seconds ? ttl_seconds * 1000 : ttl_seconds;
+    __isExpired(entry) {
+        return Boolean(entry.expired && Date.now() > entry.expired);
     }
     __get(storage, key) {
         const entry = storage.getItem(key);
         if (!entry)
             return;
-        const encoded = unveil(entry);
-        if (encoded.expired && Date.now() > encoded.expired) {
+        const unveiled = unveil(entry);
+        if (this.__isExpired(unveiled)) {
             storage.removeItem(key);
         }
         else {
-            return encoded.value;
+            return unveiled.value;
         }
     }
+    has(name, options) {
+        return Boolean(this.get(name, options));
+    }
     get(name, options = {}) {
         if (isSSR)
             return;
@@ -44,13 +37,11 @@ export class WebStorage extends VeilPrefixStorage {
         if (isSSR)
             return;
         const key = this.__toKey(name, options.prefix);
-        const expired = getTTL(options.ttl_seconds, this.ttl);
-        const internalValue = expired ? { value, expired } : { value };
-        const _value = veil(internalValue);
+        const veiled = veil(options.ttl_seconds ? { value, expired: options.ttl_seconds * 1000 } : { value });
         if (options.type === "session")
-            sessionStorage.setItem(key, _value);
+            sessionStorage.setItem(key, veiled);
         else
-            localStorage.setItem(key, _value);
+            localStorage.setItem(key, veiled);
     }
     delete(name, options = {}) {
         if (isSSR)

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@nemigo/storage",
-	"version": "1.5.0",
+	"version": "1.7.0",
 	"private": false,
 	"author": {
 		"name": "Vlad Logvin",
@@ -18,17 +18,21 @@
 		"format": "prettier --write ./"
 	},
 	"exports": {
+		"./capacity": {
+			"types": "./dist/capacity.d.ts",
+			"default": "./dist/capacity.js"
+		},
 		"./cookie": {
 			"types": "./dist/cookie.d.ts",
 			"default": "./dist/cookie.js"
 		},
-		"./internal": {
-			"types": "./dist/internal/index.d.ts",
-			"default": "./dist/internal/index.js"
+		"./derived/vault": {
+			"types": "./dist/derived/vault.d.ts",
+			"default": "./dist/derived/vault.js"
 		},
-		"./internal/veil": {
-			"types": "./dist/internal/veil.d.ts",
-			"default": "./dist/internal/veil.js"
+		"./internal/veil-prefix": {
+			"types": "./dist/internal/veil-prefix.d.ts",
+			"default": "./dist/internal/veil-prefix.js"
 		},
 		"./runtime": {
 			"types": "./dist/runtime.d.ts",
@@ -44,7 +48,7 @@
 		}
 	},
 	"peerDependencies": {
-		"@nemigo/helpers": ">=1.5.0"
+		"@nemigo/helpers": ">=1.6.0"
 	},
 	"devDependencies": {
 		"@nemigo/configs": "workspace:*",

package/dist/internal/index.d.ts

@@ -1 +0,0 @@
-export declare const getTTL: (entry_in_seconds?: number | null, storage?: number | null) => number | null | undefined;

package/dist/internal/index.js

@@ -1,10 +0,0 @@
-export const getTTL = (entry_in_seconds, storage) => {
-    if (entry_in_seconds)
-        return Date.now() + entry_in_seconds * 1000;
-    if (entry_in_seconds === null)
-        return null;
-    if (storage)
-        return Date.now() + storage;
-    if (storage === null)
-        return null;
-};

package/dist/internal/veil.d.ts

@@ -1,5 +0,0 @@
-export declare abstract class VeilPrefixStorage {
-    prefix: string;
-    protected constructor(prefix?: string);
-    __toKey(name: string, prefix: string | undefined): string;
-}

package/dist/internal/veil.js

@@ -1,10 +0,0 @@
-import { veil } from "@nemigo/helpers/veil";
-export class VeilPrefixStorage {
-    prefix;
-    constructor(prefix = "") {
-        this.prefix = prefix;
-    }
-    __toKey(name, prefix) {
-        return (prefix === undefined ? this.prefix : prefix) + veil(name);
-    }
-}