@yaasl/devtools 0.7.0-alpha.0

package/dist/@types/index.d.ts

@@ -0,0 +1,2 @@
+export { reduxDevtools } from "./reduxDevtools";
+export type { ReduxDevtoolsOptions as ApplyDevtoolsOptions } from "./reduxDevtools";

package/dist/@types/redux-devtools/Action.d.ts

@@ -0,0 +1,4 @@
+export interface Action<T extends string = string> {
+    type: T;
+}
+export type ActionCreator<A, P extends unknown[] = unknown[]> = (...args: P) => A;

package/dist/@types/redux-devtools/ExtensionOptions.d.ts

@@ -0,0 +1,146 @@
+import { Action, ActionCreator } from "./Action";
+export interface ExtensionOptions {
+    /**
+     * the instance name to be showed on the monitor page. Default value is `document.title`.
+     * If not specified and there's no document title, it will consist of `tabId` and `instanceId`.
+     */
+    name?: string;
+    /**
+     * action creators functions to be available in the Dispatcher.
+     */
+    actionCreators?: ActionCreator<unknown>[] | Record<string, ActionCreator<unknown>>;
+    /**
+     * if more than one action is dispatched in the indicated interval, all new actions will be collected and sent at once.
+     * It is the joint between performance and speed. When set to `0`, all actions will be sent instantly.
+     * Set it to a higher value when experiencing perf issues (also `maxAge` to a lower value).
+     *
+     * @default 500 ms.
+     */
+    latency?: number;
+    /**
+     * (> 1) - maximum allowed actions to be stored in the history tree. The oldest actions are removed once maxAge is reached. It's critical for performance.
+     *
+     * @default 50
+     */
+    maxAge?: number;
+    /**
+     * function which takes `action` object and id number as arguments, and should return `action` object back.
+     */
+    actionSanitizer?: <A extends Action>(action: A, id: number) => A;
+    /**
+     * function which takes `state` object and index as arguments, and should return `state` object back.
+     */
+    stateSanitizer?: <S>(state: S, index: number) => S;
+    /**
+     * *string or array of strings as regex* - actions types to be hidden / shown in the monitors (while passed to the reducers).
+     * If `actionsAllowlist` specified, `actionsDenylist` is ignored.
+     */
+    actionsDenylist?: string | string[];
+    /**
+     * *string or array of strings as regex* - actions types to be hidden / shown in the monitors (while passed to the reducers).
+     * If `actionsAllowlist` specified, `actionsDenylist` is ignored.
+     */
+    actionsAllowlist?: string | string[];
+    /**
+     * called for every action before sending, takes `state` and `action` object, and returns `true` in case it allows sending the current data to the monitor.
+     * Use it as a more advanced version of `actionsDenylist`/`actionsAllowlist` parameters.
+     */
+    predicate?: <S, A extends Action>(state: S, action: A) => boolean;
+    /**
+     * if specified as `false`, it will not record the changes till clicking on `Start recording` button.
+     * Available only for Redux enhancer, for others use `autoPause`.
+     *
+     * @default true
+     */
+    shouldRecordChanges?: boolean;
+    /**
+     * if specified, whenever clicking on `Pause recording` button and there are actions in the history log, will add this action type.
+     * If not specified, will commit when paused. Available only for Redux enhancer.
+     *
+     * @default "@@PAUSED""
+     */
+    pauseActionType?: string;
+    /**
+     * auto pauses when the extension’s window is not opened, and so has zero impact on your app when not in use.
+     * Not available for Redux enhancer (as it already does it but storing the data to be sent).
+     *
+     * @default false
+     */
+    autoPause?: boolean;
+    /**
+     * if specified as `true`, it will not allow any non-monitor actions to be dispatched till clicking on `Unlock changes` button.
+     * Available only for Redux enhancer.
+     *
+     * @default false
+     */
+    shouldStartLocked?: boolean;
+    /**
+     * if set to `false`, will not recompute the states on hot reloading (or on replacing the reducers). Available only for Redux enhancer.
+     *
+     * @default true
+     */
+    shouldHotReload?: boolean;
+    /**
+     * if specified as `true`, whenever there's an exception in reducers, the monitors will show the error message, and next actions will not be dispatched.
+     *
+     * @default false
+     */
+    shouldCatchErrors?: boolean;
+    /**
+     * If you want to restrict the extension, specify the features you allow.
+     * If not specified, all of the features are enabled. When set as an object, only those included as `true` will be allowed.
+     * Note that except `true`/`false`, `import` and `export` can be set as `custom` (which is by default for Redux enhancer), meaning that the importing/exporting occurs on the client side.
+     * Otherwise, you'll get/set the data right from the monitor part.
+     */
+    features?: {
+        /**
+         * start/pause recording of dispatched actions
+         */
+        pause?: boolean;
+        /**
+         * lock/unlock dispatching actions and side effects
+         */
+        lock?: boolean;
+        /**
+         * persist states on page reloading
+         */
+        persist?: boolean;
+        /**
+         * export history of actions in a file
+         */
+        export?: boolean | "custom";
+        /**
+         * import history of actions from a file
+         */
+        import?: boolean | "custom";
+        /**
+         * jump back and forth (time travelling)
+         */
+        jump?: boolean;
+        /**
+         * skip (cancel) actions
+         */
+        skip?: boolean;
+        /**
+         * drag and drop actions in the history list
+         */
+        reorder?: boolean;
+        /**
+         * dispatch custom actions or action creators
+         */
+        dispatch?: boolean;
+        /**
+         * generate tests for the selected actions
+         */
+        test?: boolean;
+    };
+    /**
+     * Set to true or a stacktrace-returning function to record call stack traces for dispatched actions.
+     * Defaults to false.
+     */
+    trace?: boolean | (<A extends Action>(action: A) => string);
+    /**
+     * The maximum number of stack trace entries to record per action. Defaults to 10.
+     */
+    traceLimit?: number;
+}

