@quiltt/core 5.0.0 → 5.0.2

package/dist/storage/index.cjs

@@ -0,0 +1,272 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var index_cjs = require('../observables/index.cjs');
+
+/**
+ * An error and type safe wrapper for localStorage.
+ * It allows you to subscribe to changes;
+ * but localStorage changes only fire when another
+ * window updates the record.
+ */ class LocalStorage {
+    constructor(keyPrefix = 'quiltt'){
+        this.observers = {};
+        this.isEnabled = ()=>{
+            try {
+                const testKey = `${this.keyPrefix}.ping`;
+                localStorage.setItem(testKey, 'pong');
+                localStorage.removeItem(testKey);
+                return true;
+            } catch (_error) {
+                return false;
+            }
+        };
+        this.isDisabled = ()=>!this.isEnabled();
+        this.get = (key)=>{
+            if (typeof window === 'undefined' || typeof window.localStorage === 'undefined') {
+                return undefined;
+            }
+            const fullKey = this.getFullKey(key);
+            try {
+                const state = window.localStorage.getItem(fullKey);
+                return state ? JSON.parse(state) : null;
+            } catch (error) {
+                console.warn(`localStorage Error: "${fullKey}"`, error);
+                return undefined;
+            }
+        };
+        this.set = (key, state)=>{
+            if (typeof window === 'undefined' || typeof window.localStorage === 'undefined') return;
+            const fullKey = this.getFullKey(key);
+            try {
+                if (state !== null && state !== undefined) {
+                    window.localStorage.setItem(fullKey, JSON.stringify(state));
+                } else {
+                    window.localStorage.removeItem(fullKey);
+                }
+            } catch (error) {
+                console.warn(`localStorage Error: "${fullKey}"`, error);
+            }
+        };
+        this.remove = (key)=>{
+            if (typeof window === 'undefined' || typeof window.localStorage === 'undefined') return;
+            const fullKey = this.getFullKey(key);
+            try {
+                window.localStorage.removeItem(fullKey);
+            } catch (error) {
+                console.warn(`localStorage Error: "${fullKey}"`, error);
+            }
+        };
+        this.has = (key)=>{
+            return this.get(key) !== null && this.get(key) !== undefined;
+        };
+        this.clear = ()=>{
+            if (typeof window === 'undefined' || typeof window.localStorage === 'undefined') return;
+            try {
+                const keysToRemove = [];
+                for(let i = 0; i < localStorage.length; i++){
+                    const key = localStorage.key(i);
+                    if (key?.startsWith(`${this.keyPrefix}.`)) {
+                        keysToRemove.push(key);
+                    }
+                }
+                keysToRemove.forEach((key)=>{
+                    localStorage.removeItem(key);
+                });
+            } catch (error) {
+                console.warn(`localStorage Error during clear`, error);
+            }
+        };
+        this.subscribe = (key, observer)=>{
+            const fullKey = this.getFullKey(key);
+            if (!this.observers[fullKey]) {
+                this.observers[fullKey] = [];
+            }
+            this.observers[fullKey].push(observer);
+            // Return unsubscribe function
+            return ()=>this.unsubscribe(key, observer);
+        };
+        this.unsubscribe = (key, observer)=>{
+            const fullKey = this.getFullKey(key);
+            if (this.observers[fullKey]) {
+                this.observers[fullKey] = this.observers[fullKey].filter((update)=>update !== observer);
+                // Clean up empty observer arrays
+                if (this.observers[fullKey].length === 0) {
+                    delete this.observers[fullKey];
+                }
+            }
+        };
+        // Get all keys that match quiltt prefix
+        this.keys = ()=>{
+            if (typeof window === 'undefined' || typeof window.localStorage === 'undefined') {
+                return [];
+            }
+            const keys = [];
+            try {
+                for(let i = 0; i < localStorage.length; i++){
+                    const key = localStorage.key(i);
+                    if (key?.startsWith(`${this.keyPrefix}.`)) {
+                        keys.push(key.replace(`${this.keyPrefix}.`, ''));
+                    }
+                }
+            } catch (error) {
+                console.warn('localStorage Error getting keys', error);
+            }
+            return keys;
+        };
+        this.getFullKey = (key)=>{
+            return `${this.keyPrefix}.${key}`;
+        };
+        /**
+   * Handle storage events from other windows/tabs
+   * If there is a key, then trigger the related updates. If there is no key
+   * it means that a record has been removed and everything needs to be rechecked.
+   */ this.handleStorageEvent = (event)=>{
+            const isQuilttKey = event.key?.startsWith(`${this.keyPrefix}.`);
+            if (isQuilttKey && event.key) {
+                // Parse the new value safely
+                let newState = null;
+                try {
+                    newState = event.newValue ? JSON.parse(event.newValue) : null;
+                } catch (error) {
+                    console.warn(`Failed to parse storage event value for ${event.key}`, error);
+                    return;
+                }
+                if (this.observers[event.key]) {
+                    this.observers[event.key].forEach((observer)=>{
+                        try {
+                            observer(newState);
+                        } catch (error) {
+                            console.warn(`Observer error for key ${event.key}`, error);
+                        }
+                    });
+                }
+            } else if (!event.key) {
+                // Storage was cleared or changed in a way that doesn't specify a key
+                // Re-check all observed keys
+                Object.entries(this.observers).forEach(([fullKey, observers])=>{
+                    const shortKey = fullKey.replace(`${this.keyPrefix}.`, '');
+                    const currentValue = this.get(shortKey);
+                    observers.forEach((observer)=>{
+                        try {
+                            observer(currentValue);
+                        } catch (error) {
+                            console.warn(`Observer error for key ${fullKey}`, error);
+                        }
+                    });
+                });
+            }
+        };
+        this.keyPrefix = keyPrefix;
+        if (typeof window !== 'undefined' && typeof window.addEventListener !== 'undefined') {
+            window.addEventListener('storage', this.handleStorageEvent.bind(this));
+        }
+    }
+}
+
+/**
+ * This is designed to support effectively an in memory key value store singleton,
+ * similar to localStorage, but allows you to subscribe to changes within the current
+ * window.
+ */ class MemoryStorage {
+    constructor(){
+        this.observables = {};
+        this.get = (key)=>{
+            if (this.observables[key]) {
+                return this.observables[key].get();
+            }
+            return undefined;
+        };
+        this.set = (key, state)=>{
+            if (!this.observables[key]) {
+                this.observables[key] = new index_cjs.Observable(state);
+            } else {
+                this.observables[key].set(state);
+            }
+        };
+        this.subscribe = (key, observer)=>{
+            if (!this.observables[key]) this.observables[key] = new index_cjs.Observable();
+            this.observables[key].subscribe(observer);
+        };
+        this.unsubscribe = (key, observer)=>{
+            if (this.observables[key]) {
+                this.observables[key].unsubscribe(observer);
+            }
+        };
+    }
+}
+
+/**
+ * This is wraps both local and memory storage to create a unified interface, that
+ * allows you to subscribe to all either changes made within this window, or changes
+ * made by other windows.
+ */ class Storage {
+    constructor(){
+        this.memoryStore = new MemoryStorage();
+        this.localStore = new LocalStorage();
+        this.observers = {};
+        this.monitors = new Set();
+        /**
+   * Checks memoryStorage before falling back to localStorage.
+   */ this.get = (key)=>{
+            this.monitorLocalStorageChanges(key);
+            let state = this.memoryStore.get(key);
+            if (state === undefined) {
+                state = this.localStore.get(key);
+            }
+            return state;
+        };
+        /**
+   * We don't trust localStorage to always be present, so we can't rely on it to
+   * update memoryStorage based on emitted changes. So we manage our own
+   * emitting while using the underlying events to keep memoryStore in sync with
+   * localStore.
+   */ this.set = (key, newState)=>{
+            this.monitorLocalStorageChanges(key);
+            this.localStore.set(key, newState);
+            this.memoryStore.set(key, newState);
+            this.observers[key]?.forEach((update)=>{
+                update(newState);
+            });
+        };
+        /**
+   * Allows you to subscribe to all changes in memory or local storage as a
+   * single event.
+   */ this.subscribe = (key, observer)=>{
+            if (!this.observers[key]) this.observers[key] = [];
+            this.observers[key].push(observer);
+        };
+        this.unsubscribe = (key, observer)=>{
+            this.observers[key] = this.observers[key]?.filter((update)=>update !== observer);
+        };
+        /**
+   * Sets bubble the changes down the stack starting with memoryStore and then
+   * localStore. memoryStore will emit changes to everything within the current
+   * window context, while localStore will emit changes to every other window
+   * context.
+   *
+   * To ensure that the other windows are updated correctly, changes to localStore
+   * need to be subscribed and updated to in memory store, which then may be subscribed
+   * to outside of storage.
+   */ this.monitorLocalStorageChanges = (key)=>{
+            if (this.monitors.has(key)) return;
+            this.monitors.add(key);
+            this.localStore.subscribe(key, (nextState)=>{
+                const prevValue = this.memoryStore.get(key);
+                const newState = nextState instanceof Function ? nextState(prevValue) : nextState;
+                this.memoryStore.set(key, newState);
+                this.observers[key]?.forEach((update)=>{
+                    update(newState);
+                });
+            });
+        };
+    }
+}
+/**
+ * This is an singleton to share the memory states across all instances; This
+ * basically acts like shared memory when there is no localStorage.
+ */ const GlobalStorage = new Storage();
+
+exports.GlobalStorage = GlobalStorage;
+exports.LocalStorage = LocalStorage;
+exports.MemoryStorage = MemoryStorage;
+exports.Storage = Storage;

