@unikvs/memory 0.0.1 → 0.0.4

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026-present, tai-kun
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/dist/src/errors.d.ts

@@ -0,0 +1,18 @@
+import { ErrorBase, type ErrorOptions } from "@unikvs/core";
+export type KeyNotFoundErrorMeta = {
+    readonly key: string;
+};
+export type KeyNotFoundErrorArgs = KeyNotFoundErrorMeta;
+export declare class KeyNotFoundError extends ErrorBase<KeyNotFoundErrorMeta> {
+    constructor(args: KeyNotFoundErrorArgs, options?: ErrorOptions);
+}
+export type InvalidChunkTypeErrorMeta = {
+    readonly key: string;
+    readonly chunk: unknown;
+    readonly chunkType: string;
+};
+export type InvalidChunkTypeErrorArgs = Omit<InvalidChunkTypeErrorMeta, "chunkType">;
+export declare class InvalidChunkTypeError extends ErrorBase<InvalidChunkTypeErrorMeta> {
+    constructor(args: InvalidChunkTypeErrorArgs, options?: ErrorOptions);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/src/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,KAAK,YAAY,EAAmB,MAAM,cAAc,CAAC;AAG7E,MAAM,MAAM,oBAAoB,GAAG;IACjC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG,oBAAoB,CAAC;AAExD,qBAAa,gBAAiB,SAAQ,SAAS,CAAC,oBAAoB,CAAC;gBAKhD,IAAI,EAAE,oBAAoB,EAAE,OAAO,CAAC,EAAE,YAAY;CAGtE;AAID,MAAM,MAAM,yBAAyB,GAAG;IACtC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG,IAAI,CAAC,yBAAyB,EAAE,WAAW,CAAC,CAAC;AAErF,qBAAa,qBAAsB,SAAQ,SAAS,CAAC,yBAAyB,CAAC;gBAK1D,IAAI,EAAE,yBAAyB,EAAE,OAAO,CAAC,EAAE,YAAY;CAW3E"}

package/dist/src/errors.js

@@ -0,0 +1,26 @@
+var _a, _b;
+import { ErrorBase, setErrorMessage } from "@unikvs/core";
+import getTypeName from "type-name";
+export class KeyNotFoundError extends ErrorBase {
+    constructor(args, options) {
+        super(args, ({ key }) => `Key not found: ${key}`, options);
+    }
+}
+_a = KeyNotFoundError;
+(() => {
+    _a.prototype.name = "MemoryKeyNotFoundError";
+})();
+setErrorMessage(KeyNotFoundError, ({ key }) => `キー ${key} が見つかりません`, "ja");
+export class InvalidChunkTypeError extends ErrorBase {
+    constructor(args, options) {
+        super({
+            ...args,
+            chunkType: getTypeName(args.chunk),
+        }, ({ key, chunkType }) => `Expected chunk for key ${JSON.stringify(key)} is Uint8Array<ArrayBuffer>, but got ${chunkType}`, options);
+    }
+}
+_b = InvalidChunkTypeError;
+(() => {
+    _b.prototype.name = "MemoryInvalidChunkTypeError";
+})();
+setErrorMessage(InvalidChunkTypeError, ({ key, chunkType }) => `キー ${JSON.stringify(key)} のチャンク型に Uint8Array<ArrayBuffer> を期待しましたが、${chunkType} を得ました`, "ja");

package/dist/src/memory.d.ts

@@ -0,0 +1,21 @@
+import type { IStorage } from "@unikvs/core";
+/**
+ * メモリーを永続化先として使用するストレージクラスです。
+ */
+export default class Memory implements IStorage {
+    private readonly map;
+    readonly name: string;
+    /**
+     * Memory インスタンスを初期化します。
+     */
+    constructor();
+    get isOpen(): boolean;
+    write(args: Pick<IStorage.WriteArgs<any>, "key" | "data">): void;
+    read(args: Pick<IStorage.ReadArgs, "key">): any;
+    exists(args: Pick<IStorage.ExistsArgs, "key">): boolean;
+    delete(args: Pick<IStorage.DeleteArgs, "key">): void;
+    clear(): void;
+    getWritable(args: Pick<IStorage.GetWritableArgs, "key">): WritableStream<Uint8Array<ArrayBuffer>>;
+    getReadable(args: Pick<IStorage.GetReadableArgs, "key">): ReadableStream<Uint8Array<ArrayBuffer>>;
+}
+//# sourceMappingURL=memory.d.ts.map

package/dist/src/memory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../../src/memory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAI7C;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,MAAO,YAAW,QAAQ;IAC7C,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAmB;IAEvC,SAAgB,IAAI,EAAE,MAAM,CAAC;IAE7B;;OAEG;;IAMH,IAAW,MAAM,IAAI,OAAO,CAE3B;IAEM,KAAK,CAAC,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,GAAG,CAAC,EAAE,KAAK,GAAG,MAAM,CAAC,GAAG,IAAI;IAKhE,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC,QAAQ,EAAE,KAAK,CAAC,GAAG,GAAG;IAW/C,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC,UAAU,EAAE,KAAK,CAAC,GAAG,OAAO;IAOvD,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC,UAAU,EAAE,KAAK,CAAC,GAAG,IAAI;IASpD,KAAK,IAAI,IAAI;IAIb,WAAW,CAChB,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC,eAAe,EAAE,KAAK,CAAC,GAC1C,cAAc,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC;IA4BnC,WAAW,CAChB,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC,eAAe,EAAE,KAAK,CAAC,GAC1C,cAAc,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC;CAoB3C"}

package/dist/src/memory.js

@@ -0,0 +1,83 @@
+import { InvalidChunkTypeError, KeyNotFoundError } from "./errors.js";
+/**
+ * メモリーを永続化先として使用するストレージクラスです。
+ */
+export default class Memory {
+    /**
+     * Memory インスタンスを初期化します。
+     */
+    constructor() {
+        this.name = "Memory";
+        this.map = new Map();
+    }
+    get isOpen() {
+        return true;
+    }
+    write(args) {
+        const { key, data } = args;
+        this.map.set(key, data);
+    }
+    read(args) {
+        const { key } = args;
+        if (!this.map.has(key)) {
+            throw new KeyNotFoundError({ key });
+        }
+        const value = this.map.get(key);
+        return value;
+    }
+    exists(args) {
+        const { key } = args;
+        const exists = this.map.has(key);
+        return exists;
+    }
+    delete(args) {
+        const { key } = args;
+        if (!this.map.has(key)) {
+            throw new KeyNotFoundError({ key });
+        }
+        this.map.delete(key);
+    }
+    clear() {
+        this.map.clear();
+    }
+    getWritable(args) {
+        const { key } = args;
+        const chunks = [];
+        const stream = new WritableStream({
+            write: (chunk) => {
+                if (!(chunk instanceof Uint8Array)) {
+                    throw new InvalidChunkTypeError({ key, chunk });
+                }
+                chunks.push(chunk);
+            },
+            close: () => {
+                const totalLength = chunks.reduce((sum, c) => sum + c.byteLength, 0);
+                const merged = new Uint8Array(totalLength);
+                let offset = 0;
+                for (const c of chunks) {
+                    merged.set(c, offset);
+                    offset += c.byteLength;
+                }
+                this.map.set(key, merged);
+            },
+        });
+        return stream;
+    }
+    getReadable(args) {
+        const { key } = args;
+        if (!this.map.has(key)) {
+            throw new KeyNotFoundError({ key });
+        }
+        const value = this.map.get(key);
+        const stream = new ReadableStream({
+            pull: (controller) => {
+                if (!(value instanceof Uint8Array)) {
+                    throw new InvalidChunkTypeError({ key, chunk: value });
+                }
+                controller.enqueue(value);
+                controller.close();
+            },
+        });
+        return stream;
+    }
+}

package/package.json

@@ -1,10 +1,48 @@
 {
   "name": "@unikvs/memory",
-  "version": "0.0.1",
-  "description": "OIDC trusted publishing setup package for @unikvs/memory",
-  "keywords": [
-    "oidc",
-    "trusted-publishing",
-    "setup"
-  ]
+  "version": "0.0.4",
+  "description": "",
+  "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/index.js",
+  "types": "./dist/src/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "default": "./dist/src/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc --project ./.config/tsconfig.build.json"
+  },
+  "dependencies": {
+    "@unikvs/core": "0.0.4",
+    "type-name": "^2.0.2"
+  },
+  "devDependencies": {
+    "@tsconfig/node22": "^22.0.5",
+    "@tsconfig/strictest": "^2.0.8",
+    "@types/node": "^22.19.17",
+    "@types/type-name": "^1.0.32",
+    "@vitest/browser": "^4.1.4",
+    "@vitest/browser-playwright": "^4.1.4",
+    "npm-check-updates": "^20.0.2",
+    "playwright": "^1.59.1",
+    "vitest": "^4.1.4"
+  },
+  "peerDependencies": {
+    "@logtape/logtape": "^2.0.0"
+  }
 }

