@dynamic-labs/store 2.1.0-alpha.21

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Dynamic Labs, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@dynamic-labs/store",
+  "version": "2.1.0-alpha.21",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dynamic-labs/DynamicAuth.git",
+    "directory": "packages/store"
+  },
+  "description": "Store ",
+  "bugs": {
+    "url": "https://github.com/dynamic-labs/DynamicAuth/issues"
+  },
+  "homepage": "https://github.com/dynamic-labs/DynamicAuth#readme",
+  "author": "Dynamic Labs, Inc.",
+  "license": "MIT",
+  "main": "./src/index.cjs",
+  "module": "./src/index.js",
+  "types": "./src/index.d.ts",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./src/index.d.ts",
+      "import": "./src/index.js",
+      "require": "./src/index.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "@dynamic-labs/logger": "2.1.0-alpha.21"
+  },
+  "peerDependencies": {}
+}

package/src/index.cjs

@@ -0,0 +1,14 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var createStore = require('./lib/createStore/createStore.cjs');
+var persist = require('./lib/persist/persist.cjs');
+var subscribeWithSelector = require('./lib/subscribeWithSelector/subscribeWithSelector.cjs');
+
+
+
+exports.createStore = createStore.createStore;
+exports.createPersist = persist.createPersist;
+exports.subscribeWithSelector = subscribeWithSelector.subscribeWithSelector;

package/src/index.d.ts

@@ -0,0 +1 @@
+export { type StoreApi, type PersistStorage, createPersist, createStore, subscribeWithSelector, } from './lib';

package/src/index.js

@@ -0,0 +1,4 @@
+'use client'
+export { createStore } from './lib/createStore/createStore.js';
+export { createPersist } from './lib/persist/persist.js';
+export { subscribeWithSelector } from './lib/subscribeWithSelector/subscribeWithSelector.js';

package/src/lib/createStore/createStore.cjs

@@ -0,0 +1,58 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/**
+ * Creates a store with the specified initial state and provides methods to manage and subscribe to the state.
+ *
+ * @template T - The type of the state object.
+ * @param getInitialState - A function that returns the initial state object.
+ * @returns An object that represents the store and provides methods to interact with the state.
+ */
+const createStore = (getInitialState) => {
+    const subscriptions = new Set();
+    let state = getInitialState();
+    const notifySubscribers = () => {
+        for (const subscription of subscriptions) {
+            subscription(state);
+        }
+    };
+    return {
+        /**
+         * Returns the initial state object.
+         *
+         * @returns The initial state object.
+         */
+        getInitialState: () => getInitialState(),
+        /**
+         * Returns the current state object.
+         *
+         * @returns The current state object.
+         */
+        getState: () => state,
+        /**
+         * Updates the state object with the provided partial state and notifies all subscribers.
+         *
+         * @param partialState - The partial state object to merge with the current state.
+         */
+        setState: (partialState) => {
+            state = Object.assign(Object.assign({}, state), partialState);
+            notifySubscribers();
+        },
+        /**
+         * Subscribes to state changes and invokes the provided callback whenever the state is updated.
+         *
+         * @param subscription - A callback function that receives the updated state as a parameter.
+         * @returns A function that can be called to unsubscribe from state changes.
+         */
+        subscribe: (subscription) => {
+            subscriptions.add(subscription);
+            return () => {
+                subscriptions.delete(subscription);
+            };
+        },
+    };
+};
+
+exports.createStore = createStore;

package/src/lib/createStore/createStore.d.ts

@@ -0,0 +1,9 @@
+import { StoreApi } from '../types';
+/**
+ * Creates a store with the specified initial state and provides methods to manage and subscribe to the state.
+ *
+ * @template T - The type of the state object.
+ * @param getInitialState - A function that returns the initial state object.
+ * @returns An object that represents the store and provides methods to interact with the state.
+ */
+export declare const createStore: <T extends object>(getInitialState: () => T) => StoreApi<T>;

package/src/lib/createStore/createStore.js