package/dist/storage/index.d.ts

@@ -0,0 +1,91 @@
+import { Observer } from '../observables/index.js';
+import { Maybe } from '../types.js';
+
+/**
+ * An error and type safe wrapper for localStorage.
+ * It allows you to subscribe to changes;
+ * but localStorage changes only fire when another
+ * window updates the record.
+ */
+declare class LocalStorage<T = any> {
+    private observers;
+    private readonly keyPrefix;
+    constructor(keyPrefix?: string);
+    isEnabled: () => boolean;
+    isDisabled: () => boolean;
+    get: (key: string) => Maybe<T> | undefined;
+    set: (key: string, state: Maybe<T> | undefined) => void;
+    remove: (key: string) => void;
+    has: (key: string) => boolean;
+    clear: () => void;
+    subscribe: (key: string, observer: Observer<T>) => (() => void);
+    unsubscribe: (key: string, observer: Observer<T>) => void;
+    keys: () => string[];
+    private getFullKey;
+    /**
+     * Handle storage events from other windows/tabs
+     * If there is a key, then trigger the related updates. If there is no key
+     * it means that a record has been removed and everything needs to be rechecked.
+     */
+    private handleStorageEvent;
+}
+
+/**
+ * This is designed to support effectively an in memory key value store singleton,
+ * similar to localStorage, but allows you to subscribe to changes within the current
+ * window.
+ */
+declare class MemoryStorage<T> {
+    private observables;
+    get: (key: string) => Maybe<T> | undefined;
+    set: (key: string, state: Maybe<T> | undefined) => void;
+    subscribe: (key: string, observer: Observer<T>) => void;
+    unsubscribe: (key: string, observer: Observer<T>) => void;
+}
+
+/**
+ * This is wraps both local and memory storage to create a unified interface, that
+ * allows you to subscribe to all either changes made within this window, or changes
+ * made by other windows.
+ */
+declare class Storage<T> {
+    private memoryStore;
+    private localStore;
+    private observers;
+    private monitors;
+    /**
+     * Checks memoryStorage before falling back to localStorage.
+     */
+    get: (key: string) => Maybe<T> | undefined;
+    /**
+     * We don't trust localStorage to always be present, so we can't rely on it to
+     * update memoryStorage based on emitted changes. So we manage our own
+     * emitting while using the underlying events to keep memoryStore in sync with
+     * localStore.
+     */
+    set: (key: string, newState: Maybe<T> | undefined) => void;
+    /**
+     * Allows you to subscribe to all changes in memory or local storage as a
+     * single event.
+     */
+    subscribe: (key: string, observer: Observer<T>) => void;
+    unsubscribe: (key: string, observer: Observer<T>) => void;
+    /**
+     * Sets bubble the changes down the stack starting with memoryStore and then
+     * localStore. memoryStore will emit changes to everything within the current
+     * window context, while localStore will emit changes to every other window
+     * context.
+     *
+     * To ensure that the other windows are updated correctly, changes to localStore
+     * need to be subscribed and updated to in memory store, which then may be subscribed
+     * to outside of storage.
+     */
+    private monitorLocalStorageChanges;
+}
+/**
+ * This is an singleton to share the memory states across all instances; This
+ * basically acts like shared memory when there is no localStorage.
+ */
+declare const GlobalStorage: Storage<any>;
+
+export { GlobalStorage, LocalStorage, MemoryStorage, Storage };

