strata-storage 1.0.0

package/dist/features/query.js

@@ -0,0 +1,305 @@
+/**
+ * Query Engine Feature
+ * Zero-dependency implementation of MongoDB-like query operators
+ */
+/**
+ * Query engine for advanced data filtering
+ */
+export class QueryEngine {
+    /**
+     * Check if a value matches a query condition
+     */
+    matches(value, condition) {
+        // Handle null/undefined values
+        if (value === null || value === undefined) {
+            return this.matchesNull(value, condition);
+        }
+        // If condition is not an object, use direct equality
+        if (typeof condition !== 'object' || condition === null) {
+            return this.equals(value, condition);
+        }
+        // Handle special operators
+        if (this.hasOperators(condition)) {
+            return this.matchesOperators(value, condition);
+        }
+        // Handle nested object matching
+        if (typeof value === 'object' && value !== null) {
+            return this.matchesObject(value, condition);
+        }
+        return false;
+    }
+    /**
+     * Check if object has query operators
+     */
+    hasOperators(obj) {
+        return Object.keys(obj).some((key) => key.startsWith('$'));
+    }
+    /**
+     * Match value against operators
+     */
+    matchesOperators(value, operators) {
+        for (const [op, operand] of Object.entries(operators)) {
+            if (!this.matchesOperator(value, op, operand)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Match single operator
+     */
+    matchesOperator(value, operator, operand) {
+        switch (operator) {
+            case '$eq':
+                return this.equals(value, operand);
+            case '$ne':
+                return !this.equals(value, operand);
+            case '$gt':
+                return this.compare(value, operand) > 0;
+            case '$gte':
+                return this.compare(value, operand) >= 0;
+            case '$lt':
+                return this.compare(value, operand) < 0;
+            case '$lte':
+                return this.compare(value, operand) <= 0;
+            case '$in':
+                return Array.isArray(operand) && operand.some((v) => this.equals(value, v));
+            case '$nin':
+                return Array.isArray(operand) && !operand.some((v) => this.equals(value, v));
+            case '$regex':
+                return this.matchesRegex(value, operand);
+            case '$exists':
+                return (value !== undefined) === Boolean(operand);
+            case '$type':
+                return this.getType(value) === operand;
+            case '$and':
+                return Array.isArray(operand) && operand.every((cond) => this.matches(value, cond));
+            case '$or':
+                return Array.isArray(operand) && operand.some((cond) => this.matches(value, cond));
+            case '$not':
+                return !this.matches(value, operand);
+            default:
+                return false;
+        }
+    }
+    /**
+     * Match object against condition
+     */
+    matchesObject(obj, condition) {
+        for (const [key, value] of Object.entries(condition)) {
+            if (key.startsWith('$')) {
+                // Top-level operator
+                if (!this.matchesOperator(obj, key, value)) {
+                    return false;
+                }
+            }
+            else {
+                // Property match
+                const objValue = this.getNestedValue(obj, key);
+                if (!this.matches(objValue, value)) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+    /**
+     * Get nested value from object using dot notation
+     */
+    getNestedValue(obj, path) {
+        const parts = path.split('.');
+        let current = obj;
+        for (const part of parts) {
+            if (current === null || current === undefined) {
+                return undefined;
+            }
+            if (typeof current === 'object' && part in current) {
+                current = current[part];
+            }
+            else {
+                return undefined;
+            }
+        }
+        return current;
+    }
+    /**
+     * Check equality with proper type handling
+     */
+    equals(a, b) {
+        // Handle null/undefined
+        if (a === b)
+            return true;
+        if (a === null || b === null)
+            return false;
+        if (a === undefined || b === undefined)
+            return false;
+        // Handle dates
+        if (a instanceof Date && b instanceof Date) {
+            return a.getTime() === b.getTime();
+        }
+        // Handle arrays
+        if (Array.isArray(a) && Array.isArray(b)) {
+            if (a.length !== b.length)
+                return false;
+            return a.every((val, i) => this.equals(val, b[i]));
+        }
+        // Handle objects
+        if (typeof a === 'object' && typeof b === 'object') {
+            const aKeys = Object.keys(a);
+            const bKeys = Object.keys(b);
+            if (aKeys.length !== bKeys.length)
+                return false;
+            return aKeys.every((key) => this.equals(a[key], b[key]));
+        }
+        // Default comparison
+        return a === b;
+    }
+    /**
+     * Compare values
+     */
+    compare(a, b) {
+        // Handle null/undefined
+        if (a === b)
+            return 0;
+        if (a === null || a === undefined)
+            return -1;
+        if (b === null || b === undefined)
+            return 1;
+        // Handle dates
+        if (a instanceof Date && b instanceof Date) {
+            return a.getTime() - b.getTime();
+        }
+        // Handle numbers
+        if (typeof a === 'number' && typeof b === 'number') {
+            return a - b;
+        }
+        // Handle strings
+        if (typeof a === 'string' && typeof b === 'string') {
+            return a.localeCompare(b);
+        }
+        // Type mismatch - convert to string for comparison
+        return String(a).localeCompare(String(b));
+    }
+    /**
+     * Match regex pattern
+     */
+    matchesRegex(value, pattern) {
+        if (typeof value !== 'string')
+            return false;
+        const regex = pattern instanceof RegExp ? pattern : new RegExp(pattern);
+        return regex.test(value);
+    }
+    /**
+     * Get JavaScript type of value
+     */
+    getType(value) {
+        if (value === null)
+            return 'null';
+        if (value === undefined)
+            return 'undefined';
+        if (Array.isArray(value))
+            return 'array';
+        if (value instanceof Date)
+            return 'date';
+        if (value instanceof RegExp)
+            return 'regexp';
+        return typeof value;
+    }
+    /**
+     * Handle null/undefined matching
+     */
+    matchesNull(value, condition) {
+        // Direct null/undefined comparison
+        if (condition === null || condition === undefined) {
+            return value === condition;
+        }
+        // Handle operators
+        if (typeof condition === 'object' && this.hasOperators(condition)) {
+            return this.matchesOperators(value, condition);
+        }
+        return false;
+    }
+    /**
+     * Sort array of items by multiple fields
+     */
+    sort(items, sortBy) {
+        const sorted = [...items];
+        const sortKeys = Object.entries(sortBy);
+        sorted.sort((a, b) => {
+            for (const [key, direction] of sortKeys) {
+                const aVal = this.getNestedValue(a, key);
+                const bVal = this.getNestedValue(b, key);
+                const comparison = this.compare(aVal, bVal);
+                if (comparison !== 0) {
+                    return comparison * direction;
+                }
+            }
+            return 0;
+        });
+        return sorted;
+    }
+    /**
+     * Project/transform objects based on projection spec
+     */
+    project(item, projection) {
+        const result = {};
+        const isInclusion = Object.values(projection).some((v) => v === 1 || v === true);
+        if (isInclusion) {
+            // Inclusion mode - only include specified fields
+            for (const [key, include] of Object.entries(projection)) {
+                if (include === 1 || include === true) {
+                    const value = this.getNestedValue(item, key);
+                    if (value !== undefined) {
+                        this.setNestedValue(result, key, value);
+                    }
+                }
+            }
+        }
+        else {
+            // Exclusion mode - include all except specified fields
+            result.value = { ...item };
+            for (const [key, exclude] of Object.entries(projection)) {
+                if (exclude === 0 || exclude === false) {
+                    this.deleteNestedValue(result, key);
+                }
+            }
+        }
+        return result;
+    }
+    /**
+     * Set nested value in object using dot notation
+     */
+    setNestedValue(obj, path, value) {
+        const parts = path.split('.');
+        let current = obj;
+        for (let i = 0; i < parts.length - 1; i++) {
+            const part = parts[i];
+            if (!(part in current) || typeof current[part] !== 'object') {
+                current[part] = {};
+            }
+            current = current[part];
+        }
+        current[parts[parts.length - 1]] = value;
+    }
+    /**
+     * Delete nested value from object using dot notation
+     */
+    deleteNestedValue(obj, path) {
+        const parts = path.split('.');
+        let current = obj;
+        for (let i = 0; i < parts.length - 1; i++) {
+            const part = parts[i];
+            if (!(part in current) || typeof current[part] !== 'object') {
+                return;
+            }
+            current = current[part];
+        }
+        delete current[parts[parts.length - 1]];
+    }
+}
+/**
+ * Create a query engine instance
+ */
+export function createQueryEngine() {
+    return new QueryEngine();
+}

package/dist/features/sync.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Cross-tab Synchronization Feature
+ * Zero-dependency implementation using BroadcastChannel and storage events
+ */
+import { EventEmitter } from '@/utils';
+import type { StorageType, SubscriptionCallback, UnsubscribeFunction } from '@/types';
+/**
+ * Sync configuration
+ */
+export interface SyncConfig {
+    enabled?: boolean;
+    channelName?: string;
+    storages?: StorageType[];
+    conflictResolution?: 'latest' | 'merge' | ((conflicts: unknown[]) => unknown);
+    debounceMs?: number;
+}
+/**
+ * Sync message structure
+ */
+export interface SyncMessage {
+    type: 'set' | 'remove' | 'clear';
+    key?: string;
+    value?: unknown;
+    storage: StorageType;
+    timestamp: number;
+    origin: string;
+}
+/**
+ * Cross-tab synchronization manager
+ */
+export declare class SyncManager extends EventEmitter {
+    private config;
+    private channel?;
+    private origin;
+    private listeners;
+    private debounceTimers;
+    constructor(config?: SyncConfig);
+    /**
+     * Initialize sync manager
+     */
+    initialize(): Promise<void>;
+    /**
+     * Broadcast a change to other tabs
+     */
+    broadcast(message: Omit<SyncMessage, 'origin'>): void;
+    /**
+     * Subscribe to sync events
+     */
+    subscribe(callback: SubscriptionCallback): UnsubscribeFunction;
+    /**
+     * Close sync manager
+     */
+    close(): void;
+    /**
+     * Check if BroadcastChannel is available
+     */
+    private isBroadcastChannelAvailable;
+    /**
+     * Set up BroadcastChannel for cross-tab communication
+     */
+    private setupBroadcastChannel;
+    /**
+     * Set up storage event listeners for fallback sync
+     */
+    private setupStorageEvents;
+    /**
+     * Send message through available channels
+     */
+    private sendMessage;
+    /**
+     * Emit a change event
+     */
+    private emitChange;
+    /**
+     * Generate unique origin ID
+     */
+    private generateOrigin;
+    /**
+     * Resolve conflicts between values
+     */
+    resolveConflict(values: unknown[]): unknown;
+}
+/**
+ * Create a sync manager instance
+ */
+export declare function createSyncManager(config?: SyncConfig): SyncManager;
+//# sourceMappingURL=sync.d.ts.map

package/dist/features/sync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync.d.ts","sourceRoot":"","sources":["../../src/features/sync.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AACvC,OAAO,KAAK,EAEV,WAAW,EACX,oBAAoB,EACpB,mBAAmB,EACpB,MAAM,SAAS,CAAC;AAEjB;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,WAAW,EAAE,CAAC;IACzB,kBAAkB,CAAC,EAAE,QAAQ,GAAG,OAAO,GAAG,CAAC,CAAC,SAAS,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC,CAAC;IAC9E,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,KAAK,GAAG,QAAQ,GAAG,OAAO,CAAC;IACjC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,OAAO,EAAE,WAAW,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,qBAAa,WAAY,SAAQ,YAAY;IAC3C,OAAO,CAAC,MAAM,CAAuB;IACrC,OAAO,CAAC,OAAO,CAAC,CAAmB;IACnC,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,SAAS,CAAuE;IACxF,OAAO,CAAC,cAAc,CAA0C;gBAEpD,MAAM,GAAE,UAAe;IAYnC;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAYjC;;OAEG;IACH,SAAS,CAAC,OAAO,EAAE,IAAI,CAAC,WAAW,EAAE,QAAQ,CAAC,GAAG,IAAI;IAuBrD;;OAEG;IACH,SAAS,CAAC,QAAQ,EAAE,oBAAoB,GAAG,mBAAmB;IAY9D;;OAEG;IACH,KAAK,IAAI,IAAI;IAuBb;;OAEG;IACH,OAAO,CAAC,2BAA2B;IAInC;;OAEG;IACH,OAAO,CAAC,qBAAqB;IA6B7B;;OAEG;IACH,OAAO,CAAC,kBAAkB;IA+C1B;;OAEG;IACH,OAAO,CAAC,WAAW;IAcnB;;OAEG;IACH,OAAO,CAAC,UAAU;IAIlB;;OAEG;IACH,OAAO,CAAC,cAAc;IAItB;;OAEG;IACH,eAAe,CAAC,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO;CAyB5C;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,CAAC,EAAE,UAAU,GAAG,WAAW,CAElE"}

package/dist/features/sync.js

@@ -0,0 +1,233 @@
+/**
+ * Cross-tab Synchronization Feature
+ * Zero-dependency implementation using BroadcastChannel and storage events
+ */
+import { EventEmitter } from '@/utils';
+/**
+ * Cross-tab synchronization manager
+ */
+export class SyncManager extends EventEmitter {
+    config;
+    channel;
+    origin;
+    listeners = new Map();
+    debounceTimers = new Map();
+    constructor(config = {}) {
+        super();
+        this.config = {
+            enabled: config.enabled ?? true,
+            channelName: config.channelName || 'strata-sync',
+            storages: config.storages || ['localStorage', 'sessionStorage'],
+            conflictResolution: config.conflictResolution || 'latest',
+            debounceMs: config.debounceMs || 50,
+        };
+        this.origin = this.generateOrigin();
+    }
+    /**
+     * Initialize sync manager
+     */
+    async initialize() {
+        if (!this.config.enabled)
+            return;
+        // Set up BroadcastChannel if available
+        if (this.isBroadcastChannelAvailable()) {
+            this.setupBroadcastChannel();
+        }
+        // Set up storage event listeners
+        this.setupStorageEvents();
+    }
+    /**
+     * Broadcast a change to other tabs
+     */
+    broadcast(message) {
+        if (!this.config.enabled)
+            return;
+        const fullMessage = {
+            ...message,
+            origin: this.origin,
+        };
+        // Debounce broadcasts
+        const debounceKey = `${message.type}:${message.key || '*'}`;
+        if (this.debounceTimers.has(debounceKey)) {
+            clearTimeout(this.debounceTimers.get(debounceKey));
+        }
+        this.debounceTimers.set(debounceKey, setTimeout(() => {
+            this.sendMessage(fullMessage);
+            this.debounceTimers.delete(debounceKey);
+        }, this.config.debounceMs));
+    }
+    /**
+     * Subscribe to sync events
+     */
+    subscribe(callback) {
+        const handler = (change) => {
+            callback(change);
+        };
+        this.on('change', handler);
+        return () => {
+            this.off('change', handler);
+        };
+    }
+    /**
+     * Close sync manager
+     */
+    close() {
+        // Clear all debounce timers
+        for (const timer of this.debounceTimers.values()) {
+            clearTimeout(timer);
+        }
+        this.debounceTimers.clear();
+        // Close BroadcastChannel
+        if (this.channel) {
+            this.channel.close();
+            this.channel = undefined;
+        }
+        // Remove storage event listeners
+        this.listeners.forEach((listener) => {
+            window.removeEventListener('storage', listener);
+        });
+        this.listeners.clear();
+        // Remove all event listeners
+        this.removeAllListeners();
+    }
+    /**
+     * Check if BroadcastChannel is available
+     */
+    isBroadcastChannelAvailable() {
+        return typeof window !== 'undefined' && 'BroadcastChannel' in window;
+    }
+    /**
+     * Set up BroadcastChannel for cross-tab communication
+     */
+    setupBroadcastChannel() {
+        try {
+            this.channel = new BroadcastChannel(this.config.channelName);
+            this.channel.onmessage = (event) => {
+                const message = event.data;
+                // Ignore messages from self
+                if (message.origin === this.origin)
+                    return;
+                // Emit change event
+                this.emitChange({
+                    key: message.key || '*',
+                    oldValue: undefined,
+                    newValue: message.value,
+                    source: 'remote',
+                    storage: message.storage,
+                    timestamp: message.timestamp,
+                });
+            };
+            this.channel.onmessageerror = (event) => {
+                console.error('Sync message error:', event);
+            };
+        }
+        catch (error) {
+            console.warn('Failed to set up BroadcastChannel:', error);
+        }
+    }
+    /**
+     * Set up storage event listeners for fallback sync
+     */
+    setupStorageEvents() {
+        if (typeof window === 'undefined')
+            return;
+        const listener = (event) => {
+            // Only process events from other windows
+            if (event.storageArea !== window.localStorage)
+                return;
+            // Parse the storage type from key prefix
+            let storageType = 'localStorage';
+            if (event.key?.startsWith('strata:session:')) {
+                storageType = 'sessionStorage';
+            }
+            // Check if this storage type is enabled for sync
+            if (!this.config.storages.includes(storageType))
+                return;
+            let oldValue;
+            let newValue;
+            try {
+                oldValue = event.oldValue ? JSON.parse(event.oldValue) : undefined;
+                newValue = event.newValue ? JSON.parse(event.newValue) : undefined;
+            }
+            catch {
+                // If parsing fails, use raw values
+                oldValue = event.oldValue;
+                newValue = event.newValue;
+            }
+            this.emitChange({
+                key: event.key || '*',
+                oldValue,
+                newValue,
+                source: 'remote',
+                storage: storageType,
+                timestamp: Date.now(),
+            });
+        };
+        window.addEventListener('storage', listener);
+        // Create a SubscriptionCallback wrapper for the storage event listener
+        const subscriptionCallback = (_change) => {
+            // This is handled by the listener itself
+        };
+        this.listeners.set(subscriptionCallback, listener);
+    }
+    /**
+     * Send message through available channels
+     */
+    sendMessage(message) {
+        // Send through BroadcastChannel if available
+        if (this.channel) {
+            try {
+                this.channel.postMessage(message);
+            }
+            catch (error) {
+                console.error('Failed to send sync message:', error);
+            }
+        }
+        // Storage events are automatic when using localStorage
+        // No need to manually trigger them
+    }
+    /**
+     * Emit a change event
+     */
+    emitChange(change) {
+        this.emit('change', change);
+    }
+    /**
+     * Generate unique origin ID
+     */
+    generateOrigin() {
+        return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    }
+    /**
+     * Resolve conflicts between values
+     */
+    resolveConflict(values) {
+        if (values.length === 0)
+            return null;
+        if (values.length === 1)
+            return values[0];
+        if (typeof this.config.conflictResolution === 'function') {
+            return this.config.conflictResolution(values);
+        }
+        switch (this.config.conflictResolution) {
+            case 'latest':
+                // Return the last value (most recent)
+                return values[values.length - 1];
+            case 'merge':
+                // Simple merge for objects
+                if (values.every((v) => typeof v === 'object' && v !== null && !Array.isArray(v))) {
+                    return Object.assign({}, ...values);
+                }
+                // For non-objects, use latest
+                return values[values.length - 1];
+            default:
+                return values[values.length - 1];
+        }
+    }
+}
+/**
+ * Create a sync manager instance
+ */
+export function createSyncManager(config) {
+    return new SyncManager(config);
+}