v1.2.2 - Fix network error on background, auto-retry streaming with reconnect

node_modules/@kvs/storage/module/JSONValue.d.ts

@@ -0,0 +1,16 @@
+/**
+ Matches a JSON object.
+ This type can be useful to enforce some input to be JSON-compatible or as a super-type to be extended from. Don't use this as a direct return type as the user would have to double-cast it: `jsonObject as unknown as CustomResponse`. Instead, you could extend your CustomResponse type from it to ensure your type only uses JSON-compatible types: `interface CustomResponse extends JsonObject { … }`.
+ */
+export type JsonObject = {
+    [Key in string]?: JsonValue;
+};
+/**
+ Matches a JSON array.
+ */
+export interface JsonArray extends Array<JsonValue> {
+}
+/**
+ Matches any valid JSON value.
+ */
+export type JsonValue = string | number | boolean | null | JsonObject | JsonArray;

node_modules/@kvs/storage/module/JSONValue.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=JSONValue.js.map

node_modules/@kvs/storage/module/JSONValue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"JSONValue.js","sourceRoot":"","sources":["../src/JSONValue.ts"],"names":[],"mappings":""}

node_modules/@kvs/storage/module/index.d.ts

@@ -0,0 +1,2 @@
+export { kvsStorage, deleteItem, setItem, getItem, clearItem, createIterator, hasItem, KvsStorage, KVSStorageKey, KvsStorageOptions } from "./storage";
+export { JsonValue, JsonArray, JsonObject } from "./JSONValue";

node_modules/@kvs/storage/module/index.js

@@ -0,0 +1,2 @@
+export { kvsStorage, deleteItem, setItem, getItem, clearItem, createIterator, hasItem } from "./storage";
+//# sourceMappingURL=index.js.map

node_modules/@kvs/storage/module/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,UAAU,EACV,UAAU,EACV,OAAO,EACP,OAAO,EACP,SAAS,EACT,cAAc,EACd,OAAO,EAIV,MAAM,WAAW,CAAC"}

node_modules/@kvs/storage/module/storage.d.ts

@@ -0,0 +1,20 @@
+import type { KVS, KVSOptions, StoreNames, StoreValue } from "@kvs/types";
+import { JsonValue } from "./JSONValue";
+export type KVSStorageKey = string;
+export declare const getItem: <Schema extends StorageSchema>(storage: Storage, tableName: string, key: StoreNames<Schema>) => any;
+export declare const hasItem: <Schema extends StorageSchema>(storage: Storage, tableName: string, key: StoreNames<Schema>) => boolean;
+export declare const setItem: <Schema extends StorageSchema>(storage: Storage, tableName: string, key: StoreNames<Schema>, value: StoreValue<Schema, StoreNames<Schema>> | undefined) => boolean | void;
+export declare const clearItem: (storage: Storage, tableName: string, kvsVersionKey: string, options: {
+    force: boolean;
+}) => void;
+export declare const deleteItem: <Schema extends StorageSchema>(storage: Storage, tableName: string, key: StoreNames<Schema>) => boolean;
+export declare function createIterator<Schema extends StorageSchema>(storage: Storage, tableName: string, kvsVersionKey: string): Iterator<[StoreNames<Schema>, StoreValue<Schema, StoreNames<Schema>>]>;
+export type StorageSchema = {
+    [index: string]: JsonValue;
+};
+export type KvsStorage<Schema extends StorageSchema> = KVS<Schema>;
+export type KvsStorageOptions<Schema extends StorageSchema> = KVSOptions<Schema> & {
+    kvsVersionKey?: string;
+    storage: Storage;
+};
+export declare const kvsStorage: <Schema extends StorageSchema>(options: KvsStorageOptions<Schema>) => Promise<KvsStorage<Schema>>;

node_modules/@kvs/storage/module/storage.js