package/dist/{SubscriptionLink-12s-C2VbF8Tf.js → storage/index.js}

@@ -1,43 +1,4 @@
-'use client';
-import { ApolloLink } from '@apollo/client/core';
-import { createConsumer } from '@rails/actioncable';
-import { print } from 'graphql';
-import { Observable as Observable$1 } from 'rxjs';
-
-var name = "@quiltt/core";
-var version$1 = "5.0.0";
-
-const QUILTT_API_INSECURE = (()=>{
-    try {
-        return process.env.QUILTT_API_INSECURE === 'true';
-    } catch  {
-        return false;
-    }
-})();
-const QUILTT_API_DOMAIN = (()=>{
-    try {
-        return process.env.QUILTT_API_DOMAIN;
-    } catch  {
-        return undefined;
-    }
-})();
-const QUILTT_DEBUG = (()=>{
-    try {
-        return process.env.NODE_ENV !== 'production' && process.env.QUILTT_DEBUG === 'true';
-    } catch  {
-        return false;
-    }
-})();
-const domain = QUILTT_API_DOMAIN || 'quiltt.io';
-const protocolHttp = `http${QUILTT_API_INSECURE ? '' : 's'}`;
-const protocolWebsockets = `ws${QUILTT_API_INSECURE ? '' : 's'}`;
-const debugging = QUILTT_DEBUG;
-const version = `${name}: v${version$1}`;
-const cdnBase = `${protocolHttp}://cdn.${domain}`;
-const endpointAuth = `${protocolHttp}://auth.${domain}/v1/users/session`;
-const endpointGraphQL = `${protocolHttp}://api.${domain}/v1/graphql`;
-const endpointRest = `${protocolHttp}://api.${domain}/v1`;
-const endpointWebsockets = `${protocolWebsockets}://api.${domain}/websockets`;
+import { Observable } from '../observables/index.js';
 
 /**
  * An error and type safe wrapper for localStorage.
@@ -200,33 +161,6 @@ const endpointWebsockets = `${protocolWebsockets}://api.${domain}/websockets`;
     }
 }
 
-/**
- * This is designed to support singletons to share the memory states across all
- * instance of hooks to ensure that updates only process once, by storing a value
- * then notifying all subscribers when it's updated.
- */ class Observable {
-    constructor(initialState){
-        this.observers = [];
-        this.get = ()=>{
-            return this.state;
-        };
-        this.set = (nextState)=>{
-            if (this.state === nextState) return;
-            this.state = nextState;
-            this.observers.forEach((update)=>{
-                update(nextState);
-            });
-        };
-        this.subscribe = (observer)=>{
-            this.observers.push(observer);
-        };
-        this.unsubscribe = (observer)=>{
-            this.observers = this.observers.filter((update)=>update !== observer);
-        };
-        this.state = initialState;
-    }
-}
-
 /**
  * This is designed to support effectively an in memory key value store singleton,
  * similar to localStorage, but allows you to subscribe to changes within the current
@@ -330,75 +264,4 @@ const endpointWebsockets = `${protocolWebsockets}://api.${domain}/websockets`;
  * basically acts like shared memory when there is no localStorage.
  */ const GlobalStorage = new Storage();
 
