@yaasl/core 0.8.0-alpha.0 → 0.8.0-alpha.1

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

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

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

@@ -1,19 +1,45 @@
+import { SetStateAction } from "@yaasl/utils";
+import { Atom } from "./atom";
 import { Stateful } from "./Stateful";
-type Derivation<T> = (context: {
+type GetterFn<Value> = (context: {
     get: <V>(dep: Stateful<V>) => V;
-}) => T;
-export declare class Derive<DerivedValue> extends Stateful<DerivedValue> {
-    private readonly derivation;
-    private dependencies;
-    constructor(derivation: Derivation<DerivedValue>);
-    private addDependency;
+}) => Value;
+type SetterFn<Value> = (context: {
+    value: Value;
+    set: <V>(dep: Atom<V> | SettableDerive<V>, next: SetStateAction<V>) => void;
+}) => void;
+export declare class Derive<Value> extends Stateful<Value> {
+    private readonly getter;
+    protected readonly getterDependencies: Set<Stateful<any>>;
+    constructor(getter: GetterFn<Value>);
+    private addGetDependency;
     private deriveUpdate;
 }
-/** Creates a value, derived from one or more atoms or other derived values.
+export declare class SettableDerive<Value = unknown> extends Derive<Value> {
+    private readonly setter;
+    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;
+    private addSetDependency;
+    private compareDependencies;
+}
+/** A derive atom that allows deriving and elevating values from and
+ *  to one or multiple other stateful elements.
+ *
+ *  **Note:**
+ *    - `getter` and `setter` should not have any side effects
+ *    - `getter` and `setter` must use the same atoms
  *
- *  @param get Function to derive the new value.
+ *  @param getter Function to derive a new value from other stateful elements.
+ *  @param setter Function to elevate a new value to it's stateful dependents.
  *
- *  @returns A derived instance.
+ *  @returns A derive instance.
  **/
-export declare const derive: <DerivedValue>(get: Derivation<DerivedValue>) => Derive<DerivedValue>;
+export declare function derive<Value>(getter: GetterFn<Value>): Derive<Value>;
+export declare function derive<Value>(getter: GetterFn<Value>, setter: SetterFn<Value>): SettableDerive<Value>;
 export {};

package/dist/cjs/base/derive.js

@@ -1,32 +1,77 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.derive = exports.Derive = void 0;
+exports.derive = exports.SettableDerive = exports.Derive = void 0;
+const utils_1 = require("@yaasl/utils");
 const Stateful_1 = require("./Stateful");
 class Derive extends Stateful_1.Stateful {
-    constructor(derivation) {
+    constructor(getter) {
         super(undefined);
-        this.derivation = derivation;
+        this.getter = getter;
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        this.dependencies = new Set();
-        this.value = derivation({ get: dep => this.addDependency(dep) });
+        this.getterDependencies = new Set();
+        this.value = getter({ get: dep => this.addGetDependency(dep) });
     }
-    addDependency(dependency) {
-        if (!this.dependencies.has(dependency)) {
+    addGetDependency(dependency) {
+        if (!this.getterDependencies.has(dependency)) {
             dependency.subscribe(() => this.deriveUpdate());
-            this.dependencies.add(dependency);
+            this.getterDependencies.add(dependency);
         }
         return dependency.get();
     }
     deriveUpdate() {
-        this.update(this.derivation({ get: dep => this.addDependency(dep) }));
+        this.update(this.getter({ get: dep => this.addGetDependency(dep) }));
     }
 }
 exports.Derive = Derive;
-/** Creates a value, derived from one or more atoms or other derived values.
- *
- *  @param get Function to derive the new value.
- *
- *  @returns A derived instance.
- **/
-const derive = (get) => new Derive(get);
+class SettableDerive extends Derive {
+    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),
+        });
+        if (!this.compareDependencies()) {
+            throw new Error((0, utils_1.consoleMessage)("The set and get dependencies of a derived atom do not match."));
+        }
+    }
+    /** 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) {
+        const value = next instanceof Function ? next(this.get()) : next;
+        this.setter({
+            value,
+            set: (atom, next) => {
+                const value = next instanceof Function ? next(atom.get()) : next;
+                atom.set(value);
+            },
+        });
+    }
+    addSetDependency(dependency) {
+        if (!this.setterDependencies.has(dependency)) {
+            this.setterDependencies.add(dependency);
+        }
+    }
+    compareDependencies() {
+        const { getterDependencies, setterDependencies } = this;
+        if (getterDependencies.size !== setterDependencies.size) {
+            return false;
+        }
+        return Array.from(setterDependencies).every(dependency => getterDependencies.has(dependency));
+    }
+}
+exports.SettableDerive = SettableDerive;
+function derive(getter, setter) {
+    if (setter) {
+        return new SettableDerive(getter, setter);
+    }
+    else {
+        return new Derive(getter);
+    }
+}
 exports.derive = derive;

package/dist/mjs/base/derive.js

@@ -1,27 +1,71 @@
+import { consoleMessage } from "@yaasl/utils";
 import { Stateful } from "./Stateful";
 export class Derive extends Stateful {
-    constructor(derivation) {
+    constructor(getter) {
         super(undefined);
-        this.derivation = derivation;
+        this.getter = getter;
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        this.dependencies = new Set();
-        this.value = derivation({ get: dep => this.addDependency(dep) });
+        this.getterDependencies = new Set();
+        this.value = getter({ get: dep => this.addGetDependency(dep) });
     }
-    addDependency(dependency) {
-        if (!this.dependencies.has(dependency)) {
+    addGetDependency(dependency) {
+        if (!this.getterDependencies.has(dependency)) {
             dependency.subscribe(() => this.deriveUpdate());
-            this.dependencies.add(dependency);
+            this.getterDependencies.add(dependency);
         }
         return dependency.get();
     }
     deriveUpdate() {
-        this.update(this.derivation({ get: dep => this.addDependency(dep) }));
+        this.update(this.getter({ get: dep => this.addGetDependency(dep) }));
+    }
+}
+export class SettableDerive extends Derive {
+    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),
+        });
+        if (!this.compareDependencies()) {
+            throw new Error(consoleMessage("The set and get dependencies of a derived atom do not match."));
+        }
+    }
+    /** 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) {
+        const value = next instanceof Function ? next(this.get()) : next;
+        this.setter({
+            value,
+            set: (atom, next) => {
+                const value = next instanceof Function ? next(atom.get()) : next;
+                atom.set(value);
+            },
+        });
+    }
+    addSetDependency(dependency) {
+        if (!this.setterDependencies.has(dependency)) {
+            this.setterDependencies.add(dependency);
+        }
+    }
+    compareDependencies() {
+        const { getterDependencies, setterDependencies } = this;
+        if (getterDependencies.size !== setterDependencies.size) {
+            return false;
+        }
+        return Array.from(setterDependencies).every(dependency => getterDependencies.has(dependency));
+    }
+}
+export function derive(getter, setter) {
+    if (setter) {
+        return new SettableDerive(getter, setter);
+    }
+    else {
+        return new Derive(getter);
     }
 }
-/** Creates a value, derived from one or more atoms or other derived values.
- *
- *  @param get Function to derive the new value.
- *
- *  @returns A derived instance.
- **/
-export const derive = (get) => new Derive(get);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yaasl/core",
-  "version": "0.8.0-alpha.0",
+  "version": "0.8.0-alpha.1",
   "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.8.0-alpha.0"
+    "@yaasl/utils": "0.8.0-alpha.1"
   },
   "eslintConfig": {
     "extends": [