@yaasl/core 0.7.0-alpha.0

package/dist/mjs/middleware/migration.js

@@ -0,0 +1,86 @@
+import { log } from "@yaasl/utils";
+import { middleware } from "./middleware";
+import { CONFIG } from "../base";
+const sortMigrations = (migrations) => {
+    const first = migrations.find(migration => migration.previous === null);
+    if (!first) {
+        log.error("No migration with previous version null found");
+        return [];
+    }
+    return migrations.reduce(sorted => {
+        const last = sorted.at(-1);
+        const next = migrations.find(migration => migration.previous === last?.version);
+        if (next) {
+            sorted.push(next);
+        }
+        return sorted;
+    }, [first]);
+};
+const getVersion = (atom) => {
+    const key = CONFIG.name ? `${CONFIG.name}/${atom.name}` : atom.name;
+    return localStorage.getItem(`${key}-version`);
+};
+const setVersion = (atom, version) => {
+    const key = CONFIG.name ? `${CONFIG.name}/${atom.name}` : atom.name;
+    localStorage.setItem(`${key}-version`, version);
+};
+const migrateVersion = (atom, data, migration) => {
+    if (migration.validate && !migration.validate(data)) {
+        return {
+            error: `The data of the "${atom.name}" atom does not match its version.`,
+        };
+    }
+    try {
+        return {
+            data: migration.migrate(data),
+            version: migration.version,
+        };
+    }
+    catch {
+        return {
+            error: `Something went wrong while migrating the data of the "${atom.name}" atom.`,
+        };
+    }
+};
+const performMigration = (atom, version, migrations) => {
+    const currentState = {
+        version,
+        data: atom.get(),
+    };
+    return migrations.reduce((result, migration) => {
+        const { data, version, error } = result;
+        if (error || version !== migration.previous) {
+            return result;
+        }
+        return migrateVersion(atom, data, migration);
+    }, currentState);
+};
+export const migration = middleware({
+    didInit: ({ atom, options }) => {
+        const steps = sortMigrations(options.steps);
+        const currentVersion = getVersion(atom);
+        const isLatestVersion = currentVersion === steps.at(-1)?.version;
+        if (steps.length < 1 || isLatestVersion) {
+            return;
+        }
+        if (atom.get() === atom.defaultValue) {
+            const version = steps.at(-1)?.version;
+            if (version)
+                setVersion(atom, version);
+            return;
+        }
+        const { data, version, error } = performMigration(atom, currentVersion, steps);
+        if (error) {
+            log.error(error, {
+                version: currentVersion,
+                data: atom.get(),
+            });
+            return;
+        }
+        if (version == null)
+            return;
+        setVersion(atom, version);
+        atom.set(data);
+    },
+});
+export const createMigrationStep = (migration) => migration;

package/dist/mjs/utils/Expiration.js

@@ -0,0 +1,60 @@
+const STORAGE = window.localStorage;
+export class Expiration {
+    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) {
+            this.getExpiration = () => expiresAt instanceof Function ? expiresAt() : expiresAt;
+        }
+        else if (expiresIn) {
+            this.getExpiration = () => {
+                const afterMs = expiresIn instanceof Function ? expiresIn() : expiresIn;
+                return new Date(Date.now() + afterMs);
+            };
+        }
+        else {
+            this.getExpiration = null;
+        }
+    }
+    remove() {
+        STORAGE.removeItem(this.key);
+        if (this.timeout != null) {
+            clearTimeout(this.timeout);
+            this.timeout = null;
+        }
+    }
+    init(onExpire) {
+        if (!this.getExpiration)
+            return;
+        const existing = STORAGE.getItem(this.key);
+        if (!existing) {
+            this.remove();
+            return;
+        }
+        const expiresIn = Number(existing) - Date.now();
+        const isExpired = Number.isNaN(expiresIn) || expiresIn <= 0;
+        if (isExpired) {
+            onExpire();
+            this.remove();
+        }
+        else {
+            this.dispatchExpiration(expiresIn, onExpire);
+        }
+    }
+    set(onExpire) {
+        this.remove();
+        if (!this.getExpiration)
+            return;
+        const expiration = this.getExpiration();
+        const expiresIn = Number(expiration) - Date.now();
+        this.dispatchExpiration(expiresIn, onExpire);
+        STORAGE.setItem(this.key, String(expiration.valueOf()));
+    }
+}

package/dist/mjs/utils/LocalStorage.js

