@yaasl/core 0.8.0 → 0.9.1

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

@@ -0,0 +1,31 @@
+import { Atom } from "./createAtom";
+import { SettableDerive } from "./createDerived";
+type Reducer<State> = (state: State, ...payloadArgs: any[]) => State;
+export type Reducers<State> = Record<string, Reducer<State>>;
+type Payload<R extends Reducer<any>> = Parameters<R> extends [
+    any,
+    ...infer PayloadArgs
+] ? PayloadArgs : [];
+export type Actions<State, R extends Reducers<State>> = {
+    [K in keyof R]: (...payloadArgs: Payload<R[K]>) => void;
+};
+/** Create actions to change the state of an atom.
+ *
+ *  @param atom Atom to be used.
+ *  @param reducers Reducers for custom actions to set the atoms value.
+ *
+ *  @returns Actions to change the state of the atom.
+ *
+ *  @example
+ *  const counter = createAtom({ defaultValue: 0 })
+ *  const actions = createActions(counter, {
+ *    increment: (state) => state + 1,
+ *    decrement: (state) => state - 1,
+ *    add: (state, value: number) => state + value,
+ *    subtract: (state, value: number) => state - value,
+ *  })
+ *  actions.increment()
+ *  actions.add(5)
+ **/
+export declare const createActions: <State, R extends Reducers<State>>(atom: Atom<State> | SettableDerive<State>, reducers: R) => Actions<State, R>;
+export {};

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

