@cj-tech-master/excelts 4.0.0 → 4.0.1-canary.20260104072032.0453bbe

package/dist/browser/modules/stream/types.d.ts

@@ -0,0 +1,238 @@
+/**
+ * Stream Module - Shared Types
+ *
+ * Common type definitions for stream operations across Node.js and Browser.
+ * These types provide a unified interface regardless of the underlying implementation.
+ */
+/**
+ * Options for creating readable streams
+ */
+export interface ReadableStreamOptions {
+    /** High water mark for backpressure (bytes) */
+    highWaterMark?: number;
+    /** Enable object mode (non-binary data) */
+    objectMode?: boolean;
+}
+/**
+ * Options for creating writable streams
+ */
+export interface WritableStreamOptions {
+    /** High water mark for backpressure (bytes) */
+    highWaterMark?: number;
+    /** Enable object mode (non-binary data) */
+    objectMode?: boolean;
+}
+/**
+ * Options for creating transform streams
+ */
+export interface TransformStreamOptions {
+    /** High water mark for backpressure (bytes) */
+    highWaterMark?: number;
+    /** Enable object mode (non-binary data) */
+    objectMode?: boolean;
+}
+/**
+ * Options for creating duplex streams
+ */
+export interface DuplexStreamOptions {
+    /** Enable object mode for both read and write sides (Node compatibility) */
+    objectMode?: boolean;
+    /** High water mark for both sides (Node compatibility) */
+    highWaterMark?: number;
+    /** Allow half-open (Node compatibility) */
+    allowHalfOpen?: boolean;
+    /** High water mark for read side */
+    readableHighWaterMark?: number;
+    /** High water mark for write side */
+    writableHighWaterMark?: number;
+    /** Enable object mode for read side */
+    readableObjectMode?: boolean;
+    /** Enable object mode for write side */
+    writableObjectMode?: boolean;
+}
+/**
+ * Callback for transform operations
+ */
+export type TransformCallback<T = Uint8Array> = (error?: Error | null, data?: T) => void;
+/**
+ * Callback for flush operations
+ */
+export type FlushCallback<T = Uint8Array> = (error?: Error | null, data?: T) => void;
+/**
+ * Callback for write operations
+ */
+export type WriteCallback = (error?: Error | null) => void;
+/**
+ * Callback for destroy operations
+ */
+export type DestroyCallback = (error?: Error | null) => void;
+/**
+ * Event listener type
+ */
+export type EventListener = (...args: any[]) => void;
+/**
+ * Common event emitter interface
+ */
+export interface IEventEmitter {
+    on(event: string, listener: EventListener): this;
+    once(event: string, listener: EventListener): this;
+    off(event: string, listener: EventListener): this;
+    removeListener(event: string | symbol, listener: EventListener): this;
+    emit(event: string, ...args: any[]): boolean;
+    removeAllListeners(event?: string): this;
+}
+/**
+ * Minimal readable-like stream shape used by `pipeline`/`finished` signatures.
+ * Kept intentionally permissive so both Node streams and browser wrappers match.
+ */
+export interface ReadableLike extends IEventEmitter {
+    pipe(destination: any): any;
+    destroy?(error?: Error): void;
+    readableEnded?: boolean;
+}
+/**
+ * Minimal writable-like stream shape used by `pipeline`/`finished` signatures.
+ * Kept intentionally permissive so both Node streams and browser wrappers match.
+ */
+export interface WritableLike extends IEventEmitter {
+    write(chunk: any, ...args: any[]): any;
+    end(...args: any[]): any;
+    destroy?(error?: Error): void;
+    writableFinished?: boolean;
+}
+/**
+ * Stream-like union accepted by `pipeline`/`finished` across Node and browser.
+ * Includes Web Streams to support browser-native and Node's WHATWG streams.
+ */
+export type PipelineStreamLike = ReadableLike | WritableLike | (ReadableLike & WritableLike) | ReadableStream<any> | WritableStream<any> | TransformStream<any, any>;
+/**
+ * Common readable stream interface
+ */
+export interface IReadable<T = any> extends ReadableLike, AsyncIterable<T> {
+    read(size?: number): T | null;
+    destroy(error?: Error): any;
+    pipe(destination: any): any;
+    unpipe(destination?: any): this;
+    pause(): this;
+    resume(): this;
+    isPaused(): boolean;
+    readonly readable: boolean;
+    readonly readableEnded: boolean;
+    readonly readableLength: number;
+    readonly readableHighWaterMark?: number;
+    readonly readableObjectMode?: boolean;
+    readonly readableFlowing?: boolean | null;
+    readonly destroyed?: boolean;
+}
+/**
+ * Common writable stream interface
+ */
+export interface IWritable<T = any> extends WritableLike {
+    write(chunk: T, callback?: WriteCallback): boolean;
+    write(chunk: T, encoding?: string, callback?: WriteCallback): boolean;
+    end(callback?: () => void): this;
+    end(chunk: T, callback?: () => void): this;
+    end(chunk: T, encoding?: string, callback?: () => void): this;
+    destroy(error?: Error): any;
+    readonly writable: boolean;
+    readonly writableEnded: boolean;
+    readonly writableFinished: boolean;
+    readonly writableLength: number;
+    readonly writableHighWaterMark?: number;
+    readonly destroyed?: boolean;
+}
+/**
+ * Common transform stream interface
+ */
+export interface ITransform<TInput = any, TOutput = any> extends IReadable<TOutput>, IWritable<TInput> {
+    _transform(chunk: TInput, encoding: string, callback: TransformCallback<TOutput>): void;
+    _flush(callback: FlushCallback<TOutput>): void;
+}
+/**
+ * Common duplex stream interface
+ */
+export interface IDuplex<TRead = any, TWrite = any> extends IReadable<TRead>, IWritable<TWrite> {
+}
+/**
+ * Options for pull stream
+ */
+export interface PullStreamOptions {
+    /** Enable object mode */
+    objectMode?: boolean;
+    /** High water mark for internal buffer */
+    highWaterMark?: number;
+}
+/**
+ * Pull stream interface - allows pulling data on demand
+ */
+export interface IPullStream extends IEventEmitter {
+    write(chunk: Uint8Array): boolean;
+    end(chunk?: Uint8Array): void;
+    destroy(error?: Error): void;
+    /** Pull exactly N bytes from buffer */
+    pull(size: number): Promise<Uint8Array>;
+    /** Pull until pattern is found */
+    pullUntil(pattern: Uint8Array, includePattern?: boolean): Promise<Uint8Array>;
+    /** Stream data until pattern */
+    stream(eof: number | Uint8Array): IReadable<Uint8Array>;
+    readonly length: number;
+    readonly isFinished: boolean;
+    readonly matchPosition: number | undefined;
+}
+/**
+ * Options for buffered stream
+ */
+export interface BufferedStreamOptions {
+    /** Batch size for internal read-write buffers */
+    batchSize?: number;
+}
+/**
+ * Buffered stream interface - manages internal buffering
+ */
+export interface IBufferedStream extends IEventEmitter {
+    write(chunk: Uint8Array | string): boolean;
+    read(size?: number): Uint8Array | null;
+    end(chunk?: Uint8Array | string): void;
+    destroy(error?: Error): void;
+    toUint8Array(): Uint8Array;
+    readonly bufferedLength: number;
+    readonly isFinished: boolean;
+}
+/**
+ * Passthrough stream - passes data through unchanged
+ */
+export type IPassThrough<T = Uint8Array> = ITransform<T, T>;
+/**
+ * Collector interface - collects all chunks
+ */
+export interface ICollector<T = any> extends IWritable<T> {
+    readonly chunks: T[];
+    readonly isFinished?: boolean;
+}
+/**
+ * Pipeline source - can be a readable stream or async iterable
+ */
+export type PipelineSource<T> = IReadable<T> | AsyncIterable<T> | Iterable<T>;
+/**
+ * Pipeline transform - a transform stream or function
+ */
+export type PipelineTransform<TIn, TOut> = ITransform<TIn, TOut> | ((source: AsyncIterable<TIn>) => AsyncIterable<TOut>);
+/**
+ * Pipeline destination - a writable stream or async generator
+ */
+export type PipelineDestination<T, R> = IWritable<T> | ((source: AsyncIterable<T>) => Promise<R>);
+/**
+ * Data chunk interface for flexible chunk handling
+ */
+export interface DataChunk {
+    readonly length: number;
+    copy(target: Uint8Array, targetOffset: number, offset: number, length: number): number;
+    toUint8Array(): Uint8Array;
+}
+/**
+ * Read-write buffer options
+ */
+export interface ReadWriteBufferOptions {
+    /** Initial buffer size */
+    size?: number;
+}

