@quiltt/core 3.5.3 → 3.5.5

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # @quiltt/core
 
+## 3.5.5
+
+### Patch Changes
+
+- [#218](https://github.com/quiltt/quiltt-js/pull/218) [`7dd42db`](https://github.com/quiltt/quiltt-js/commit/7dd42dbc744805d68fbff8fbed73a4bd68022b44) Thanks [@tom-quiltt](https://github.com/tom-quiltt)! - Fix changeset md to release packages
+
+- [#213](https://github.com/quiltt/quiltt-js/pull/213) [`5648e3c`](https://github.com/quiltt/quiltt-js/commit/5648e3c91d572d97ad88115710ab840b98e1d469) Thanks [@zubairaziz](https://github.com/zubairaziz)! - Add exported files to '@quiltt/react-native'"
+
+- [#210](https://github.com/quiltt/quiltt-js/pull/210) [`e57fdb8`](https://github.com/quiltt/quiltt-js/commit/e57fdb8c21e90b6a3492bc7a0c858031384caebf) Thanks [@zubairaziz](https://github.com/zubairaziz)! - Migrate bundler to 'bunchee'
+
+- [#215](https://github.com/quiltt/quiltt-js/pull/215) [`c36abb4`](https://github.com/quiltt/quiltt-js/commit/c36abb47cffea3d754fd243b321f2ae50518c297) Thanks [@tom-quiltt](https://github.com/tom-quiltt)! - Remove React Native SDK about:srcdoc warning
+
+- [#216](https://github.com/quiltt/quiltt-js/pull/216) [`2895899`](https://github.com/quiltt/quiltt-js/commit/289589913c55f8dad2e818d71c4be39c93e5a52a) Thanks [@tom-quiltt](https://github.com/tom-quiltt)! - Fix release changeset command
+
+## 3.5.4
+
+### Patch Changes
+
+- [#209](https://github.com/quiltt/quiltt-js/pull/209) [`6c5aa5f`](https://github.com/quiltt/quiltt-js/commit/6c5aa5fb0212f9dce84e71fe91e2182f463f7318) Thanks [@tom-quiltt](https://github.com/tom-quiltt)! - Expose Institutions to React Native API
+
 ## 3.5.3
 
 ### Patch Changes

package/dist/SubscriptionLink-client-B5Tmyqw7.js

@@ -0,0 +1,300 @@
+'use client';
+import { ApolloLink, Observable as Observable$1 } from '@apollo/client/core/index.js';
+import { print } from 'graphql';
+import { c as createConsumer } from './index-client-BY-d8Msy.js';
+
+var name = "@quiltt/core";
+var version$1 = "3.5.5";
+
+const QUILTT_API_INSECURE = (()=>{
+    try {
+        return process.env.QUILTT_API_INSECURE;
+    } catch  {
+        return undefined;
+    }
+})();
+const QUILTT_API_DOMAIN = (()=>{
+    try {
+        return process.env.QUILTT_API_DOMAIN;
+    } catch  {
+        return undefined;
+    }
+})();
+const QUILTT_DEBUG = (()=>{
+    try {
+        return !!process.env.QUILTT_DEBUG || process.env.NODE_ENV !== 'production';
+    } catch  {
+        return false;
+    }
+})();
+const domain = QUILTT_API_DOMAIN || 'quiltt.io';
+const protocolHttp = `http${QUILTT_API_INSECURE ? '' : 's'}`;
+const protocolWebsockets = `ws${QUILTT_API_DOMAIN ? '' : '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 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(initalState){
+        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 = initalState;
+    }
+}
+
+/**
+ * An error and type safe wrapper for localStorage.
+ * It allows you to subscribe to changes;
+ * but localStorage changes only fire with another
+ * window updates the record.
+ */ class LocalStorage {
+    constructor(){
+        this.observers = {};
+        this.isEnabled = ()=>{
+            try {
+                localStorage.setItem(`quiltt.ping`, 'pong');
+                localStorage.removeItem(`quiltt.ping`);
+                return true;
+            } catch (error) {
+                return false;
+            }
+        };
+        this.isDisabled = ()=>!this.isEnabled();
+        this.get = (key)=>{
+            if (typeof window === 'undefined' || !!window.expo) return undefined;
+            try {
+                const state = window.localStorage.getItem(`quiltt.${key}`);
+                return state ? JSON.parse(state) : state;
+            } catch (error) {
+                console.warn(`localStorage Error: "quiltt.${key}"`, error);
+                return undefined;
+            }
+        };
+        this.set = (key, state)=>{
+            if (typeof window === 'undefined' || !!window.expo) return;
+            try {
+                if (state) {
+                    window.localStorage.setItem(`quiltt.${key}`, JSON.stringify(state));
+                } else {
+                    window.localStorage.removeItem(`quiltt.${key}`);
+                }
+            } catch (error) {
+                console.warn(`localStorage Error: "quiltt.${key}"`, error);
+            }
+        };
+        this.remove = (key)=>{
+            try {
+                window.localStorage.removeItem(`quiltt.${key}`);
+            } catch (error) {
+                console.warn(`localStorage Error: "quiltt.${key}">`, error);
+            }
+        };
+        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);
+        };
+        // if there is a key, then trigger the related updates. If there is not key
+        // it means that a record has been removed and everything needs to be rechecked.
+        this.handleStorageEvent = (event)=>{
+            if (event.key && event.key.includes('quiltt.')) {
+                const newState = event.newValue ? JSON.parse(event.newValue) : null;
+                if (this.observers[event.key]) {
+                    this.observers[event.key].forEach((update)=>update(newState));
+                }
+            } else {
+                Object.entries(this.observers).forEach(([key, observers])=>{
+                    observers.forEach((update)=>update(this.get(key)));
+                });
+            }
+        };
+        if (typeof window !== 'undefined' && !window?.expo) {
+            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();
+            } else {
+                return undefined;
+            }
+        };
+        this.set = (key, state)=>{
+            if (!this.observables[key]) {
+                this.observables[key] = new Observable(state);
+            } else {
+                this.observables[key].set(state);
+            }
+        };
+        this.subscribe = (key, observer)=>{
+            if (!this.observables[key]) this.observables[key] = new 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();
+
+class ActionCableLink extends ApolloLink {
+    constructor(options){
+        super();
+        this.cables = {};
+        this.channelName = options.channelName || 'GraphqlChannel';
+        this.actionName = options.actionName || 'execute';
+        this.connectionParams = options.connectionParams || {};
+    }
+    // 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 null;
+        }
+        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 channel = this.cables[token].subscriptions.create(Object.assign({}, {
+                channel: this.channelName,
+                channelId: channelId
+            }, connectionParams), {
+                connected: ()=>{
+                    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
+                    });
+                },
+                received: (payload)=>{
+                    if (payload?.result?.data || payload?.result?.errors) {
+                        observer.next(payload.result);
+                    }
+                    if (!payload.more) {
+                        observer.complete();
+                    }
+                }
+            });
+            // 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, endpointWebsockets as b, cdnBase as c, debugging as d, endpointGraphQL as e, Storage as f, version as v };