strata-storage 2.4.2 → 2.5.0

package/dist/integrations/angular/index.js

@@ -0,0 +1,395 @@
+/**
+ * Angular integration for Strata Storage
+ */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var StrataModule_1;
+import { Injectable, InjectionToken, Inject, Optional, NgModule, Pipe, Directive, Input, HostListener, } from '@angular/core';
+import { NgControl } from '@angular/forms';
+import { Observable, BehaviorSubject, Subject, from, interval, combineLatest, throwError, } from 'rxjs';
+import { map, switchMap, catchError, takeUntil, distinctUntilChanged, shareReplay, startWith, filter, } from 'rxjs/operators';
+import { Strata } from "../../core/Strata.js";
+import { logger } from "../../utils/logger.js";
+// Configuration / instance injection tokens
+export const STRATA_CONFIG = new InjectionToken('strata.config');
+export const STRATA_INSTANCE = new InjectionToken('strata.instance');
+/**
+ * Strata Service - Main service for storage operations
+ */
+let StrataService = class StrataService {
+    strata;
+    destroy$ = new Subject();
+    initialized$ = new BehaviorSubject(false);
+    changes$ = new Subject();
+    constructor(instance, config) {
+        // Prefer a caller-provided instance (provider-free pattern); otherwise build
+        // one from the optional config token.
+        this.strata = instance ?? new Strata(config);
+        this.initialize();
+    }
+    async initialize() {
+        try {
+            await this.strata.initialize();
+            this.initialized$.next(true);
+            // Subscribe to all storage changes
+            this.strata.subscribe((change) => {
+                this.changes$.next(change);
+            });
+        }
+        catch (error) {
+            logger.error('Failed to initialize Strata:', error);
+            this.initialized$.next(false);
+        }
+    }
+    /**
+     * Wait for initialization
+     */
+    get ready$() {
+        return this.initialized$.pipe(filter((initialized) => initialized), startWith(false));
+    }
+    /**
+     * Get storage changes observable
+     */
+    get changes() {
+        return this.changes$.asObservable();
+    }
+    /**
+     * Get a value from storage
+     */
+    get(key, options) {
+        return this.ready$.pipe(switchMap(() => from(this.strata.get(key, options))), catchError((error) => {
+            logger.error(`Failed to get key ${key}:`, error);
+            return throwError(() => error);
+        }));
+    }
+    /**
+     * Set a value in storage
+     */
+    set(key, value, options) {
+        return this.ready$.pipe(switchMap(() => from(this.strata.set(key, value, options))), catchError((error) => {
+            logger.error(`Failed to set key ${key}:`, error);
+            return throwError(() => error);
+        }));
+    }
+    /**
+     * Remove a value from storage
+     */
+    remove(key, options) {
+        return this.ready$.pipe(switchMap(() => from(this.strata.remove(key, options))), catchError((error) => {
+            logger.error(`Failed to remove key ${key}:`, error);
+            return throwError(() => error);
+        }));
+    }
+    /**
+     * Check if key exists
+     */
+    has(key, options) {
+        return this.ready$.pipe(switchMap(() => from(this.strata.has(key, options))), catchError(() => from([false])));
+    }
+    /**
+     * Clear storage
+     */
+    clear(options) {
+        return this.ready$.pipe(switchMap(() => from(this.strata.clear(options))), catchError((error) => {
+            logger.error('Failed to clear storage:', error);
+            return throwError(() => error);
+        }));
+    }
+    /**
+     * Get all keys
+     */
+    keys(pattern, options) {
+        return this.ready$.pipe(switchMap(() => from(this.strata.keys(pattern, options))), catchError(() => from([[]])));
+    }
+    /**
+     * Query storage
+     */
+    query(condition, options) {
+        return this.ready$.pipe(switchMap(() => from(this.strata.query(condition, options))), catchError(() => from([[]])));
+    }
+    /**
+     * Get storage size
+     */
+    size(detailed) {
+        return this.ready$.pipe(switchMap(() => from(this.strata.size(detailed))), catchError(() => from([{ total: 0, count: 0 }])));
+    }
+    /**
+     * Watch a specific key
+     */
+    watch(key, options) {
+        return combineLatest([
+            this.get(key, options),
+            this.changes.pipe(filter((change) => change.key === key), map((change) => change.newValue)),
+        ]).pipe(map(([initial]) => initial), distinctUntilChanged(), shareReplay(1), takeUntil(this.destroy$));
+    }
+    /**
+     * Get TTL for a key
+     */
+    getTTL(key, options) {
+        return this.ready$.pipe(switchMap(() => from(this.strata.getTTL(key, options))), catchError(() => from([null])));
+    }
+    /**
+     * Extend TTL
+     */
+    extendTTL(key, extension, options) {
+        return this.ready$.pipe(switchMap(() => from(this.strata.extendTTL(key, extension, options))), catchError((error) => {
+            logger.error(`Failed to extend TTL for key ${key}:`, error);
+            return throwError(() => error);
+        }));
+    }
+    /**
+     * Make key persistent
+     */
+    persist(key, options) {
+        return this.ready$.pipe(switchMap(() => from(this.strata.persist(key, options))), catchError((error) => {
+            logger.error(`Failed to persist key ${key}:`, error);
+            return throwError(() => error);
+        }));
+    }
+    /**
+     * Generate secure password
+     */
+    generatePassword(length) {
+        return this.strata.generatePassword(length);
+    }
+    /**
+     * Hash data
+     */
+    hash(data) {
+        return from(this.strata.hash(data));
+    }
+    ngOnDestroy() {
+        this.destroy$.next();
+        this.destroy$.complete();
+        this.strata.close();
+    }
+};
+StrataService = __decorate([
+    Injectable({
+        providedIn: 'root',
+    }),
+    __param(0, Optional()),
+    __param(0, Inject(STRATA_INSTANCE)),
+    __param(1, Optional()),
+    __param(1, Inject(STRATA_CONFIG)),
+    __metadata("design:paramtypes", [Strata, Object])
+], StrataService);
+export { StrataService };
+/**
+ * Storage pipe for template usage
+ */
+let StoragePipe = class StoragePipe {
+    strata;
+    value = null;
+    key = null;
+    subscription = null;
+    constructor(strata) {
+        this.strata = strata;
+    }
+    transform(key, defaultValue) {
+        if (this.key !== key) {
+            this.key = key;
+            this.dispose();
+            this.subscription = this.strata
+                .watch(key)
+                .subscribe((value) => (this.value = value ?? defaultValue));
+        }
+        return this.value;
+    }
+    ngOnDestroy() {
+        this.dispose();
+    }
+    dispose() {
+        if (this.subscription) {
+            this.subscription.unsubscribe();
+            this.subscription = null;
+        }
+    }
+};
+StoragePipe = __decorate([
+    Pipe({
+        name: 'storage',
+        pure: false,
+    }),
+    __metadata("design:paramtypes", [StrataService])
+], StoragePipe);
+export { StoragePipe };
+/**
+ * TTL pipe for displaying time to live
+ */
+let TTLPipe = class TTLPipe {
+    strata;
+    ttl = null;
+    key = null;
+    subscription = null;
+    constructor(strata) {
+        this.strata = strata;
+    }
+    transform(key) {
+        if (this.key !== key) {
+            this.key = key;
+            this.dispose();
+            // Update TTL every second
+            this.subscription = interval(1000)
+                .pipe(startWith(0), switchMap(() => this.strata.getTTL(key)))
+                .subscribe((milliseconds) => {
+                if (milliseconds === null || milliseconds <= 0) {
+                    this.ttl = null;
+                }
+                else {
+                    this.ttl = this.formatTTL(milliseconds);
+                }
+            });
+        }
+        return this.ttl;
+    }
+    ngOnDestroy() {
+        this.dispose();
+    }
+    dispose() {
+        if (this.subscription) {
+            this.subscription.unsubscribe();
+            this.subscription = null;
+        }
+    }
+    formatTTL(milliseconds) {
+        const seconds = Math.floor(milliseconds / 1000);
+        const minutes = Math.floor(seconds / 60);
+        const hours = Math.floor(minutes / 60);
+        const days = Math.floor(hours / 24);
+        if (days > 0) {
+            return `${days}d ${hours % 24}h`;
+        }
+        else if (hours > 0) {
+            return `${hours}h ${minutes % 60}m`;
+        }
+        else if (minutes > 0) {
+            return `${minutes}m ${seconds % 60}s`;
+        }
+        else {
+            return `${seconds}s`;
+        }
+    }
+};
+TTLPipe = __decorate([
+    Pipe({
+        name: 'ttl',
+        pure: false,
+    }),
+    __metadata("design:paramtypes", [StrataService])
+], TTLPipe);
+export { TTLPipe };
+/**
+ * Storage directive for form inputs
+ */
+let StorageDirective = class StorageDirective {
+    control;
+    strata;
+    key;
+    strataOptions;
+    strataDebounce = 500;
+    subscription = null;
+    timeout = null;
+    constructor(control, strata) {
+        this.control = control;
+        this.strata = strata;
+    }
+    ngOnInit() {
+        // Load initial value
+        this.subscription = this.strata.get(this.key, this.strataOptions).subscribe((value) => {
+            if (value !== null && this.control.control) {
+                this.control.control.setValue(value, { emitEvent: false });
+            }
+        });
+    }
+    onValueChange(value) {
+        if (this.timeout) {
+            clearTimeout(this.timeout);
+        }
+        this.timeout = setTimeout(() => {
+            this.strata.set(this.key, value, this.strataOptions).subscribe();
+        }, this.strataDebounce);
+    }
+    ngOnDestroy() {
+        if (this.subscription) {
+            this.subscription.unsubscribe();
+        }
+        if (this.timeout) {
+            clearTimeout(this.timeout);
+        }
+    }
+};
+__decorate([
+    Input('strataStorage'),
+    __metadata("design:type", String)
+], StorageDirective.prototype, "key", void 0);
+__decorate([
+    Input(),
+    __metadata("design:type", Object)
+], StorageDirective.prototype, "strataOptions", void 0);
+__decorate([
+    Input(),
+    __metadata("design:type", Object)
+], StorageDirective.prototype, "strataDebounce", void 0);
+__decorate([
+    HostListener('input', ['$event.target.value']),
+    HostListener('change', ['$event.target.value']),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], StorageDirective.prototype, "onValueChange", null);
+StorageDirective = __decorate([
+    Directive({
+        selector: '[strataStorage]',
+    }),
+    __metadata("design:paramtypes", [NgControl,
+        StrataService])
+], StorageDirective);
+export { StorageDirective };
+/**
+ * Strata Module
+ */
+let StrataModule = StrataModule_1 = class StrataModule {
+    static forRoot(config) {
+        return {
+            ngModule: StrataModule_1,
+            providers: [{ provide: STRATA_CONFIG, useValue: config }, StrataService],
+        };
+    }
+};
+StrataModule = StrataModule_1 = __decorate([
+    NgModule({
+        declarations: [StoragePipe, TTLPipe, StorageDirective],
+        exports: [StoragePipe, TTLPipe, StorageDirective],
+    })
+], StrataModule);
+export { StrataModule };
+/**
+ * Standalone-Angular provider — supply a pre-created Strata instance (the
+ * provider-free, no-NgModule pattern) or a config object. Use it in
+ * bootstrapApplication() or a component's `providers`.
+ *
+ * @example
+ * ```ts
+ * import { defineStorage } from 'strata-storage';
+ * import { provideStrata } from 'strata-storage/angular';
+ * const storage = defineStorage();
+ * bootstrapApplication(AppComponent, { providers: [provideStrata(storage)] });
+ * ```
+ */
+export function provideStrata(instanceOrConfig) {
+    if (instanceOrConfig instanceof Strata) {
+        return [{ provide: STRATA_INSTANCE, useValue: instanceOrConfig }, StrataService];
+    }
+    return [{ provide: STRATA_CONFIG, useValue: instanceOrConfig ?? null }, StrataService];
+}