package/dist/browser/modules/stream/types.js

@@ -0,0 +1,7 @@
+/**
+ * Stream Module - Shared Types
+ *
+ * Common type definitions for stream operations across Node.js and Browser.
+ * These types provide a unified interface regardless of the underlying implementation.
+ */
+export {};

package/dist/browser/modules/stream/utils.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Stream Utilities
+ *
+ * Small, cross-platform helpers built on top of the platform stream
+ * implementation selected by `./streams` (Node.js or browser).
+ */
+import type { IReadable, ITransform } from "@stream/types";
+export declare function collect<T>(stream: {
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+}): Promise<T[]>;
+export declare function text(stream: {
+    [Symbol.asyncIterator](): AsyncIterator<Uint8Array>;
+}): Promise<string>;
+export declare function json<T = unknown>(stream: {
+    [Symbol.asyncIterator](): AsyncIterator<Uint8Array>;
+}): Promise<T>;
+export declare function bytes(stream: {
+    [Symbol.asyncIterator](): AsyncIterator<Uint8Array>;
+}): Promise<Uint8Array>;
+export declare function fromString(str: string): IReadable<Uint8Array>;
+export declare function fromJSON(data: unknown): IReadable<Uint8Array>;
+export declare function fromBytes(data: Uint8Array): IReadable<Uint8Array>;
+export declare function transform<TIn = Uint8Array, TOut = TIn>(fn: (chunk: TIn) => TOut | Promise<TOut>): ITransform<TIn, TOut>;
+export declare function filter<T>(predicate: (chunk: T) => boolean | Promise<boolean>): ITransform<T, T>;