package/dist/@types/redux-devtools/Message.d.ts

@@ -0,0 +1,32 @@
+import { Action } from "./Action";
+type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type GenericMessage<Type extends string, State extends string | undefined, Payload extends {
+    type?: string;
+} | undefined> = Action<Type> & {
+    state: State;
+    payload?: Payload;
+};
+type ImportAction = GenericMessage<"DISPATCH", undefined, {
+    type: "IMPORT_STATE";
+    nextLiftedState: {
+        computedStates: {
+            state: Record<string, unknown>;
+        }[];
+    };
+}>;
+type StateAction = GenericMessage<"DISPATCH", string, {
+    type: "JUMP_TO_ACTION" | "ROLLBACK";
+    actionId?: number;
+    timestamp?: number;
+}>;
+type StatelessAction = GenericMessage<"DISPATCH", undefined, {
+    type: "RESET" | "COMMIT";
+    timestamp: number;
+}>;
+type StartAction = GenericMessage<"START", undefined, undefined | {
+    type: undefined;
+}>;
+export type Message = Prettify<StartAction | StateAction | StatelessAction | ImportAction>;
+export {};

package/dist/@types/redux-devtools/getReduxConnection.d.ts

@@ -0,0 +1,25 @@
+import { Action } from "./Action";
+import { Message } from "./Message";
+export interface ConnectionResponse {
+    /** Initiate the connection and add it to the extension connections.
+     *  Should only be executed once in the live time of the connection.
+     */
+    init: (state: unknown) => void;
+    /** Send a new action to the connection to display the state change in the extension.
+     *  For example when the value of the store changes.
+     */
+    send: (action: Action, state: unknown) => void;
+    /** Add a subscription to the connection.
+     *  The provided listener will be executed when the user interacts with the extension
+     *  with actions like time traveling, importing a state or the likes.
+     *
+     *  @param listener function to be executed when an action is submitted
+     *  @returns function to unsubscribe the applied listener
+     */
+    subscribe: (listener: (message: Message) => void) => (() => void) | undefined;
+}
+/** Wrapper to create a new or get the existing connection to the redux extension
+ *  Connections are used to display the stores value and value changes within the extension
+ *  as well as reacting to extension actions like time traveling.
+ **/
+export declare const getReduxConnection: (name: string) => ConnectionResponse | null | undefined;

