@novasamatech/storage-adapter 0.5.0-9

package/README.md

@@ -0,0 +1,11 @@
+# @novasamatech/storage-adapter
+
+Statement store integration layer.
+
+## Overview
+
+## Installation
+
+```shell
+npm install @novasamatech/storage-adapter --save -E
+```

package/dist/fieldView.d.ts

@@ -0,0 +1,26 @@
+import type { ResultAsync } from 'neverthrow';
+import type { StorageAdapter } from './types.js';
+type Params<T> = {
+    storage: StorageAdapter;
+    key: string;
+    initial: T;
+    autosync?: boolean;
+    from(value: string): T;
+    to(value: T): string | null;
+};
+export declare function fieldView<T>({ storage, initial, key, from, to, autosync }: Params<T>): {
+    read(): ResultAsync<T, Error>;
+    write(value: T): ResultAsync<T, Error> | ResultAsync<null, Error>;
+    clear(): ResultAsync<void, Error>;
+    subscribe(fn: (value: T) => void): VoidFunction;
+};
+export declare function fieldListView<T>(params: Params<T[]>): {
+    add(value: T): ResultAsync<T, Error>;
+    filter(fn: (value: T) => boolean): ResultAsync<T[], Error>;
+    mutate(fn: (value: T[]) => T[]): ResultAsync<T[], Error>;
+    read(): ResultAsync<T[], Error>;
+    write(value: T[]): ResultAsync<T[], Error> | ResultAsync<null, Error>;
+    clear(): ResultAsync<void, Error>;
+    subscribe(fn: (value: T[]) => void): VoidFunction;
+};
+export {};

package/dist/fieldView.js

@@ -0,0 +1,53 @@
+import { okAsync } from 'neverthrow';
+import { nonNullable } from './helpers.js';
+export function fieldView({ storage, initial, key, from, to, autosync = true }) {
+    const enhancedStorage = {
+        read() {
+            return storage.read(key).map(x => (nonNullable(x) ? from(x) : initial));
+        },
+        write(value) {
+            const data = to(value);
+            if (data !== null) {
+                return storage.write(key, data).map(() => value);
+            }
+            return okAsync(null);
+        },
+        clear() {
+            return storage.clear(key);
+        },
+        subscribe(fn) {
+            if (autosync) {
+                enhancedStorage.read().andTee(fn);
+            }
+            return storage.subscribe(key, x => fn(nonNullable(x) ? from(x) : initial));
+        },
+    };
+    if (autosync) {
+        enhancedStorage.read();
+    }
+    return enhancedStorage;
+}
+export function fieldListView(params) {
+    const view = fieldView(params);
+    const listView = {
+        ...view,
+        add(value) {
+            return listView.mutate(list => list.concat(value)).map(() => value);
+        },
+        filter(fn) {
+            return listView.mutate(list => {
+                const filtered = list.filter(fn);
+                return filtered.length === list.length ? list : filtered;
+            });
+        },
+        mutate(fn) {
+            return listView.read().andThen(list => {
+                const result = fn(list);
+                if (result === list)
+                    return okAsync(result);
+                return listView.write(result).map(() => result);
+            });
+        },
+    };
+    return listView;
+}

package/dist/helpers.d.ts

@@ -0,0 +1,2 @@
+export declare function toError(err: unknown): Error;
+export declare function nonNullable<T>(value: T): value is Exclude<NonNullable<T>, void>;

package/dist/helpers.js

