npm - @quantum-hub/qhub-api - Versions diffs - 1.0.4 - Mend

@quantum-hub/qhub-api 1.0.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (813) hide show

package/src/api/platform/core/form-data-utils/FormDataWrapper.ts ADDED Viewed

@@ -0,0 +1,140 @@
+import { toMultipartDataPart, type Uploadable } from "../../core/file/index.js";
+import { toJson } from "../../core/json.js";
+import { RUNTIME } from "../runtime/index.js";
+interface FormDataRequest<Body> {
+    body: Body;
+    headers: Record<string, string>;
+    duplex?: "half";
+}
+export async function newFormData(): Promise<FormDataWrapper> {
+    return new FormDataWrapper();
+}
+export class FormDataWrapper {
+    private fd: FormData = new FormData();
+    public async setup(): Promise<void> {
+        // noop
+    }
+    public append(key: string, value: unknown): void {
+        this.fd.append(key, String(value));
+    }
+    public async appendFile(key: string, value: Uploadable): Promise<void> {
+        const { data, filename, contentType } = await toMultipartDataPart(value);
+        const blob = await convertToBlob(data, contentType);
+        if (filename) {
+            this.fd.append(key, blob, filename);
+        } else {
+            this.fd.append(key, blob);
+        }
+    }
+    public getRequest(): FormDataRequest<FormData> {
+        return {
+            body: this.fd,
+            headers: {},
+            duplex: "half" as const,
+        };
+    }
+}
+type StreamLike = {
+    read?: () => unknown;
+    pipe?: (dest: unknown) => unknown;
+} & unknown;
+function isStreamLike(value: unknown): value is StreamLike {
+    return typeof value === "object" && value != null && ("read" in value || "pipe" in value);
+}
+function isReadableStream(value: unknown): value is ReadableStream {
+    return typeof value === "object" && value != null && "getReader" in value;
+}
+function isBuffer(value: unknown): value is Buffer {
+    return typeof Buffer !== "undefined" && Buffer.isBuffer && Buffer.isBuffer(value);
+}
+function isArrayBufferView(value: unknown): value is ArrayBufferView {
+    return ArrayBuffer.isView(value);
+}
+async function streamToBuffer(stream: unknown): Promise<Buffer> {
+    if (RUNTIME.type === "node") {
+        const { Readable } = await import("stream");
+        if (stream instanceof Readable) {
+            const chunks: Buffer[] = [];
+            for await (const chunk of stream) {
+                chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+            }
+            return Buffer.concat(chunks);
+        }
+    }
+    if (isReadableStream(stream)) {
+        const reader = stream.getReader();
+        const chunks: Uint8Array[] = [];
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done) break;
+                chunks.push(value);
+            }
+        } finally {
+            reader.releaseLock();
+        }
+        const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+        const result = new Uint8Array(totalLength);
+        let offset = 0;
+        for (const chunk of chunks) {
+            result.set(chunk, offset);
+            offset += chunk.length;
+        }
+        return Buffer.from(result);
+    }
+    throw new Error(
+        `Unsupported stream type: ${typeof stream}. Expected Node.js Readable stream or Web ReadableStream.`,
+    );
+}
+async function convertToBlob(value: unknown, contentType?: string): Promise<Blob> {
+    if (isStreamLike(value) || isReadableStream(value)) {
+        const buffer = await streamToBuffer(value);
+        return new Blob([buffer as unknown as Uint8Array<ArrayBuffer>], { type: contentType });
+    }
+    if (value instanceof Blob) {
+        return value;
+    }
+    if (isBuffer(value)) {
+        return new Blob([value as unknown as Uint8Array<ArrayBuffer>], { type: contentType });
+    }
+    if (value instanceof ArrayBuffer) {
+        return new Blob([value], { type: contentType });
+    }
+    if (isArrayBufferView(value)) {
+        return new Blob([value as unknown as Uint8Array<ArrayBuffer>], { type: contentType });
+    }
+    if (typeof value === "string") {
+        return new Blob([value], { type: contentType });
+    }
+    if (typeof value === "object" && value !== null) {
+        return new Blob([toJson(value)], { type: contentType ?? "application/json" });
+    }
+    return new Blob([String(value)], { type: contentType });
+}

