@yaasl/core 0.9.2 → 0.10.0-alpha.1

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

@@ -1,3 +1,4 @@
+import { EffectAtomCallback } from "../effects/createEffect";
 interface Config {
     /** Global name to make internal keys unique
      *  among UIs on the same domain.
@@ -6,6 +7,8 @@ interface Config {
      *  "{config-name}/{atom-name}")
      **/
     name?: string;
+    /** Global effects to apply on all atoms. (e.g. reduxDevtools) */
+    globalEffects: EffectAtomCallback<any>[];
 }
 /** Global configuration object to change internal behavior of yaasl.
  *

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

@@ -12,7 +12,7 @@ export type Actions<State, R extends Reducers<State>> = {
 /** 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.
+ *  @param reducers Reducers for custom actions to set the atom's value.
  *
  *  @returns Actions to change the state of the atom.
  *

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

@@ -1,39 +1,35 @@
-import { SetStateAction } from "@yaasl/utils";
-import { Actions, Reducers } from "./createActions";
+import { Updater } from "@yaasl/utils";
 import { Stateful } from "./Stateful";
 import { EffectAtomCallback } from "../effects/createEffect";
-export interface AtomConfig<Value, R extends Reducers<Value> = Reducers<Value>> {
+export interface AtomConfig<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;
+    effects?: EffectAtomCallback<any, any>[];
 }
-export declare class Atom<Value = unknown, R extends Reducers<Value> = Reducers<Value>> extends Stateful<Value> {
+export declare class Atom<Value = unknown> extends Stateful<Value> {
     /** Default value of the atom. */
     readonly defaultValue: Value;
     /** Identifier of the atom. */
     readonly name: string;
-    /** Actions that can be used to set the atom's value. */
-    readonly actions: Actions<Value, R>;
-    constructor({ defaultValue, name, effects, reducers, }: AtomConfig<Value, R>);
+    private effects;
+    constructor({ defaultValue, name, effects: localEffects, }: AtomConfig<Value>);
+    private initEffects;
     /** 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;
+    set(next: Updater<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.
  **/
-export declare const createAtom: <Value, R extends Reducers<Value> = Reducers<Value>>(config: AtomConfig<Value, R>) => Atom<Value, R>;
+export declare const createAtom: <Value>(config: AtomConfig<Value>) => Atom<Value>;

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

