unikvs 0.0.2 → 0.0.3

package/dist/src/core/unikvs.js

@@ -0,0 +1,678 @@
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _UniKvs_instances, _UniKvs_con, _UniKvs_context, _UniKvs_destinations, _UniKvs_transformers, _UniKvs_transformerSet, _UniKvs_open;
+import { asyncmux, Asyncmux } from "asyncmux";
+import combineSignals from "./_combine-signals.js";
+import log from "./_logger.js";
+import mergeContext from "./_merge-context.js";
+import toValueStream from "./_to-value-stream.js";
+import UniKvsConfig from "./unikvs-config.js";
+class UniKvs {
+    static config() {
+        return new UniKvsConfig(this);
+    }
+    constructor(context, destinations, transformers) {
+        _UniKvs_instances.add(this);
+        _UniKvs_con.set(this, void 0);
+        _UniKvs_context.set(this, void 0);
+        _UniKvs_destinations.set(this, void 0);
+        _UniKvs_transformers.set(this, void 0);
+        _UniKvs_transformerSet.set(this, void 0);
+        __classPrivateFieldSet(this, _UniKvs_con, null, "f");
+        __classPrivateFieldSet(this, _UniKvs_context, context, "f");
+        __classPrivateFieldSet(this, _UniKvs_destinations, destinations, "f");
+        __classPrivateFieldSet(this, _UniKvs_transformers, transformers, "f");
+        __classPrivateFieldSet(this, _UniKvs_transformerSet, new Set(transformers), "f");
+    }
+    get isOpen() {
+        return !!__classPrivateFieldGet(this, _UniKvs_con, "f");
+    }
+    async open(arg0 = {}) {
+        const env_1 = { stack: [], error: void 0, hasError: false };
+        try {
+            if (__classPrivateFieldGet(this, _UniKvs_con, "f")) {
+                throw new Error();
+            }
+            __classPrivateFieldSet(this, _UniKvs_con, {
+                ac: new AbortController(),
+                ioMux: new Asyncmux(),
+            }, "f");
+            const { ac } = __classPrivateFieldGet(this, _UniKvs_con, "f");
+            const { signal } = (function parseOpenArguments() {
+                const { signal } = arg0 instanceof AbortSignal ? { signal: arg0 } : arg0;
+                return {
+                    signal: combineSignals([signal, ac.signal]),
+                };
+            })();
+            const _ = __addDisposableResource(env_1, await asyncmux(this, signal), false);
+            if (__classPrivateFieldGet(this, _UniKvs_con, "f").ac !== ac) {
+                throw new Error();
+            }
+            const context = { "unikvs:action": "open" };
+            const plugins = [...__classPrivateFieldGet(this, _UniKvs_destinations, "f"), ...__classPrivateFieldGet(this, _UniKvs_transformers, "f")];
+            const openFns = [];
+            const dispose = [];
+            for (const plugin of plugins) {
+                if (plugin.isOpen || !plugin.open) {
+                    continue;
+                }
+                openFns.push(async () => {
+                    await plugin.open(signal, context);
+                    if (!plugin.close) {
+                        return;
+                    }
+                    dispose.push(async () => {
+                        try {
+                            await plugin.close(signal, context);
+                        }
+                        catch (ex) {
+                            if (!__classPrivateFieldGet(this, _UniKvs_transformerSet, "f").has(plugin)) {
+                                log.warn `Failed to close storage: ${ex}`;
+                            }
+                            else {
+                                log.warn `Failed to close transformer: ${ex}`;
+                            }
+                        }
+                    });
+                });
+            }
+            try {
+                if (openFns.length > 0) {
+                    const errors = [];
+                    await Promise.all(openFns.map(async (f) => {
+                        try {
+                            await f();
+                        }
+                        catch (ex) {
+                            errors.push(ex);
+                        }
+                    }));
+                    switch (errors.length) {
+                        case 0:
+                            break;
+                        case 1:
+                            throw errors[0];
+                        default:
+                            throw new AggregateError(errors);
+                    }
+                }
+            }
+            catch (ex) {
+                if (dispose.length > 0) {
+                    await Promise.all(dispose.map((f) => f()));
+                }
+                __classPrivateFieldSet(this, _UniKvs_con, null, "f");
+                throw ex;
+            }
+        }
+        catch (e_1) {
+            env_1.error = e_1;
+            env_1.hasError = true;
+        }
+        finally {
+            __disposeResources(env_1);
+        }
+    }
+    async close(arg0 = {}) {
+        const env_2 = { stack: [], error: void 0, hasError: false };
+        try {
+            if (!__classPrivateFieldGet(this, _UniKvs_con, "f")) {
+                throw new Error();
+            }
+            const { signal } = (function parseCloseArguments() {
+                const { signal } = arg0 instanceof AbortSignal ? { signal: arg0 } : arg0;
+                return {
+                    signal: combineSignals([signal, AbortSignal.timeout(10e3)]),
+                };
+            })();
+            const { ac, ioMux } = __classPrivateFieldGet(this, _UniKvs_con, "f");
+            ac.abort();
+            const _lock = __addDisposableResource(env_2, await asyncmux(this, signal), false);
+            const _ioLock = __addDisposableResource(env_2, await ioMux.lock({ signal }), false);
+            if (!__classPrivateFieldGet(this, _UniKvs_con, "f")) {
+                throw new Error();
+            }
+            const context = { "unikvs:action": "close" };
+            const plugins = [...__classPrivateFieldGet(this, _UniKvs_destinations, "f"), ...__classPrivateFieldGet(this, _UniKvs_transformers, "f")];
+            const closeFns = [];
+            for (const plugin of plugins) {
+                if (plugin.isOpen || !plugin.close) {
+                    continue;
+                }
+                closeFns.push(async () => {
+                    await plugin.close(signal, context);
+                });
+            }
+            if (closeFns.length > 0) {
+                const errors = [];
+                await Promise.all(closeFns.map(async (f) => {
+                    try {
+                        await f();
+                    }
+                    catch (ex) {
+                        errors.push(ex);
+                    }
+                }));
+                switch (errors.length) {
+                    case 0:
+                        break;
+                    case 1:
+                        throw errors[0];
+                    default:
+                        throw new AggregateError(errors);
+                }
+            }
+        }
+        catch (e_2) {
+            env_2.error = e_2;
+            env_2.hasError = true;
+        }
+        finally {
+            __disposeResources(env_2);
+        }
+    }
+    async set(arg0, arg1, arg2) {
+        const env_3 = { stack: [], error: void 0, hasError: false };
+        try {
+            if (!__classPrivateFieldGet(this, _UniKvs_con, "f")) {
+                throw new Error();
+            }
+            const { ac, ioMux } = __classPrivateFieldGet(this, _UniKvs_con, "f");
+            const { key, value, signal, context } = (function parseSetArguments(ctx) {
+                const { key, value, signal, context } = typeof arg0 === "object"
+                    ? arg0
+                    : {
+                        ...arg2,
+                        key: arg0,
+                        value: arg1,
+                    };
+                return {
+                    key,
+                    value,
+                    signal: combineSignals([signal, ac.signal]),
+                    context: mergeContext(ctx, context),
+                };
+            })(__classPrivateFieldGet(this, _UniKvs_context, "f"));
+            const _lock = __addDisposableResource(env_3, await asyncmux.readonly(this, signal), false);
+            if (!__classPrivateFieldGet(this, _UniKvs_con, "f")) {
+                throw new Error();
+            }
+            context["unikvs:action"] = "set";
+            const _close = __addDisposableResource(env_3, await __classPrivateFieldGet(this, _UniKvs_instances, "m", _UniKvs_open).call(this, signal, context), true);
+            const errors = [];
+            if (value instanceof ReadableStream) {
+                const env_4 = { stack: [], error: void 0, hasError: false };
+                try {
+                    let data = value;
+                    for (const transformer of __classPrivateFieldGet(this, _UniKvs_transformers, "f")) {
+                        const e = await transformer.getEncodable(signal, context);
+                        data = data.pipeThrough(e);
+                    }
+                    const _ioLock = __addDisposableResource(env_4, await ioMux.lock({ key, signal }), false);
+                    await Promise.all(__classPrivateFieldGet(this, _UniKvs_destinations, "f").map(async (storage, i) => {
+                        let r = data;
+                        if (i !== __classPrivateFieldGet(this, _UniKvs_destinations, "f").length - 1) {
+                            [r, data] = data.tee();
+                        }
+                        try {
+                            const w = await storage.getWritable(key, signal, context);
+                            await r.pipeTo(w, { signal });
+                        }
+                        catch (ex) {
+                            errors.push(ex);
+                        }
+                    }));
+                }
+                catch (e_3) {
+                    env_4.error = e_3;
+                    env_4.hasError = true;
+                }
+                finally {
+                    __disposeResources(env_4);
+                }
+            }
+            else {
+                const env_5 = { stack: [], error: void 0, hasError: false };
+                try {
+                    let data = value;
+                    for (const transformer of __classPrivateFieldGet(this, _UniKvs_transformers, "f")) {
+                        data = await transformer.encode(data, signal, context);
+                    }
+                    const _ioLock = __addDisposableResource(env_5, await ioMux.lock({ key, signal }), false);
+                    await Promise.all(__classPrivateFieldGet(this, _UniKvs_destinations, "f").map(async (storage) => {
+                        try {
+                            await storage.write(key, data, signal, context);
+                        }
+                        catch (ex) {
+                            errors.push(ex);
+                        }
+                    }));
+                }
+                catch (e_4) {
+                    env_5.error = e_4;
+                    env_5.hasError = true;
+                }
+                finally {
+                    __disposeResources(env_5);
+                }
+            }
+            switch (errors.length) {
+                case 0:
+                    break;
+                case 1:
+                    throw errors[0];
+                default:
+                    throw new AggregateError(errors);
+            }
+        }
+        catch (e_5) {
+            env_3.error = e_5;
+            env_3.hasError = true;
+        }
+        finally {
+            const result_1 = __disposeResources(env_3);
+            if (result_1)
+                await result_1;
+        }
+    }
+    async get(arg0, arg1 = {}) {
+        const env_6 = { stack: [], error: void 0, hasError: false };
+        try {
+            if (!__classPrivateFieldGet(this, _UniKvs_con, "f")) {
+                throw new Error();
+            }
+            const { ac, ioMux } = __classPrivateFieldGet(this, _UniKvs_con, "f");
+            const { key, signal, context } = (function parseGetArguments(ctx) {
+                const { key, signal, context } = typeof arg0 === "object"
+                    ? arg0
+                    : {
+                        ...arg1,
+                        key: arg0,
+                    };
+                return {
+                    key,
+                    signal: combineSignals([signal, ac.signal]),
+                    context: mergeContext(ctx, context),
+                };
+            })(__classPrivateFieldGet(this, _UniKvs_context, "f"));
+            const _lock = __addDisposableResource(env_6, await asyncmux.readonly(this, signal), false);
+            if (!__classPrivateFieldGet(this, _UniKvs_con, "f")) {
+                throw new Error();
+            }
+            context["unikvs:action"] = "get";
+            const _close = __addDisposableResource(env_6, await __classPrivateFieldGet(this, _UniKvs_instances, "m", _UniKvs_open).call(this, signal, context), true);
+            const NONE = {};
+            let data = NONE;
+            {
+                const env_7 = { stack: [], error: void 0, hasError: false };
+                try {
+                    const _ioLock = __addDisposableResource(env_7, await ioMux.rLock({ key, signal }), false);
+                    for (const storage of __classPrivateFieldGet(this, _UniKvs_destinations, "f")) {
+                        if (await storage.exists(key, signal, context)) {
+                            data = await storage.read(key, signal, context);
+                        }
+                    }
+                }
+                catch (e_6) {
+                    env_7.error = e_6;
+                    env_7.hasError = true;
+                }
+                finally {
+                    __disposeResources(env_7);
+                }
+            }
+            if (data === NONE) {
+                throw new Error();
+            }
+            if (__classPrivateFieldGet(this, _UniKvs_transformers, "f").length > 0) {
+                for (const transformer of __classPrivateFieldGet(this, _UniKvs_transformers, "f").toReversed()) {
+                    data = await transformer.decode(data, signal, context);
+                }
+            }
+            return data;
+        }
+        catch (e_7) {
+            env_6.error = e_7;
+            env_6.hasError = true;
+        }
+        finally {
+            const result_2 = __disposeResources(env_6);
+            if (result_2)
+                await result_2;
+        }
+    }
+    async stream(arg0, arg1 = {}) {
+        const env_8 = { stack: [], error: void 0, hasError: false };
+        try {
+            if (!__classPrivateFieldGet(this, _UniKvs_con, "f")) {
+                throw new Error();
+            }
+            const { ac, ioMux } = __classPrivateFieldGet(this, _UniKvs_con, "f");
+            const { key, signal, context } = (function parseStreamArguments(ctx) {
+                const { key, signal, context } = typeof arg0 === "object"
+                    ? arg0
+                    : {
+                        ...arg1,
+                        key: arg0,
+                    };
+                return {
+                    key,
+                    signal: combineSignals([signal, ac.signal]),
+                    context: mergeContext(ctx, context),
+                };
+            })(__classPrivateFieldGet(this, _UniKvs_context, "f"));
+            const _lock = __addDisposableResource(env_8, await asyncmux.readonly(this, signal), false);
+            if (!__classPrivateFieldGet(this, _UniKvs_con, "f")) {
+                throw new Error();
+            }
+            context["unikvs:action"] = "stream";
+            const _close = __addDisposableResource(env_8, await __classPrivateFieldGet(this, _UniKvs_instances, "m", _UniKvs_open).call(this, signal, context), true);
+            const NONE = {};
+            let r = NONE;
+            {
+                const env_9 = { stack: [], error: void 0, hasError: false };
+                try {
+                    const _ioLock = __addDisposableResource(env_9, await ioMux.rLock({ key, signal }), false);
+                    for (const storage of __classPrivateFieldGet(this, _UniKvs_destinations, "f")) {
+                        if (await storage.exists(key, signal, context)) {
+                            r = await storage.getReadable(key, signal, context);
+                        }
+                    }
+                }
+                catch (e_8) {
+                    env_9.error = e_8;
+                    env_9.hasError = true;
+                }
+                finally {
+                    __disposeResources(env_9);
+                }
+            }
+            if (r === NONE) {
+                throw new Error();
+            }
+            if (__classPrivateFieldGet(this, _UniKvs_transformers, "f").length > 0) {
+                for (const transformer of __classPrivateFieldGet(this, _UniKvs_transformers, "f").toReversed()) {
+                    const d = await transformer.getDecodable(signal, context);
+                    r = r.pipeThrough(d);
+                }
+            }
+            return toValueStream(r);
+        }
+        catch (e_9) {
+            env_8.error = e_9;
+            env_8.hasError = true;
+        }
+        finally {
+            const result_3 = __disposeResources(env_8);
+            if (result_3)
+                await result_3;
+        }
+    }
+    async has(arg0, arg1 = {}) {
+        const env_10 = { stack: [], error: void 0, hasError: false };
+        try {
+            if (!__classPrivateFieldGet(this, _UniKvs_con, "f")) {
+                throw new Error();
+            }
+            const { ac, ioMux } = __classPrivateFieldGet(this, _UniKvs_con, "f");
+            const { key, signal, context } = (function parseHasArguments(ctx) {
+                const { key, signal, context } = typeof arg0 === "object"
+                    ? arg0
+                    : {
+                        ...arg1,
+                        key: arg0,
+                    };
+                return {
+                    key,
+                    signal: combineSignals([signal, ac.signal]),
+                    context: mergeContext(ctx, context),
+                };
+            })(__classPrivateFieldGet(this, _UniKvs_context, "f"));
+            const _lock = __addDisposableResource(env_10, await asyncmux.readonly(this, signal), false);
+            if (!__classPrivateFieldGet(this, _UniKvs_con, "f")) {
+                throw new Error();
+            }
+            context["unikvs:action"] = "has";
+            const _close = __addDisposableResource(env_10, await __classPrivateFieldGet(this, _UniKvs_instances, "m", _UniKvs_open).call(this, signal, context), true);
+            const _ioLock = __addDisposableResource(env_10, await ioMux.rLock({ key, signal }), false);
+            for (const storage of __classPrivateFieldGet(this, _UniKvs_destinations, "f")) {
+                if (await storage.exists(key, signal, context)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        catch (e_10) {
+            env_10.error = e_10;
+            env_10.hasError = true;
+        }
+        finally {
+            const result_4 = __disposeResources(env_10);
+            if (result_4)
+                await result_4;
+        }
+    }
+    async delete(arg0, arg1 = {}) {
+        const env_11 = { stack: [], error: void 0, hasError: false };
+        try {
+            if (!__classPrivateFieldGet(this, _UniKvs_con, "f")) {
+                throw new Error();
+            }
+            const { ac, ioMux } = __classPrivateFieldGet(this, _UniKvs_con, "f");
+            const { key, signal, context } = (function parseDeleteArguments(ctx) {
+                const { key, signal, context } = typeof arg0 === "object"
+                    ? arg0
+                    : {
+                        ...arg1,
+                        key: arg0,
+                    };
+                return {
+                    key,
+                    signal: combineSignals([signal, ac.signal]),
+                    context: mergeContext(ctx, context),
+                };
+            })(__classPrivateFieldGet(this, _UniKvs_context, "f"));
+            const _lock = __addDisposableResource(env_11, await asyncmux.readonly(this, signal), false);
+            if (!__classPrivateFieldGet(this, _UniKvs_con, "f")) {
+                throw new Error();
+            }
+            context["unikvs:action"] = "delete";
+            const _close = __addDisposableResource(env_11, await __classPrivateFieldGet(this, _UniKvs_instances, "m", _UniKvs_open).call(this, signal, context), true);
+            const errors = [];
+            const _ioLock = __addDisposableResource(env_11, await ioMux.lock({ key, signal }), false);
+            await Promise.all(__classPrivateFieldGet(this, _UniKvs_destinations, "f").map(async (storage) => {
+                try {
+                    if (await storage.exists(key, signal, context)) {
+                        await storage.delete(key, signal, context);
+                    }
+                }
+                catch (ex) {
+                    errors.push(ex);
+                }
+            }));
+            switch (errors.length) {
+                case 0:
+                    break;
+                case 1:
+                    throw errors[0];
+                default:
+                    throw new AggregateError(errors);
+            }
+        }
+        catch (e_11) {
+            env_11.error = e_11;
+            env_11.hasError = true;
+        }
+        finally {
+            const result_5 = __disposeResources(env_11);
+            if (result_5)
+                await result_5;
+        }
+    }
+    async clear(options = {}) {
+        const env_12 = { stack: [], error: void 0, hasError: false };
+        try {
+            if (!__classPrivateFieldGet(this, _UniKvs_con, "f")) {
+                throw new Error();
+            }
+            const { ac, ioMux } = __classPrivateFieldGet(this, _UniKvs_con, "f");
+            const { signal, context } = (function parseClearArguments(ctx) {
+                const { signal, context } = options;
+                return {
+                    signal: combineSignals([signal, ac.signal]),
+                    context: mergeContext(ctx, context),
+                };
+            })(__classPrivateFieldGet(this, _UniKvs_context, "f"));
+            const _lock = __addDisposableResource(env_12, await asyncmux.readonly(this, signal), false);
+            if (!__classPrivateFieldGet(this, _UniKvs_con, "f")) {
+                throw new Error();
+            }
+            context["unikvs:action"] = "clear";
+            const _close = __addDisposableResource(env_12, await __classPrivateFieldGet(this, _UniKvs_instances, "m", _UniKvs_open).call(this, signal, context), true);
+            const errors = [];
+            const _ioLock = __addDisposableResource(env_12, await ioMux.lock({ signal }), false);
+            await Promise.all(__classPrivateFieldGet(this, _UniKvs_destinations, "f").map(async (storage) => {
+                try {
+                    await storage.clear(signal, context);
+                }
+                catch (ex) {
+                    errors.push(ex);
+                }
+            }));
+            switch (errors.length) {
+                case 0:
+                    break;
+                case 1:
+                    throw errors[0];
+                default:
+                    throw new AggregateError(errors);
+            }
+        }
+        catch (e_12) {
+            env_12.error = e_12;
+            env_12.hasError = true;
+        }
+        finally {
+            const result_6 = __disposeResources(env_12);
+            if (result_6)
+                await result_6;
+        }
+    }
+}
+_UniKvs_con = new WeakMap(), _UniKvs_context = new WeakMap(), _UniKvs_destinations = new WeakMap(), _UniKvs_transformers = new WeakMap(), _UniKvs_transformerSet = new WeakMap(), _UniKvs_instances = new WeakSet(), _UniKvs_open = async function _UniKvs_open(signal, context) {
+    const plugins = [...__classPrivateFieldGet(this, _UniKvs_destinations, "f"), ...__classPrivateFieldGet(this, _UniKvs_transformers, "f")];
+    const openFns = [];
+    const dispose = [];
+    for (const plugin of plugins) {
+        if (plugin.isOpen || !plugin.open) {
+            continue;
+        }
+        openFns.push(async () => {
+            await plugin.open(signal, context);
+            if (!plugin.close) {
+                return;
+            }
+            dispose.push(async () => {
+                try {
+                    await plugin.close(signal, context);
+                }
+                catch (ex) {
+                    if (!__classPrivateFieldGet(this, _UniKvs_transformerSet, "f").has(plugin)) {
+                        log.warn `Failed to close storage: ${ex}`;
+                    }
+                    else {
+                        log.warn `Failed to close transformer: ${ex}`;
+                    }
+                }
+            });
+        });
+    }
+    if (openFns.length > 0) {
+        const errors = [];
+        await Promise.all(openFns.map(async (f) => {
+            try {
+                await f();
+            }
+            catch (ex) {
+                errors.push(ex);
+            }
+        }));
+        switch (errors.length) {
+            case 0:
+                break;
+            case 1:
+                throw errors[0];
+            default:
+                throw new AggregateError(errors);
+        }
+    }
+    return {
+        async [Symbol.asyncDispose]() {
+            if (dispose.length > 0) {
+                await Promise.all(dispose.map((f) => f()));
+            }
+        },
+    };
+};
+export default UniKvs;

package/dist/src/core/utils.types.d.ts

@@ -0,0 +1,3 @@
+export type ValueOf<T> = T[keyof T];
+export type MaybePromise<T> = T | PromiseLike<T>;
+//# sourceMappingURL=utils.types.d.ts.map

package/dist/src/core/utils.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.types.d.ts","sourceRoot":"","sources":["../../../src/core/utils.types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;AAEpC,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC"}

package/dist/src/core/utils.types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/core/value-stream.types.d.ts

@@ -0,0 +1,4 @@
+export interface ValueStream<T> extends ReadableStream<T> {
+    [Symbol.asyncIterator](): AsyncIteratorObject<T, undefined, unknown>;
+}
+//# sourceMappingURL=value-stream.types.d.ts.map