@@ -0,0 +1,54 @@
+'use client'
+/**
+ * Creates a store with the specified initial state and provides methods to manage and subscribe to the state.
+ *
+ * @template T - The type of the state object.
+ * @param getInitialState - A function that returns the initial state object.
+ * @returns An object that represents the store and provides methods to interact with the state.
+ */
+const createStore = (getInitialState) => {
+    const subscriptions = new Set();
+    let state = getInitialState();
+    const notifySubscribers = () => {
+        for (const subscription of subscriptions) {
+            subscription(state);
+        }
+    };
+    return {
+        /**
+         * Returns the initial state object.
+         *
+         * @returns The initial state object.
+         */
+        getInitialState: () => getInitialState(),
+        /**
+         * Returns the current state object.
+         *
+         * @returns The current state object.
+         */
+        getState: () => state,
+        /**
+         * Updates the state object with the provided partial state and notifies all subscribers.
+         *
+         * @param partialState - The partial state object to merge with the current state.
+         */
+        setState: (partialState) => {
+            state = Object.assign(Object.assign({}, state), partialState);
+            notifySubscribers();
+        },
+        /**
+         * Subscribes to state changes and invokes the provided callback whenever the state is updated.
+         *
+         * @param subscription - A callback function that receives the updated state as a parameter.
+         * @returns A function that can be called to unsubscribe from state changes.
+         */
+        subscribe: (subscription) => {
+            subscriptions.add(subscription);
+            return () => {
+                subscriptions.delete(subscription);
+            };
+        },
+    };
+};
+
+export { createStore };

package/src/lib/createStore/index.d.ts

@@ -0,0 +1 @@
+export { createStore } from './createStore';

package/src/lib/index.d.ts

@@ -0,0 +1,4 @@
+export type { StoreApi } from './types';
+export { createStore } from './createStore';
+export { createPersist, type PersistStorage } from './persist';
+export { subscribeWithSelector } from './subscribeWithSelector';

package/src/lib/persist/index.d.ts

@@ -0,0 +1,2 @@
+export { createPersist } from './persist';
+export type { PersistStorage } from './persist';

package/src/lib/persist/persist.cjs

@@ -0,0 +1,30 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var logger = require('../utils/logger/logger.cjs');
+
+/**
+ * Creates a persist middleware that saves the store state to the storage.
+ */
+const createPersist = ({ name, version = 0, storage }) => (store) => {
+    store.subscribe((state) => {
+        storage.setItem(name, JSON.stringify({ state, version }));
+    });
+    const storedState = storage.getItem(name);
+    if (storedState) {
+        try {
+            const { state: storedStateData, version: storedVersion } = JSON.parse(storedState);
+            if (storedVersion === version) {
+                store.setState(storedStateData);
+            }
+        }
+        catch (error) {
+            logger.logger.error('Failed to load state from storage', error);
+        }
+    }
+    return store;
+};
+
+exports.createPersist = createPersist;

package/src/lib/persist/persist.d.ts

@@ -0,0 +1,15 @@
+import { StoreApi } from '../types';
+export type PersistStorage = {
+    getItem: (key: string) => string | null;
+    setItem: (key: string, value: string) => void;
+};
+type CreatePersistProps = {
+    name: string;
+    version?: number;
+    storage: PersistStorage;
+};
+/**
+ * Creates a persist middleware that saves the store state to the storage.
+ */
+export declare const createPersist: ({ name, version, storage }: CreatePersistProps) => <TStore extends object>(store: StoreApi<TStore>) => StoreApi<TStore>;
+export {};

package/src/lib/persist/persist.js

@@ -0,0 +1,26 @@
+'use client'
+import { logger } from '../utils/logger/logger.js';
+
+/**
+ * Creates a persist middleware that saves the store state to the storage.
+ */
+const createPersist = ({ name, version = 0, storage }) => (store) => {
+    store.subscribe((state) => {
+        storage.setItem(name, JSON.stringify({ state, version }));
+    });
+    const storedState = storage.getItem(name);
+    if (storedState) {
+        try {
+            const { state: storedStateData, version: storedVersion } = JSON.parse(storedState);
+            if (storedVersion === version) {
+                store.setState(storedStateData);
+            }
+        }
+        catch (error) {
+            logger.error('Failed to load state from storage', error);
+        }
+    }
+    return store;
+};
+
+export { createPersist };

package/src/lib/shallow/index.d.ts

@@ -0,0 +1 @@
+export { shallow } from './shallow';

package/src/lib/shallow/shallow.cjs

