@yaasl/core 0.7.0-alpha.0

package/dist/@types/base/Stateful.d.ts

@@ -0,0 +1,19 @@
+export declare class Stateful<Value = unknown> {
+    protected value: Value;
+    private listeners;
+    constructor(value: Value);
+    /** Read the value of state.
+     *
+     * @returns The current value.
+     **/
+    get(): Value;
+    /** Subscribe to value changes.
+     *
+     *  @param callback Function to use the new value.
+     *
+     *  @returns A callback to unsubscribe the passed callback.
+     */
+    subscribe(callback: (value: Value) => void): () => boolean;
+    private emit;
+    protected update(value: Value): void;
+}

package/dist/@types/base/atom.d.ts

@@ -0,0 +1,38 @@
+import { SetStateAction } from "@yaasl/utils";
+import { Stateful } from "./Stateful";
+import { MiddlewareAtomCallback } from "../middleware/middleware";
+interface AtomConfig<AtomValue> {
+    /** Value that will be returned if the atom is not defined in the store */
+    defaultValue: AtomValue;
+    /** Name of the atom. Must be unique among all atoms. */
+    name?: string;
+    /** Middleware that will be applied on the atom */
+    middleware?: MiddlewareAtomCallback<any>[];
+}
+export declare class Atom<AtomValue = unknown> extends Stateful<AtomValue> {
+    readonly defaultValue: AtomValue;
+    readonly name: string;
+    didInit: Promise<void> | boolean;
+    constructor({ defaultValue, name, middleware, }: AtomConfig<AtomValue>);
+    /** Set the value of the atom.
+     *
+     * @param next New value or function to create the
+     * new value based off the previous value.
+     */
+    set(next: SetStateAction<AtomValue>): void;
+    /** Resolve the value of a promise and set as atom value.
+     *
+     * @param promise Promise to unwrap
+     */
+    unwrap(promise: Promise<AtomValue>): Promise<AtomValue>;
+}
+/** Creates an atom store.
+ *
+ * @param config.defaultValue Value that will be used initially.
+ * @param config.name Name of the atom. Must be unique among all atoms. Defaults to "atom-{number}".
+ * @param config.middleware Middleware that will be applied on the atom.
+ *
+ * @returns An atom instance.
+ **/
+export declare const atom: <AtomValue>(config: AtomConfig<AtomValue>) => Atom<AtomValue>;
+export {};

package/dist/@types/base/config.d.ts

@@ -0,0 +1,16 @@
+interface Config {
+    /** Global name to make internal keys unique
+     *  among UIs on the same domain.
+     *
+     *  (e.g. local storage keys look like this if a name is set:
+     *  "{config-name}/{atom-name}")
+     **/
+    name?: string;
+}
+/** Global configuration object to change internal behavior of yaasl.
+ *
+ *  Values should be set once in your application entrypoint,
+ *  before yaasl is being used.
+ **/
+export declare const CONFIG: Config;
+export {};

package/dist/@types/base/derive.d.ts

@@ -0,0 +1,19 @@
+import { Stateful } from "./Stateful";
+type Derivation<T> = (context: {
+    get: <V>(dep: Stateful<V>) => V;
+}) => T;
+export declare class Derive<DerivedValue> extends Stateful<DerivedValue> {
+    private readonly derivation;
+    private dependencies;
+    constructor(derivation: Derivation<DerivedValue>);
+    private addDependency;
+    private deriveUpdate;
+}
+/** Creates a value, derived from one or more atoms or other derived values.
+ *
+ *  @param get Function to derive the new value.
+ *
+ *  @returns A derived instance.
+ **/
+export declare const derive: <DerivedValue>(get: Derivation<DerivedValue>) => Derive<DerivedValue>;
+export {};

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

@@ -0,0 +1,4 @@
+export * from "./atom";
+export * from "./derive";
+export * from "./config";
+export * from "./Stateful";

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

@@ -0,0 +1,2 @@
+export * from "./base";
+export * from "./middleware";