package/dist/browser/modules/stream/utils.js

@@ -0,0 +1,85 @@
+/**
+ * Stream Utilities
+ *
+ * Small, cross-platform helpers built on top of the platform stream
+ * implementation selected by `./streams` (Node.js or browser).
+ */
+import { createReadableFromArray, createTransform } from "./streams.browser.js";
+import { stringToUint8Array as _stringToUint8Array, uint8ArrayToString as _uint8ArrayToString } from "./shared.js";
+// =============================================================================
+// High-Level Stream Consumers
+// =============================================================================
+export async function collect(stream) {
+    const result = [];
+    for await (const chunk of stream) {
+        result.push(chunk);
+    }
+    return result;
+}
+export async function text(stream) {
+    const chunks = [];
+    let totalLength = 0;
+    for await (const chunk of stream) {
+        chunks.push(chunk);
+        totalLength += chunk.length;
+    }
+    if (chunks.length === 1) {
+        return _uint8ArrayToString(chunks[0]);
+    }
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    for (let i = 0, len = chunks.length; i < len; i++) {
+        const c = chunks[i];
+        result.set(c, offset);
+        offset += c.length;
+    }
+    return _uint8ArrayToString(result);
+}
+export async function json(stream) {
+    const str = await text(stream);
+    return JSON.parse(str);
+}
+export async function bytes(stream) {
+    const chunks = [];
+    let totalLength = 0;
+    for await (const chunk of stream) {
+        chunks.push(chunk);
+        totalLength += chunk.length;
+    }
+    if (chunks.length === 1) {
+        return chunks[0];
+    }
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    for (let i = 0, len = chunks.length; i < len; i++) {
+        const c = chunks[i];
+        result.set(c, offset);
+        offset += c.length;
+    }
+    return result;
+}
+// =============================================================================
+// Stream Factory Helpers
+// =============================================================================
+export function fromString(str) {
+    return createReadableFromArray([_stringToUint8Array(str)], {
+        objectMode: false
+    });
+}
+export function fromJSON(data) {
+    return fromString(JSON.stringify(data));
+}
+export function fromBytes(data) {
+    return createReadableFromArray([data], { objectMode: false });
+}
+export function transform(fn) {
+    return createTransform(fn);
+}
+export function filter(predicate) {
+    return createTransform(async (chunk) => {
+        if (await predicate(chunk)) {
+            return chunk;
+        }
+        return undefined;
+    }, { objectMode: true });
+}

package/dist/browser/utils/browser.d.ts

@@ -0,0 +1,9 @@
+import type { Plugin } from "vitest/config";
+/**
+ * Prefer sibling `.browser.*` implementation when it exists.
+ *
+ * Example:
+ * - resolved: `/abs/path/to/streams.ts`
+ * - if `/abs/path/to/streams.browser.ts` exists => use it
+ */
+export declare function preferBrowserFilesPlugin(): Plugin;