@@ -0,0 +1,173 @@
+function invariant(condition, message) {
+    if (condition) {
+        return;
+    }
+    throw new Error(message);
+}
+const TABLE_KEY_MARKER = ".__.";
+export const getItem = (storage, tableName, key) => {
+    const storageKey = `${tableName}${TABLE_KEY_MARKER}${String(key)}`;
+    const item = storage.getItem(storageKey);
+    return item !== null ? JSON.parse(item) : undefined;
+};
+export const hasItem = (storage, tableName, key) => {
+    const storageKey = `${tableName}${TABLE_KEY_MARKER}${String(key)}`;
+    return storage.getItem(storageKey) !== null;
+};
+export const setItem = (storage, tableName, key, value) => {
+    // It is difference with IndexedDB implementation.
+    // This behavior compatible with localStorage.
+    if (value === undefined) {
+        return deleteItem(storage, tableName, key);
+    }
+    const storageKey = `${tableName}${TABLE_KEY_MARKER}${String(key)}`;
+    return storage.setItem(storageKey, JSON.stringify(value));
+};
+export const clearItem = (storage, tableName, kvsVersionKey, options) => {
+    // TODO: kvsVersionKey is special type
+    const currentVersion = getItem(storage, tableName, kvsVersionKey);
+    // clear all
+    storage.clear();
+    // if option.force is true, does not restore metadata.
+    if (options.force) {
+        return;
+    }
+    // set kvs version again
+    if (currentVersion !== undefined) {
+        setItem(storage, tableName, kvsVersionKey, currentVersion);
+    }
+};
+export const deleteItem = (storage, tableName, key) => {
+    const storageKey = `${tableName}${TABLE_KEY_MARKER}${String(key)}`;
+    try {
+        storage.removeItem(storageKey);
+        return true;
+    }
+    catch (_a) {
+        return false;
+    }
+};
+export function* createIterator(storage, tableName, kvsVersionKey) {
+    const tableKeyPrefix = `${tableName}${TABLE_KEY_MARKER}`;
+    for (let i = 0; i < storage.length; i++) {
+        const key = storage.key(i);
+        if (!key) {
+            continue;
+        }
+        // skip another storage
+        if (!key.startsWith(tableKeyPrefix)) {
+            continue;
+        }
+        // skip meta key
+        const keyWithoutPrefix = key.replace(tableKeyPrefix, "");
+        if (keyWithoutPrefix === kvsVersionKey) {
+            continue;
+        }
+        const value = getItem(storage, tableName, keyWithoutPrefix);
+        yield [keyWithoutPrefix, value];
+    }
+}
+const DEFAULT_KVS_VERSION = 1;
+const openStorage = async ({ storage, version, tableName, kvsVersionKey, onUpgrade }) => {
+    // kvsVersionKey is special type
+    // first `oldVersion` is `0`
+    let oldVersion = getItem(storage, tableName, kvsVersionKey);
+    if (oldVersion === undefined) {
+        setItem(storage, tableName, kvsVersionKey, DEFAULT_KVS_VERSION);
+        // first `oldVersion` is `0`
+        // https://github.com/azu/kvs/issues/8
+        oldVersion = 0;
+    }
+    // if user set newVersion, upgrade it
+    if (oldVersion !== version) {
+        await onUpgrade({
+            oldVersion,
+            newVersion: version,
+            storage
+        });
+        // save current version if upgrade is success
+        setItem(storage, tableName, kvsVersionKey, version);
+        return storage;
+    }
+    return storage;
+};
+const createStore = ({ tableName, storage, kvsVersionKey }) => {
+    const store = {
+        get(key) {
+            return Promise.resolve().then(() => {
+                return getItem(storage, tableName, key);
+            });
+        },
+        has(key) {
+            return Promise.resolve().then(() => {
+                return hasItem(storage, tableName, key);
+            });
+        },
+        set(key, value) {
+            return Promise.resolve()
+                .then(() => {
+                return setItem(storage, tableName, key, value);
+            })
+                .then(() => {
+                return store;
+            });
+        },
+        clear() {
+            return Promise.resolve().then(() => {
+                return clearItem(storage, tableName, kvsVersionKey, { force: false });
+            });
+        },
+        delete(key) {
+            return Promise.resolve().then(() => {
+                return deleteItem(storage, tableName, key);
+            });
+        },
+        dropInstance() {
+            return Promise.resolve().then(() => {
+                return clearItem(storage, tableName, kvsVersionKey, { force: true });
+            });
+        },
+        close() {
+            // Noop function
+            return Promise.resolve();
+        },
+        [Symbol.asyncIterator]() {
+            const iterator = createIterator(storage, tableName, kvsVersionKey);
+            return {
+                next() {
+                    return Promise.resolve().then(() => {
+                        return iterator.next();
+                    });
+                }
+            };
+        }
+    };
+    return store;
+};
+export const kvsStorage = async (options) => {
+    var _a;
+    const { name, version, upgrade, ...kvStorageOptions } = options;
+    invariant(typeof name === "string", "name should be string");
+    invariant(name.length > 0, "name should not be empty");
+    invariant(!name.includes(TABLE_KEY_MARKER), `name can not include ${TABLE_KEY_MARKER}. It is reserved in kvs.`);
+    invariant(typeof version === "number", `version should be number`);
+    const kvsVersionKey = (_a = kvStorageOptions.kvsVersionKey) !== null && _a !== void 0 ? _a : "__kvs_version__";
+    const storage = await openStorage({
+        storage: options.storage,
+        version: options.version,
+        tableName: name,
+        onUpgrade: ({ oldVersion, newVersion, storage }) => {
+            if (!options.upgrade) {
+                return;
+            }
+            return options.upgrade({
+                kvs: createStore({ tableName: name, storage, kvsVersionKey }),
+                oldVersion,
+                newVersion
+            });
+        },
+        kvsVersionKey
+    });
+    return createStore({ tableName: name, storage, kvsVersionKey });
+};
+//# sourceMappingURL=storage.js.map