package/dist/@types/redux-devtools/getReduxExtension.d.ts

@@ -0,0 +1,28 @@
+import { ExtensionOptions } from "./ExtensionOptions";
+import { ConnectionResponse } from "./getReduxConnection";
+interface Config extends ExtensionOptions {
+    type?: string;
+}
+export interface ReduxDevtoolsExtension {
+    /** Create a connection to the extension.
+     *  This will connect a store (like an atom) to the extension and
+     *  display it within the extension tab.
+     *
+     *  @param options https://github.com/reduxjs/redux-devtools/blob/main/extension/docs/API/Arguments.md
+     *  @returns https://github.com/reduxjs/redux-devtools/blob/main/extension/docs/API/Methods.md#connectoptions
+     */
+    connect: (config: Config) => ConnectionResponse;
+    /** Disconnects all existing connections to the redux extension.
+     *  Only use this when you are sure that no other connection exists
+     *  or you want to remove all existing connections.
+     */
+    disconnect?: () => void;
+}
+declare global {
+    interface Window {
+        __REDUX_DEVTOOLS_EXTENSION__?: ReduxDevtoolsExtension;
+    }
+}
+/** Returns the global redux extension object if available */
+export declare const getReduxExtension: () => ReduxDevtoolsExtension | null;
+export {};

package/dist/@types/redux-devtools/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./getReduxConnection";
+export * from "./getReduxExtension";
+export * from "./ExtensionOptions";
+export * from "./Message";

package/dist/@types/reduxDevtools.d.ts

@@ -0,0 +1,17 @@
+import { Atom } from "@yaasl/core";
+import { ConnectionResponse } from "./redux-devtools";
+export declare const connectAtom: (connection: ConnectionResponse, atom: Atom<any>) => void;
+export interface ReduxDevtoolsOptions {
+    /** Disables the middleware. Useful for production. */
+    disable?: boolean;
+}
+/** Middleware to make use of the
+ *  [redux devtools](https://github.com/reduxjs/redux-devtools)
+ *  browser extension.
+ *
+ * @param options.disable Disables the middleware. Useful for production.
+ *
+ * @returns The middleware to be used on atoms.
+ **/
+export declare const reduxDevtools: (...[optionsArg]: [] | [undefined] | [ReduxDevtoolsOptions]) => import("../../core/dist/@types/middleware/middleware").MiddlewareAtomCallback<ReduxDevtoolsOptions | undefined>;
+export declare const disconnectAllConnections: () => void;

package/dist/@types/utils/cache.d.ts

@@ -0,0 +1,7 @@
+import { Atom } from "@yaasl/core";
+export declare const cache: {
+    getAtomValue: (atom: Atom) => unknown;
+    setAtomValue: (atom: Atom, value: unknown) => unknown;
+    getStore: () => Record<string, unknown>;
+    reset: () => {};
+};

package/dist/@types/utils/subscribeStore.d.ts

@@ -0,0 +1,4 @@
+import { Atom } from "@yaasl/core";
+import { ConnectionResponse } from "../redux-devtools";
+export declare const subscribeStore: (atom: Atom, connection: ConnectionResponse) => void;
+export declare const resetSubscriptions: () => void;

package/dist/@types/utils/updates.d.ts

@@ -0,0 +1,5 @@
+export declare const updates: {
+    pause: () => boolean;
+    resume: () => boolean;
+    isPaused: () => boolean;
+};