@@ -0,0 +1,12 @@
+export function toError(err) {
+    if (err instanceof Error) {
+        return err;
+    }
+    if (err) {
+        return new Error(err.toString());
+    }
+    return new Error('Unknown error occurred.');
+}
+export function nonNullable(value) {
+    return value !== null && value !== undefined;
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export type { StorageAdapter } from './types.js';
+export { createMemoryAdapter } from './memory.js';
+export { createLocalStorageAdapter } from './localStorage.js';
+export { fieldListView, fieldView } from './fieldView.js';

package/dist/index.js

@@ -0,0 +1,3 @@
+export { createMemoryAdapter } from './memory.js';
+export { createLocalStorageAdapter } from './localStorage.js';
+export { fieldListView, fieldView } from './fieldView.js';

package/dist/localStorage.d.ts

@@ -0,0 +1,2 @@
+import type { StorageAdapter } from './types.js';
+export declare function createLocalStorageAdapter(prefix: string): StorageAdapter;

package/dist/localStorage.js

@@ -0,0 +1,36 @@
+import { createNanoEvents } from 'nanoevents';
+import { fromAsyncThrowable } from 'neverthrow';
+import { toError } from './helpers.js';
+export function createLocalStorageAdapter(prefix) {
+    const events = createNanoEvents();
+    const withPrefix = (key) => `PAPP_${prefix}_${key}`;
+    return {
+        write: fromAsyncThrowable(async (key, value) => {
+            const prefixedKey = withPrefix(key);
+            localStorage.setItem(prefixedKey, value);
+            events.emit(prefixedKey, value);
+        }, toError),
+        read: fromAsyncThrowable(async (key) => {
+            return localStorage.getItem(withPrefix(key));
+        }, toError),
+        clear: fromAsyncThrowable(async (key) => {
+            const prefixedKey = withPrefix(key);
+            localStorage.removeItem(prefixedKey);
+            events.emit(prefixedKey, null);
+        }, toError),
+        subscribe(key, callback) {
+            const prefixedKey = withPrefix(key);
+            const unsubscribeLocalListener = events.on(prefixedKey, callback);
+            const externalListener = (event) => {
+                if (event.storageArea === localStorage && event.key === prefixedKey) {
+                    callback(event.newValue);
+                }
+            };
+            window.addEventListener('storage', externalListener);
+            return () => {
+                unsubscribeLocalListener();
+                window.removeEventListener('storage', externalListener);
+            };
+        },
+    };
+}

package/dist/memory.d.ts

@@ -0,0 +1,2 @@
+import type { StorageAdapter } from './types.js';
+export declare function createMemoryAdapter(external?: Record<string, string>): StorageAdapter;

package/dist/memory.js

@@ -0,0 +1,22 @@
+import { createNanoEvents } from 'nanoevents';
+import { fromAsyncThrowable } from 'neverthrow';
+export function createMemoryAdapter(external) {
+    const events = createNanoEvents();
+    const storage = external ? { ...external } : {};
+    return {
+        write: fromAsyncThrowable(async (key, value) => {
+            storage[key] = value;
+            events.emit(key, value);
+        }),
+        read: fromAsyncThrowable(async (key) => {
+            return storage[key] ?? null;
+        }),
+        clear: fromAsyncThrowable(async (key) => {
+            delete storage[key];
+            events.emit(key, null);
+        }),
+        subscribe(key, callback) {
+            return events.on(key, callback);
+        },
+    };
+}

package/dist/types.d.ts

@@ -0,0 +1,7 @@
+import { ResultAsync } from 'neverthrow';
+export type StorageAdapter = {
+    write(key: string, value: string): ResultAsync<void, Error>;
+    read(key: string): ResultAsync<string | null, Error>;
+    clear(key: string): ResultAsync<void, Error>;
+    subscribe(key: string, callback: (value: string | null) => unknown): VoidFunction;
+};

package/dist/types.js

@@ -0,0 +1 @@
+import { ResultAsync } from 'neverthrow';

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@novasamatech/storage-adapter",
+  "type": "module",
+  "version": "0.5.0-9",
+  "description": "Statement store integration",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/novasamatech/spektr-sdk.git"
+  },
+  "keywords": [
+    "polkadot"
+  ],
+  "main": "dist/index.js",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "dependencies": {
+    "nanoevents": "^9.1.0",
+    "neverthrow": "^8.2.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}