package/dist/browser/utils/browser.js

@@ -0,0 +1,49 @@
+import fs from "node:fs";
+import path from "node:path";
+/**
+ * Prefer sibling `.browser.*` implementation when it exists.
+ *
+ * Example:
+ * - resolved: `/abs/path/to/streams.ts`
+ * - if `/abs/path/to/streams.browser.ts` exists => use it
+ */
+export function preferBrowserFilesPlugin() {
+    return {
+        name: "excelts-prefer-browser-files",
+        enforce: "pre",
+        async resolveId(source, importer) {
+            if (source.startsWith("\0") || source.startsWith("virtual:") || source.startsWith("node:")) {
+                return null;
+            }
+            const resolved = await this.resolve(source, importer, {
+                skipSelf: true
+            });
+            if (!resolved) {
+                return null;
+            }
+            if (typeof resolved === "object" && resolved.external) {
+                return resolved;
+            }
+            const resolvedId = typeof resolved === "string" ? resolved : resolved.id;
+            if (typeof resolvedId !== "string") {
+                return resolved;
+            }
+            const cleanId = resolvedId.split("?")[0].split("#")[0];
+            if (!path.isAbsolute(cleanId)) {
+                return resolved;
+            }
+            if (cleanId.includes(".browser.")) {
+                return resolved;
+            }
+            const ext = path.extname(cleanId);
+            if (!ext || cleanId.endsWith(".d.ts")) {
+                return resolved;
+            }
+            const candidate = cleanId.slice(0, -ext.length) + ".browser" + ext;
+            if (fs.existsSync(candidate)) {
+                return candidate;
+            }
+            return resolved;
+        }
+    };
+}

package/dist/browser/utils/datetime.d.ts

@@ -0,0 +1,56 @@
+/**
+ * High-performance native date parsing and formatting utilities
+ *
+ * Zero external dependencies. Optimized for CSV batch processing.
+ * Uses character code operations and lookup tables for maximum speed.
+ */
+/** Supported date format strings */
+export type DateFormat = "YYYY-MM-DD[T]HH:mm:ssZ" | "YYYY-MM-DD[T]HH:mm:ss" | "YYYY-MM-DD[T]HH:mm:ss.SSSZ" | "YYYY-MM-DD" | "YYYY-MM-DD HH:mm:ss" | "MM-DD-YYYY" | "MM-DD-YYYY HH:mm:ss" | "MM/DD/YYYY HH:mm:ss" | "DD-MM-YYYY" | "DD-MM-YYYY HH:mm:ss" | "DD/MM/YYYY HH:mm:ss";
+/**
+ * Optimized date parser for batch processing
+ *
+ * @example
+ * const parser = DateParser.create(["YYYY-MM-DD"]);
+ * const dates = parser.parseAll(csvStrings);
+ */
+export declare class DateParser {
+    private readonly fns;
+    private readonly single;
+    private readonly fn0;
+    private constructor();
+    /** Create parser for specific formats */
+    static create(formats: readonly DateFormat[]): DateParser;
+    /** Create parser for auto-detecting ISO formats */
+    static iso(): DateParser;
+    /** Parse single value */
+    parse: (value: string) => Date | null;
+    /** Parse array of values */
+    parseAll(values: string[]): (Date | null)[];
+    /** Parse and filter valid dates */
+    parseValid(values: string[]): Date[];
+}
+/**
+ * Optimized date formatter for batch processing
+ *
+ * @example
+ * const formatter = DateFormatter.create("YYYY-MM-DD", { utc: true });
+ * const strings = formatter.formatAll(dates);
+ */
+export declare class DateFormatter {
+    private readonly fn;
+    private constructor();
+    /** Create ISO formatter (fastest) */
+    static iso(utc?: boolean): DateFormatter;
+    /** Create custom format formatter */
+    static create(format: string, options?: {
+        utc?: boolean;
+    }): DateFormatter;
+    /** Generic formatter for arbitrary formats */
+    private static createGeneric;
+    /** Format single date */
+    format: (date: Date) => string;
+    /** Format array of dates */
+    formatAll(dates: Date[]): string[];
+}
+/** Get supported format strings */
+export declare function getSupportedFormats(): DateFormat[];