package/src/errors.ts

@@ -0,0 +1,53 @@
+import { ErrorBase, type ErrorOptions, setErrorMessage } from "@unikvs/core";
+import getTypeName from "type-name";
+
+export type KeyNotFoundErrorMeta = {
+  readonly key: string;
+};
+
+export type KeyNotFoundErrorArgs = KeyNotFoundErrorMeta;
+
+export class KeyNotFoundError extends ErrorBase<KeyNotFoundErrorMeta> {
+  static {
+    this.prototype.name = "MemoryKeyNotFoundError";
+  }
+
+  public constructor(args: KeyNotFoundErrorArgs, options?: ErrorOptions) {
+    super(args, ({ key }) => `Key not found: ${key}`, options);
+  }
+}
+
+setErrorMessage(KeyNotFoundError, ({ key }) => `キー ${key} が見つかりません`, "ja");
+
+export type InvalidChunkTypeErrorMeta = {
+  readonly key: string;
+  readonly chunk: unknown;
+  readonly chunkType: string;
+};
+
+export type InvalidChunkTypeErrorArgs = Omit<InvalidChunkTypeErrorMeta, "chunkType">;
+
+export class InvalidChunkTypeError extends ErrorBase<InvalidChunkTypeErrorMeta> {
+  static {
+    this.prototype.name = "MemoryInvalidChunkTypeError";
+  }
+
+  public constructor(args: InvalidChunkTypeErrorArgs, options?: ErrorOptions) {
+    super(
+      {
+        ...args,
+        chunkType: getTypeName(args.chunk),
+      },
+      ({ key, chunkType }) =>
+        `Expected chunk for key ${JSON.stringify(key)} is Uint8Array<ArrayBuffer>, but got ${chunkType}`,
+      options,
+    );
+  }
+}
+
+setErrorMessage(
+  InvalidChunkTypeError,
+  ({ key, chunkType }) =>
+    `キー ${JSON.stringify(key)} のチャンク型に Uint8Array<ArrayBuffer> を期待しましたが、${chunkType} を得ました`,
+  "ja",
+);