package/dist/cjs/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reduxDevtools = void 0;
+var reduxDevtools_1 = require("./reduxDevtools");
+Object.defineProperty(exports, "reduxDevtools", { enumerable: true, get: function () { return reduxDevtools_1.reduxDevtools; } });

package/dist/cjs/redux-devtools/Action.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/redux-devtools/ExtensionOptions.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/redux-devtools/Message.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/redux-devtools/getReduxConnection.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getReduxConnection = void 0;
+const getReduxExtension_1 = require("./getReduxExtension");
+const connections = {};
+/** Wrapper to create a new or get the existing connection to the redux extension
+ *  Connections are used to display the stores value and value changes within the extension
+ *  as well as reacting to extension actions like time traveling.
+ **/
+const getReduxConnection = (name) => {
+    const existing = connections[name];
+    if (existing)
+        return existing;
+    const extension = (0, getReduxExtension_1.getReduxExtension)();
+    if (!extension)
+        return null;
+    connections[name] = extension.connect({ name });
+    return connections[name];
+};
+exports.getReduxConnection = getReduxConnection;

package/dist/cjs/redux-devtools/getReduxExtension.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getReduxExtension = void 0;
+const utils_1 = require("@yaasl/utils");
+let didWarn = false;
+/** Returns the global redux extension object if available */
+const getReduxExtension = () => {
+    const reduxExtension = window.__REDUX_DEVTOOLS_EXTENSION__;
+    if (!reduxExtension) {
+        if (!didWarn) {
+            didWarn = true;
+            utils_1.log.warn("Redux devtools extension was not found");
+        }
+        return null;
+    }
+    return reduxExtension;
+};
+exports.getReduxExtension = getReduxExtension;

package/dist/cjs/redux-devtools/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./getReduxConnection"), exports);
+__exportStar(require("./getReduxExtension"), exports);
+__exportStar(require("./ExtensionOptions"), exports);
+__exportStar(require("./Message"), exports);

package/dist/cjs/reduxDevtools.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.disconnectAllConnections = exports.reduxDevtools = exports.connectAtom = void 0;
+const core_1 = require("@yaasl/core");
+const redux_devtools_1 = require("./redux-devtools");
+const cache_1 = require("./utils/cache");
+const subscribeStore_1 = require("./utils/subscribeStore");
+const updates_1 = require("./utils/updates");
+const getKey = () => { var _a; return (_a = core_1.CONFIG.name) !== null && _a !== void 0 ? _a : "yaasl"; };
+let isInitPhase = true;
+const connectAtom = (connection, atom) => {
+    cache_1.cache.setAtomValue(atom, atom.get());
+    if (isInitPhase) {
+        connection.init(cache_1.cache.getStore());
+        (0, subscribeStore_1.subscribeStore)(atom, connection);
+    }
+    else {
+        connection.send({ type: `SET/${atom.name}` }, cache_1.cache.getStore());
+    }
+};
+exports.connectAtom = connectAtom;
+/** Middleware to make use of the
+ *  [redux devtools](https://github.com/reduxjs/redux-devtools)
+ *  browser extension.
+ *
+ * @param options.disable Disables the middleware. Useful for production.
+ *
+ * @returns The middleware to be used on atoms.
+ **/
+exports.reduxDevtools = (0, core_1.middleware)(({ atom, options = {} }) => {
+    if (options.disable)
+        return {};
+    const connection = (0, redux_devtools_1.getReduxConnection)(getKey());
+    if (connection == null)
+        return {};
+    (0, exports.connectAtom)(connection, atom);
+    return {
+        set: ({ atom, value }) => {
+            isInitPhase = false;
+            if (updates_1.updates.isPaused())
+                return;
+            cache_1.cache.setAtomValue(atom, value);
+            connection.send({ type: `SET/${atom.name}` }, cache_1.cache.getStore());
+        },
+    };
+});
+/* For internal testing only */
+const disconnectAllConnections = () => {
+    cache_1.cache.reset();
+    (0, subscribeStore_1.resetSubscriptions)();
+    isInitPhase = true;
+};
+exports.disconnectAllConnections = disconnectAllConnections;