package/dist/@types/middleware/MiddlewareDispatcher.d.ts

@@ -0,0 +1,14 @@
+import { MiddlewareAtomCallback } from "./middleware";
+import { Atom } from "../base/atom";
+interface MiddlewareDispatcherConstructor {
+    atom: Atom<any>;
+    middleware: MiddlewareAtomCallback<any>[];
+}
+export declare class MiddlewareDispatcher {
+    didInit: Promise<void> | boolean;
+    private middleware;
+    constructor({ atom, middleware }: MiddlewareDispatcherConstructor);
+    private subscribeSetters;
+    private callMiddlewareAction;
+}
+export {};

package/dist/@types/middleware/expiration.d.ts

@@ -0,0 +1,17 @@
+export interface ExpirationOptions {
+    /** Date at which the value expires */
+    expiresAt?: Date | (() => Date);
+    /** Milliseconds in which the value expires. Will be ignored if expiresAt is set. */
+    expiresIn?: number | (() => number);
+}
+/** Middleware to make an atom value expirable and reset to its defaulValue.
+ *
+ * __Note:__ When using `expiresAt`, a function returning the date should be prefered since using a static date might end in an infinite loop.
+ *
+ * @param {ExpirationOptions | undefined} options
+ * @param options.expiresAt Date at which the value expires
+ * @param options.expiresIn Milliseconds in which the value expires. Will be ignored if expiresAt is set.
+ *
+ * @returns The middleware to be used on atoms.
+ **/
+export declare const expiration: (__0_0: ExpirationOptions) => import("./middleware").MiddlewareAtomCallback<ExpirationOptions>;

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

@@ -0,0 +1,10 @@
+export { middleware } from "./middleware";
+export type { Middleware } from "./middleware";
+export { localStorage } from "./localStorage";
+export type { LocalStorageOptions, LocalStorageParser } from "./localStorage";
+export { indexedDb } from "./indexedDb";
+export type { IndexedDbOptions } from "./indexedDb";
+export { expiration } from "./expiration";
+export type { ExpirationOptions } from "./expiration";
+export { migration, createMigrationStep } from "./migration";
+export type { MigrationOptions, MigrationStep } from "./migration";

package/dist/@types/middleware/indexedDb.d.ts

@@ -0,0 +1,15 @@
+export interface IndexedDbOptions {
+    /** Use your own store key. Will be `atom.name` by default. */
+    key?: string;
+}
+/** Middleware to save and load atom values to an indexedDb.
+ *
+ *  Will use one database and store for all atoms with your `CONFIG.name`
+ *  as name or `yaasl` if not set.
+ *
+ * @param {IndexedDbOptions | undefined} options
+ * @param options.key Use your own store key. Will be `atom.name` by default.
+ *
+ * @returns The middleware to be used on atoms.
+ **/
+export declare const indexedDb: (...[optionsArg]: [] | [undefined] | [IndexedDbOptions]) => import("./middleware").MiddlewareAtomCallback<IndexedDbOptions | undefined>;

package/dist/@types/middleware/localStorage.d.ts

@@ -0,0 +1,28 @@
+export interface LocalStorageParser<T = any> {
+    parse: (value: string) => T;
+    stringify: (value: T) => string;
+}
+export interface LocalStorageOptions {
+    /** Use your own key for the local storage.
+     *  Will be "{config-name}/{atom-name}" by default.
+     */
+    key?: string;
+    /** Disable the synchronization of values over browser tabs */
+    noTabSync?: boolean;
+    /** Custom functions to stringify and parse values.
+     *  Defaults to JSON.stringify and JSON.parse.
+     *  Use this when handling complex datatypes like Maps or Sets.
+     */
+    parser?: LocalStorageParser;
+}
+/** Middleware to save and load atom values to the local storage.
+ *
+ * @param {LocalStorageOptions | undefined} options
+ * @param options.key Use your own key for the local storage.
+ *   Will be "{config-name}/{atom-name}" by default.
+ * @param options.noTabSync Disable the synchronization of values over browser tabs.
+ * @param options.parser Custom functions to stringify and parse values. Defaults to JSON.stringify and JSON.parse. Use this when handling complex datatypes like Maps or Sets.
+ *
+ * @returns The middleware to be used on atoms.
+ **/
+export declare const localStorage: (...[optionsArg]: [] | [undefined] | [LocalStorageOptions]) => import("./middleware").MiddlewareAtomCallback<LocalStorageOptions | undefined>;

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

