@yaasl/core 0.7.0 → 0.8.0-alpha.1

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

@@ -1,3 +1,4 @@
+type Callback<Value> = (value: Value, previous: Value) => void;
 export declare class Stateful<Value = unknown> {
     protected value: Value;
     private listeners;
@@ -13,7 +14,8 @@ export declare class Stateful<Value = unknown> {
      *
      *  @returns A callback to unsubscribe the passed callback.
      */
-    subscribe(callback: (value: Value) => void): () => boolean;
+    subscribe(callback: Callback<Value>): () => boolean;
     private emit;
     protected update(value: Value): void;
 }
+export {};

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";
-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: Promise<void> | boolean;
-    constructor({ defaultValue, name, middleware, }: AtomConfig<AtomValue>);
+    didInit: PromiseLike<void> | boolean;
+    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,5 +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 {};
+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/@types/middleware/MiddlewareDispatcher.d.ts

@@ -5,8 +5,9 @@ interface MiddlewareDispatcherConstructor {
     middleware: MiddlewareAtomCallback<any>[];
 }
 export declare class MiddlewareDispatcher {
-    didInit: Promise<void> | boolean;
+    didInit: PromiseLike<void> | boolean;
     private middleware;
+    private scheduler;
     constructor({ atom, middleware }: MiddlewareDispatcherConstructor);
     private subscribeSetters;
     private callMiddlewareAction;

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

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

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

@@ -3,5 +3,7 @@ export declare class Thenable<T = undefined> implements PromiseLike<T> {
     private value?;
     constructor(value?: T | undefined);
     then<Result = T, Reject = never>(onfulfilled?: Executor<T, Result>, onrejected?: Executor<any, Reject>): PromiseLike<Result | Reject>;
+    static isThenable(item: unknown): boolean;
+    static all(items: PromiseLike<any>[]): Promise<any[]> | Thenable<unknown[]>;
 }
 export {};

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

@@ -0,0 +1 @@
+export declare const isPromise: (value: unknown) => value is Promise<any>;

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

@@ -0,0 +1 @@
+export declare const isPromiseLike: (value: unknown) => value is PromiseLike<any>;

package/dist/cjs/base/Stateful.js

@@ -23,13 +23,14 @@ class Stateful {
         this.listeners.add(callback);
         return () => this.listeners.delete(callback);
     }
-    emit() {
-        this.listeners.forEach(listener => listener(this.get()));
+    emit(value, previous) {
+        this.listeners.forEach(listener => listener(value, previous));
     }
     update(value) {
         if (this.value !== value) {
+            const previous = this.value;
             this.value = value;
-            this.emit();
+            this.emit(value, previous);
         }
     }
 }

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/cjs/middleware/MiddlewareDispatcher.js

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

package/dist/cjs/utils/Scheduler.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Scheduler = void 0;
+const isPromiseLike_1 = require("./isPromiseLike");
+const Thenable_1 = require("./Thenable");
+const toVoid = () => {
+    // omit args
+};
+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 (0, isPromiseLike_1.isPromiseLike)(result) ? result : new Thenable_1.Thenable(result);
+        });
+        return Thenable_1.Thenable.all(result);
+    }
+}
+exports.Scheduler = Scheduler;

package/dist/cjs/utils/Thenable.js