package/dist/integrations/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Framework integrations for Strata Storage
+ *
+ * Import the integration for your framework:
+ *
+ * React:
+ * import { StrataProvider, useStrata, useStorage } from 'strata-storage/react';
+ *
+ * Vue:
+ * import { StrataPlugin, useStrata, useStorage } from 'strata-storage/vue';
+ *
+ * Angular:
+ * import { StrataModule, StrataService } from 'strata-storage/angular';
+ */
+//# sourceMappingURL=index.d.ts.map

package/dist/integrations/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/integrations/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG"}

package/dist/integrations/index.js

@@ -0,0 +1,18 @@
+"use strict";
+/**
+ * Framework integrations for Strata Storage
+ *
+ * Import the integration for your framework:
+ *
+ * React:
+ * import { StrataProvider, useStrata, useStorage } from 'strata-storage/react';
+ *
+ * Vue:
+ * import { StrataPlugin, useStrata, useStorage } from 'strata-storage/vue';
+ *
+ * Angular:
+ * import { StrataModule, StrataService } from 'strata-storage/angular';
+ */
+// Note: Framework integrations are exported via separate entry points
+// This file is kept for backward compatibility but should not re-export
+// to avoid dependency issues

package/dist/integrations/react/index.d.ts

@@ -0,0 +1,75 @@
+/**
+ * React integration for Strata Storage.
+ *
+ * Two usage styles, both fully supported:
+ *
+ * 1. No-provider (Zustand-style, recommended): create an instance anywhere and
+ *    bind hooks to it with `createStrataHooks` — no Provider required.
+ *
+ *    ```tsx
+ *    import { defineStorage } from 'strata-storage';
+ *    import { createStrataHooks } from 'strata-storage/react';
+ *    const storage = defineStorage();
+ *    export const { useStorage } = createStrataHooks(storage);
+ *    ```
+ *
+ * 2. Provider-based (classic): wrap the tree in <StrataProvider> and call the
+ *    exported hooks, which read the instance from context.
+ */
+import { Strata } from '@/core/Strata';
+import type { StrataConfig, StorageOptions, QueryCondition } from '@/types';
+/**
+ * Bind the Strata hooks to a specific instance — the framework-agnostic,
+ * no-Provider pattern (mirrors Zustand's `create`). Call once at module scope
+ * and use the returned hooks in any component, no Provider needed.
+ *
+ * @example
+ * ```tsx
+ * const storage = defineStorage();
+ * export const { useStorage, useStorageQuery, useStorageTTL } =
+ *   createStrataHooks(storage);
+ * ```
+ */
+export declare function createStrataHooks(strata: Strata): {
+    useStorage: <T = unknown>(key: string, defaultValue?: T, options?: StorageOptions) => [T | null, (value: T | null, options?: StorageOptions) => Promise<void>, boolean];
+    useStorageQuery: <T = unknown>(condition: QueryCondition, options?: StorageOptions) => {
+        data: {
+            key: string;
+            value: T;
+        }[];
+        loading: boolean;
+        refetch: () => Promise<void>;
+    };
+    useStorageTTL: (key: string, options?: StorageOptions) => {
+        ttl: number | null;
+        extendTTL: (extension: number) => Promise<void>;
+        persist: () => Promise<void>;
+    };
+};
+interface StrataProviderProps {
+    children: React.ReactNode;
+    config?: StrataConfig;
+    /** Provide an existing instance instead of creating one from `config`. */
+    instance?: Strata;
+    loadingComponent?: React.ReactNode;
+    fallback?: React.ReactNode;
+}
+export declare function StrataProvider({ children, config, instance, loadingComponent, fallback, }: StrataProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function useStrata(): Strata;
+export declare function useStrataInitialized(): boolean;
+export declare function useStorage<T = unknown>(key: string, defaultValue?: T, options?: StorageOptions): [T | null, (value: T | null, options?: StorageOptions) => Promise<void>, boolean];
+export declare function useStorageQuery<T = unknown>(condition: QueryCondition, options?: StorageOptions): {
+    data: {
+        key: string;
+        value: T;
+    }[];
+    loading: boolean;
+    refetch: () => Promise<void>;
+};
+export declare function useStorageTTL(key: string, options?: StorageOptions): {
+    ttl: number | null;
+    extendTTL: (extension: number) => Promise<void>;
+    persist: () => Promise<void>;
+};
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/integrations/react/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/integrations/react/index.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAGH,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACvC,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAiB,cAAc,EAAE,MAAM,SAAS,CAAC;AA2H3F;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM;iBAC1B,CAAC,iBAAiB,MAAM,iBAAiB,CAAC,YAAY,cAAc,4CA1HhD,cAAc,KAAK,OAAO,CAAC,IAAI,CAAC;sBA6H/C,CAAC,uBAAuB,cAAc,YAAY,cAAc;;iBAhFnE,MAAM;;;iBAAwB,OAAO;iBAAW,MAAM,OAAO,CAAC,IAAI,CAAC;;yBAmF7D,MAAM,YAAY,cAAc;;+BAtCxC,MAAM;;;EA0C3B;AAgBD,UAAU,mBAAmB;IAC3B,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;IAC1B,MAAM,CAAC,EAAE,YAAY,CAAC;IACtB,0EAA0E;IAC1E,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,gBAAgB,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;IACnC,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;CAC5B;AAED,wBAAgB,cAAc,CAAC,EAC7B,QAAQ,EACR,MAAM,EACN,QAAQ,EACR,gBAAgB,EAChB,QAAQ,GACT,EAAE,mBAAmB,2CA+BrB;AAED,wBAAgB,SAAS,IAAI,MAAM,CAalC;AAED,wBAAgB,oBAAoB,IAAI,OAAO,CAE9C;AAED,wBAAgB,UAAU,CAAC,CAAC,GAAG,OAAO,EACpC,GAAG,EAAE,MAAM,EACX,YAAY,CAAC,EAAE,CAAC,EAChB,OAAO,CAAC,EAAE,cAAc,GACvB,CAAC,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,CAAC,EAAE,cAAc,KAAK,OAAO,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC,CAEnF;AAED,wBAAgB,eAAe,CAAC,CAAC,GAAG,OAAO,EAAE,SAAS,EAAE,cAAc,EAAE,OAAO,CAAC,EAAE,cAAc;;aAlLxE,MAAM;;;aAAwB,OAAO;aAAW,MAAM,OAAO,CAAC,IAAI,CAAC;EAoL1F;AAED,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,cAAc;;2BAzI7C,MAAM;;EA2I3B"}