@@ -0,0 +1,31 @@
+import { Atom } from "../base";
+export type ActionType = "init" | "didInit" | "set";
+interface MiddlewarePayload<Options> {
+    value: unknown;
+    atom: Atom;
+    options: Options;
+}
+export interface MiddlewareActions<Options> {
+    init?: (payload: MiddlewarePayload<Options>) => Promise<any> | void;
+    didInit?: (payload: MiddlewarePayload<Options>) => Promise<any> | void;
+    set?: (payload: MiddlewarePayload<Options>) => void;
+}
+interface MiddlewareSetupProps<Options> {
+    atom: Atom;
+    options: Options;
+}
+export type MiddlewareAtomCallback<Options> = (atom: Atom<any>) => Middleware<Options>;
+export type MiddlewareSetup<Options> = MiddlewareActions<Options> | ((props: MiddlewareSetupProps<Options>) => MiddlewareActions<Options>);
+export interface Middleware<Options = unknown> {
+    options: Options;
+    actions: MiddlewareActions<Options>;
+}
+/** Create middlewares to be used in combination with atoms.
+ *
+ * @param setup Middleware actions or function to create middleware actions.
+ *   Middleware actions are fired in the atom lifecycle, alongside to the subscriptions.
+ *
+ * @returns A middleware function to be used in atoms.
+ **/
+export declare const middleware: <Options = undefined>(setup: MiddlewareSetup<Options>) => (...[optionsArg]: Options extends undefined ? [Options] | [] : [Options]) => MiddlewareAtomCallback<Options>;
+export {};

package/dist/@types/middleware/migration.d.ts

@@ -0,0 +1,19 @@
+export interface MigrationStep<Version extends string = string, PreviousVersion extends string | null = string | null, OldData = any, NewData = any> {
+    /** Previous version of the data, before performing the migration */
+    previous: PreviousVersion;
+    /** Version of the data after the migration */
+    version: Version;
+    /** Function to migrate the data */
+    migrate: (data: OldData) => NewData;
+    /** Function to validate the data before migrating */
+    validate?: (data: unknown) => data is OldData;
+}
+export interface MigrationOptions {
+    /** Migration steps to perform.
+     *
+     *  Note: One step must have a `previous` version set to null as entry point.
+     **/
+    steps: MigrationStep[];
+}
+export declare const migration: (__0_0: MigrationOptions) => import("./middleware").MiddlewareAtomCallback<MigrationOptions>;
+export declare const createMigrationStep: <Version extends string, PreviousVersion extends string | null, OldData, NewData>(migration: MigrationStep<Version, PreviousVersion, OldData, NewData>) => MigrationStep<Version, PreviousVersion, OldData, NewData>;

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

@@ -0,0 +1,18 @@
+export interface ExpirationOptions {
+    /** Local storage key to persist the expiration */
+    key: string;
+    /** Date at which the value expires */
+    expiresAt?: Date | (() => Date);
+    /** Milliseconds in which the value expires. Will be ignored if expiresAt is set. */
+    expiresIn?: number | (() => number);
+}
+export declare class Expiration {
+    private readonly key;
+    private readonly getExpiration;
+    private timeout;
+    constructor({ key, expiresAt, expiresIn }: ExpirationOptions);
+    remove(): void;
+    private dispatchExpiration;
+    init(onExpire: () => void): void;
+    set(onExpire: () => void): void;
+}

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