package/src/memory.ts

@@ -0,0 +1,113 @@
+import type { IStorage } from "@unikvs/core";
+
+import { InvalidChunkTypeError, KeyNotFoundError } from "./errors.js";
+
+/**
+ * メモリーを永続化先として使用するストレージクラスです。
+ */
+export default class Memory implements IStorage {
+  private readonly map: Map<string, any>;
+
+  public readonly name: string;
+
+  /**
+   * Memory インスタンスを初期化します。
+   */
+  public constructor() {
+    this.name = "Memory";
+    this.map = new Map();
+  }
+
+  public get isOpen(): boolean {
+    return true;
+  }
+
+  public write(args: Pick<IStorage.WriteArgs<any>, "key" | "data">): void {
+    const { key, data } = args;
+    this.map.set(key, data);
+  }
+
+  public read(args: Pick<IStorage.ReadArgs, "key">): any {
+    const { key } = args;
+    if (!this.map.has(key)) {
+      throw new KeyNotFoundError({ key });
+    }
+
+    const value = this.map.get(key);
+
+    return value;
+  }
+
+  public exists(args: Pick<IStorage.ExistsArgs, "key">): boolean {
+    const { key } = args;
+    const exists = this.map.has(key);
+
+    return exists;
+  }
+
+  public delete(args: Pick<IStorage.DeleteArgs, "key">): void {
+    const { key } = args;
+    if (!this.map.has(key)) {
+      throw new KeyNotFoundError({ key });
+    }
+
+    this.map.delete(key);
+  }
+
+  public clear(): void {
+    this.map.clear();
+  }
+
+  public getWritable(
+    args: Pick<IStorage.GetWritableArgs, "key">,
+  ): WritableStream<Uint8Array<ArrayBuffer>> {
+    const { key } = args;
+    const chunks: Uint8Array[] = [];
+    const stream = new WritableStream<Uint8Array<ArrayBuffer>>({
+      write: (chunk) => {
+        if (!(chunk instanceof Uint8Array)) {
+          throw new InvalidChunkTypeError({ key, chunk });
+        }
+
+        chunks.push(chunk);
+      },
+      close: () => {
+        const totalLength = chunks.reduce((sum, c) => sum + c.byteLength, 0);
+        const merged = new Uint8Array(totalLength);
+
+        let offset = 0;
+        for (const c of chunks) {
+          merged.set(c, offset);
+          offset += c.byteLength;
+        }
+
+        this.map.set(key, merged);
+      },
+    });
+
+    return stream;
+  }
+
+  public getReadable(
+    args: Pick<IStorage.GetReadableArgs, "key">,
+  ): ReadableStream<Uint8Array<ArrayBuffer>> {
+    const { key } = args;
+    if (!this.map.has(key)) {
+      throw new KeyNotFoundError({ key });
+    }
+
+    const value = this.map.get(key);
+    const stream = new ReadableStream<Uint8Array<ArrayBuffer>>({
+      pull: (controller) => {
+        if (!(value instanceof Uint8Array)) {
+          throw new InvalidChunkTypeError({ key, chunk: value });
+        }
+
+        controller.enqueue(value as Uint8Array<ArrayBuffer>);
+        controller.close();
+      },
+    });
+
+    return stream;
+  }
+}