package/dist/cjs/utils/cache.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cache = void 0;
+let storeCache = {};
+const setAtomValue = (atom, value) => (storeCache[atom.name] = value);
+const getAtomValue = (atom) => storeCache[atom.name];
+exports.cache = {
+    getAtomValue,
+    setAtomValue,
+    getStore: () => storeCache,
+    reset: () => (storeCache = {}),
+};

package/dist/cjs/utils/subscribeStore.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resetSubscriptions = exports.subscribeStore = void 0;
+const cache_1 = require("./cache");
+const updates_1 = require("./updates");
+let observedAtoms = new Set();
+const synchronize = (state) => {
+    updates_1.updates.pause();
+    Array.from(observedAtoms).forEach(atom => {
+        const atomName = atom.name;
+        if (!(atomName in state))
+            return;
+        const newValue = state[atomName];
+        const cachedValue = cache_1.cache.getAtomValue(atom);
+        if (newValue === cachedValue)
+            return;
+        cache_1.cache.setAtomValue(atom, newValue);
+        atom.set(newValue);
+    });
+    updates_1.updates.resume();
+};
+const getDefaultState = () => Array.from(observedAtoms).reduce((result, atom) => {
+    result[atom.name] = atom.defaultValue;
+    return result;
+}, {});
+let didInit = false;
+const subscribeStore = (atom, connection) => {
+    observedAtoms.add(atom);
+    if (didInit)
+        return;
+    didInit = true;
+    connection.subscribe(action => {
+        const { payload } = action;
+        const nextState = !action.state
+            ? null
+            : JSON.parse(action.state);
+        switch (payload === null || payload === void 0 ? void 0 : payload.type) {
+            case "COMMIT":
+                connection.init(cache_1.cache.getStore());
+                break;
+            case "JUMP_TO_ACTION":
+            case "ROLLBACK":
+                if (!nextState)
+                    return;
+                synchronize(nextState);
+                break;
+            case "RESET":
+                synchronize(getDefaultState());
+                connection.send({ type: `RESET_ATOMS` }, cache_1.cache.getStore());
+                break;
+            case "IMPORT_STATE":
+                payload.nextLiftedState.computedStates.forEach(({ state }) => {
+                    synchronize(state);
+                    connection.send({ type: `IMPORT_STORE` }, cache_1.cache.getStore());
+                });
+                break;
+        }
+    });
+};
+exports.subscribeStore = subscribeStore;
+const resetSubscriptions = () => {
+    didInit = false;
+    observedAtoms = new Set();
+};
+exports.resetSubscriptions = resetSubscriptions;

package/dist/cjs/utils/updates.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updates = void 0;
+let paused = false;
+exports.updates = {
+    pause: () => (paused = true),
+    resume: () => (paused = false),
+    isPaused: () => paused,
+};

package/dist/mjs/index.js

@@ -0,0 +1 @@
+export { reduxDevtools } from "./reduxDevtools";

package/dist/mjs/redux-devtools/Action.js

@@ -0,0 +1 @@
+export {};

package/dist/mjs/redux-devtools/ExtensionOptions.js

@@ -0,0 +1 @@
+export {};

package/dist/mjs/redux-devtools/Message.js

@@ -0,0 +1 @@
+export {};

package/dist/mjs/redux-devtools/getReduxConnection.js

@@ -0,0 +1,16 @@
+import { getReduxExtension } from "./getReduxExtension";
+const connections = {};
+/** Wrapper to create a new or get the existing connection to the redux extension
+ *  Connections are used to display the stores value and value changes within the extension
+ *  as well as reacting to extension actions like time traveling.
+ **/
+export const getReduxConnection = (name) => {
+    const existing = connections[name];
+    if (existing)
+        return existing;
+    const extension = getReduxExtension();
+    if (!extension)
+        return null;
+    connections[name] = extension.connect({ name });
+    return connections[name];
+};