@@ -0,0 +1,17 @@
+import { Dispatch } from "@yaasl/utils";
+export interface LocalStorageParser<T = any> {
+    parse: (value: string) => T;
+    stringify: (value: T) => string;
+}
+export interface LocalStorageConstructorOptions<T> {
+    parser?: LocalStorageParser<T>;
+    onTabSync?: Dispatch<T | null>;
+}
+export declare class LocalStorage<T = unknown> {
+    private readonly key;
+    private parser;
+    constructor(key: string, options?: LocalStorageConstructorOptions<T>);
+    get(): T | null;
+    set(value: T): void;
+    remove(): void;
+}

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

@@ -0,0 +1,9 @@
+export declare class Store<T> {
+    private name;
+    private database;
+    constructor(name: string);
+    private getStore;
+    get(key: string): Promise<T | undefined>;
+    set(key: string, value: T): Promise<void>;
+    delete(key: string): Promise<undefined>;
+}

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

@@ -0,0 +1,7 @@
+type Executor<T, R> = ((value: T) => R | PromiseLike<R>) | undefined | null;
+export declare class Thenable<T = undefined> implements PromiseLike<T> {
+    private value?;
+    constructor(value?: T | undefined);
+    then<Result = T, Reject = never>(onfulfilled?: Executor<T, Result>, onrejected?: Executor<any, Reject>): PromiseLike<Result | Reject>;
+}
+export {};

package/dist/cjs/base/Stateful.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Stateful = void 0;
+class Stateful {
+    constructor(value) {
+        this.value = value;
+        this.listeners = new Set();
+    }
+    /** Read the value of state.
+     *
+     * @returns The current value.
+     **/
+    get() {
+        return this.value;
+    }
+    /** Subscribe to value changes.
+     *
+     *  @param callback Function to use the new value.
+     *
+     *  @returns A callback to unsubscribe the passed callback.
+     */
+    subscribe(callback) {
+        this.listeners.add(callback);
+        return () => this.listeners.delete(callback);
+    }
+    emit() {
+        this.listeners.forEach(listener => listener(this.get()));
+    }
+    update(value) {
+        if (this.value !== value) {
+            this.value = value;
+            this.emit();
+        }
+    }
+}
+exports.Stateful = Stateful;

package/dist/cjs/base/atom.js

@@ -0,0 +1,67 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.atom = exports.Atom = void 0;
+const Stateful_1 = require("./Stateful");
+const MiddlewareDispatcher_1 = require("../middleware/MiddlewareDispatcher");
+let key = 0;
+class Atom extends Stateful_1.Stateful {
+    constructor({ defaultValue, name = `atom-${++key}`, middleware, }) {
+        super(defaultValue);
+        this.didInit = false;
+        this.name = name;
+        this.defaultValue = defaultValue;
+        if (!middleware || middleware.length === 0) {
+            this.didInit = true;
+            return;
+        }
+        const { didInit } = new MiddlewareDispatcher_1.MiddlewareDispatcher({ atom: this, middleware });
+        if (typeof didInit === "boolean") {
+            this.didInit = didInit;
+        }
+        else {
+            this.didInit = didInit.then(() => {
+                this.didInit = true;
+            });
+        }
+    }
+    /** Set the value of the atom.
+     *
+     * @param next New value or function to create the
+     * new value based off the previous value.
+     */
+    set(next) {
+        const value = next instanceof Function ? next(this.get()) : next;
+        super.update(value);
+    }
+    /** Resolve the value of a promise and set as atom value.
+     *
+     * @param promise Promise to unwrap
+     */
+    unwrap(promise) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const value = yield promise;
+            this.set(value);
+            return value;
+        });
+    }
+}
+exports.Atom = Atom;
+/** Creates an atom store.
+ *
+ * @param config.defaultValue Value that will be used initially.
+ * @param config.name Name of the atom. Must be unique among all atoms. Defaults to "atom-{number}".
+ * @param config.middleware Middleware that will be applied on the atom.
+ *
+ * @returns An atom instance.
+ **/
+const atom = (config) => new Atom(config);
+exports.atom = atom;