@@ -0,0 +1,53 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/**
+ * Shallow compare two objects
+ * source: https://github.com/pmndrs/zustand/blob/main/src/vanilla/shallow.ts
+ */
+const shallow = (objA, objB) => {
+    if (Object.is(objA, objB)) {
+        return true;
+    }
+    if (typeof objA !== 'object' ||
+        objA === null ||
+        typeof objB !== 'object' ||
+        objB === null) {
+        return false;
+    }
+    if (objA instanceof Map && objB instanceof Map) {
+        if (objA.size !== objB.size)
+            return false;
+        for (const [key, value] of objA) {
+            if (!Object.is(value, objB.get(key))) {
+                return false;
+            }
+        }
+        return true;
+    }
+    if (objA instanceof Set && objB instanceof Set) {
+        if (objA.size !== objB.size)
+            return false;
+        for (const value of objA) {
+            if (!objB.has(value)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    const keysA = Object.keys(objA);
+    if (keysA.length !== Object.keys(objB).length) {
+        return false;
+    }
+    for (const keyA of keysA) {
+        if (!Object.prototype.hasOwnProperty.call(objB, keyA) ||
+            !Object.is(objA[keyA], objB[keyA])) {
+            return false;
+        }
+    }
+    return true;
+};
+
+exports.shallow = shallow;

package/src/lib/shallow/shallow.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Shallow compare two objects
+ * source: https://github.com/pmndrs/zustand/blob/main/src/vanilla/shallow.ts
+ */
+export declare const shallow: <T>(objA: T, objB: T) => boolean;

package/src/lib/shallow/shallow.js

@@ -0,0 +1,49 @@
+'use client'
+/**
+ * Shallow compare two objects
+ * source: https://github.com/pmndrs/zustand/blob/main/src/vanilla/shallow.ts
+ */
+const shallow = (objA, objB) => {
+    if (Object.is(objA, objB)) {
+        return true;
+    }
+    if (typeof objA !== 'object' ||
+        objA === null ||
+        typeof objB !== 'object' ||
+        objB === null) {
+        return false;
+    }
+    if (objA instanceof Map && objB instanceof Map) {
+        if (objA.size !== objB.size)
+            return false;
+        for (const [key, value] of objA) {
+            if (!Object.is(value, objB.get(key))) {
+                return false;
+            }
+        }
+        return true;
+    }
+    if (objA instanceof Set && objB instanceof Set) {
+        if (objA.size !== objB.size)
+            return false;
+        for (const value of objA) {
+            if (!objB.has(value)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    const keysA = Object.keys(objA);
+    if (keysA.length !== Object.keys(objB).length) {
+        return false;
+    }
+    for (const keyA of keysA) {
+        if (!Object.prototype.hasOwnProperty.call(objB, keyA) ||
+            !Object.is(objA[keyA], objB[keyA])) {
+            return false;
+        }
+    }
+    return true;
+};
+
+export { shallow };

package/src/lib/subscribeWithSelector/index.d.ts

@@ -0,0 +1 @@
+export { subscribeWithSelector } from './subscribeWithSelector';

package/src/lib/subscribeWithSelector/subscribeWithSelector.cjs

@@ -0,0 +1,38 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var shallow = require('../shallow/shallow.cjs');
+
+/**
+ * Subscribes to a specific slice of the store state and invokes a callback whenever the slice changes.
+ * @template TStore - The type of the store.
+ * @template StateSlice - The type of the selected slice of the store state.
+ * @param {StoreApi<TStore>} store - The store object.
+ * @param {(state: TStore) => StateSlice} selector - A function that selects the desired slice of the store state.
+ * @returns {SliceSubscription<StateSlice>} - A function that can be used to subscribe.
+ * @example
+ * const store = createStore<{ counter: number; }>(() => ({ counter: 0 }));
+ * const subscribeToCounter = subscribeWithSelector(
+ *  store,
+ * (state) => state.counter,
+ * );
+ * const unsubscribe = subscribeToCounter((counter) => {
+ *   console.log('Counter changed:', counter);
+ * });
+ * // To unsubscribe, call the returned function
+ * unsubscribe();
+ */
+const subscribeWithSelector = (store, selector) => (callback) => {
+    let lastSlice = selector(store.getState());
+    return store.subscribe((state) => {
+        const nextSlice = selector(state);
+        if (shallow.shallow(lastSlice, nextSlice) === false) {
+            lastSlice = nextSlice;
+            callback(nextSlice);
+        }
+    });
+};
+
+exports.subscribeWithSelector = subscribeWithSelector;

package/src/lib/subscribeWithSelector/subscribeWithSelector.d.ts

@@ -0,0 +1,23 @@
+import { StoreApi } from '../types';
+type SliceSubscription<StateSlice> = (subscription: (state: StateSlice) => void) => () => void;
+/**
+ * Subscribes to a specific slice of the store state and invokes a callback whenever the slice changes.
+ * @template TStore - The type of the store.
+ * @template StateSlice - The type of the selected slice of the store state.
+ * @param {StoreApi<TStore>} store - The store object.
+ * @param {(state: TStore) => StateSlice} selector - A function that selects the desired slice of the store state.
+ * @returns {SliceSubscription<StateSlice>} - A function that can be used to subscribe.
+ * @example
+ * const store = createStore<{ counter: number; }>(() => ({ counter: 0 }));
+ * const subscribeToCounter = subscribeWithSelector(
+ *  store,
+ * (state) => state.counter,
+ * );
+ * const unsubscribe = subscribeToCounter((counter) => {
+ *   console.log('Counter changed:', counter);
+ * });
+ * // To unsubscribe, call the returned function
+ * unsubscribe();
+ */
+export declare const subscribeWithSelector: <TStore extends object, StateSlice>(store: StoreApi<TStore>, selector: (state: TStore) => StateSlice) => SliceSubscription<StateSlice>;
+export {};

package/src/lib/subscribeWithSelector/subscribeWithSelector.js

@@ -0,0 +1,34 @@
+'use client'
+import { shallow } from '../shallow/shallow.js';
+
+/**
+ * Subscribes to a specific slice of the store state and invokes a callback whenever the slice changes.
+ * @template TStore - The type of the store.
+ * @template StateSlice - The type of the selected slice of the store state.
+ * @param {StoreApi<TStore>} store - The store object.
+ * @param {(state: TStore) => StateSlice} selector - A function that selects the desired slice of the store state.
+ * @returns {SliceSubscription<StateSlice>} - A function that can be used to subscribe.
+ * @example
+ * const store = createStore<{ counter: number; }>(() => ({ counter: 0 }));
+ * const subscribeToCounter = subscribeWithSelector(
+ *  store,
+ * (state) => state.counter,
+ * );
+ * const unsubscribe = subscribeToCounter((counter) => {
+ *   console.log('Counter changed:', counter);
+ * });
+ * // To unsubscribe, call the returned function
+ * unsubscribe();
+ */
+const subscribeWithSelector = (store, selector) => (callback) => {
+    let lastSlice = selector(store.getState());
+    return store.subscribe((state) => {
+        const nextSlice = selector(state);
+        if (shallow(lastSlice, nextSlice) === false) {
+            lastSlice = nextSlice;
+            callback(nextSlice);
+        }
+    });
+};
+
+export { subscribeWithSelector };

package/src/lib/types.d.ts

@@ -0,0 +1,6 @@
+export type StoreApi<T extends object> = {
+    getState: () => T;
+    setState: (partialState: Partial<T>) => void;
+    getInitialState: () => T;
+    subscribe: (subscription: (state: T) => void) => () => void;
+};

package/src/lib/utils/logger/index.d.ts

@@ -0,0 +1 @@
+export { logger } from './logger';

package/src/lib/utils/logger/logger.cjs

@@ -0,0 +1,10 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var logger$1 = require('@dynamic-labs/logger');
+
+const logger = new logger$1.Logger('@dynamic-labs/logger');
+
+exports.logger = logger;

package/src/lib/utils/logger/logger.d.ts

@@ -0,0 +1,2 @@
+import { Logger } from '@dynamic-labs/logger';
+export declare const logger: Logger;

package/src/lib/utils/logger/logger.js

@@ -0,0 +1,6 @@
+'use client'
+import { Logger } from '@dynamic-labs/logger';
+
+const logger = new Logger('@dynamic-labs/logger');
+
+export { logger };