package/dist/mjs/redux-devtools/getReduxExtension.js

@@ -0,0 +1,14 @@
+import { log } from "@yaasl/utils";
+let didWarn = false;
+/** Returns the global redux extension object if available */
+export const getReduxExtension = () => {
+    const reduxExtension = window.__REDUX_DEVTOOLS_EXTENSION__;
+    if (!reduxExtension) {
+        if (!didWarn) {
+            didWarn = true;
+            log.warn("Redux devtools extension was not found");
+        }
+        return null;
+    }
+    return reduxExtension;
+};

package/dist/mjs/redux-devtools/index.js

@@ -0,0 +1,4 @@
+export * from "./getReduxConnection";
+export * from "./getReduxExtension";
+export * from "./ExtensionOptions";
+export * from "./Message";

package/dist/mjs/reduxDevtools.js

@@ -0,0 +1,48 @@
+import { CONFIG, middleware } from "@yaasl/core";
+import { getReduxConnection } from "./redux-devtools";
+import { cache } from "./utils/cache";
+import { resetSubscriptions, subscribeStore } from "./utils/subscribeStore";
+import { updates } from "./utils/updates";
+const getKey = () => CONFIG.name ?? "yaasl";
+let isInitPhase = true;
+export const connectAtom = (connection, atom) => {
+    cache.setAtomValue(atom, atom.get());
+    if (isInitPhase) {
+        connection.init(cache.getStore());
+        subscribeStore(atom, connection);
+    }
+    else {
+        connection.send({ type: `SET/${atom.name}` }, cache.getStore());
+    }
+};
+/** Middleware to make use of the
+ *  [redux devtools](https://github.com/reduxjs/redux-devtools)
+ *  browser extension.
+ *
+ * @param options.disable Disables the middleware. Useful for production.
+ *
+ * @returns The middleware to be used on atoms.
+ **/
+export const reduxDevtools = middleware(({ atom, options = {} }) => {
+    if (options.disable)
+        return {};
+    const connection = getReduxConnection(getKey());
+    if (connection == null)
+        return {};
+    connectAtom(connection, atom);
+    return {
+        set: ({ atom, value }) => {
+            isInitPhase = false;
+            if (updates.isPaused())
+                return;
+            cache.setAtomValue(atom, value);
+            connection.send({ type: `SET/${atom.name}` }, cache.getStore());
+        },
+    };
+});
+/* For internal testing only */
+export const disconnectAllConnections = () => {
+    cache.reset();
+    resetSubscriptions();
+    isInitPhase = true;
+};

package/dist/mjs/utils/cache.js

@@ -0,0 +1,9 @@
+let storeCache = {};
+const setAtomValue = (atom, value) => (storeCache[atom.name] = value);
+const getAtomValue = (atom) => storeCache[atom.name];
+export const cache = {
+    getAtomValue,
+    setAtomValue,
+    getStore: () => storeCache,
+    reset: () => (storeCache = {}),
+};

package/dist/mjs/utils/subscribeStore.js