package/dist/cjs/base/config.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONFIG = void 0;
+/** Global configuration object to change internal behavior of yaasl.
+ *
+ *  Values should be set once in your application entrypoint,
+ *  before yaasl is being used.
+ **/
+exports.CONFIG = {
+    name: undefined,
+};

package/dist/cjs/base/derive.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.derive = exports.Derive = void 0;
+const Stateful_1 = require("./Stateful");
+class Derive extends Stateful_1.Stateful {
+    constructor(derivation) {
+        super(undefined);
+        this.derivation = derivation;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this.dependencies = new Set();
+        this.value = derivation({ get: dep => this.addDependency(dep) });
+    }
+    addDependency(dependency) {
+        if (!this.dependencies.has(dependency)) {
+            dependency.subscribe(() => this.deriveUpdate());
+            this.dependencies.add(dependency);
+        }
+        return dependency.get();
+    }
+    deriveUpdate() {
+        this.update(this.derivation({ get: dep => this.addDependency(dep) }));
+    }
+}
+exports.Derive = Derive;
+/** Creates a value, derived from one or more atoms or other derived values.
+ *
+ *  @param get Function to derive the new value.
+ *
+ *  @returns A derived instance.
+ **/
+const derive = (get) => new Derive(get);
+exports.derive = derive;

package/dist/cjs/base/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("./atom"), exports);
+__exportStar(require("./derive"), exports);
+__exportStar(require("./config"), exports);
+__exportStar(require("./Stateful"), exports);

package/dist/cjs/index.js

@@ -0,0 +1,18 @@
+"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("./base"), exports);
+__exportStar(require("./middleware"), exports);

package/dist/cjs/middleware/MiddlewareDispatcher.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MiddlewareDispatcher = void 0;
+const Thenable_1 = require("../utils/Thenable");
+const isPromise = (value) => value instanceof Promise;
+class MiddlewareDispatcher {
+    constructor({ atom, middleware }) {
+        this.didInit = false;
+        this.middleware = [];
+        this.middleware = middleware.map(create => create(atom));
+        const result = this.callMiddlewareAction("init", atom)
+            .then(() => this.subscribeSetters(atom))
+            .then(() => this.callMiddlewareAction("didInit", atom))
+            .then(() => {
+            this.didInit = true;
+        });
+        if (result instanceof Promise) {
+            this.didInit = result;
+        }
+    }
+    subscribeSetters(atom) {
+        atom.subscribe(value => void this.callMiddlewareAction("set", atom, value));
+    }
+    callMiddlewareAction(action, atom, value = atom.get()) {
+        const result = this.middleware.map(middleware => {
+            const { actions, options } = middleware;
+            const actionFn = actions[action];
+            return actionFn === null || actionFn === void 0 ? void 0 : actionFn({ value, atom, options });
+        });
+        const promises = result.filter(isPromise);
+        return promises.length ? Promise.all(promises) : new Thenable_1.Thenable();
+    }
+}
+exports.MiddlewareDispatcher = MiddlewareDispatcher;

