unikvs 0.0.2 → 0.0.3

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

@@ -0,0 +1 @@
+{"version":3,"file":"value-stream.types.d.ts","sourceRoot":"","sources":["../../../src/core/value-stream.types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,WAAW,CAAC,CAAC,CAAE,SAAQ,cAAc,CAAC,CAAC,CAAC;IACvD,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,mBAAmB,CAAC,CAAC,EAAE,SAAS,EAAE,OAAO,CAAC,CAAC;CACtE"}

package/dist/src/core/value-stream.types.js

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

package/dist/src/destinations/memory-storage.d.ts

@@ -0,0 +1,17 @@
+import type { IStorage, Key } from "../core/storage.types.js";
+type TypedArray = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array;
+type Chunk = ArrayBuffer | TypedArray;
+export default class MemoryStorage implements IStorage {
+    readonly isOpen: boolean;
+    private store;
+    constructor();
+    write(key: Key, data: any): void;
+    getWritable(key: Key): WritableStream<Chunk>;
+    read(key: Key): any;
+    getReadable(key: Key): ReadableStream;
+    exists(key: Key): boolean;
+    delete(key: Key): void;
+    clear(): void;
+}
+export {};
+//# sourceMappingURL=memory-storage.d.ts.map

package/dist/src/destinations/memory-storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-storage.d.ts","sourceRoot":"","sources":["../../../src/destinations/memory-storage.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,0BAA0B,CAAC;AAG9D,KAAK,UAAU,GACX,SAAS,GACT,UAAU,GACV,iBAAiB,GACjB,UAAU,GACV,WAAW,GACX,UAAU,GACV,WAAW,GACX,YAAY,GACZ,YAAY,GACZ,aAAa,GACb,cAAc,CAAC;AAEnB,KAAK,KAAK,GAAG,WAAW,GAAG,UAAU,CAAC;AAYtC,MAAM,CAAC,OAAO,OAAO,aAAc,YAAW,QAAQ;IACpD,SAAgB,MAAM,EAAE,OAAO,CAAQ;IAEvC,OAAO,CAAC,KAAK,CAAgB;;IAMtB,KAAK,CAAC,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,GAAG,IAAI;IAIhC,WAAW,CAAC,GAAG,EAAE,GAAG,GAAG,cAAc,CAAC,KAAK,CAAC;IA8B5C,IAAI,CAAC,GAAG,EAAE,GAAG,GAAG,GAAG;IAkDnB,WAAW,CAAC,GAAG,EAAE,GAAG,GAAG,cAAc;IAoBrC,MAAM,CAAC,GAAG,EAAE,GAAG,GAAG,OAAO;IAQzB,MAAM,CAAC,GAAG,EAAE,GAAG,GAAG,IAAI;IAItB,KAAK,IAAI,IAAI;CAGrB"}

package/dist/src/destinations/memory-storage.js

@@ -0,0 +1,113 @@
+import getType from "type-name";
+import { TypeError } from "../core/errors.js";
+class Chunks extends Array {
+}
+function isTypedArray(x) {
+    return ArrayBuffer.isView(x) && !(x instanceof DataView);
+}
+function isArrayBuffer(x) {
+    return x instanceof ArrayBuffer;
+}
+export default class MemoryStorage {
+    constructor() {
+        this.isOpen = true;
+        this.store = new Map();
+    }
+    write(key, data) {
+        this.store.set(key, data);
+    }
+    getWritable(key) {
+        const chunks = new Chunks();
+        let firstChunk = null;
+        return new WritableStream({
+            write: (chunk) => {
+                if (!isTypedArray(chunk) && !isArrayBuffer(chunk)) {
+                    throw new TypeError({
+                        actualValue: chunk,
+                        expectedType: "ArrayBuffer | TypedArray",
+                    });
+                }
+                if (firstChunk === null) {
+                    firstChunk = chunk;
+                }
+                else if (!(chunk instanceof firstChunk.constructor)) {
+                    throw new TypeError({
+                        actualValue: chunk,
+                        expectedType: getType(firstChunk),
+                    });
+                }
+                chunks.push(chunk);
+            },
+            close: () => {
+                this.store.set(key, chunks);
+            },
+        });
+    }
+    read(key) {
+        const data = this.store.get(key);
+        if (data instanceof Chunks) {
+            if (data.length === 0) {
+                return null;
+            }
+            const firstChunk = data[0];
+            if (isTypedArray(firstChunk)) {
+                const chunks = data;
+                const Constructor = firstChunk.constructor;
+                const totalLength = chunks.reduce((len, chunk) => len + chunk.length, 0);
+                const mergedArray = new Constructor(totalLength);
+                let offset = 0;
+                for (const chunk of chunks) {
+                    mergedArray.set(chunk, offset);
+                    offset += chunk.length;
+                }
+                return mergedArray;
+            }
+            if (isArrayBuffer(firstChunk)) {
+                const chunks = data;
+                const totalLength = data.reduce((len, chunk) => len + chunk.byteLength, 0);
+                const mergedArray = new Uint8Array(totalLength);
+                let offset = 0;
+                for (const chunk of chunks) {
+                    mergedArray.set(new Uint8Array(chunk), offset);
+                    offset += chunk.byteLength;
+                }
+                return mergedArray.buffer;
+            }
+            throw new TypeError({
+                actualValue: firstChunk,
+                expectedType: "ArrayBuffer | TypedArray",
+            });
+        }
+        return data;
+    }
+    getReadable(key) {
+        const data = this.store.get(key);
+        return new ReadableStream({
+            start(controller) {
+                if (data !== undefined) {
+                    if (data instanceof Chunks) {
+                        for (const chunk of data) {
+                            controller.enqueue(chunk);
+                        }
+                    }
+                    else {
+                        controller.enqueue(data);
+                    }
+                }
+                controller.close();
+            },
+        });
+    }
+    exists(key) {
+        return this.store.has(key);
+    }
+    // public keys(): Iterable<Key> {
+    //   return this.store.keys();
+    // }
+    delete(key) {
+        this.store.delete(key);
+    }
+    clear() {
+        this.store.clear();
+    }
+}

package/dist/src/types/storage.d.ts

@@ -0,0 +1,5 @@
+export type { Context } from "../core/context.types.js";
+export type { IPlugin } from "../core/plugin.types.js";
+export type { MaybePromise } from "../core/utils.types.js";
+export type * from "../core/storage.types.js";
+//# sourceMappingURL=storage.d.ts.map

package/dist/src/types/storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.d.ts","sourceRoot":"","sources":["../../../src/types/storage.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAC;AACxD,YAAY,EAAE,OAAO,EAAE,MAAM,yBAAyB,CAAC;AACvD,YAAY,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAE3D,mBAAmB,0BAA0B,CAAC"}

package/dist/src/types/storage.js

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

package/dist/src/types/transformer.d.ts

@@ -0,0 +1,5 @@
+export type { Context } from "../core/context.types.js";
+export type { IPlugin } from "../core/plugin.types.js";
+export type { MaybePromise } from "../core/utils.types.js";
+export type * from "../core/transformer.types.js";
+//# sourceMappingURL=transformer.d.ts.map

package/dist/src/types/transformer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transformer.d.ts","sourceRoot":"","sources":["../../../src/types/transformer.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAC;AACxD,YAAY,EAAE,OAAO,EAAE,MAAM,yBAAyB,CAAC;AACvD,YAAY,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAE3D,mBAAmB,8BAA8B,CAAC"}

package/dist/src/types/transformer.js

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

package/package.json

@@ -1,10 +1,73 @@
 {
   "name": "unikvs",
-  "version": "0.0.2",
-  "description": "OIDC trusted publishing setup package for unikvs",
+  "version": "0.0.3",
+  "description": "",
   "keywords": [
-    "oidc",
-    "trusted-publishing",
-    "setup"
-  ]
+    "kv",
+    "kvs"
+  ],
+  "homepage": "https://github.com/tai-kun/unikvs",
+  "license": "MIT",
+  "author": "tai-kun",
+  "repository": {
+    "url": "https://github.com/tai-kun/unikvs"
+  },
+  "files": [
+    "dist",
+    "src",
+    "package.json",
+    "LICENSE"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/src/core/index.js",
+  "module": "./dist/src/core/index.js",
+  "types": "./dist/src/core/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/src/core/index.d.ts",
+      "import": "./dist/src/core/index.js",
+      "require": "./dist/src/core/index.js"
+    },
+    "./storage/memory": {
+      "types": "./dist/src/destinations/memory-storage.d.ts",
+      "import": "./dist/src/destinations/memory-storage.js",
+      "require": "./dist/src/destinations/memory-storage.js"
+    },
+    "./types/storage": {
+      "types": "./dist/src/types/storage.d.ts",
+      "import": "./dist/src/types/storage.js",
+      "require": "./dist/src/types/storage.js"
+    },
+    "./types/transformer": {
+      "types": "./dist/src/types/transformer.d.ts",
+      "import": "./dist/src/types/transformer.js",
+      "require": "./dist/src/types/transformer.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc --project ./.config/tsconfig.build.json"
+  },
+  "dependencies": {
+    "@logtape/logtape": "^2.0.5",
+    "asyncmux": "^0.0.5",
+    "i18n-error-base": "^0.0.3",
+    "type-name": "^2.0.2"
+  },
+  "devDependencies": {
+    "@tsconfig/node22": "^22.0.5",
+    "@tsconfig/strictest": "^2.0.8",
+    "@types/filename-reserved-regex": "^3.0.0",
+    "@types/node": "^22.19.17",
+    "@types/type-name": "^1.0.32",
+    "@vitest/browser": "^4.1.2",
+    "@vitest/browser-playwright": "^4.1.2",
+    "npm-check-updates": "^20.0.0",
+    "oxfmt": "^0.44.0",
+    "oxlint": "^1.59.0",
+    "oxlint-tsgolint": "^0.20.0",
+    "playwright": "^1.59.1",
+    "typescript": "^6.0.2",
+    "vitest": "^4.1.2"
+  }
 }