@@ -1,4 +1,4 @@
-import { SetStateAction } from "@yaasl/utils";
+import { Updater } from "@yaasl/utils";
 import { Atom } from "./createAtom";
 import { Stateful } from "./Stateful";
 type GetterFn<Value> = (context: {
@@ -6,7 +6,7 @@ type GetterFn<Value> = (context: {
 }) => Value;
 type SetterFn<Value> = (context: {
     value: Value;
-    set: <V>(dep: Atom<V> | SettableDerive<V>, next: SetStateAction<V>) => void;
+    set: <V>(dep: Atom<V> | SettableDerive<V>, next: Updater<V>) => void;
 }) => void;
 export declare class Derive<Value> extends Stateful<Value> {
     private readonly getter;
@@ -17,14 +17,14 @@ 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, import("./createActions").Reducers<any>> | SettableDerive<any>>;
+    protected readonly setterDependencies: Set<Atom<any> | SettableDerive<any>>;
     constructor(getter: GetterFn<Value>, setter: SetterFn<Value>);
     /** Set the value of the derived atom.
      *
      * @param next New value or function to create the
      * new value based off the previous value.
      */
-    set(next: SetStateAction<Value>): void;
+    set(next: Updater<Value>): void;
     private addSetDependency;
     private compareDependencies;
 }

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

@@ -1,15 +1,16 @@
+import { Prettify } from "@yaasl/utils";
 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 PathableValue = Record<string | number, unknown>;
+export type ObjPath<Obj> = Prettify<Obj> extends PathableValue ? {
+    [K in keyof Obj]: `${Exclude<K, symbol>}${"" | `.${ObjPath<Obj[K]>}`}`;
+}[keyof Obj] : never;
+type ObjPathValue<State, Path> = State extends PathableValue ? Path extends `${infer Current}.${infer Next}` ? ObjPathValue<State[Current], Next> : State[Path & string] : never;
+export declare class PathSelector<ParentValue, Path extends ObjPath<ParentValue>> extends Stateful<ObjPathValue<ParentValue, Path>> {
+    constructor(atom: Stateful<ParentValue>, 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);
+type InferValuesFromAtoms<ParentAtoms extends readonly unknown[], ParentValues extends unknown[] = []> = ParentAtoms extends [Stateful<infer Value>, ...infer Rest] ? InferValuesFromAtoms<Rest, [...ParentValues, Value]> : ParentValues;
+export declare class CombinerSelector<ParentAtoms extends [Stateful<any>, ...Stateful<any>[]], CombinedValue> extends Stateful<CombinedValue> {
+    constructor(atoms: ParentAtoms, combiner: (...res: InferValuesFromAtoms<ParentAtoms>) => CombinedValue);
 }
 interface CreateSelectorOverloads {
     /** Creates a value, selected from one atom with an object value by using a key path.
@@ -19,7 +20,7 @@ interface CreateSelectorOverloads {
      *
      *  @returns A PathSelector instance.
      **/
-    <State, Path extends DeepKeys<State>>(atom: Stateful<State>, path: Path): PathSelector<State, Path>;
+    <ParentValue, Path extends ObjPath<ParentValue>>(atom: Stateful<ParentValue>, path: Path): PathSelector<ParentValue, 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.
@@ -27,7 +28,7 @@ interface CreateSelectorOverloads {
      *
      *  @returns A CombinerSelector instance.
      **/
-    <Atoms extends [Stateful<any>, ...Stateful<any>[]], CombinedState>(states: Atoms, combiner: (...res: InferValuesFromAtoms<Atoms>) => CombinedState): CombinerSelector<CombinedState, Atoms>;
+    <ParentAtoms extends [Stateful<any>, ...Stateful<any>[]], CombinedValue>(states: ParentAtoms, combiner: (...res: InferValuesFromAtoms<ParentAtoms>) => CombinedValue): CombinerSelector<ParentAtoms, CombinedValue>;
 }
 export declare const createSelector: CreateSelectorOverloads;
 export {};

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

@@ -0,0 +1,35 @@
+import { Actions, Reducers } from "./createActions";
+import { Atom, AtomConfig } from "./createAtom";
+import { CombinerSelector, ObjPath, PathSelector } from "./createSelector";
+interface ReducersProp<State, R extends Reducers<State> | undefined> {
+    /** Reducers for custom actions to set the atom's value. */
+    reducers?: R;
+}
+type Selectors<State> = Record<string, ObjPath<State> | ((state: State) => any)>;
+type ConditionalActions<State, R> = keyof R extends never ? {} : R extends Reducers<State> ? {
+    /** Actions that can be used to set the atom's value. */
+    actions: Actions<State, R>;
+} : {};
+interface SelectorsProp<State, S extends Selectors<State> | undefined> {
+    /** Selectors to create values from the atom. */
+    selectors?: S;
+}
+type GetSelector<State, S extends ObjPath<State> | ((state: State) => any)> = S extends ObjPath<State> ? PathSelector<State, S> : S extends (state: State) => any ? CombinerSelector<[Atom<State>], ReturnType<S>> : never;
+type ConditionalSelectors<State, S> = keyof S extends never ? {} : S extends Selectors<State> ? {
+    /** Selectors to create new values based on the atom's value. */
+    selectors: {
+        [K in keyof S]: GetSelector<State, S[K]>;
+    };
+} : {};
+/** Creates a slice with actions and selectors.
+ *
+ * @param config.defaultValue Value that will be used initially.
+ * @param config.name Name of the atom.
+ * @param config.effects Effects that will be applied on the atom.
+ * @param config.reducers Reducers for custom actions to set the atom's value.
+ * @param config.selectors Path or combiner selectors to use the atom's values to create new ones.
+ *
+ * @returns An atom instance with actions and selectors.
+ **/
+export declare const createSlice: <State, R extends Reducers<State> | undefined, S extends Selectors<State> | undefined>(config: AtomConfig<State> & ReducersProp<State, R> & SelectorsProp<State, S>) => Atom<State> & ConditionalActions<State, R> & ConditionalSelectors<State, S>;
+export {};

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

@@ -1,5 +1,7 @@
 export * from "./config";
+export * from "./createActions";
 export * from "./createAtom";
 export * from "./createDerived";
 export * from "./createSelector";
+export * from "./createSlice";
 export * from "./Stateful";

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

@@ -1,15 +1,15 @@
-import { EffectAtomCallback } from "./createEffect";
+import { ActionType, EffectAtomCallback } from "./createEffect";
 import { Atom } from "../base/createAtom";
-interface EffectDispatcherConstructor {
-    atom: Atom<any>;
-    effects: EffectAtomCallback<any>[];
+export declare class EffectActions<Value> {
+    private readonly atom;
+    private options;
+    private actions;
+    constructor(atom: Atom<Value>, effectCreator: EffectAtomCallback<unknown, Value>);
+    createAction(action: ActionType): ((prev: Value) => Value | PromiseLike<Value>) | undefined;
 }
-export declare class EffectDispatcher {
-    didInit: PromiseLike<void> | boolean;
+export declare class EffectDispatcher<Value> {
     private effects;
-    private scheduler;
-    constructor({ atom, effects }: EffectDispatcherConstructor);
-    private subscribeSetters;
-    private callEffectAction;
+    private queue;
+    constructor(atom: Atom<Value>, effects: EffectAtomCallback<unknown, Value>[]);
+    dispatch(action: ActionType, startValue: Value): PromiseLike<Value>;
 }
-export {};

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

@@ -1,13 +1,22 @@
+import { Updater, Dispatch } from "@yaasl/utils";
 import { Atom } from "../base";
 export type ActionType = "init" | "didInit" | "set";
-interface EffectPayload<Options, AtomValue> {
+export interface EffectPayload<Options = undefined, AtomValue = any> {
+    /** Current value of the atom */
     value: AtomValue;
+    /** Function to set the value of the atom */
+    set: Dispatch<Updater<AtomValue>>;
+    /** The atom which the effect is applied on */
     atom: Atom<AtomValue>;
+    /** Options passed to the effect */
     options: Options;
 }
-interface EffectActions<Options, AtomValue> {
-    init?: (payload: EffectPayload<Options, AtomValue>) => Promise<any> | void;
-    didInit?: (payload: EffectPayload<Options, AtomValue>) => Promise<any> | void;
+export interface EffectActions<Options, AtomValue> {
+    /** Action to be called when the atom is created */
+    init?: (payload: EffectPayload<Options, AtomValue>) => PromiseLike<any> | void;
+    /** Action to be called after the init phase */
+    didInit?: (payload: EffectPayload<Options, AtomValue>) => PromiseLike<any> | void;
+    /** Action to be called when the atom's value is set */
     set?: (payload: EffectPayload<Options, AtomValue>) => void;
 }
 interface EffectSetupProps<Options, AtomValue> {
@@ -28,7 +37,7 @@ export interface Effect<Options = unknown, AtomValue = unknown> {
  *   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.
+ * - `set`: Action to be called when the atom's value is set.
  *
  * @param setup Effect actions or function to create effect actions.
  *   Effect actions are fired in the atom lifecycle, alongside to the subscriptions.

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

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

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

@@ -12,4 +12,4 @@ export interface IndexedDbOptions {
  *
  * @returns The effect to be used on atoms.
  **/
-export declare const indexedDb: (...[optionsArg]: [] | [undefined] | [IndexedDbOptions]) => import("./createEffect").EffectAtomCallback<IndexedDbOptions | undefined, any>;
+export declare const indexedDb: (...[optionsArg]: [] | [undefined] | [IndexedDbOptions]) => import("./createEffect").EffectAtomCallback<IndexedDbOptions | undefined, unknown>;

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

@@ -25,4 +25,4 @@ export interface LocalStorageOptions {
  *
  * @returns The effect to be used on atoms.
  **/
-export declare const localStorage: (...[optionsArg]: [] | [undefined] | [LocalStorageOptions]) => import("./createEffect").EffectAtomCallback<LocalStorageOptions | undefined, any>;
+export declare const localStorage: (...[optionsArg]: [] | [undefined] | [LocalStorageOptions]) => import("./createEffect").EffectAtomCallback<LocalStorageOptions | undefined, unknown>;

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

@@ -0,0 +1,8 @@
+type Task<Value> = (prev: Value) => PromiseLike<Value> | Value;
+export declare class Queue<T = void> {
+    private last;
+    private queue;
+    push(...tasks: Task<T>[]): this;
+    run(prev: T): PromiseLike<T>;
+}
+export {};

package/dist/cjs/base/config.js

@@ -8,4 +8,5 @@ exports.CONFIG = void 0;
  **/
 exports.CONFIG = {
     name: undefined,
+    globalEffects: [],
 };

package/dist/cjs/base/createActions.js

@@ -4,7 +4,7 @@ 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.
+ *  @param reducers Reducers for custom actions to set the atom's value.
  *
  *  @returns Actions to change the state of the atom.
  *

package/dist/cjs/base/createAtom.js

@@ -1,22 +1,43 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createAtom = exports.Atom = void 0;
-const createActions_1 = require("./createActions");
+const utils_1 = require("@yaasl/utils");
+const config_1 = require("./config");
 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 = {}, }) {
+    constructor({ defaultValue, name = `atom-${++key}`, effects: localEffects = [], }) {
         super(defaultValue);
         this.name = name;
         this.defaultValue = defaultValue;
-        this.actions = (0, createActions_1.createActions)(this, reducers);
-        if (!effects || effects.length === 0) {
-            this.didInit = true;
+        const effects = [
+            ...config_1.CONFIG.globalEffects,
+            ...localEffects,
+        ];
+        this.effects = new EffectDispatcher_1.EffectDispatcher(this, effects);
+        if (effects.length === 0) {
+            this.setDidInit(true);
             return;
         }
-        const { didInit } = new EffectDispatcher_1.EffectDispatcher({ atom: this, effects });
-        this.setDidInit(didInit);
+        const result = this.initEffects();
+        if (result instanceof utils_1.Thenable) {
+            this.setDidInit(true);
+        }
+        else {
+            this.setDidInit(result.then(utils_1.toVoid));
+        }
+    }
+    initEffects() {
+        const updateValue = (value) => {
+            super.update(value);
+            return value;
+        };
+        return new utils_1.Thenable(this.defaultValue)
+            .then(value => this.effects.dispatch("init", value))
+            .then(updateValue)
+            .then(value => this.effects.dispatch("didInit", value))
+            .then(updateValue);
     }
     /** Set the value of the atom.
      *
@@ -24,8 +45,10 @@ class Atom extends Stateful_1.Stateful {
      * new value based off the previous value.
      */
     set(next) {
-        const value = next instanceof Function ? next(this.get()) : next;
-        super.update(value);
+        const newState = (0, utils_1.updater)(next, this.get());
+        void this.effects
+            .dispatch("set", newState)
+            .then(value => super.update(value));
     }
 }
 exports.Atom = Atom;
@@ -34,7 +57,6 @@ exports.Atom = Atom;
  * @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.
  **/

package/dist/cjs/base/createDerived.js

@@ -50,11 +50,11 @@ class SettableDerive extends Derive {
      * new value based off the previous value.
      */
     set(next) {
-        const value = next instanceof Function ? next(this.get()) : next;
+        const value = (0, utils_1.updater)(next, this.get());
         this.setter({
             value,
             set: (atom, next) => {
-                const value = next instanceof Function ? next(atom.get()) : next;
+                const value = (0, utils_1.updater)(next, atom.get());
                 atom.set(value);
             },
         });

package/dist/cjs/base/createSlice.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSlice = void 0;
+const createActions_1 = require("./createActions");
+const createAtom_1 = require("./createAtom");
+const createSelector_1 = require("./createSelector");
+const isEmpty = (obj) => !obj || Object.keys(obj).length === 0;
+const createSelectors = (atom, selectors) => Object.fromEntries(Object.entries(selectors).map(([key, selector]) => [
+    key,
+    typeof selector === "string"
+        ? (0, createSelector_1.createSelector)(atom, selector)
+        : (0, createSelector_1.createSelector)([atom], selector),
+]));
+/** Creates a slice with actions and selectors.
+ *
+ * @param config.defaultValue Value that will be used initially.
+ * @param config.name Name of the atom.
+ * @param config.effects Effects that will be applied on the atom.
+ * @param config.reducers Reducers for custom actions to set the atom's value.
+ * @param config.selectors Path or combiner selectors to use the atom's values to create new ones.
+ *
+ * @returns An atom instance with actions and selectors.
+ **/
+const createSlice = (config) => {
+    const atom = new createAtom_1.Atom(config);
+    const actionsProp = isEmpty(config.reducers)
+        ? {}
+        : {
+            actions: (0, createActions_1.createActions)(atom, config.reducers),
+        };
+    const selectorsProp = isEmpty(config.selectors)
+        ? {}
+        : {
+            selectors: createSelectors(atom, config.selectors),
+        };
+    return Object.assign(atom, actionsProp, selectorsProp);
+};
+exports.createSlice = createSlice;

package/dist/cjs/base/index.js

@@ -15,7 +15,9 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./config"), exports);
+__exportStar(require("./createActions"), exports);
 __exportStar(require("./createAtom"), exports);
 __exportStar(require("./createDerived"), exports);
 __exportStar(require("./createSelector"), exports);
+__exportStar(require("./createSlice"), exports);
 __exportStar(require("./Stateful"), exports);

package/dist/cjs/effects/EffectDispatcher.js

@@ -1,37 +1,47 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EffectDispatcher = void 0;
+exports.EffectDispatcher = exports.EffectActions = void 0;
 const utils_1 = require("@yaasl/utils");
-const Scheduler_1 = require("../utils/Scheduler");
-class EffectDispatcher {
-    constructor({ atom, effects }) {
-        this.didInit = false;
-        this.effects = [];
-        this.scheduler = new Scheduler_1.Scheduler();
-        this.effects = effects.map(create => create(atom));
-        this.callEffectAction("init", atom);
-        this.subscribeSetters(atom);
-        this.callEffectAction("didInit", atom);
-        const { queue } = this.scheduler;
-        if (!(0, utils_1.isPromiseLike)(queue)) {
-            this.didInit = true;
+const Queue_1 = require("../utils/Queue");
+const isTruthy = (value) => !!value;
+class EffectActions {
+    constructor(atom, effectCreator) {
+        this.atom = atom;
+        const { actions, options } = effectCreator(atom);
+        this.options = options;
+        this.actions = actions;
+    }
+    createAction(action) {
+        const actionFn = this.actions[action];
+        if (!actionFn)
             return;
-        }
-        this.didInit = queue.then(() => {
-            this.didInit = true;
-        });
+        return (prev) => {
+            const nextValue = { current: prev };
+            const set = (next) => (nextValue.current = (0, utils_1.updater)(next, nextValue.current));
+            const result = actionFn({
+                value: prev,
+                set,
+                atom: this.atom,
+                options: this.options,
+            });
+            return (0, utils_1.isPromiseLike)(result)
+                ? result.then(() => nextValue.current)
+                : nextValue.current;
+        };
     }
-    subscribeSetters(atom) {
-        atom.subscribe(value => this.callEffectAction("set", atom, () => value));
+}
+exports.EffectActions = EffectActions;
+class EffectDispatcher {
+    constructor(atom, effects) {
+        this.effects = [];
+        this.queue = new Queue_1.Queue();
+        this.effects = effects.map(create => new EffectActions(atom, create));
     }
-    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.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);
+    dispatch(action, startValue) {
+        const tasks = this.effects
+            .map(effect => effect.createAction(action))
+            .filter(isTruthy);
+        return this.queue.push(...tasks).run(startValue);
     }
 }
 exports.EffectDispatcher = EffectDispatcher;

package/dist/cjs/effects/createEffect.js

@@ -9,7 +9,7 @@ exports.createEffect = void 0;
  *   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.
+ * - `set`: Action to be called when the atom's value is set.
  *
  * @param setup Effect actions or function to create effect actions.
  *   Effect actions are fired in the atom lifecycle, alongside to the subscriptions.

package/dist/cjs/effects/indexedDb.js

@@ -28,20 +28,19 @@ 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 {
-        init: ({ atom }) => {
-            var _a;
+        init: (_b) => __awaiter(void 0, [_b], void 0, function* ({ atom, set }) {
+            var _c;
             if (!atomDb) {
-                atomDb = new Store_1.Store((_a = base_1.CONFIG.name) !== null && _a !== void 0 ? _a : "yaasl");
+                atomDb = new Store_1.Store((_c = base_1.CONFIG.name) !== null && _c !== void 0 ? _c : "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));
-                }
-            }));
-        },
+            const existing = yield atomDb.get(key);
+            if (existing != null) {
+                set(existing);
+            }
+            else {
+                yield atomDb.set(key, atom.defaultValue);
+            }
+        }),
         set: ({ value }) => {
             void (atomDb === null || atomDb === void 0 ? void 0 : atomDb.set(key, value));
         },

package/dist/cjs/effects/localStorage.js

@@ -22,17 +22,19 @@ exports.localStorage = (0, createEffect_1.createEffect)(({ atom, options = {} })
         onTabSync: noTabSync ? undefined : value => atom.set(value),
     });
     return {
-        init: ({ atom }) => {
+        init: ({ set }) => {
             const existing = storage.get();
-            if (existing === null) {
-                storage.set(atom.defaultValue);
+            if (existing != null) {
+                set(existing);
+            }
+        },
+        set: ({ value, atom }) => {
+            if (value === atom.defaultValue) {
+                storage.remove();
             }
             else {
-                atom.set(existing);
+                storage.set(value);
             }
         },
-        set: ({ value }) => {
-            storage.set(value);
-        },
     };
 });

package/dist/cjs/effects/migration.js

@@ -69,7 +69,7 @@ const performMigration = (atom, version, migrations) => {
  *  @returns The effect to be used on atoms.
  **/
 exports.migration = (0, createEffect_1.createEffect)({
-    didInit: ({ atom, options }) => {
+    didInit: ({ atom, options, set }) => {
         var _a, _b;
         const steps = sortMigrations(options.steps);
         const currentVersion = getVersion(atom);
@@ -94,7 +94,7 @@ exports.migration = (0, createEffect_1.createEffect)({
         if (version == null)
             return;
         setVersion(atom, version);
-        atom.set(data);
+        set(data);
     },
 });
 /** Helper to create a step for the migration effect.

package/dist/cjs/utils/Queue.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Queue = void 0;
+const utils_1 = require("@yaasl/utils");
+class Queue {
+    constructor() {
+        this.last = null;
+        this.queue = [];
+    }
+    push(...tasks) {
+        this.queue.push(...tasks);
+        return this;
+    }
+    run(prev) {
+        const init = this.last ? this.last.then(() => prev) : new utils_1.Thenable(prev);
+        const result = this.queue.reduce((result, next) => result.then(prev => next(prev)), init);
+        this.queue = [];
+        this.last = result.then(value => {
+            if (this.last === result) {
+                this.last = null;
+            }
+            return value;
+        });
+        return result;
+    }
+}
+exports.Queue = Queue;

package/dist/mjs/base/Stateful.js

@@ -1,9 +1,10 @@
 export class Stateful {
+    value;
+    /** Promise that resolves when the states initialization was finished. */
+    didInit = false;
+    listeners = new Set();
     constructor(value) {
         this.value = value;
-        /** Promise that resolves when the states initialization was finished. */
-        this.didInit = false;
-        this.listeners = new Set();
     }
     /** Read the value of state.
      *

package/dist/mjs/base/config.js

@@ -5,4 +5,5 @@
  **/
 export const CONFIG = {
     name: undefined,
+    globalEffects: [],
 };

package/dist/mjs/base/createActions.js

@@ -1,7 +1,7 @@
 /** 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.
+ *  @param reducers Reducers for custom actions to set the atom's value.
  *
  *  @returns Actions to change the state of the atom.
  *

package/dist/mjs/base/createAtom.js

@@ -1,19 +1,45 @@
-import { createActions } from "./createActions";
+import { updater, Thenable, toVoid } from "@yaasl/utils";
+import { CONFIG } from "./config";
 import { Stateful } from "./Stateful";
 import { EffectDispatcher } from "../effects/EffectDispatcher";
 let key = 0;
 export class Atom extends Stateful {
-    constructor({ defaultValue, name = `atom-${++key}`, effects, reducers = {}, }) {
+    /** Default value of the atom. */
+    defaultValue;
+    /** Identifier of the atom. */
+    name;
+    effects;
+    constructor({ defaultValue, name = `atom-${++key}`, effects: localEffects = [], }) {
         super(defaultValue);
         this.name = name;
         this.defaultValue = defaultValue;
-        this.actions = createActions(this, reducers);
-        if (!effects || effects.length === 0) {
-            this.didInit = true;
+        const effects = [
+            ...CONFIG.globalEffects,
+            ...localEffects,
+        ];
+        this.effects = new EffectDispatcher(this, effects);
+        if (effects.length === 0) {
+            this.setDidInit(true);
             return;
         }
-        const { didInit } = new EffectDispatcher({ atom: this, effects });
-        this.setDidInit(didInit);
+        const result = this.initEffects();
+        if (result instanceof Thenable) {
+            this.setDidInit(true);
+        }
+        else {
+            this.setDidInit(result.then(toVoid));
+        }
+    }
+    initEffects() {
+        const updateValue = (value) => {
+            super.update(value);
+            return value;
+        };
+        return new Thenable(this.defaultValue)
+            .then(value => this.effects.dispatch("init", value))
+            .then(updateValue)
+            .then(value => this.effects.dispatch("didInit", value))
+            .then(updateValue);
     }
     /** Set the value of the atom.
      *
@@ -21,8 +47,10 @@ export class Atom extends Stateful {
      * new value based off the previous value.
      */
     set(next) {
-        const value = next instanceof Function ? next(this.get()) : next;
-        super.update(value);
+        const newState = updater(next, this.get());
+        void this.effects
+            .dispatch("set", newState)
+            .then(value => super.update(value));
     }
 }
 /** Creates an atom store.
@@ -30,7 +58,6 @@ export class Atom extends Stateful {
  * @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.
  **/

package/dist/mjs/base/createDerived.js

@@ -1,4 +1,4 @@
-import { consoleMessage, toVoid } from "@yaasl/utils";
+import { consoleMessage, toVoid, updater } from "@yaasl/utils";
 import { Stateful } from "./Stateful";
 const allDidInit = (atoms) => {
     const inits = atoms
@@ -7,11 +7,12 @@ const allDidInit = (atoms) => {
     return inits.length === 0 ? true : Promise.all(inits).then(toVoid);
 };
 export class Derive extends Stateful {
+    getter;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    getterDependencies = new Set();
     constructor(getter) {
         super(undefined);
         this.getter = getter;
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        this.getterDependencies = new Set();
         this.value = getter({ get: dep => this.addGetDependency(dep) });
         this.setDidInit(allDidInit(Array.from(this.getterDependencies)));
     }
@@ -27,11 +28,12 @@ export class Derive extends Stateful {
     }
 }
 export class SettableDerive extends Derive {
+    setter;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    setterDependencies = new Set();
     constructor(getter, setter) {
         super(getter);
         this.setter = setter;
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        this.setterDependencies = new Set();
         setter({
             value: this.get(),
             set: dep => this.addSetDependency(dep),
@@ -46,11 +48,11 @@ export class SettableDerive extends Derive {
      * new value based off the previous value.
      */
     set(next) {
-        const value = next instanceof Function ? next(this.get()) : next;
+        const value = updater(next, this.get());
         this.setter({
             value,
             set: (atom, next) => {
-                const value = next instanceof Function ? next(atom.get()) : next;
+                const value = updater(next, atom.get());
                 atom.set(value);
             },
         });

package/dist/mjs/base/createSlice.js

@@ -0,0 +1,34 @@
+import { createActions } from "./createActions";
+import { Atom } from "./createAtom";
+import { createSelector, } from "./createSelector";
+const isEmpty = (obj) => !obj || Object.keys(obj).length === 0;
+const createSelectors = (atom, selectors) => Object.fromEntries(Object.entries(selectors).map(([key, selector]) => [
+    key,
+    typeof selector === "string"
+        ? createSelector(atom, selector)
+        : createSelector([atom], selector),
+]));
+/** Creates a slice with actions and selectors.
+ *
+ * @param config.defaultValue Value that will be used initially.
+ * @param config.name Name of the atom.
+ * @param config.effects Effects that will be applied on the atom.
+ * @param config.reducers Reducers for custom actions to set the atom's value.
+ * @param config.selectors Path or combiner selectors to use the atom's values to create new ones.
+ *
+ * @returns An atom instance with actions and selectors.
+ **/
+export const createSlice = (config) => {
+    const atom = new Atom(config);
+    const actionsProp = isEmpty(config.reducers)
+        ? {}
+        : {
+            actions: createActions(atom, config.reducers),
+        };
+    const selectorsProp = isEmpty(config.selectors)
+        ? {}
+        : {
+            selectors: createSelectors(atom, config.selectors),
+        };
+    return Object.assign(atom, actionsProp, selectorsProp);
+};

package/dist/mjs/base/index.js

@@ -1,5 +1,7 @@
 export * from "./config";
+export * from "./createActions";
 export * from "./createAtom";
 export * from "./createDerived";
 export * from "./createSelector";
+export * from "./createSlice";
 export * from "./Stateful";

package/dist/mjs/effects/EffectDispatcher.js

@@ -1,33 +1,45 @@
-import { isPromiseLike } from "@yaasl/utils";
-import { Scheduler } from "../utils/Scheduler";
-export class EffectDispatcher {
-    constructor({ atom, effects }) {
-        this.didInit = false;
-        this.effects = [];
-        this.scheduler = new Scheduler();
-        this.effects = effects.map(create => create(atom));
-        this.callEffectAction("init", atom);
-        this.subscribeSetters(atom);
-        this.callEffectAction("didInit", atom);
-        const { queue } = this.scheduler;
-        if (!isPromiseLike(queue)) {
-            this.didInit = true;
+import { isPromiseLike, updater } from "@yaasl/utils";
+import { Queue } from "../utils/Queue";
+const isTruthy = (value) => !!value;
+export class EffectActions {
+    atom;
+    options;
+    actions;
+    constructor(atom, effectCreator) {
+        this.atom = atom;
+        const { actions, options } = effectCreator(atom);
+        this.options = options;
+        this.actions = actions;
+    }
+    createAction(action) {
+        const actionFn = this.actions[action];
+        if (!actionFn)
             return;
-        }
-        this.didInit = queue.then(() => {
-            this.didInit = true;
-        });
+        return (prev) => {
+            const nextValue = { current: prev };
+            const set = (next) => (nextValue.current = updater(next, nextValue.current));
+            const result = actionFn({
+                value: prev,
+                set,
+                atom: this.atom,
+                options: this.options,
+            });
+            return isPromiseLike(result)
+                ? result.then(() => nextValue.current)
+                : nextValue.current;
+        };
     }
-    subscribeSetters(atom) {
-        atom.subscribe(value => this.callEffectAction("set", atom, () => value));
+}
+export class EffectDispatcher {
+    effects = [];
+    queue = new Queue();
+    constructor(atom, effects) {
+        this.effects = effects.map(create => new EffectActions(atom, create));
     }
-    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.effects.map(({ actions, options }) => {
-            const actionFn = actions[action];
-            return () => actionFn?.({ value: getValue(), atom, options });
-        });
-        void this.scheduler.run(tasks);
+    dispatch(action, startValue) {
+        const tasks = this.effects
+            .map(effect => effect.createAction(action))
+            .filter(isTruthy);
+        return this.queue.push(...tasks).run(startValue);
     }
 }

package/dist/mjs/effects/createEffect.js

@@ -6,7 +6,7 @@
  *   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.
+ * - `set`: Action to be called when the atom's value is set.
  *
  * @param setup Effect actions or function to create effect actions.
  *   Effect actions are fired in the atom lifecycle, alongside to the subscriptions.

package/dist/mjs/effects/indexedDb.js

@@ -15,18 +15,17 @@ let atomDb = null;
 export const indexedDb = createEffect(({ atom, options }) => {
     const key = options?.key ?? atom.name;
     return {
-        init: ({ atom }) => {
+        init: async ({ atom, set }) => {
             if (!atomDb) {
                 atomDb = new Store(CONFIG.name ?? "yaasl");
             }
-            return atomDb.get(key).then(async (value) => {
-                if (value !== undefined) {
-                    atom.set(value);
-                }
-                else {
-                    await atomDb?.set(key, atom.defaultValue);
-                }
-            });
+            const existing = await atomDb.get(key);
+            if (existing != null) {
+                set(existing);
+            }
+            else {
+                await atomDb.set(key, atom.defaultValue);
+            }
         },
         set: ({ value }) => {
             void atomDb?.set(key, value);

package/dist/mjs/effects/localStorage.js

@@ -19,17 +19,19 @@ export const localStorage = createEffect(({ atom, options = {} }) => {
         onTabSync: noTabSync ? undefined : value => atom.set(value),
     });
     return {
-        init: ({ atom }) => {
+        init: ({ set }) => {
             const existing = storage.get();
-            if (existing === null) {
-                storage.set(atom.defaultValue);
+            if (existing != null) {
+                set(existing);
+            }
+        },
+        set: ({ value, atom }) => {
+            if (value === atom.defaultValue) {
+                storage.remove();
             }
             else {
-                atom.set(existing);
+                storage.set(value);
             }
         },
-        set: ({ value }) => {
-            storage.set(value);
-        },
     };
 });

package/dist/mjs/effects/migration.js

@@ -66,7 +66,7 @@ const performMigration = (atom, version, migrations) => {
  *  @returns The effect to be used on atoms.
  **/
 export const migration = createEffect({
-    didInit: ({ atom, options }) => {
+    didInit: ({ atom, options, set }) => {
         const steps = sortMigrations(options.steps);
         const currentVersion = getVersion(atom);
         const isLatestVersion = currentVersion === steps.at(-1)?.version;
@@ -90,7 +90,7 @@ export const migration = createEffect({
         if (version == null)
             return;
         setVersion(atom, version);
-        atom.set(data);
+        set(data);
     },
 });
 /** Helper to create a step for the migration effect.

package/dist/mjs/utils/Expiration.js

@@ -1,13 +1,9 @@
 const STORAGE = window.localStorage;
 export class Expiration {
+    key;
+    getExpiration;
+    timeout = null;
     constructor({ key, expiresAt, expiresIn }) {
-        this.timeout = null;
-        this.dispatchExpiration = (expiresIn, onExpire) => {
-            this.timeout = setTimeout(() => {
-                onExpire();
-                this.remove();
-            }, expiresIn);
-        };
         this.timeout = null;
         this.key = key;
         if (expiresAt) {
@@ -30,6 +26,12 @@ export class Expiration {
             this.timeout = null;
         }
     }
+    dispatchExpiration = (expiresIn, onExpire) => {
+        this.timeout = setTimeout(() => {
+            onExpire();
+            this.remove();
+        }, expiresIn);
+    };
     init(onExpire) {
         if (!this.getExpiration)
             return;

package/dist/mjs/utils/LocalStorage.js

@@ -10,6 +10,8 @@ const syncOverBrowserTabs = (observingKey, onTabSync) => window.addEventListener
     onTabSync(newValue);
 });
 export class LocalStorage {
+    key;
+    parser;
     constructor(key, options = {}) {
         this.key = key;
         this.parser = options.parser ?? defaultParser;

package/dist/mjs/utils/Queue.js

@@ -0,0 +1,21 @@
+import { Thenable } from "@yaasl/utils";
+export class Queue {
+    last = null;
+    queue = [];
+    push(...tasks) {
+        this.queue.push(...tasks);
+        return this;
+    }
+    run(prev) {
+        const init = this.last ? this.last.then(() => prev) : new Thenable(prev);
+        const result = this.queue.reduce((result, next) => result.then(prev => next(prev)), init);
+        this.queue = [];
+        this.last = result.then(value => {
+            if (this.last === result) {
+                this.last = null;
+            }
+            return value;
+        });
+        return result;
+    }
+}

package/dist/mjs/utils/Store.js

@@ -3,6 +3,8 @@ const promisifyRequest = (request) => new Promise((resolve, reject) => {
     request.onerror = () => reject(request.error);
 });
 export class Store {
+    name;
+    database;
     constructor(name) {
         this.name = name;
         const openRequest = indexedDB.open(`${name}-database`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yaasl/core",
-  "version": "0.9.2",
+  "version": "0.10.0-alpha.1",
   "description": "yet another atomic store library (vanilla-js)",
   "author": "PrettyCoffee",
   "license": "MIT",
@@ -28,7 +28,7 @@
     "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:mjs": "tsc -p ./tsconfig.node.json --outDir ./dist/mjs -m esnext -t esnext",
     "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": "vitest run",
@@ -38,7 +38,7 @@
     "validate": "run-s lint test build"
   },
   "dependencies": {
-    "@yaasl/utils": "0.9.2"
+    "@yaasl/utils": "0.10.0-alpha.1"
   },
   "eslintConfig": {
     "extends": [

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

@@ -1,7 +0,0 @@
-type Task = () => PromiseLike<unknown> | unknown;
-export declare class Scheduler {
-    queue: PromiseLike<void> | null;
-    run(...tasks: Task[] | Task[][]): PromiseLike<void>;
-    private execute;
-}
-export {};

package/dist/cjs/utils/Scheduler.js

@@ -1,27 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Scheduler = void 0;
-const utils_1 = require("@yaasl/utils");
-class Scheduler {
-    constructor() {
-        this.queue = null;
-    }
-    run(...tasks) {
-        const run = () => this.execute(tasks.flat()).then(utils_1.toVoid);
-        const promise = this.queue ? this.queue.then(run) : run();
-        this.queue = promise;
-        return promise.then(() => {
-            if (this.queue !== promise)
-                return;
-            this.queue = null;
-        });
-    }
-    execute(tasks) {
-        const result = tasks.map(task => {
-            const result = task();
-            return (0, utils_1.isPromiseLike)(result) ? result : new utils_1.Thenable(result);
-        });
-        return utils_1.Thenable.all(result);
-    }
-}
-exports.Scheduler = Scheduler;

package/dist/mjs/utils/Scheduler.js

@@ -1,23 +0,0 @@
-import { toVoid, isPromiseLike, Thenable } from "@yaasl/utils";
-export class Scheduler {
-    constructor() {
-        this.queue = null;
-    }
-    run(...tasks) {
-        const run = () => this.execute(tasks.flat()).then(toVoid);
-        const promise = this.queue ? this.queue.then(run) : run();
-        this.queue = promise;
-        return promise.then(() => {
-            if (this.queue !== promise)
-                return;
-            this.queue = null;
-        });
-    }
-    execute(tasks) {
-        const result = tasks.map(task => {
-            const result = task();
-            return isPromiseLike(result) ? result : new Thenable(result);
-        });
-        return Thenable.all(result);
-    }
-}