unikvs 0.0.2 → 0.0.3

package/src/core/utils.types.ts

@@ -0,0 +1,3 @@
+export type ValueOf<T> = T[keyof T];
+
+export type MaybePromise<T> = T | PromiseLike<T>;

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

@@ -0,0 +1,3 @@
+export interface ValueStream<T> extends ReadableStream<T> {
+  [Symbol.asyncIterator](): AsyncIteratorObject<T, undefined, unknown>;
+}

package/src/destinations/memory-storage.ts

@@ -0,0 +1,160 @@
+import getType from "type-name";
+
+import { TypeError } from "../core/errors.js";
+import type { IStorage, Key } from "../core/storage.types.js";
+
+// https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Global_Objects/TypedArray#typedarray_%E3%82%AA%E3%83%96%E3%82%B8%E3%82%A7%E3%82%AF%E3%83%88
+type TypedArray =
+  | Int8Array
+  | Uint8Array
+  | Uint8ClampedArray
+  | Int16Array
+  | Uint16Array
+  | Int32Array
+  | Uint32Array
+  | Float32Array
+  | Float64Array
+  | BigInt64Array
+  | BigUint64Array;
+
+type Chunk = ArrayBuffer | TypedArray;
+
+class Chunks extends Array<Chunk> {}
+
+function isTypedArray(x: unknown): x is TypedArray {
+  return ArrayBuffer.isView(x) && !(x instanceof DataView);
+}
+
+function isArrayBuffer(x: unknown): x is ArrayBuffer {
+  return x instanceof ArrayBuffer;
+}
+
+export default class MemoryStorage implements IStorage {
+  public readonly isOpen: boolean = true;
+
+  private store: Map<Key, any>;
+
+  public constructor() {
+    this.store = new Map();
+  }
+
+  public write(key: Key, data: any): void {
+    this.store.set(key, data);
+  }
+
+  public getWritable(key: Key): WritableStream<Chunk> {
+    const chunks = new Chunks();
+    let firstChunk: Chunk | null = null;
+
+    return new WritableStream({
+      write: (chunk) => {
+        if (!isTypedArray(chunk) && !isArrayBuffer(chunk)) {
+          throw new TypeError({
+            actualValue: chunk satisfies never,
+            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);
+      },
+    });
+  }
+
+  public read(key: Key): any {
+    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 as TypedArray[];
+
+        const Constructor = firstChunk.constructor as { new (n: number): TypedArray };
+        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 as any, offset);
+          offset += chunk.length;
+        }
+
+        return mergedArray;
+      }
+
+      if (isArrayBuffer(firstChunk)) {
+        const chunks = data as ArrayBuffer[];
+
+        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 satisfies never,
+        expectedType: "ArrayBuffer | TypedArray",
+      });
+    }
+
+    return data;
+  }
+
+  public getReadable(key: Key): ReadableStream {
+    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();
+      },
+    });
+  }
+
+  public exists(key: Key): boolean {
+    return this.store.has(key);
+  }
+
+  // public keys(): Iterable<Key> {
+  //   return this.store.keys();
+  // }
+
+  public delete(key: Key): void {
+    this.store.delete(key);
+  }
+
+  public clear(): void {
+    this.store.clear();
+  }
+}

package/src/types/storage.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";

package/src/types/transformer.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";

package/README.md

@@ -1,45 +0,0 @@
-# unikvs
-
-## ⚠️ 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`
-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**