package/src/core/_assign-context.ts

@@ -0,0 +1,5 @@
+import type { Context } from "./context.types.js";
+
+export default function assignContext(target: Context, source: Readonly<Context>): void {
+  Object.assign(target, source);
+}

package/src/core/_combine-signals.ts

@@ -0,0 +1,40 @@
+let combineSignals: (signals: readonly (AbortSignal | null | undefined)[]) => AbortSignal;
+
+if ("any" in AbortSignal && typeof AbortSignal.any === "function") {
+  const AbortSignalAny = AbortSignal.any.bind(AbortSignal);
+  combineSignals = function combineSignals(inputSignals) {
+    const signals = inputSignals.filter((s) => s != null);
+    return AbortSignalAny(signals);
+  };
+} else {
+  combineSignals = function combineSignals(inputSignals) {
+    const ac = new AbortController();
+    const signals: AbortSignal[] = [];
+
+    for (const signal of inputSignals) {
+      if (signal?.aborted) {
+        ac.abort(signal.reason);
+        return ac.signal;
+      }
+
+      if (signal) {
+        signals.push(signal);
+      }
+    }
+
+    function handleAbort(this: AbortSignal): void {
+      ac.abort(this.reason);
+      for (const signal of signals) {
+        signal.removeEventListener("abort", handleAbort);
+      }
+    }
+
+    for (const signal of signals) {
+      signal.addEventListener("abort", handleAbort, { once: true });
+    }
+
+    return ac.signal;
+  };
+}
+
+export default combineSignals;