package/src/api/platform/core/form-data-utils/encodeAsFormParameter.ts ADDED Viewed

@@ -0,0 +1,12 @@
+import { toQueryString } from "../url/qs.js";
+export function encodeAsFormParameter(value: unknown): Record<string, string> {
+    const stringified = toQueryString(value, { encode: false });
+    const keyValuePairs = stringified.split("&").map((pair) => {
+        const [key, value] = pair.split("=");
+        return [key, value] as const;
+    });
+    return Object.fromEntries(keyValuePairs);
+}

package/src/api/platform/core/form-data-utils/index.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ export { encodeAsFormParameter } from "./encodeAsFormParameter.js";
2	+ export * from "./FormDataWrapper.js";

package/src/api/platform/core/headers.ts ADDED Viewed

@@ -0,0 +1,33 @@
+export function mergeHeaders(...headersArray: (Record<string, unknown> | null | undefined)[]): Record<string, unknown> {
+    const result: Record<string, unknown> = {};
+    for (const [key, value] of headersArray
+        .filter((headers) => headers != null)
+        .flatMap((headers) => Object.entries(headers))) {
+        const insensitiveKey = key.toLowerCase();
+        if (value != null) {
+            result[insensitiveKey] = value;
+        } else if (insensitiveKey in result) {
+            delete result[insensitiveKey];
+        }
+    }
+    return result;
+}
+export function mergeOnlyDefinedHeaders(
+    ...headersArray: (Record<string, unknown> | null | undefined)[]
+): Record<string, unknown> {
+    const result: Record<string, unknown> = {};
+    for (const [key, value] of headersArray
+        .filter((headers) => headers != null)
+        .flatMap((headers) => Object.entries(headers))) {
+        const insensitiveKey = key.toLowerCase();
+        if (value != null) {
+            result[insensitiveKey] = value;
+        }
+    }
+    return result;
+}

package/src/api/platform/core/index.ts ADDED Viewed

@@ -0,0 +1,8 @@
+export * from "./auth/index.js";
+export * from "./base64.js";
+export * from "./fetcher/index.js";
+export * as file from "./file/index.js";
+export * from "./form-data-utils/index.js";
+export * as logging from "./logging/index.js";
+export * from "./runtime/index.js";
+export * as url from "./url/index.js";

package/src/api/platform/core/json.ts ADDED Viewed

@@ -0,0 +1,27 @@
+/**
+ * Serialize a value to JSON
+ * @param value A JavaScript value, usually an object or array, to be converted.
+ * @param replacer A function that transforms the results.
+ * @param space Adds indentation, white space, and line break characters to the return-value JSON text to make it easier to read.
+ * @returns JSON string
+ */
+export const toJson = (
+    value: unknown,
+    replacer?: (this: unknown, key: string, value: unknown) => unknown,
+    space?: string | number,
+): string => {
+    return JSON.stringify(value, replacer, space);
+};
+/**
+ * Parse JSON string to object, array, or other type
+ * @param text A valid JSON string.
+ * @param reviver A function that transforms the results. This function is called for each member of the object. If a member contains nested objects, the nested objects are transformed before the parent object is.
+ * @returns Parsed object, array, or other type
+ */
+export function fromJson<T = unknown>(
+    text: string,
+    reviver?: (this: unknown, key: string, value: unknown) => unknown,
+): T {
+    return JSON.parse(text, reviver);
+}

package/src/api/platform/core/logging/exports.ts ADDED Viewed

@@ -0,0 +1,19 @@
+import * as logger from "./logger.js";
+export namespace logging {
+    /**
+     * Configuration for logger instances.
+     */
+    export type LogConfig = logger.LogConfig;
+    export type LogLevel = logger.LogLevel;
+    export const LogLevel: typeof logger.LogLevel = logger.LogLevel;
+    export type ILogger = logger.ILogger;
+    /**
+     * Console logger implementation that outputs to the console.
+     */
+    export type ConsoleLogger = logger.ConsoleLogger;
+    /**
+     * Console logger implementation that outputs to the console.
+     */
+    export const ConsoleLogger: typeof logger.ConsoleLogger = logger.ConsoleLogger;
+}

package/src/api/platform/core/logging/index.ts ADDED Viewed

	@@ -0,0 +1 @@
1	+ export * from "./logger.js";

