@yaasl/core 0.10.1 → 0.11.0-alpha.0

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

@@ -0,0 +1,13 @@
+import type { Callback, Stateful } from "./Stateful";
+export declare class Destroyable {
+    isDestroyed: boolean;
+    private dependents;
+    private unsubscribers;
+    /** Make this atom unusable and remove all references.
+     **/
+    destroy(): void;
+    /** Subscribe to another atom and automatically destroy the atom instance, if the parent is destroyed */
+    protected subscribeTo<T>(parent: Stateful<T>, callback: Callback<T>): void;
+    protected addDependent(dependent: Destroyable): void;
+    protected removeDependent(dependent: Destroyable): void;
+}

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

@@ -1,5 +1,6 @@
-type Callback<Value> = (value: Value, previous: Value) => void;
-export declare class Stateful<Value = unknown> {
+import { Destroyable } from "./Destroyable";
+export type Callback<Value> = (value: Value, previous: Value) => void;
+export declare class Stateful<Value = unknown> extends Destroyable {
     protected value: Value;
     /** Promise that resolves when the states initialization was finished. */
     didInit: PromiseLike<void> | boolean;
@@ -17,8 +18,10 @@ export declare class Stateful<Value = unknown> {
      *  @returns A callback to unsubscribe the passed callback.
      */
     subscribe(callback: Callback<Value>): () => boolean;
+    /** Make this atom unusable and remove all references.
+     **/
+    destroy(): void;
     private emit;
     protected update(value: Value): void;
     protected setDidInit(didInit: boolean | PromiseLike<void>): void;
 }
-export {};

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

@@ -1,4 +1,4 @@
-import { EffectAtomCallback } from "../effects/createEffect";
+import type { EffectAtomCallback } from "../effects/createEffect";
 interface Config {
     /** Global name to make internal keys unique
      *  among UIs on the same domain.

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

@@ -1,5 +1,5 @@
-import { Atom } from "./createAtom";
-import { SettableDerive } from "./createDerived";
+import type { Atom } from "./createAtom";
+import type { 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 [

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

@@ -1,6 +1,6 @@
 import { Updater } from "@yaasl/utils";
 import { Stateful } from "./Stateful";
-import { EffectAtomCallback } from "../effects/createEffect";
+import type { EffectAtomCallback } from "../effects/createEffect";
 export interface AtomConfig<Value> {
     /** Value that will be used initially. */
     defaultValue: Value;

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

@@ -1,5 +1,5 @@
 import { Updater } from "@yaasl/utils";
-import { Atom } from "./createAtom";
+import type { Atom } from "./createAtom";
 import { Stateful } from "./Stateful";
 type GetterFn<Value> = (context: {
     get: <V>(dep: Stateful<V>) => V;

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

@@ -1,5 +1,5 @@
-import { ActionType, EffectAtomCallback } from "./createEffect";
-import { Atom } from "../base/createAtom";
+import type { ActionType, EffectAtomCallback } from "./createEffect";
+import type { Atom } from "../base/createAtom";
 export declare class EffectActions<Value> {
     private readonly atom;
     private options;

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

@@ -1,5 +1,5 @@
-import { Updater, Dispatch } from "@yaasl/utils";
-import { Atom } from "../base";
+import type { Updater, Dispatch } from "@yaasl/utils";
+import type { Atom } from "../base";
 export type ActionType = "init" | "didInit" | "set";
 export interface EffectPayload<Options = undefined, AtomValue = any> {
     /** Current value of the atom */

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

@@ -14,4 +14,4 @@ export interface ExpirationOptions {
  *
  * @returns The effect to be used on atoms.
  **/
-export declare const expiration: (__0_0: ExpirationOptions) => import("./createEffect").EffectAtomCallback<ExpirationOptions, any>;
+export declare const expiration: (optionsArg: ExpirationOptions) => import("./createEffect").EffectAtomCallback<ExpirationOptions, any>;

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

@@ -25,7 +25,7 @@ export interface MigrationOptions {
  *
  *  @returns The effect to be used on atoms.
  **/
-export declare const migration: (__0_0: MigrationOptions) => import("./createEffect").EffectAtomCallback<MigrationOptions, unknown>;
+export declare const migration: (optionsArg: MigrationOptions) => import("./createEffect").EffectAtomCallback<MigrationOptions, unknown>;
 /** Helper to create a step for the migration effect.
  *
  *  @param migration Migration step to create.

package/dist/cjs/base/Destroyable.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Destroyable = void 0;
+const utils_1 = require("@yaasl/utils");
+class Destroyable {
+    constructor() {
+        this.isDestroyed = false;
+        this.dependents = new Set();
+        this.unsubscribers = new Set();
+    }
+    /** Make this atom unusable and remove all references.
+     **/
+    destroy() {
+        this.dependents.forEach(dependent => dependent.destroy());
+        this.unsubscribers.forEach(unsubscribe => unsubscribe());
+        this.dependents.clear();
+        this.unsubscribers.clear();
+        this.isDestroyed = true;
+        const throwOnCall = () => {
+            const name = "name" in this ? this.name : undefined;
+            throw new Error((0, utils_1.consoleMessage)("The methods of a destroyed atom cannot be called.", {
+                scope: name,
+            }));
+        };
+        Object.assign(this, {
+            set: throwOnCall,
+            get: throwOnCall,
+            subscribe: throwOnCall,
+        });
+    }
+    /** Subscribe to another atom and automatically destroy the atom instance, if the parent is destroyed */
+    subscribeTo(parent, callback) {
+        parent.addDependent(this);
+        const unsubscribe = parent.subscribe(callback);
+        this.unsubscribers.add(() => {
+            unsubscribe();
+            parent.removeDependent(this);
+        });
+    }
+    addDependent(dependent) {
+        this.dependents.add(dependent);
+    }
+    removeDependent(dependent) {
+        this.dependents.delete(dependent);
+    }
+}
+exports.Destroyable = Destroyable;

package/dist/cjs/base/Stateful.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Stateful = void 0;
-class Stateful {
+const Destroyable_1 = require("./Destroyable");
+class Stateful extends Destroyable_1.Destroyable {
     constructor(value) {
+        super();
         this.value = value;
         /** Promise that resolves when the states initialization was finished. */
         this.didInit = false;
@@ -25,6 +27,13 @@ class Stateful {
         this.listeners.add(callback);
         return () => this.listeners.delete(callback);
     }
+    /** Make this atom unusable and remove all references.
+     **/
+    destroy() {
+        super.destroy();
+        this.value = null;
+        this.listeners = new Set();
+    }
     emit(value, previous) {
         this.listeners.forEach(listener => listener(value, previous));
     }

package/dist/cjs/base/createAtom.js

@@ -45,7 +45,10 @@ class Atom extends Stateful_1.Stateful {
      * new value based off the previous value.
      */
     set(next) {
-        const newState = (0, utils_1.updater)(next, this.get());
+        const oldState = this.get();
+        const newState = (0, utils_1.updater)(next, oldState);
+        if (oldState === newState)
+            return;
         void this.effects
             .dispatch("set", newState)
             .then(value => super.update(value));

package/dist/cjs/base/createDerived.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createDerived = exports.SettableDerive = exports.Derive = void 0;
+exports.SettableDerive = exports.Derive = void 0;
+exports.createDerived = createDerived;
 const utils_1 = require("@yaasl/utils");
 const Stateful_1 = require("./Stateful");
 const allDidInit = (atoms) => {
@@ -20,7 +21,7 @@ class Derive extends Stateful_1.Stateful {
     }
     addGetDependency(dependency) {
         if (!this.getterDependencies.has(dependency)) {
-            dependency.subscribe(() => this.deriveUpdate());
+            this.subscribeTo(dependency, () => this.deriveUpdate());
             this.getterDependencies.add(dependency);
         }
         return dependency.get();
@@ -50,9 +51,12 @@ class SettableDerive extends Derive {
      * new value based off the previous value.
      */
     set(next) {
-        const value = (0, utils_1.updater)(next, this.get());
+        const oldState = this.get();
+        const newState = (0, utils_1.updater)(next, oldState);
+        if (oldState === newState)
+            return;
         this.setter({
-            value,
+            value: newState,
             set: (atom, next) => {
                 const value = (0, utils_1.updater)(next, atom.get());
                 atom.set(value);
@@ -81,4 +85,3 @@ function createDerived(getter, setter) {
         return new Derive(getter);
     }
 }
-exports.createDerived = createDerived;

package/dist/cjs/base/createSelector.js

@@ -9,7 +9,7 @@ const selectPath = (state, path) => path
 class PathSelector extends Stateful_1.Stateful {
     constructor(atom, path) {
         super(selectPath(atom.get(), path));
-        atom.subscribe(state => this.update(selectPath(state, path)));
+        this.subscribeTo(atom, state => this.update(selectPath(state, path)));
         this.setDidInit(atom.didInit);
     }
 }
@@ -28,7 +28,7 @@ class CombinerSelector extends Stateful_1.Stateful {
             return combiner(...values);
         };
         super(selectState());
-        atoms.forEach(atom => atom.subscribe(() => this.update(selectState())));
+        atoms.forEach(atom => this.subscribeTo(atom, () => this.update(selectState())));
         this.setDidInit(allDidInit(atoms));
     }
 }

package/dist/cjs/effects/indexedDb.js

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

package/dist/mjs/base/Destroyable.js

@@ -0,0 +1,41 @@
+import { consoleMessage } from "@yaasl/utils";
+export class Destroyable {
+    isDestroyed = false;
+    dependents = new Set();
+    unsubscribers = new Set();
+    /** Make this atom unusable and remove all references.
+     **/
+    destroy() {
+        this.dependents.forEach(dependent => dependent.destroy());
+        this.unsubscribers.forEach(unsubscribe => unsubscribe());
+        this.dependents.clear();
+        this.unsubscribers.clear();
+        this.isDestroyed = true;
+        const throwOnCall = () => {
+            const name = "name" in this ? this.name : undefined;
+            throw new Error(consoleMessage("The methods of a destroyed atom cannot be called.", {
+                scope: name,
+            }));
+        };
+        Object.assign(this, {
+            set: throwOnCall,
+            get: throwOnCall,
+            subscribe: throwOnCall,
+        });
+    }
+    /** Subscribe to another atom and automatically destroy the atom instance, if the parent is destroyed */
+    subscribeTo(parent, callback) {
+        parent.addDependent(this);
+        const unsubscribe = parent.subscribe(callback);
+        this.unsubscribers.add(() => {
+            unsubscribe();
+            parent.removeDependent(this);
+        });
+    }
+    addDependent(dependent) {
+        this.dependents.add(dependent);
+    }
+    removeDependent(dependent) {
+        this.dependents.delete(dependent);
+    }
+}

package/dist/mjs/base/Stateful.js

@@ -1,9 +1,11 @@
-export class Stateful {
+import { Destroyable } from "./Destroyable";
+export class Stateful extends Destroyable {
     value;
     /** Promise that resolves when the states initialization was finished. */
     didInit = false;
     listeners = new Set();
     constructor(value) {
+        super();
         this.value = value;
     }
     /** Read the value of state.
@@ -23,6 +25,13 @@ export class Stateful {
         this.listeners.add(callback);
         return () => this.listeners.delete(callback);
     }
+    /** Make this atom unusable and remove all references.
+     **/
+    destroy() {
+        super.destroy();
+        this.value = null;
+        this.listeners = new Set();
+    }
     emit(value, previous) {
         this.listeners.forEach(listener => listener(value, previous));
     }

package/dist/mjs/base/createAtom.js

@@ -47,7 +47,10 @@ export class Atom extends Stateful {
      * new value based off the previous value.
      */
     set(next) {
-        const newState = updater(next, this.get());
+        const oldState = this.get();
+        const newState = updater(next, oldState);
+        if (oldState === newState)
+            return;
         void this.effects
             .dispatch("set", newState)
             .then(value => super.update(value));

package/dist/mjs/base/createDerived.js

@@ -18,7 +18,7 @@ export class Derive extends Stateful {
     }
     addGetDependency(dependency) {
         if (!this.getterDependencies.has(dependency)) {
-            dependency.subscribe(() => this.deriveUpdate());
+            this.subscribeTo(dependency, () => this.deriveUpdate());
             this.getterDependencies.add(dependency);
         }
         return dependency.get();
@@ -48,9 +48,12 @@ export class SettableDerive extends Derive {
      * new value based off the previous value.
      */
     set(next) {
-        const value = updater(next, this.get());
+        const oldState = this.get();
+        const newState = updater(next, oldState);
+        if (oldState === newState)
+            return;
         this.setter({
-            value,
+            value: newState,
             set: (atom, next) => {
                 const value = updater(next, atom.get());
                 atom.set(value);

package/dist/mjs/base/createSelector.js

@@ -6,7 +6,7 @@ const selectPath = (state, path) => path
 export class PathSelector extends Stateful {
     constructor(atom, path) {
         super(selectPath(atom.get(), path));
-        atom.subscribe(state => this.update(selectPath(state, path)));
+        this.subscribeTo(atom, state => this.update(selectPath(state, path)));
         this.setDidInit(atom.didInit);
     }
 }
@@ -24,7 +24,7 @@ export class CombinerSelector extends Stateful {
             return combiner(...values);
         };
         super(selectState());
-        atoms.forEach(atom => atom.subscribe(() => this.update(selectState())));
+        atoms.forEach(atom => this.subscribeTo(atom, () => this.update(selectState())));
         this.setDidInit(allDidInit(atoms));
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yaasl/core",
-  "version": "0.10.1",
+  "version": "0.11.0-alpha.0",
   "description": "yet another atomic store library (vanilla-js)",
   "author": "PrettyCoffee",
   "license": "MIT",
@@ -38,7 +38,7 @@
     "validate": "run-s lint test build"
   },
   "dependencies": {
-    "@yaasl/utils": "0.10.1"
+    "@yaasl/utils": "0.11.0-alpha.0"
   },
   "eslintConfig": {
     "extends": [