package/src/core/_is-iterable.ts

@@ -0,0 +1,3 @@
+export default function isIterable(o: object): o is Iterable<unknown> | AsyncIterable<unknown> {
+  return Symbol.iterator in o || Symbol.asyncIterator in o;
+}

package/src/core/_is-plain-object.ts

@@ -0,0 +1,11 @@
+const ObjectConstructor = Object;
+
+// oxlint-disable typescript-eslint/unbound-method
+const ObjectToString = ObjectConstructor.prototype.toString;
+
+export default function isPlainObject(value: any): value is Record<keyof any, unknown> {
+  return (
+    ObjectToString.call(value) === "[object Object]" &&
+    (value.constructor === ObjectConstructor || value.constructor === undefined)
+  );
+}

package/src/core/_logger.ts

@@ -0,0 +1,5 @@
+import { getLogger } from "@logtape/logtape";
+
+const log = /*#__PURE__*/ getLogger("unikvs");
+
+export default log;

package/src/core/_merge-context.ts

@@ -0,0 +1,9 @@
+import toContext from "./_to-context.js";
+import type { Context, ContextSource } from "./context.types.js";
+
+export default function mergeContext(
+  a: Readonly<Context>,
+  b: Readonly<Context> | ContextSource | undefined,
+): Context {
+  return b ? { ...a, ...toContext(b) } : a;
+}