package/src/api/platform/core/logging/logger.ts ADDED Viewed

@@ -0,0 +1,203 @@
+export const LogLevel = {
+    Debug: "debug",
+    Info: "info",
+    Warn: "warn",
+    Error: "error",
+} as const;
+export type LogLevel = (typeof LogLevel)[keyof typeof LogLevel];
+const logLevelMap: Record<LogLevel, number> = {
+    [LogLevel.Debug]: 1,
+    [LogLevel.Info]: 2,
+    [LogLevel.Warn]: 3,
+    [LogLevel.Error]: 4,
+};
+export interface ILogger {
+    /**
+     * Logs a debug message.
+     * @param message - The message to log
+     * @param args - Additional arguments to log
+     */
+    debug(message: string, ...args: unknown[]): void;
+    /**
+     * Logs an info message.
+     * @param message - The message to log
+     * @param args - Additional arguments to log
+     */
+    info(message: string, ...args: unknown[]): void;
+    /**
+     * Logs a warning message.
+     * @param message - The message to log
+     * @param args - Additional arguments to log
+     */
+    warn(message: string, ...args: unknown[]): void;
+    /**
+     * Logs an error message.
+     * @param message - The message to log
+     * @param args - Additional arguments to log
+     */
+    error(message: string, ...args: unknown[]): void;
+}
+/**
+ * Configuration for logger initialization.
+ */
+export interface LogConfig {
+    /**
+     * Minimum log level to output.
+     * @default LogLevel.Info
+     */
+    level?: LogLevel;
+    /**
+     * Logger implementation to use.
+     * @default new ConsoleLogger()
+     */
+    logger?: ILogger;
+    /**
+     * Whether logging should be silenced.
+     * @default true
+     */
+    silent?: boolean;
+}
+/**
+ * Default console-based logger implementation.
+ */
+export class ConsoleLogger implements ILogger {
+    debug(message: string, ...args: unknown[]): void {
+        console.debug(message, ...args);
+    }
+    info(message: string, ...args: unknown[]): void {
+        console.info(message, ...args);
+    }
+    warn(message: string, ...args: unknown[]): void {
+        console.warn(message, ...args);
+    }
+    error(message: string, ...args: unknown[]): void {
+        console.error(message, ...args);
+    }
+}
+/**
+ * Logger class that provides level-based logging functionality.
+ */
+export class Logger {
+    private readonly level: number;
+    private readonly logger: ILogger;
+    private readonly silent: boolean;
+    /**
+     * Creates a new logger instance.
+     * @param config - Logger configuration
+     */
+    constructor(config: Required<LogConfig>) {
+        this.level = logLevelMap[config.level];
+        this.logger = config.logger;
+        this.silent = config.silent;
+    }
+    /**
+     * Checks if a log level should be output based on configuration.
+     * @param level - The log level to check
+     * @returns True if the level should be logged
+     */
+    public shouldLog(level: LogLevel): boolean {
+        return !this.silent && this.level <= logLevelMap[level];
+    }
+    /**
+     * Checks if debug logging is enabled.
+     * @returns True if debug logs should be output
+     */
+    public isDebug(): boolean {
+        return this.shouldLog(LogLevel.Debug);
+    }
+    /**
+     * Logs a debug message if debug logging is enabled.
+     * @param message - The message to log
+     * @param args - Additional arguments to log
+     */
+    public debug(message: string, ...args: unknown[]): void {
+        if (this.isDebug()) {
+            this.logger.debug(message, ...args);
+        }
+    }
+    /**
+     * Checks if info logging is enabled.
+     * @returns True if info logs should be output
+     */
+    public isInfo(): boolean {
+        return this.shouldLog(LogLevel.Info);
+    }
+    /**
+     * Logs an info message if info logging is enabled.
+     * @param message - The message to log
+     * @param args - Additional arguments to log
+     */
+    public info(message: string, ...args: unknown[]): void {
+        if (this.isInfo()) {
+            this.logger.info(message, ...args);
+        }
+    }
+    /**
+     * Checks if warning logging is enabled.
+     * @returns True if warning logs should be output
+     */
+    public isWarn(): boolean {
+        return this.shouldLog(LogLevel.Warn);
+    }
+    /**
+     * Logs a warning message if warning logging is enabled.
+     * @param message - The message to log
+     * @param args - Additional arguments to log
+     */
+    public warn(message: string, ...args: unknown[]): void {
+        if (this.isWarn()) {
+            this.logger.warn(message, ...args);
+        }
+    }
+    /**
+     * Checks if error logging is enabled.
+     * @returns True if error logs should be output
+     */
+    public isError(): boolean {
+        return this.shouldLog(LogLevel.Error);
+    }
+    /**
+     * Logs an error message if error logging is enabled.
+     * @param message - The message to log
+     * @param args - Additional arguments to log
+     */
+    public error(message: string, ...args: unknown[]): void {
+        if (this.isError()) {
+            this.logger.error(message, ...args);
+        }
+    }
+}
+export function createLogger(config?: LogConfig | Logger): Logger {
+    if (config == null) {
+        return defaultLogger;
+    }
+    if (config instanceof Logger) {
+        return config;
+    }
+    config = config ?? {};
+    config.level ??= LogLevel.Info;
+    config.logger ??= new ConsoleLogger();
+    config.silent ??= true;
+    return new Logger(config as Required<LogConfig>);
+}
+const defaultLogger: Logger = new Logger({
+    level: LogLevel.Info,
+    logger: new ConsoleLogger(),
+    silent: true,
+});