package/README.md

@@ -1,45 +0,0 @@
-# @unikvs/memory
-
-## ⚠️ IMPORTANT NOTICE ⚠️
-
-**This package is created solely for the purpose of setting up OIDC (OpenID Connect) trusted publishing with npm.**
-
-This is **NOT** a functional package and contains **NO** code or functionality beyond the OIDC setup configuration.
-
-## Purpose
-
-This package exists to:
-1. Configure OIDC trusted publishing for the package name `@unikvs/memory`
-2. Enable secure, token-less publishing from CI/CD workflows
-3. Establish provenance for packages published under this name
-
-## What is OIDC Trusted Publishing?
-
-OIDC trusted publishing allows package maintainers to publish packages directly from their CI/CD workflows without needing to manage npm access tokens. Instead, it uses OpenID Connect to establish trust between the CI/CD provider (like GitHub Actions) and npm.
-
-## Setup Instructions
-
-To properly configure OIDC trusted publishing for this package:
-
-1. Go to [npmjs.com](https://www.npmjs.com/) and navigate to your package settings
-2. Configure the trusted publisher (e.g., GitHub Actions)
-3. Specify the repository and workflow that should be allowed to publish
-4. Use the configured workflow to publish your actual package
-
-## DO NOT USE THIS PACKAGE
-
-This package is a placeholder for OIDC configuration only. It:
-- Contains no executable code
-- Provides no functionality
-- Should not be installed as a dependency
-- Exists only for administrative purposes
-
-## More Information
-
-For more details about npm's trusted publishing feature, see:
-- [npm Trusted Publishing Documentation](https://docs.npmjs.com/generating-provenance-statements)
-- [GitHub Actions OIDC Documentation](https://docs.github.com/en/actions/deployment/security-hardening-your-deployments/about-security-hardening-with-openid-connect)
-
----
-
-**Maintained for OIDC setup purposes only**