package/src/core/_to-context.ts

@@ -0,0 +1,59 @@
+import isIterable from "./_is-iterable.js";
+import isPlainObject from "./_is-plain-object.js";
+import type { Context, ContextKeyValuePair, ContextSource } from "./context.types.js";
+import { TypeError } from "./errors.js";
+
+function isValidKeyValuePair(x: unknown): x is ContextKeyValuePair {
+  return (
+    Array.isArray(x) &&
+    x.length === 2 &&
+    (typeof x[0] === "string" || typeof x[0] === "number" || typeof x[0] === "symbol") &&
+    1 in x
+  );
+}
+
+function iterableToContext(iterable: Iterable<ContextKeyValuePair>): Context {
+  const ctx: Context = {};
+  for (const item of iterable) {
+    if (!isValidKeyValuePair(item)) {
+      throw new TypeError({
+        actualValue: item satisfies never,
+        expectedType: "ContextKeyValuePair",
+      });
+    }
+
+    const [key, value] = item;
+    ctx[key] = value;
+  }
+
+  return ctx;
+}
+
+function contextToContext(ctx: Readonly<Context>, copy: boolean): Readonly<Context> {
+  if (copy) {
+    ctx = { ...ctx };
+  }
+
+  return ctx;
+}
+
+function toContext(source: ContextSource, options: { copy: true }): Context;
+
+function toContext(source: ContextSource): Readonly<Context>;
+
+function toContext(source: ContextSource, options: { copy: boolean } = { copy: false }) {
+  if (isIterable(source)) {
+    return iterableToContext(source);
+  }
+
+  if (isPlainObject(source)) {
+    return contextToContext(source, options.copy);
+  }
+
+  throw new TypeError({
+    actualValue: source satisfies never,
+    expectedType: "ContextSource",
+  });
+}
+
+export default toContext;

package/src/core/_to-value-stream.ts

@@ -0,0 +1,41 @@
+import log from "./_logger.js";
+import type { IReadableStream } from "./storage.types.js";
+import type { ValueStream } from "./value-stream.types.js";
+
+export default function toValueStream<T>(r: IReadableStream<T>): ValueStream<T> {
+  if (Symbol.asyncIterator in r) {
+    return r;
+  }
+
+  return Object.assign(r, {
+    async *[Symbol.asyncIterator](this: IReadableStream<T>) {
+      const r = this.getReader();
+      try {
+        while (true) {
+          const { done, value } = await r.read();
+          if (done) {
+            break;
+          }
+
+          yield value;
+        }
+      } catch (ex) {
+        try {
+          await r.cancel(ex);
+        } catch (ex) {
+          log.error`Failed to cancel reader: ${ex}`;
+        }
+
+        throw ex;
+      } finally {
+        try {
+          r.releaseLock();
+        } catch (ex) {
+          log.error`Failed to release reader's lock: ${ex}`;
+        }
+      }
+
+      return undefined;
+    },
+  });
+}