@@ -1,10 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Thenable = void 0;
-const isPromiselike = (value) => typeof value === "object" &&
-    value !== null &&
-    "then" in value &&
-    typeof value.then === "function";
+const isPromiseLike_1 = require("./isPromiseLike");
 class Thenable {
     constructor(value) {
         this.value = value;
@@ -12,14 +9,28 @@ class Thenable {
     then(onfulfilled, onrejected) {
         try {
             const result = !onfulfilled ? this.value : onfulfilled(this.value);
-            return isPromiselike(result) ? result : new Thenable(result);
+            return (0, isPromiseLike_1.isPromiseLike)(result) ? result : new Thenable(result);
         }
         catch (error) {
             if (!onrejected)
                 throw error;
             const result = onrejected(error);
-            return isPromiselike(result) ? result : new Thenable(result);
+            return (0, isPromiseLike_1.isPromiseLike)(result) ? result : new Thenable(result);
         }
     }
+    static isThenable(item) {
+        return item instanceof Thenable;
+    }
+    static all(items) {
+        const onlyThenables = items.every(item => this.isThenable(item));
+        if (!onlyThenables) {
+            return Promise.all(items);
+        }
+        const result = [];
+        items.forEach(item => void item.then(value => {
+            result.push(value);
+        }));
+        return new Thenable(result);
+    }
 }
 exports.Thenable = Thenable;

package/dist/cjs/utils/isPromise.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPromise = void 0;
+const isPromise = (value) => value instanceof Promise;
+exports.isPromise = isPromise;

package/dist/cjs/utils/isPromiseLike.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPromiseLike = void 0;
+const isPromiseLike = (value) => typeof value === "object" &&
+    value !== null &&
+    "then" in value &&
+    typeof value.then === "function";
+exports.isPromiseLike = isPromiseLike;

package/dist/mjs/base/Stateful.js

@@ -20,13 +20,14 @@ export class Stateful {
         this.listeners.add(callback);
         return () => this.listeners.delete(callback);
     }
-    emit() {
-        this.listeners.forEach(listener => listener(this.get()));
+    emit(value, previous) {
+        this.listeners.forEach(listener => listener(value, previous));
     }
     update(value) {
         if (this.value !== value) {
+            const previous = this.value;
             this.value = value;
-            this.emit();
+            this.emit(value, previous);
         }
     }
 }

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/dist/mjs/middleware/MiddlewareDispatcher.js

@@ -1,30 +1,33 @@
-import { Thenable } from "../utils/Thenable";
-const isPromise = (value) => value instanceof Promise;
+import { isPromiseLike } from "../utils/isPromiseLike";
+import { Scheduler } from "../utils/Scheduler";
 export class MiddlewareDispatcher {
     constructor({ atom, middleware }) {
         this.didInit = false;
         this.middleware = [];
+        this.scheduler = new Scheduler();
         this.middleware = middleware.map(create => create(atom));
-        const result = this.callMiddlewareAction("init", atom)
-            .then(() => this.subscribeSetters(atom))
-            .then(() => this.callMiddlewareAction("didInit", atom))
-            .then(() => {
+        this.callMiddlewareAction("init", atom);
+        this.subscribeSetters(atom);
+        this.callMiddlewareAction("didInit", atom);
+        const { queue } = this.scheduler;
+        if (!isPromiseLike(queue)) {
             this.didInit = true;
-        });
-        if (result instanceof Promise) {
-            this.didInit = result;
+            return;
         }
+        this.didInit = queue.then(() => {
+            this.didInit = true;
+        });
     }
     subscribeSetters(atom) {
-        atom.subscribe(value => void this.callMiddlewareAction("set", atom, value));
+        atom.subscribe(value => this.callMiddlewareAction("set", atom, () => value));
     }
-    callMiddlewareAction(action, atom, value = atom.get()) {
-        const result = this.middleware.map(middleware => {
-            const { actions, options } = middleware;
+    callMiddlewareAction(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 actionFn = actions[action];
-            return actionFn?.({ value, atom, options });
+            return () => actionFn?.({ value: getValue(), atom, options });
         });
-        const promises = result.filter(isPromise);
-        return promises.length ? Promise.all(promises) : new Thenable();
+        void this.scheduler.run(tasks);
     }
 }

package/dist/mjs/utils/Scheduler.js

@@ -0,0 +1,27 @@
+import { isPromiseLike } from "./isPromiseLike";
+import { Thenable } from "./Thenable";
+const toVoid = () => {
+    // omit args
+};
+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);
+    }
+}

package/dist/mjs/utils/Thenable.js

@@ -1,7 +1,4 @@
-const isPromiselike = (value) => typeof value === "object" &&
-    value !== null &&
-    "then" in value &&
-    typeof value.then === "function";
+import { isPromiseLike } from "./isPromiseLike";
 export class Thenable {
     constructor(value) {
         this.value = value;
@@ -9,13 +6,27 @@ export class Thenable {
     then(onfulfilled, onrejected) {
         try {
             const result = !onfulfilled ? this.value : onfulfilled(this.value);
-            return isPromiselike(result) ? result : new Thenable(result);
+            return isPromiseLike(result) ? result : new Thenable(result);
         }
         catch (error) {
             if (!onrejected)
                 throw error;
             const result = onrejected(error);
-            return isPromiselike(result) ? result : new Thenable(result);
+            return isPromiseLike(result) ? result : new Thenable(result);
         }
     }
+    static isThenable(item) {
+        return item instanceof Thenable;
+    }
+    static all(items) {
+        const onlyThenables = items.every(item => this.isThenable(item));
+        if (!onlyThenables) {
+            return Promise.all(items);
+        }
+        const result = [];
+        items.forEach(item => void item.then(value => {
+            result.push(value);
+        }));
+        return new Thenable(result);
+    }
 }

package/dist/mjs/utils/isPromise.js

@@ -0,0 +1 @@
+export const isPromise = (value) => value instanceof Promise;

package/dist/mjs/utils/isPromiseLike.js

@@ -0,0 +1,4 @@
+export const isPromiseLike = (value) => typeof value === "object" &&
+    value !== null &&
+    "then" in value &&
+    typeof value.then === "function";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yaasl/core",
-  "version": "0.7.0",
+  "version": "0.8.0-alpha.1",
   "description": "yet another atomic store library (vanilla-js)",
   "author": "PrettyCoffee",
   "license": "MIT",
@@ -31,18 +31,14 @@
     "compile:mjs": "tsc -p ./tsconfig.node.json --outDir ./dist/mjs -m es2020 -t es2020",
     "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": "jest --testMatch ./**/*.test.*",
-    "test:watch": "npm run test -- --watchAll",
+    "test": "vitest run",
+    "test:watch": "vitest watch",
     "lint": "eslint ./src",
     "lint:fix": "eslint ./src --fix",
     "validate": "run-s lint test build"
   },
   "dependencies": {
-    "@yaasl/utils": "0.7.0"
-  },
-  "jest": {
-    "preset": "ts-jest",
-    "testEnvironment": "jsdom"
+    "@yaasl/utils": "0.8.0-alpha.1"
   },
   "eslintConfig": {
     "extends": [