@@ -0,0 +1,54 @@
+import { consoleMessage, log } from "@yaasl/utils";
+const STORAGE = window.localStorage;
+const defaultParser = {
+    parse: JSON.parse,
+    stringify: JSON.stringify,
+};
+const syncOverBrowserTabs = (observingKey, onTabSync) => window.addEventListener("storage", ({ key, newValue }) => {
+    if (observingKey !== key)
+        return;
+    onTabSync(newValue);
+});
+export class LocalStorage {
+    constructor(key, options = {}) {
+        this.key = key;
+        this.parser = options.parser ?? defaultParser;
+        if (!options.onTabSync)
+            return;
+        syncOverBrowserTabs(key, value => {
+            const newValue = value === null ? null : this.parser.parse(value);
+            if (newValue === null) {
+                this.remove();
+            }
+            else {
+                this.set(newValue);
+            }
+            options.onTabSync?.(newValue);
+        });
+    }
+    get() {
+        const value = STORAGE.getItem(this.key);
+        try {
+            return typeof value !== "string" ? null : this.parser.parse(value);
+        }
+        catch {
+            throw new Error(consoleMessage(`Value of local storage key "${this.key}" could not be parsed.`));
+        }
+    }
+    set(value) {
+        try {
+            if (value === null) {
+                STORAGE.removeItem(this.key);
+            }
+            else {
+                STORAGE.setItem(this.key, this.parser.stringify(value));
+            }
+        }
+        catch {
+            log.error(`Value of atom with local storage key "${this.key}" could not be set.`, { value });
+        }
+    }
+    remove() {
+        STORAGE.removeItem(this.key);
+    }
+}

package/dist/mjs/utils/Store.js

@@ -0,0 +1,33 @@
+const promisifyRequest = (request) => new Promise((resolve, reject) => {
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error);
+});
+export class Store {
+    constructor(name) {
+        this.name = name;
+        const openRequest = indexedDB.open(`${name}-database`);
+        this.database = promisifyRequest(openRequest);
+        openRequest.onupgradeneeded = () => {
+            const database = openRequest.result;
+            const exists = database.objectStoreNames.contains(name);
+            if (!exists) {
+                database.createObjectStore(name);
+            }
+        };
+    }
+    async getStore(mode) {
+        const database = await this.database;
+        return database.transaction(this.name, mode).objectStore(this.name);
+    }
+    async get(key) {
+        return this.getStore("readonly").then(store => promisifyRequest(store.get(key)));
+    }
+    set(key, value) {
+        return this.getStore("readwrite").then(async (store) => {
+            await promisifyRequest(store.put(value, key));
+        });
+    }
+    delete(key) {
+        return this.getStore("readwrite").then(store => promisifyRequest(store.delete(key)));
+    }
+}

package/dist/mjs/utils/Thenable.js

@@ -0,0 +1,21 @@
+const isPromiselike = (value) => typeof value === "object" &&
+    value !== null &&
+    "then" in value &&
+    typeof value.then === "function";
+export class Thenable {
+    constructor(value) {
+        this.value = value;
+    }
+    then(onfulfilled, onrejected) {
+        try {
+            const result = !onfulfilled ? this.value : onfulfilled(this.value);
+            return isPromiselike(result) ? result : new Thenable(result);
+        }
+        catch (error) {
+            if (!onrejected)
+                throw error;
+            const result = onrejected(error);
+            return isPromiselike(result) ? result : new Thenable(result);
+        }
+    }
+}

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@yaasl/core",
+  "version": "0.7.0-alpha.0",
+  "description": "yet another atomic store library (vanilla-js)",
+  "author": "PrettyCoffee",
+  "license": "MIT",
+  "homepage": "https://github.com/PrettyCoffee/yaasl#readme",
+  "keywords": [
+    "atom",
+    "store",
+    "vanilla-js"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/PrettyCoffee/yaasl.git"
+  },
+  "bugs": {
+    "url": "https://github.com/PrettyCoffee/yaasl/issues"
+  },
+  "main": "./dist/cjs/index.js",
+  "types": "./dist/@types/index.d.ts",
+  "exports": {
+    "types": "./dist/@types/index.d.ts",
+    "import": "./dist/mjs/index.js",
+    "require": "./dist/cjs/index.js"
+  },
+  "scripts": {
+    "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: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",
+    "lint": "eslint ./src",
+    "lint:fix": "eslint ./src --fix",
+    "validate": "run-s lint test build"
+  },
+  "dependencies": {
+    "@yaasl/utils": "0.7.0-alpha.0"
+  },
+  "jest": {
+    "preset": "ts-jest",
+    "testEnvironment": "jsdom"
+  },
+  "eslintConfig": {
+    "extends": [
+      "../../.eslintrc"
+    ]
+  },
+  "lint-staged": {
+    "*.{ts,tsx}": [
+      "npm run lint:fix"
+    ]
+  }
+}

package/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "../../tsconfig.json",
+}

package/tsconfig.node.json

@@ -0,0 +1,9 @@
+{
+  "extends": "./tsconfig.json",
+  "include": ["./src"],
+  "exclude": ["./**/*.test.ts"],
+  "compilerOptions": {
+    "declaration": false,
+    "noEmit": false,
+  }
+}