package/src/api/platform/core/runtime/index.ts ADDED Viewed

	@@ -0,0 +1 @@
1	+ export { RUNTIME } from "./runtime.js";

package/src/api/platform/core/runtime/runtime.ts ADDED Viewed

@@ -0,0 +1,134 @@
+interface DenoGlobal {
+    version: {
+        deno: string;
+    };
+}
+interface BunGlobal {
+    version: string;
+}
+declare const Deno: DenoGlobal | undefined;
+declare const Bun: BunGlobal | undefined;
+declare const EdgeRuntime: string | undefined;
+declare const self: typeof globalThis.self & {
+    importScripts?: unknown;
+};
+/**
+ * A constant that indicates which environment and version the SDK is running in.
+ */
+export const RUNTIME: Runtime = evaluateRuntime();
+export interface Runtime {
+    type: "browser" | "web-worker" | "deno" | "bun" | "node" | "react-native" | "unknown" | "workerd" | "edge-runtime";
+    version?: string;
+    parsedVersion?: number;
+}
+function evaluateRuntime(): Runtime {
+    /**
+     * A constant that indicates whether the environment the code is running is a Web Browser.
+     */
+    const isBrowser = typeof window !== "undefined" && typeof window.document !== "undefined";
+    if (isBrowser) {
+        return {
+            type: "browser",
+            version: window.navigator.userAgent,
+        };
+    }
+    /**
+     * A constant that indicates whether the environment the code is running is Cloudflare.
+     * https://developers.cloudflare.com/workers/runtime-apis/web-standards/#navigatoruseragent
+     */
+    const isCloudflare = typeof globalThis !== "undefined" && globalThis?.navigator?.userAgent === "Cloudflare-Workers";
+    if (isCloudflare) {
+        return {
+            type: "workerd",
+        };
+    }
+    /**
+     * A constant that indicates whether the environment the code is running is Edge Runtime.
+     * https://vercel.com/docs/functions/runtimes/edge-runtime#check-if-you're-running-on-the-edge-runtime
+     */
+    const isEdgeRuntime = typeof EdgeRuntime === "string";
+    if (isEdgeRuntime) {
+        return {
+            type: "edge-runtime",
+        };
+    }
+    /**
+     * A constant that indicates whether the environment the code is running is a Web Worker.
+     */
+    const isWebWorker =
+        typeof self === "object" &&
+        typeof self?.importScripts === "function" &&
+        (self.constructor?.name === "DedicatedWorkerGlobalScope" ||
+            self.constructor?.name === "ServiceWorkerGlobalScope" ||
+            self.constructor?.name === "SharedWorkerGlobalScope");
+    if (isWebWorker) {
+        return {
+            type: "web-worker",
+        };
+    }
+    /**
+     * A constant that indicates whether the environment the code is running is Deno.
+     * FYI Deno spoofs process.versions.node, see https://deno.land/std@0.177.0/node/process.ts?s=versions
+     */
+    const isDeno =
+        typeof Deno !== "undefined" && typeof Deno.version !== "undefined" && typeof Deno.version.deno !== "undefined";
+    if (isDeno) {
+        return {
+            type: "deno",
+            version: Deno.version.deno,
+        };
+    }
+    /**
+     * A constant that indicates whether the environment the code is running is Bun.sh.
+     */
+    const isBun = typeof Bun !== "undefined" && typeof Bun.version !== "undefined";
+    if (isBun) {
+        return {
+            type: "bun",
+            version: Bun.version,
+        };
+    }
+    /**
+     * A constant that indicates whether the environment the code is running is in React-Native.
+     * This check should come before Node.js detection since React Native may have a process polyfill.
+     * https://github.com/facebook/react-native/blob/main/packages/react-native/Libraries/Core/setUpNavigator.js
+     */
+    const isReactNative = typeof navigator !== "undefined" && navigator?.product === "ReactNative";
+    if (isReactNative) {
+        return {
+            type: "react-native",
+        };
+    }
+    /**
+     * A constant that indicates whether the environment the code is running is Node.JS.
+     */
+    const isNode =
+        typeof process !== "undefined" &&
+        "version" in process &&
+        !!process.version &&
+        "versions" in process &&
+        !!process.versions?.node;
+    if (isNode) {
+        return {
+            type: "node",
+            version: process.versions.node,
+            parsedVersion: Number(process.versions.node.split(".")[0]),
+        };
+    }
+    return {
+        type: "unknown",
+    };
+}

