@cj-tech-master/excelts 3.1.0-canary.20260102041828.82ed571 → 3.1.0

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

@@ -1,282 +0,0 @@
-/**
- * Native Stream Implementation - Node.js
- *
- * Uses Node.js native stream module for maximum performance.
- * Provides Readable, Writable, Transform, Duplex, and PassThrough streams.
- */
-import { Readable, Writable as NodeWritable, Transform, Duplex, PassThrough } from "stream";
-import type { TransformStreamOptions, ReadableStreamOptions, WritableStreamOptions, DuplexStreamOptions, PullStreamOptions, BufferedStreamOptions, DataChunk, ICollector, IDuplex, IEventEmitter, IPassThrough, IReadable, ITransform, IWritable, PipelineStreamLike, ReadableLike, WritableLike } from "@stream/types";
-import { BufferedStream as StandaloneBufferedStream, StringChunk as StandaloneStringChunk, BufferChunk as StandaloneBufferChunk } from "@stream/buffered-stream";
-import { PullStream as StandalonePullStream } from "@stream/pull-stream";
-/**
- * Extended Writable options that match browser API
- * Supports wrapping an existing Node.js stream
- */
-export interface WritableOptions<T = Uint8Array> extends WritableStreamOptions {
-    /** Existing Node.js Writable stream to wrap (for API compatibility with browser) */
-    stream?: NodeWritable;
-    autoDestroy?: boolean;
-    emitClose?: boolean;
-    defaultEncoding?: BufferEncoding;
-    write?: (this: Writable<T>, chunk: T, encoding: BufferEncoding, callback: (error?: Error | null) => void) => void;
-    final?: (this: Writable<T>, callback: (error?: Error | null) => void) => void;
-}
-/**
- * Unified Writable class - wraps Node.js Writable with browser-compatible API
- *
- * Supports the same `{ stream }` option as browser version for wrapping existing streams.
- */
-export declare class Writable<T = Uint8Array> extends NodeWritable {
-    constructor(options?: WritableOptions<T>);
-}
-export { Readable, Transform, Duplex, PassThrough };
-/**
- * Normalize a user-provided writable into a Node.js-compatible Writable.
- *
- * This keeps Web/Node branching at the stream-module boundary.
- */
-export declare function normalizeWritable<T = Uint8Array>(stream: WritableLike | WritableStream<T> | NodeWritable): WritableLike;
-/**
- * Pipeline streams together with proper error handling and cleanup
- * Returns a promise that resolves when the pipeline completes
- */
-type PipelineStream = PipelineStreamLike;
-type PipelineCallback = (err?: Error | null) => void;
-export interface PipelineOptions {
-    signal?: AbortSignal;
-    end?: boolean;
-}
-/**
- * Pipeline streams together with proper error handling and cleanup.
- * Node.js compatible with support for options and callbacks.
- */
-export declare function pipeline(...args: [...PipelineStream[], PipelineOptions | PipelineCallback] | PipelineStream[]): Promise<void>;
-/**
- * Wait for a stream to finish
- */
-export interface FinishedOptions {
-    readable?: boolean;
-    writable?: boolean;
-    error?: boolean;
-    signal?: AbortSignal;
-}
-/**
- * Wait for a stream to finish, close, or error.
- * Node.js compatible with support for options and callbacks.
- */
-export declare function finished(stream: PipelineStream, optionsOrCallback?: FinishedOptions | PipelineCallback, callback?: PipelineCallback): Promise<void>;
-/**
- * Create a readable stream from various sources
- */
-export declare function createReadable<_T = Uint8Array>(options?: ReadableStreamOptions & {
-    read?: (size: number) => void;
-    destroy?: (error: Error | null, callback: (error: Error | null) => void) => void;
-}): IReadable<_T>;
-/**
- * Create a readable stream from an async iterable
- */
-export declare function createReadableFromAsyncIterable<T>(iterable: AsyncIterable<T>, options?: ReadableStreamOptions): IReadable<T>;
-/**
- * Create a readable stream from an array
- */
-export declare function createReadableFromArray<T>(data: T[], options?: ReadableStreamOptions): IReadable<T>;
-/**
- * Create a writable stream
- */
-export declare function createWritable<T = Uint8Array>(options?: WritableStreamOptions & {
-    write?: (chunk: T, encoding: string, callback: (error?: Error | null) => void) => void;
-    final?: (callback: (error?: Error | null) => void) => void;
-    destroy?: (error: Error | null, callback: (error: Error | null) => void) => void;
-}): IWritable<T>;
-/**
- * Create a transform stream from a transform function
- */
-export declare function createTransform<TInput = Uint8Array, TOutput = Uint8Array>(transformFn: (chunk: TInput, encoding?: string) => TOutput | Promise<TOutput>, options?: TransformStreamOptions & {
-    flush?: () => TOutput | Promise<TOutput> | void;
-}): ITransform<TInput, TOutput>;
-/**
- * Create a duplex stream
- */
-export declare function createDuplex<_TRead = Uint8Array, TWrite = Uint8Array>(options?: DuplexStreamOptions & {
-    readable?: unknown;
-    writable?: unknown;
-    allowHalfOpen?: boolean;
-    objectMode?: boolean;
-    read?: (this: any, size: number) => void;
-    write?: (this: any, chunk: TWrite, encoding: string, callback: (error?: Error | null) => void) => void;
-    final?: (this: any, callback: (error?: Error | null) => void) => void;
-    destroy?: (this: any, error: Error | null, callback: (error: Error | null) => void) => void;
-}): IDuplex<_TRead, TWrite>;
-/**
- * Create a passthrough stream
- */
-export declare function createPassThrough<_T = any>(options?: TransformStreamOptions): IPassThrough<_T>;
-/**
- * A writable stream that collects all chunks
- */
-export declare class Collector<T = Uint8Array> extends Writable {
-    chunks: T[];
-    constructor(options?: WritableStreamOptions);
-    /**
-     * Get all collected data as a single Uint8Array (for binary mode)
-     */
-    toUint8Array(): Uint8Array;
-    /**
-     * Get all collected data as a string
-     */
-    toString(): string;
-}
-/**
- * Create a collector stream
- */
-export declare function createCollector<T = Uint8Array>(options?: WritableStreamOptions): ICollector<T>;
-export declare class PullStream extends StandalonePullStream {
-}
-/**
- * Create a pull stream
- */
-export declare function createPullStream(options?: PullStreamOptions): PullStream;
-/**
- * String chunk implementation
- */
-export declare class StringChunk extends StandaloneStringChunk implements DataChunk {
-}
-/**
- * Buffer chunk implementation
- */
-export declare class BufferChunk extends StandaloneBufferChunk implements DataChunk {
-}
-/**
- * Buffered stream with efficient chunk management
- */
-export declare class BufferedStream extends StandaloneBufferedStream {
-}
-/**
- * Create a buffered stream
- */
-export declare function createBufferedStream(options?: BufferedStreamOptions): BufferedStream;
-/**
- * Convert a stream to a promise that resolves when finished
- */
-export declare function streamToPromise(stream: PipelineStream): Promise<void>;
-/**
- * Collect all data from a readable stream into a Uint8Array
- * (Node.js equivalent of browser streamToBuffer)
- */
-export declare function streamToBuffer(stream: AsyncIterable<Uint8Array> | ReadableStream<Uint8Array>): Promise<Uint8Array>;
-/**
- * Collect all data from a readable stream into a Uint8Array
- */
-export declare function streamToUint8Array(stream: AsyncIterable<Uint8Array> | ReadableStream<Uint8Array>): Promise<Uint8Array>;
-/**
- * Collect all data from a readable stream into a string
- */
-export declare function streamToString(stream: AsyncIterable<Uint8Array> | ReadableStream<Uint8Array>, encoding?: string): Promise<string>;
-/**
- * Drain a stream (consume all data without processing)
- */
-export declare function drainStream(stream: AsyncIterable<unknown> | ReadableStream<unknown>): Promise<void>;
-/**
- * Copy from a readable stream to a writable stream
- */
-export declare function copyStream(source: PipelineStreamLike, destination: PipelineStreamLike): Promise<void>;
-/**
- * Add abort signal handling to any stream
- */
-export declare function addAbortSignal<T extends (ReadableLike | WritableLike) & {
-    destroy(error?: Error): any;
-}>(signal: AbortSignal, stream: T): T;
-/**
- * Create a readable stream from a generator function
- */
-export declare function createReadableFromGenerator<T>(generator: () => AsyncGenerator<T, void, unknown>, options?: ReadableStreamOptions): IReadable<T>;
-/**
- * Create a readable stream from a Promise
- */
-export declare function createReadableFromPromise<T>(promise: Promise<T>, options?: ReadableStreamOptions): IReadable<T>;
-/**
- * Compose multiple transform streams into one
- */
-export declare function compose<_T = any, _R = any>(...transforms: Array<ITransform<any, any>>): Transform;
-/**
- * Wait for multiple streams to finish
- */
-export declare function finishedAll(streams: ReadonlyArray<PipelineStreamLike>): Promise<void>;
-/**
- * Create a readable stream that emits nothing and immediately ends
- */
-export declare function createEmptyReadable<_T = Uint8Array>(options?: ReadableStreamOptions): IReadable<_T>;
-/**
- * Create a writable stream that discards all data (like /dev/null)
- */
-export declare function createNullWritable<_T = any>(options?: WritableStreamOptions): IWritable<_T>;
-/**
- * Promisified version of once for events
- */
-export declare function once(emitter: IEventEmitter, event: string, options?: {
-    signal?: AbortSignal;
-}): Promise<any[]>;
-/**
- * Convert a callback-based operation to a promise
- */
-export declare function promisify<T>(fn: (callback: (error?: Error | null, result?: T) => void) => void): Promise<T>;
-/**
- * Check if an object is a readable stream
- */
-export declare function isReadable(obj: unknown): obj is ReadableLike;
-/**
- * Check if an object is a writable stream
- */
-export declare function isWritable(obj: unknown): obj is WritableLike;
-/**
- * Check if an object is a transform stream
- */
-export declare function isTransform(obj: unknown): obj is ITransform<any, any>;
-/**
- * Check if an object is a duplex stream
- */
-export declare function isDuplex(obj: unknown): obj is IDuplex<any, any>;
-/**
- * Check if an object is any kind of stream
- */
-export declare function isStream(obj: unknown): obj is ReadableLike | WritableLike;
-/**
- * Check if a stream has been destroyed
- */
-export declare function isDestroyed(stream: {
-    destroyed?: boolean;
-} | null | undefined): boolean;
-/**
- * Check if a readable stream has been disturbed (read from)
- */
-export declare function isDisturbed(stream: unknown): boolean;
-/**
- * Check if a stream has an error
- */
-export declare function isErrored(stream: {
-    errored?: unknown;
-} | null | undefined): boolean;
-/**
- * Get the default high water mark for streams
- */
-export declare function getDefaultHighWaterMark(objectMode: boolean): number;
-/**
- * Set the default high water mark for streams
- * Note: This is a no-op in this implementation as we use fixed defaults
- */
-export declare function setDefaultHighWaterMark(_objectMode: boolean, _value: number): void;
-/**
- * Create a pair of connected Duplex streams
- */
-export declare function duplexPair<T = Uint8Array>(options?: DuplexStreamOptions): [Duplex, Duplex];
-export declare const consumers: {
-    arrayBuffer(stream: AsyncIterable<Uint8Array> | ReadableStream<Uint8Array>): Promise<ArrayBuffer>;
-    blob(stream: AsyncIterable<Uint8Array> | ReadableStream<Uint8Array>, options?: BlobPropertyBag): Promise<Blob>;
-    buffer(stream: AsyncIterable<Uint8Array> | ReadableStream<Uint8Array>): Promise<Uint8Array>;
-    json(stream: AsyncIterable<Uint8Array> | ReadableStream<Uint8Array>): Promise<any>;
-    text(stream: AsyncIterable<Uint8Array> | ReadableStream<Uint8Array>, encoding?: string): Promise<string>;
-};
-export declare const promises: {
-    pipeline: typeof pipeline;
-    finished: typeof finished;
-};

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

@@ -1,238 +0,0 @@
-/**
- * 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/types/modules/stream/utils.d.ts

@@ -1,24 +0,0 @@
-/**
- * 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/types/utils/browser.d.ts

@@ -1,9 +0,0 @@
-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/types/utils/env.d.ts

@@ -1,14 +0,0 @@
-/**
- * Environment detection utilities
- * Common functions to detect runtime environment (Node.js vs Browser)
- */
-/**
- * Check if running in Node.js environment
- * Returns true if process.versions.node exists
- */
-export declare function isNode(): boolean;
-/**
- * Check if running in browser environment
- * Returns true if window and document are defined
- */
-export declare function isBrowser(): boolean;

package/dist/types/utils/uuid.d.ts

@@ -1,11 +0,0 @@
-/**
- * Generate a UUID v4.
- *
- * This exists to avoid a hard dependency on `crypto.randomUUID()` so that
- * older supported browsers can still generate UUIDs.
- *
- * - Prefers `crypto.randomUUID()` when available.
- * - Falls back to `crypto.getRandomValues()`.
- * - Last-resort fallback uses `Math.random()` (NOT cryptographically secure).
- */
-export declare function uuidV4(): string;