-// Adapted from https://github.com/rmosolgo/graphql-ruby/blob/master/javascript_client/src/subscriptions/ActionCableLink.ts
-class ActionCableLink extends ApolloLink {
-    constructor(options){
-        super();
-        this.cables = {};
-        this.channelName = options.channelName || 'GraphqlChannel';
-        this.actionName = options.actionName || 'execute';
-        this.connectionParams = options.connectionParams || {};
-        this.callbacks = options.callbacks || {};
-    }
-    // Interestingly, this link does _not_ call through to `next` because
-    // instead, it sends the request to ActionCable.
-    request(operation, _next) {
-        const token = GlobalStorage.get('session');
-        if (!token) {
-            console.warn('QuilttClient attempted to send an unauthenticated Subscription');
-            return new Observable$1((observer)=>{
-                observer.error(new Error('No authentication token available'));
-            });
-        }
-        if (!this.cables[token]) {
-            this.cables[token] = createConsumer(endpointWebsockets + (token ? `?token=${token}` : ''));
-        }
-        return new Observable$1((observer)=>{
-            const channelId = Math.round(Date.now() + Math.random() * 100000).toString(16);
-            const actionName = this.actionName;
-            const connectionParams = typeof this.connectionParams === 'function' ? this.connectionParams(operation) : this.connectionParams;
-            const callbacks = this.callbacks;
-            const channel = this.cables[token].subscriptions.create(Object.assign({}, {
-                channel: this.channelName,
-                channelId: channelId
-            }, connectionParams), {
-                connected: (args)=>{
-                    channel.perform(actionName, {
-                        query: operation.query ? print(operation.query) : null,
-                        variables: operation.variables,
-                        // This is added for persisted operation support:
-                        operationId: operation.operationId,
-                        operationName: operation.operationName
-                    });
-                    callbacks.connected?.(args);
-                },
-                received: (payload)=>{
-                    if (payload?.result?.data || payload?.result?.errors) {
-                        observer.next(payload.result);
-                    }
-                    if (!payload.more) {
-                        observer.complete();
-                    }
-                    callbacks.received?.(payload);
-                },
-                disconnected: ()=>{
-                    callbacks.disconnected?.();
-                }
-            });
-            // Make the ActionCable subscription behave like an Apollo subscription
-            return Object.assign(channel, {
-                closed: false
-            });
-        });
-    }
-}
-
-class SubscriptionLink extends ActionCableLink {
-    constructor(){
-        super({
-            channelName: 'GraphQLChannel'
-        });
-    }
-}
-
-export { GlobalStorage as G, LocalStorage as L, MemoryStorage as M, Observable as O, SubscriptionLink as S, endpointAuth as a, endpointRest as b, Storage as c, debugging as d, endpointGraphQL as e, cdnBase as f, endpointWebsockets as g, version as v };
+export { GlobalStorage, LocalStorage, MemoryStorage, Storage };