package/src/api/platform/core/url/encodePathParam.ts ADDED Viewed

@@ -0,0 +1,18 @@
+export function encodePathParam(param: unknown): string {
+    if (param === null) {
+        return "null";
+    }
+    const typeofParam = typeof param;
+    switch (typeofParam) {
+        case "undefined":
+            return "undefined";
+        case "string":
+        case "number":
+        case "boolean":
+            break;
+        default:
+            param = String(param);
+            break;
+    }
+    return encodeURIComponent(param as string | number | boolean);
+}

package/src/api/platform/core/url/index.ts ADDED Viewed

@@ -0,0 +1,3 @@
+export { encodePathParam } from "./encodePathParam.js";
+export { join } from "./join.js";
+export { toQueryString } from "./qs.js";

package/src/api/platform/core/url/join.ts ADDED Viewed

@@ -0,0 +1,79 @@
+export function join(base: string, ...segments: string[]): string {
+    if (!base) {
+        return "";
+    }
+    if (segments.length === 0) {
+        return base;
+    }
+    if (base.includes("://")) {
+        let url: URL;
+        try {
+            url = new URL(base);
+        } catch {
+            return joinPath(base, ...segments);
+        }
+        const lastSegment = segments[segments.length - 1];
+        const shouldPreserveTrailingSlash = lastSegment?.endsWith("/");
+        for (const segment of segments) {
+            const cleanSegment = trimSlashes(segment);
+            if (cleanSegment) {
+                url.pathname = joinPathSegments(url.pathname, cleanSegment);
+            }
+        }
+        if (shouldPreserveTrailingSlash && !url.pathname.endsWith("/")) {
+            url.pathname += "/";
+        }
+        return url.toString();
+    }
+    return joinPath(base, ...segments);
+}
+function joinPath(base: string, ...segments: string[]): string {
+    if (segments.length === 0) {
+        return base;
+    }
+    let result = base;
+    const lastSegment = segments[segments.length - 1];
+    const shouldPreserveTrailingSlash = lastSegment?.endsWith("/");
+    for (const segment of segments) {
+        const cleanSegment = trimSlashes(segment);
+        if (cleanSegment) {
+            result = joinPathSegments(result, cleanSegment);
+        }
+    }
+    if (shouldPreserveTrailingSlash && !result.endsWith("/")) {
+        result += "/";
+    }
+    return result;
+}
+function joinPathSegments(left: string, right: string): string {
+    if (left.endsWith("/")) {
+        return left + right;
+    }
+    return `${left}/${right}`;
+}
+function trimSlashes(str: string): string {
+    if (!str) return str;
+    let start = 0;
+    let end = str.length;
+    if (str.startsWith("/")) start = 1;
+    if (str.endsWith("/")) end = str.length - 1;
+    return start === 0 && end === str.length ? str : str.slice(start, end);
+}