@@ -0,0 +1,60 @@
+import { cache } from "./cache";
+import { updates } from "./updates";
+let observedAtoms = new Set();
+const synchronize = (state) => {
+    updates.pause();
+    Array.from(observedAtoms).forEach(atom => {
+        const atomName = atom.name;
+        if (!(atomName in state))
+            return;
+        const newValue = state[atomName];
+        const cachedValue = cache.getAtomValue(atom);
+        if (newValue === cachedValue)
+            return;
+        cache.setAtomValue(atom, newValue);
+        atom.set(newValue);
+    });
+    updates.resume();
+};
+const getDefaultState = () => Array.from(observedAtoms).reduce((result, atom) => {
+    result[atom.name] = atom.defaultValue;
+    return result;
+}, {});
+let didInit = false;
+export const subscribeStore = (atom, connection) => {
+    observedAtoms.add(atom);
+    if (didInit)
+        return;
+    didInit = true;
+    connection.subscribe(action => {
+        const { payload } = action;
+        const nextState = !action.state
+            ? null
+            : JSON.parse(action.state);
+        switch (payload?.type) {
+            case "COMMIT":
+                connection.init(cache.getStore());
+                break;
+            case "JUMP_TO_ACTION":
+            case "ROLLBACK":
+                if (!nextState)
+                    return;
+                synchronize(nextState);
+                break;
+            case "RESET":
+                synchronize(getDefaultState());
+                connection.send({ type: `RESET_ATOMS` }, cache.getStore());
+                break;
+            case "IMPORT_STATE":
+                payload.nextLiftedState.computedStates.forEach(({ state }) => {
+                    synchronize(state);
+                    connection.send({ type: `IMPORT_STORE` }, cache.getStore());
+                });
+                break;
+        }
+    });
+};
+export const resetSubscriptions = () => {
+    didInit = false;
+    observedAtoms = new Set();
+};

package/dist/mjs/utils/updates.js

@@ -0,0 +1,6 @@
+let paused = false;
+export const updates = {
+    pause: () => (paused = true),
+    resume: () => (paused = false),
+    isPaused: () => paused,
+};

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@yaasl/devtools",
+  "version": "0.7.0-alpha.0",
+  "description": "yaasl redux-devtools-extension middleware",
+  "author": "PrettyCoffee",
+  "license": "MIT",
+  "homepage": "https://github.com/PrettyCoffee/yaasl#readme",
+  "keywords": [
+    "devtools"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/PrettyCoffee/yaasl.git"
+  },
+  "bugs": {
+    "url": "https://github.com/PrettyCoffee/yaasl/issues"
+  },
+  "main": "./dist/cjs/index.js",
+  "types": "./dist/@types/index.d.ts",
+  "exports": {
+    "types": "./dist/@types/index.d.ts",
+    "import": "./dist/mjs/index.js",
+    "require": "./dist/cjs/index.js"
+  },
+  "scripts": {
+    "build": "run-s clean compile",
+    "clean": "rimraf ./dist",
+    "compile": "run-p compile:mjs compile:cjs compile:types",
+    "compile:mjs": "tsc -p ./tsconfig.node.json --outDir ./dist/mjs -m es2020 -t es2020",
+    "compile:cjs": "tsc -p ./tsconfig.node.json --outDir ./dist/cjs -m commonjs -t es2015",
+    "compile:types": "tsc -p ./tsconfig.node.json --outDir ./dist/@types --declaration --emitDeclarationOnly",
+    "test": "jest --testMatch ./**/*.test.*",
+    "test:watch": "npm run test -- --watchAll",
+    "lint": "eslint ./src",
+    "lint:fix": "eslint ./src --fix",
+    "validate": "run-s lint test build"
+  },
+  "dependencies": {
+    "@yaasl/core": "0.7.0-alpha.0",
+    "@yaasl/utils": "0.7.0-alpha.0"
+  },
+  "jest": {
+    "preset": "ts-jest",
+    "testEnvironment": "jsdom"
+  },
+  "eslintConfig": {
+    "extends": [
+      "../../.eslintrc"
+    ]
+  },
+  "lint-staged": {
+    "*.{ts,tsx}": [
+      "npm run lint:fix"
+    ]
+  }
+}

package/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "../../tsconfig.json",
+}

package/tsconfig.node.json

@@ -0,0 +1,9 @@
+{
+  "extends": "./tsconfig.json",
+  "include": ["./src"],
+  "exclude": ["./**/*.test.ts"],
+  "compilerOptions": {
+    "declaration": false,
+    "noEmit": false,
+  }
+}