@@ -0,0 +1,42 @@
+import { SetStateAction } from "@yaasl/utils";
+import { Actions, Reducers } from "./createActions";
+import { Stateful } from "./Stateful";
+import { EffectAtomCallback } from "../effects/createEffect";
+export interface AtomConfig<Value, R extends Reducers<Value> = Reducers<Value>> {
+    /** Value that will be used initially. */
+    defaultValue: Value;
+    /** Name of the atom. Must be unique among all atoms. Defaults to "atom-{number}". */
+    name?: string;
+    /** Effects that will be applied on the atom. */
+    effects?: EffectAtomCallback<any>[];
+    /** Reducers for custom actions to set the atom's value. */
+    reducers?: R;
+}
+export declare class Atom<Value = unknown, R extends Reducers<Value> = Reducers<Value>> extends Stateful<Value> {
+    readonly defaultValue: Value;
+    readonly name: string;
+    readonly actions: Actions<Value, R>;
+    constructor({ defaultValue, name, effects, reducers, }: AtomConfig<Value, R>);
+    /** 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<Value>): void;
+}
+/** 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.effects Effects that will be applied on the atom.
+ * @param config.reducers Reducers for custom actions to set the atom's value.
+ *
+ * @returns An atom instance.
+ * - `result.get`: Read the value of state.
+ * - `result.subscribe`: Subscribe to value changes.
+ * - `result.set`: Set the value of the atom.
+ * - `result.actions`: All actions that were created with reducers.
+ * - `result.didInit`: State of the atom's effects initialization process.
+ *   Will be a promise if the initialization is pending and `true` if finished.
+ **/
+export declare const createAtom: <Value, R extends Reducers<Value> = Reducers<Value>>(config: AtomConfig<Value, R>) => Atom<Value, R>;

package/dist/@types/base/{derive.d.ts → createDerived.d.ts}

@@ -1,5 +1,5 @@
 import { SetStateAction } from "@yaasl/utils";
-import { Atom } from "./atom";
+import { Atom } from "./createAtom";
 import { Stateful } from "./Stateful";
 type GetterFn<Value> = (context: {
     get: <V>(dep: Stateful<V>) => V;
@@ -17,7 +17,7 @@ export declare class Derive<Value> extends Stateful<Value> {
 }
 export declare class SettableDerive<Value = unknown> extends Derive<Value> {
     private readonly setter;
-    protected readonly setterDependencies: Set<Atom<any> | SettableDerive<any>>;
+    protected readonly setterDependencies: Set<Atom<any, import("./createActions").Reducers<any>> | SettableDerive<any>>;
     constructor(getter: GetterFn<Value>, setter: SetterFn<Value>);
     /** Set the value of the derived atom.
      *
@@ -40,6 +40,6 @@ export declare class SettableDerive<Value = unknown> extends Derive<Value> {
  *
  *  @returns A derive instance.
  **/
-export declare function derive<Value>(getter: GetterFn<Value>): Derive<Value>;
-export declare function derive<Value>(getter: GetterFn<Value>, setter: SetterFn<Value>): SettableDerive<Value>;
+export declare function createDerived<Value>(getter: GetterFn<Value>): Derive<Value>;
+export declare function createDerived<Value>(getter: GetterFn<Value>, setter: SetterFn<Value>): SettableDerive<Value>;
 export {};

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

@@ -0,0 +1,33 @@
+import { Stateful } from "./Stateful";
+type PathableState = Record<string | number, unknown>;
+type DeepKeys<State> = State extends PathableState ? {
+    [K in keyof State]: `${Exclude<K, symbol>}${"" | `.${DeepKeys<State[K]>}`}`;
+}[keyof State] : never;
+type DeepValue<State, Path> = State extends PathableState ? Path extends `${infer Current}.${infer Next}` ? DeepValue<State[Current], Next> : State[Path & string] : never;
+export declare class PathSelector<State, Path extends DeepKeys<State>> extends Stateful<DeepValue<State, Path>> {
+    constructor(atom: Stateful<State>, path: Path);
+}
+type InferValuesFromAtoms<Atoms extends readonly unknown[], States extends unknown[] = []> = Atoms extends [Stateful<infer Value>, ...infer Rest] ? InferValuesFromAtoms<Rest, [...States, Value]> : States;
+export declare class CombinerSelector<State, Atoms extends [Stateful<any>, ...Stateful<any>[]]> extends Stateful<State> {
+    constructor(atoms: Atoms, combiner: (...res: InferValuesFromAtoms<Atoms>) => State);
+}
+interface CreateSelectorOverloads {
+    /** Creates a value, selected from one atom with an object value by using a key path.
+     *
+     *  @param atom The atom to select a value from. The internal state must be an object.
+     *  @param path The path to the value you want to select.
+     *
+     *  @returns A PathSelector instance.
+     **/
+    <State, Path extends DeepKeys<State>>(atom: Stateful<State>, path: Path): PathSelector<State, Path>;
+    /** Creates a value, selected from one atom with an object value by using a key path.
+     *
+     *  @param atoms Atoms you need to combine to receive the new value.
+     *  @param combiner Combiner function to use the atom values and create a new value.
+     *
+     *  @returns A CombinerSelector instance.
+     **/
+    <Atoms extends [Stateful<any>, ...Stateful<any>[]], CombinedState>(states: Atoms, combiner: (...res: InferValuesFromAtoms<Atoms>) => CombinedState): CombinerSelector<CombinedState, Atoms>;
+}
+export declare const createSelector: CreateSelectorOverloads;
+export {};

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

@@ -1,5 +1,5 @@
-export * from "./atom";
-export * from "./derive";
 export * from "./config";
-export * from "./select";
+export * from "./createAtom";
+export * from "./createDerived";
+export * from "./createSelector";
 export * from "./Stateful";

package/dist/@types/effects/EffectDispatcher.d.ts

@@ -0,0 +1,15 @@
+import { EffectAtomCallback } from "./createEffect";
+import { Atom } from "../base/createAtom";
+interface EffectDispatcherConstructor {
+    atom: Atom<any>;
+    effects: EffectAtomCallback<any>[];
+}
+export declare class EffectDispatcher {
+    didInit: PromiseLike<void> | boolean;
+    private effects;
+    private scheduler;
+    constructor({ atom, effects }: EffectDispatcherConstructor);
+    private subscribeSetters;
+    private callEffectAction;
+}
+export {};

package/dist/@types/effects/createEffect.d.ts

@@ -0,0 +1,39 @@
+import { Atom } from "../base";
+export type ActionType = "init" | "didInit" | "set";
+interface EffectPayload<Options, AtomValue> {
+    value: AtomValue;
+    atom: Atom<AtomValue>;
+    options: Options;
+}
+interface EffectActions<Options, AtomValue> {
+    init?: (payload: EffectPayload<Options, AtomValue>) => Promise<any> | void;
+    didInit?: (payload: EffectPayload<Options, AtomValue>) => Promise<any> | void;
+    set?: (payload: EffectPayload<Options, AtomValue>) => void;
+}
+interface EffectSetupProps<Options, AtomValue> {
+    atom: Atom<AtomValue>;
+    options: Options;
+}
+export type EffectAtomCallback<Options = unknown, AtomValue = unknown> = (atom: Atom<AtomValue>) => Effect<Options, AtomValue>;
+type EffectSetup<Options, AtomValue> = EffectActions<Options, AtomValue> | ((props: EffectSetupProps<Options, AtomValue>) => EffectActions<Options, AtomValue>);
+export interface Effect<Options = unknown, AtomValue = unknown> {
+    options: Options;
+    actions: EffectActions<Options, AtomValue>;
+}
+/** Create effects to be used in combination with atoms.
+ *
+ * Effects can be used to interact with an atom by using the following lifecycle actions:
+ *
+ * - `init`: Action to be called when the atom is created, but before subscribing to `set` events.
+ *   May return a promise that can be awaited by using `atom.didInit`.
+ * - `didInit`: Action to be called when the atom is created, but after subscribing to `set` events.
+ *   May return a promise that can be awaited by using `atom.didInit`.
+ * - `set`: Action to be called when the atom's `set` function is called.
+ *
+ * @param setup Effect actions or function to create effect actions.
+ *   Effect actions are fired in the atom lifecycle, alongside to the subscriptions.
+ *
+ * @returns The effect to be used on atoms.
+ **/
+export declare const createEffect: <Options = undefined, AtomValue = any>(setup: EffectSetup<Options, AtomValue>) => (...[optionsArg]: Options extends undefined ? [Options] | [] : [Options]) => EffectAtomCallback<Options, AtomValue>;
+export {};

package/dist/@types/{middleware → effects}/expiration.d.ts

@@ -4,7 +4,7 @@ export interface ExpirationOptions {
     /** 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.
+/** Effect 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.
  *
@@ -12,6 +12,6 @@ export interface ExpirationOptions {
  * @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.
+ * @returns The effect to be used on atoms.
  **/
-export declare const expiration: (__0_0: ExpirationOptions) => import("./middleware").MiddlewareAtomCallback<ExpirationOptions, any>;
+export declare const expiration: (__0_0: ExpirationOptions) => import("./createEffect").EffectAtomCallback<ExpirationOptions, any>;

package/dist/@types/{middleware → effects}/index.d.ts

@@ -1,5 +1,5 @@
-export { middleware } from "./middleware";
-export type { Middleware } from "./middleware";
+export { createEffect } from "./createEffect";
+export type { Effect } from "./createEffect";
 export { localStorage } from "./localStorage";
 export type { LocalStorageOptions, LocalStorageParser } from "./localStorage";
 export { indexedDb } from "./indexedDb";

package/dist/@types/{middleware → effects}/indexedDb.d.ts

@@ -10,6 +10,6 @@ export interface IndexedDbOptions {
  * @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.
+ * @returns The effect to be used on atoms.
  **/
-export declare const indexedDb: (...[optionsArg]: [] | [undefined] | [IndexedDbOptions]) => import("./middleware").MiddlewareAtomCallback<IndexedDbOptions | undefined, any>;
+export declare const indexedDb: (...[optionsArg]: [] | [undefined] | [IndexedDbOptions]) => import("./createEffect").EffectAtomCallback<IndexedDbOptions | undefined, any>;

package/dist/@types/{middleware → effects}/localStorage.d.ts

@@ -23,6 +23,6 @@ export interface LocalStorageOptions {
  * @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.
+ * @returns The effect to be used on atoms.
  **/
-export declare const localStorage: (...[optionsArg]: [] | [undefined] | [LocalStorageOptions]) => import("./middleware").MiddlewareAtomCallback<LocalStorageOptions | undefined, any>;
+export declare const localStorage: (...[optionsArg]: [] | [undefined] | [LocalStorageOptions]) => import("./createEffect").EffectAtomCallback<LocalStorageOptions | undefined, any>;

package/dist/@types/{middleware → effects}/migration.d.ts

@@ -9,11 +9,27 @@ export interface MigrationStep<Version extends string = string, PreviousVersion
     validate?: (data: unknown) => data is OldData;
 }
 export interface MigrationOptions {
-    /** Migration steps to perform.
+    /** An array of migration steps to perform for outdated values.
      *
-     *  Note: One step must have a `previous` version set to null as entry point.
+     *  __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, unknown>;
+/** Effect to migrate the persisted value of an atom to a newer version.
+ *  You can use the `createMigrationStep` helper to create migration steps.
+ *
+ *  @param {MigrationOptions} options
+ *  @param options.steps An array of migration steps to perform for outdated values.
+ *
+ * __Note:__ One step must have a `previous` version set to null as entry point.
+ *
+ *  @returns The effect to be used on atoms.
+ **/
+export declare const migration: (__0_0: MigrationOptions) => import("./createEffect").EffectAtomCallback<MigrationOptions, unknown>;
+/** Helper to create a step for the migration effect.
+ *
+ *  @param migration Migration step to create.
+ *
+ *  @returns The migration step.
+ **/
 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/index.d.ts

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

package/dist/cjs/base/createActions.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createActions = void 0;
+/** Create actions to change the state of an atom.
+ *
+ *  @param atom Atom to be used.
+ *  @param reducers Reducers for custom actions to set the atoms value.
+ *
+ *  @returns Actions to change the state of the atom.
+ *
+ *  @example
+ *  const counter = createAtom({ defaultValue: 0 })
+ *  const actions = createActions(counter, {
+ *    increment: (state) => state + 1,
+ *    decrement: (state) => state - 1,
+ *    add: (state, value: number) => state + value,
+ *    subtract: (state, value: number) => state - value,
+ *  })
+ *  actions.increment()
+ *  actions.add(5)
+ **/
+const createActions = (atom, reducers) => Object.entries(reducers).reduce((result, [key, reducerFn]) => {
+    result[key] = (...payloadArgs) => {
+        atom.set((state) => reducerFn(state, ...payloadArgs));
+    };
+    return result;
+}, {});
+exports.createActions = createActions;

package/dist/cjs/base/createAtom.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAtom = exports.Atom = void 0;
+const createActions_1 = require("./createActions");
+const Stateful_1 = require("./Stateful");
+const EffectDispatcher_1 = require("../effects/EffectDispatcher");
+let key = 0;
+class Atom extends Stateful_1.Stateful {
+    constructor({ defaultValue, name = `atom-${++key}`, effects, reducers = {}, }) {
+        super(defaultValue);
+        this.name = name;
+        this.defaultValue = defaultValue;
+        this.actions = (0, createActions_1.createActions)(this, reducers);
+        if (!effects || effects.length === 0) {
+            this.didInit = true;
+            return;
+        }
+        const { didInit } = new EffectDispatcher_1.EffectDispatcher({ atom: this, effects });
+        this.setDidInit(didInit);
+    }
+    /** 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);
+    }
+}
+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.effects Effects that will be applied on the atom.
+ * @param config.reducers Reducers for custom actions to set the atom's value.
+ *
+ * @returns An atom instance.
+ * - `result.get`: Read the value of state.
+ * - `result.subscribe`: Subscribe to value changes.
+ * - `result.set`: Set the value of the atom.
+ * - `result.actions`: All actions that were created with reducers.
+ * - `result.didInit`: State of the atom's effects initialization process.
+ *   Will be a promise if the initialization is pending and `true` if finished.
+ **/
+const createAtom = (config) => new Atom(config);
+exports.createAtom = createAtom;

package/dist/cjs/base/{derive.js → createDerived.js}

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.derive = exports.SettableDerive = exports.Derive = void 0;
+exports.createDerived = exports.SettableDerive = exports.Derive = void 0;
 const utils_1 = require("@yaasl/utils");
 const Stateful_1 = require("./Stateful");
 const allDidInit = (atoms) => {
@@ -73,7 +73,7 @@ class SettableDerive extends Derive {
     }
 }
 exports.SettableDerive = SettableDerive;
-function derive(getter, setter) {
+function createDerived(getter, setter) {
     if (setter) {
         return new SettableDerive(getter, setter);
     }
@@ -81,4 +81,4 @@ function derive(getter, setter) {
         return new Derive(getter);
     }
 }
-exports.derive = derive;
+exports.createDerived = createDerived;

package/dist/cjs/base/createSelector.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSelector = exports.CombinerSelector = exports.PathSelector = void 0;
+const utils_1 = require("@yaasl/utils");
+const Stateful_1 = require("./Stateful");
+const selectPath = (state, path) => path
+    .split(".")
+    .reduce((result, key) => result[key], state);
+class PathSelector extends Stateful_1.Stateful {
+    constructor(atom, path) {
+        super(selectPath(atom.get(), path));
+        atom.subscribe(state => this.update(selectPath(state, path)));
+        this.setDidInit(atom.didInit);
+    }
+}
+exports.PathSelector = PathSelector;
+// -- Combiner selector
+const allDidInit = (atoms) => {
+    const inits = atoms
+        .map(atom => atom.didInit)
+        .filter((didInit) => typeof didInit !== "boolean");
+    return inits.length === 0 ? true : Promise.all(inits).then(utils_1.toVoid);
+};
+class CombinerSelector extends Stateful_1.Stateful {
+    constructor(atoms, combiner) {
+        const selectState = () => {
+            const values = atoms.map(atom => atom.get());
+            return combiner(...values);
+        };
+        super(selectState());
+        atoms.forEach(atom => atom.subscribe(() => this.update(selectState())));
+        this.setDidInit(allDidInit(atoms));
+    }
+}
+exports.CombinerSelector = CombinerSelector;
+const createSelector = (atoms, selector) => {
+    if (atoms instanceof Stateful_1.Stateful && typeof selector === "string") {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+        return new PathSelector(atoms, selector);
+    }
+    if (Array.isArray(atoms) && typeof selector === "function") {
+        return new CombinerSelector(atoms, selector);
+    }
+    throw new Error("Selector args do not match any overload");
+};
+exports.createSelector = createSelector;

package/dist/cjs/base/index.js

@@ -14,8 +14,8 @@ 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("./select"), exports);
+__exportStar(require("./createAtom"), exports);
+__exportStar(require("./createDerived"), exports);
+__exportStar(require("./createSelector"), exports);
 __exportStar(require("./Stateful"), exports);

package/dist/cjs/{middleware/MiddlewareDispatcher.js → effects/EffectDispatcher.js}

@@ -1,17 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MiddlewareDispatcher = void 0;
+exports.EffectDispatcher = void 0;
 const utils_1 = require("@yaasl/utils");
 const Scheduler_1 = require("../utils/Scheduler");
-class MiddlewareDispatcher {
-    constructor({ atom, middleware }) {
+class EffectDispatcher {
+    constructor({ atom, effects }) {
         this.didInit = false;
-        this.middleware = [];
+        this.effects = [];
         this.scheduler = new Scheduler_1.Scheduler();
-        this.middleware = middleware.map(create => create(atom));
-        this.callMiddlewareAction("init", atom);
+        this.effects = effects.map(create => create(atom));
+        this.callEffectAction("init", atom);
         this.subscribeSetters(atom);
-        this.callMiddlewareAction("didInit", atom);
+        this.callEffectAction("didInit", atom);
         const { queue } = this.scheduler;
         if (!(0, utils_1.isPromiseLike)(queue)) {
             this.didInit = true;
@@ -22,16 +22,16 @@ class MiddlewareDispatcher {
         });
     }
     subscribeSetters(atom) {
-        atom.subscribe(value => this.callMiddlewareAction("set", atom, () => value));
+        atom.subscribe(value => this.callEffectAction("set", atom, () => value));
     }
-    callMiddlewareAction(action, atom, 
+    callEffectAction(action, atom, 
     /* Must be a function to make sure it is using the latest value when used in promise */
     getValue = () => atom.get()) {
-        const tasks = this.middleware.map(({ actions, options }) => {
+        const tasks = this.effects.map(({ actions, options }) => {
             const actionFn = actions[action];
             return () => actionFn === null || actionFn === void 0 ? void 0 : actionFn({ value: getValue(), atom, options });
         });
         void this.scheduler.run(tasks);
     }
 }
-exports.MiddlewareDispatcher = MiddlewareDispatcher;
+exports.EffectDispatcher = EffectDispatcher;

package/dist/cjs/effects/createEffect.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEffect = void 0;
+/** Create effects to be used in combination with atoms.
+ *
+ * Effects can be used to interact with an atom by using the following lifecycle actions:
+ *
+ * - `init`: Action to be called when the atom is created, but before subscribing to `set` events.
+ *   May return a promise that can be awaited by using `atom.didInit`.
+ * - `didInit`: Action to be called when the atom is created, but after subscribing to `set` events.
+ *   May return a promise that can be awaited by using `atom.didInit`.
+ * - `set`: Action to be called when the atom's `set` function is called.
+ *
+ * @param setup Effect actions or function to create effect actions.
+ *   Effect actions are fired in the atom lifecycle, alongside to the subscriptions.
+ *
+ * @returns The effect to be used on atoms.
+ **/
+const createEffect = (setup) => (...[optionsArg]) => (atom) => {
+    const options = optionsArg;
+    const actions = setup instanceof Function ? setup({ options, atom }) : setup;
+    return {
+        options,
+        actions,
+    };
+};
+exports.createEffect = createEffect;

package/dist/cjs/{middleware → effects}/expiration.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.expiration = void 0;
-const middleware_1 = require("./middleware");
+const createEffect_1 = require("./createEffect");
 const base_1 = require("../base");
 const Expiration_1 = require("../utils/Expiration");
 const STORAGE = window.localStorage;
@@ -13,7 +13,7 @@ const syncOverBrowserTabs = (observingKey, onChange) => window.addEventListener(
         return;
     onChange(newValue);
 });
-/** Middleware to make an atom value expirable and reset to its defaulValue.
+/** Effect 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.
  *
@@ -21,9 +21,9 @@ const syncOverBrowserTabs = (observingKey, onChange) => window.addEventListener(
  * @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.
+ * @returns The effect to be used on atoms.
  **/
-exports.expiration = (0, middleware_1.middleware)(({ atom, options = {} }) => {
+exports.expiration = (0, createEffect_1.createEffect)(({ atom, options = {} }) => {
     var _a;
     const hasExpiration = Boolean((_a = options.expiresAt) !== null && _a !== void 0 ? _a : options.expiresIn);
     if (!hasExpiration)

package/dist/cjs/{middleware → effects}/index.js

@@ -1,8 +1,8 @@
 "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; } });
+exports.createMigrationStep = exports.migration = exports.expiration = exports.indexedDb = exports.localStorage = exports.createEffect = void 0;
+var createEffect_1 = require("./createEffect");
+Object.defineProperty(exports, "createEffect", { enumerable: true, get: function () { return createEffect_1.createEffect; } });
 var localStorage_1 = require("./localStorage");
 Object.defineProperty(exports, "localStorage", { enumerable: true, get: function () { return localStorage_1.localStorage; } });
 var indexedDb_1 = require("./indexedDb");

package/dist/cjs/{middleware → effects}/indexedDb.js

@@ -10,7 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.indexedDb = void 0;
-const middleware_1 = require("./middleware");
+const createEffect_1 = require("./createEffect");
 const base_1 = require("../base");
 const Store_1 = require("../utils/Store");
 let atomDb = null;
@@ -22,9 +22,9 @@ let atomDb = null;
  * @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.
+ * @returns The effect to be used on atoms.
  **/
-exports.indexedDb = (0, middleware_1.middleware)(({ atom, options }) => {
+exports.indexedDb = (0, createEffect_1.createEffect)(({ atom, options }) => {
     var _a;
     const key = (_a = options === null || options === void 0 ? void 0 : options.key) !== null && _a !== void 0 ? _a : atom.name;
     return {

package/dist/cjs/{middleware → effects}/localStorage.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.localStorage = void 0;
-const middleware_1 = require("./middleware");
+const createEffect_1 = require("./createEffect");
 const base_1 = require("../base");
 const LocalStorage_1 = require("../utils/LocalStorage");
 /** Middleware to save and load atom values to the local storage.
@@ -12,9 +12,9 @@ const LocalStorage_1 = require("../utils/LocalStorage");
  * @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.
+ * @returns The effect to be used on atoms.
  **/
-exports.localStorage = (0, middleware_1.middleware)(({ atom, options = {} }) => {
+exports.localStorage = (0, createEffect_1.createEffect)(({ atom, options = {} }) => {
     const internalKey = base_1.CONFIG.name ? `${base_1.CONFIG.name}/${atom.name}` : atom.name;
     const { key = internalKey, parser, noTabSync } = options;
     const storage = new LocalStorage_1.LocalStorage(key, {