package/src/core/_with-readable-stream-from.ts

@@ -0,0 +1,70 @@
+import isIterable from "./_is-iterable.js";
+import log from "./_logger.js";
+import { TypeError } from "./errors.js";
+
+interface ReadableStreamWithFrom extends ReadableStream {
+  from<T>(iterable: Iterable<T> | AsyncIterable<T>): ReadableStream<T>;
+}
+
+export default function withReadableStreamFrom<T>(
+  cb: (ReadableStream: ReadableStreamWithFrom) => T,
+): T {
+  if ("from" in ReadableStream) {
+    return cb(ReadableStream as any);
+  }
+
+  try {
+    (ReadableStream as any).from = function ReadableStreamFrom<T>(
+      iterable: Iterable<T> | AsyncIterable<T>,
+    ): ReadableStream<T> {
+      if (!isIterable(iterable)) {
+        throw new TypeError({
+          actualValue: iterable satisfies never,
+          expectedType: "(Iterable | AsyncIterable)",
+        });
+      }
+
+      const iter: AsyncIterator<T> =
+        Symbol.asyncIterator in iterable
+          ? iterable[Symbol.asyncIterator]()
+          : (async function* (iterable) {
+              yield* iterable;
+            })(iterable);
+
+      let done = false;
+
+      return new ReadableStream<T>({
+        async pull(controller) {
+          if (done) {
+            return;
+          }
+
+          try {
+            const result = await iter.next();
+            if (result.done) {
+              done = true;
+              controller.close();
+            } else {
+              controller.enqueue(result.value);
+            }
+          } catch (ex) {
+            done = true;
+            controller.error(ex);
+          }
+        },
+        async cancel(reason) {
+          done = true;
+          try {
+            await iter.return?.(reason);
+          } catch (ex) {
+            log.error`Failed to close iterator: ${ex}`;
+          }
+        },
+      });
+    };
+
+    return cb(ReadableStream as any);
+  } finally {
+    delete (ReadableStream as any).from;
+  }
+}

package/src/core/context.types.ts

@@ -0,0 +1,7 @@
+import type { ValueOf } from "./utils.types.js";
+
+export type Context = Record<keyof any, unknown>;
+
+export type ContextKeyValuePair = readonly [key: keyof Context, value: ValueOf<Context>];
+
+export type ContextSource = Readonly<Context> | Iterable<ContextKeyValuePair>;

package/src/core/errors.ts

@@ -0,0 +1,37 @@
+import { type ErrorMeta, I18nErrorBase, setErrorMessage } from "i18n-error-base";
+import getTypeName from "type-name";
+
+export { setErrorMessage };
+
+export class ErrorBase<
+  TMeta extends ErrorMeta | undefined = ErrorMeta | undefined,
+> extends I18nErrorBase<TMeta> {}
+
+export type TypeErrorMeta = {
+  expectedType: string;
+  actualValue: unknown;
+  actualType: string;
+};
+
+export class TypeError extends ErrorBase<TypeErrorMeta> {
+  static {
+    this.prototype.name = "UniKvsTypeError";
+  }
+
+  public constructor(meta: Readonly<Pick<TypeErrorMeta, "expectedType" | "actualValue">>) {
+    super(
+      {
+        actualType: getTypeName(meta.actualValue),
+        actualValue: meta.actualValue,
+        expectedType: meta.expectedType,
+      },
+      ({ expectedType, actualType }) => `Expected type ${expectedType}, but got ${actualType}`,
+    );
+  }
+}
+
+/*#__PURE__*/ setErrorMessage(
+  TypeError,
+  ({ expectedType, actualType }) => `型 ${expectedType} を期待しましたが、${actualType} を得ました`,
+  "ja",
+);