package/dist/timing/index.cjs

@@ -0,0 +1,30 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/**
+ * This is designed to support singletons to timeouts that can broadcast
+ * to any observers, preventing race conditions with multiple timeouts.
+ */ class Timeoutable {
+    constructor(){
+        this.observers = [];
+        this.set = (callback, delay)=>{
+            if (this.timeout) {
+                clearTimeout(this.timeout);
+            }
+            // Replace all observers with the new one
+            this.observers = [
+                callback
+            ];
+            this.timeout = setTimeout(this.broadcast.bind(this), delay);
+        };
+        this.clear = (observer)=>{
+            this.observers = this.observers.filter((callback)=>callback !== observer);
+        };
+        // Only sends to the 1st listener, but ensures that someone is notified
+        this.broadcast = ()=>{
+            if (this.observers.length === 0) return;
+            this.observers[0](undefined);
+        };
+    }
+}
+
+exports.Timeoutable = Timeoutable;

package/dist/timing/index.d.ts

@@ -0,0 +1,15 @@
+import { Observer } from '../observables/index.js';
+
+/**
+ * This is designed to support singletons to timeouts that can broadcast
+ * to any observers, preventing race conditions with multiple timeouts.
+ */
+declare class Timeoutable {
+    private timeout?;
+    private observers;
+    set: (callback: () => void, delay: number | undefined) => void;
+    clear: (observer: Observer<void>) => void;
+    private broadcast;
+}
+
+export { Timeoutable };

package/dist/timing/index.js

@@ -0,0 +1,28 @@
+/**
+ * This is designed to support singletons to timeouts that can broadcast
+ * to any observers, preventing race conditions with multiple timeouts.
+ */ class Timeoutable {
+    constructor(){
+        this.observers = [];
+        this.set = (callback, delay)=>{
+            if (this.timeout) {
+                clearTimeout(this.timeout);
+            }
+            // Replace all observers with the new one
+            this.observers = [
+                callback
+            ];
+            this.timeout = setTimeout(this.broadcast.bind(this), delay);
+        };
+        this.clear = (observer)=>{
+            this.observers = this.observers.filter((callback)=>callback !== observer);
+        };
+        // Only sends to the 1st listener, but ensures that someone is notified
+        this.broadcast = ()=>{
+            if (this.observers.length === 0) return;
+            this.observers[0](undefined);
+        };
+    }
+}
+
+export { Timeoutable };

package/dist/types.cjs

@@ -0,0 +1 @@
+

package/dist/types.d.ts

@@ -0,0 +1,28 @@
+/** Utility types to extend default TS utilities */
+type Maybe<T> = T | null;
+type InputMaybe<T> = Maybe<T>;
+type Exact<T extends {
+    [key: string]: unknown;
+}> = {
+    [K in keyof T]: T[K];
+};
+type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]?: Maybe<T[SubKey]>;
+};
+type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]: Maybe<T[SubKey]>;
+};
+type Nullable<T> = {
+    [K in keyof T]: T[K] | null;
+};
+type Mutable<Type> = {
+    -readonly [Key in keyof Type]: Type[Key];
+};
+type DeepPartial<T> = T extends object ? {
+    [P in keyof T]?: DeepPartial<T[P]>;
+} : T;
+type DeepReadonly<T> = T extends object ? {
+    [P in keyof T]: DeepReadonly<T[P]>;
+} : T;
+
+export type { DeepPartial, DeepReadonly, Exact, InputMaybe, MakeMaybe, MakeOptional, Maybe, Mutable, Nullable };

package/dist/types.js

@@ -0,0 +1 @@
+