package/dist/cjs/middleware/expiration.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expiration = void 0;
+const middleware_1 = require("./middleware");
+const base_1 = require("../base");
+const Expiration_1 = require("../utils/Expiration");
+const STORAGE = window.localStorage;
+const syncOverBrowserTabs = (observingKey, onChange) => window.addEventListener("storage", ({ key, newValue }) => {
+    if (observingKey !== key)
+        return;
+    const currentValue = STORAGE.getItem(observingKey);
+    if (currentValue === newValue)
+        return;
+    onChange(newValue);
+});
+/** Middleware to make an atom value expirable and reset to its defaulValue.
+ *
+ * __Note:__ When using `expiresAt`, a function returning the date should be prefered since using a static date might end in an infinite loop.
+ *
+ * @param {ExpirationOptions | undefined} options
+ * @param options.expiresAt Date at which the value expires
+ * @param options.expiresIn Milliseconds in which the value expires. Will be ignored if expiresAt is set.
+ *
+ * @returns The middleware to be used on atoms.
+ **/
+exports.expiration = (0, middleware_1.middleware)(({ atom, options = {} }) => {
+    var _a;
+    const hasExpiration = Boolean((_a = options.expiresAt) !== null && _a !== void 0 ? _a : options.expiresIn);
+    if (!hasExpiration)
+        return {};
+    const key = base_1.CONFIG.name ? `${base_1.CONFIG.name}/${atom.name}` : atom.name;
+    const expiration = new Expiration_1.Expiration(Object.assign(Object.assign({}, options), { key: `${key}-expires-at` }));
+    const reset = () => {
+        expiration.remove();
+        atom.set(atom.defaultValue);
+    };
+    return {
+        init: () => {
+            expiration.init(reset);
+            syncOverBrowserTabs(key, () => expiration.init(reset));
+        },
+        set: ({ value }) => {
+            if (value === atom.defaultValue)
+                return;
+            expiration.set(reset);
+        },
+    };
+});

package/dist/cjs/middleware/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMigrationStep = exports.migration = exports.expiration = exports.indexedDb = exports.localStorage = exports.middleware = void 0;
+var middleware_1 = require("./middleware");
+Object.defineProperty(exports, "middleware", { enumerable: true, get: function () { return middleware_1.middleware; } });
+var localStorage_1 = require("./localStorage");
+Object.defineProperty(exports, "localStorage", { enumerable: true, get: function () { return localStorage_1.localStorage; } });
+var indexedDb_1 = require("./indexedDb");
+Object.defineProperty(exports, "indexedDb", { enumerable: true, get: function () { return indexedDb_1.indexedDb; } });
+var expiration_1 = require("./expiration");
+Object.defineProperty(exports, "expiration", { enumerable: true, get: function () { return expiration_1.expiration; } });
+var migration_1 = require("./migration");
+Object.defineProperty(exports, "migration", { enumerable: true, get: function () { return migration_1.migration; } });
+Object.defineProperty(exports, "createMigrationStep", { enumerable: true, get: function () { return migration_1.createMigrationStep; } });

package/dist/cjs/middleware/indexedDb.js

@@ -0,0 +1,49 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.indexedDb = void 0;
+const middleware_1 = require("./middleware");
+const base_1 = require("../base");
+const Store_1 = require("../utils/Store");
+let atomDb = null;
+/** Middleware to save and load atom values to an indexedDb.
+ *
+ *  Will use one database and store for all atoms with your `CONFIG.name`
+ *  as name or `yaasl` if not set.
+ *
+ * @param {IndexedDbOptions | undefined} options
+ * @param options.key Use your own store key. Will be `atom.name` by default.
+ *
+ * @returns The middleware to be used on atoms.
+ **/
+exports.indexedDb = (0, middleware_1.middleware)(({ atom, options }) => {
+    var _a;
+    const key = (_a = options === null || options === void 0 ? void 0 : options.key) !== null && _a !== void 0 ? _a : atom.name;
+    return {
+        init: ({ atom }) => {
+            var _a;
+            if (!atomDb) {
+                atomDb = new Store_1.Store((_a = base_1.CONFIG.name) !== null && _a !== void 0 ? _a : "yaasl");
+            }
+            return atomDb.get(key).then((value) => __awaiter(void 0, void 0, void 0, function* () {
+                if (value !== undefined) {
+                    atom.set(value);
+                }
+                else {
+                    yield (atomDb === null || atomDb === void 0 ? void 0 : atomDb.set(key, atom.defaultValue));
+                }
+            }));
+        },
+        set: ({ value }) => {
+            void (atomDb === null || atomDb === void 0 ? void 0 : atomDb.set(key, value));
+        },
+    };
+});