package/src/core/index.ts

@@ -0,0 +1,23 @@
+export type * from "./context.types.js";
+
+export type { TypeErrorMeta } from "./errors.js";
+export { setErrorMessage, TypeError, ErrorBase } from "./errors.js";
+
+export type * from "./plugin.types.js";
+
+export type * from "./storage.types.js";
+
+export type * from "./to-readable-stream.js";
+export { default as toReadableStream } from "./to-readable-stream.js";
+
+export type * from "./transformer.types.js";
+
+export type * from "./unikvs-config.js";
+export { default as UniKvsConfig } from "./unikvs-config.js";
+
+export type * from "./unikvs.js";
+export { default as UniKvs } from "./unikvs.js";
+
+export type * from "./utils.types.js";
+
+export type * from "./value-stream.types.js";

package/src/core/plugin.types.ts

@@ -0,0 +1,10 @@
+import type { Context } from "./context.types.js";
+import type { MaybePromise } from "./utils.types.js";
+
+export interface IPlugin {
+  readonly isOpen: boolean;
+
+  open?(signal: AbortSignal, context: Context): MaybePromise<void>;
+
+  close?(signal: AbortSignal, context: Context): MaybePromise<void>;
+}

package/src/core/storage.types.ts

@@ -0,0 +1,53 @@
+import type { Context } from "./context.types.js";
+import type { IPlugin } from "./plugin.types.js";
+import type { MaybePromise } from "./utils.types.js";
+
+export type Key = string;
+
+export interface IWritableStream<TData = any> extends WritableStream<TData> {}
+
+export interface IWritableStreamStorage<TData = any> {
+  getWritable(
+    key: Key,
+    signal: AbortSignal,
+    context: Context,
+  ): MaybePromise<IWritableStream<TData>>;
+}
+
+export interface IReadableStream<TData = any> extends ReadableStream<TData> {}
+
+export interface IReadableStreamStorage<TData = any> {
+  getReadable(
+    key: Key,
+    signal: AbortSignal,
+    context: Context,
+  ): MaybePromise<IReadableStream<TData>>;
+}
+
+export interface IStorage<
+  TWriteDataInput = any,
+  TReadDataOutput = TWriteDataInput,
+  TWriteChunkInput = TWriteDataInput extends ArrayBufferLike | ArrayBufferView
+    ? TWriteDataInput
+    : any,
+  TReadChunkOutput = TWriteChunkInput,
+>
+  extends
+    IPlugin,
+    Partial<IWritableStreamStorage<TWriteChunkInput>>,
+    Partial<IReadableStreamStorage<TReadChunkOutput>> {
+  write(key: Key, data: TWriteDataInput, signal: AbortSignal, context: Context): MaybePromise<void>;
+
+  read(key: Key, signal: AbortSignal, context: Context): MaybePromise<TReadDataOutput>;
+
+  exists(key: Key, signal: AbortSignal, context: Context): MaybePromise<boolean>;
+
+  // keys(
+  //   signal: AbortSignal,
+  //   context: Context,
+  // ): MaybePromise<AsyncIterable<Key> | Iterable<MaybePromise<Key>> | ArrayLike<MaybePromise<Key>>>;
+
+  delete(key: Key, signal: AbortSignal, context: Context): MaybePromise<void>;
+
+  clear(signal: AbortSignal, context: Context): MaybePromise<void>;
+}

package/src/core/to-readable-stream.ts

@@ -0,0 +1,7 @@
+import withReadableStreamFrom from "./_with-readable-stream-from.js";
+
+export default function toReadableStream<T>(
+  iterable: Iterable<T> | AsyncIterable<T>,
+): ReadableStream<T> {
+  return withReadableStreamFrom((ReadableStream) => ReadableStream.from(iterable));
+}