documonster 0.20.2 → 0.21.0

package/dist/esm/modules/stream/browser/factories.js

@@ -1,218 +1,36 @@
 /**
- * Browser Stream - Factory functions
- */
-import { createCollector } from "./collector.js";
-import { Duplex } from "./duplex.js";
-import { PassThrough } from "./passthrough.js";
-import { Readable, pumpAsyncIterableToReadable } from "./readable.js";
-import { Transform } from "./transform.js";
-import { Writable } from "./writable.js";
-import { BufferedStream, createStringChunk, createByteChunk } from "../buffered-stream.js";
-import { PullStream } from "../pull-stream.js";
-// Re-export shared stream classes
-export { PullStream, BufferedStream, createStringChunk, createByteChunk };
-/** Create a pull stream */
-export function createPullStream(options) {
-    return new PullStream(options);
-}
-/** Create a buffered stream */
-export function createBufferedStream(options) {
-    return new BufferedStream(options);
-}
-// =============================================================================
-// Stream Creation Functions
-// =============================================================================
-/**
- * Create a readable stream with custom read implementation
- */
-export function createReadable(options) {
-    // Readable already supports Node-style `read()` via the constructor option.
-    // Keep this helper minimal to avoid accidental double-read behavior.
-    return new Readable(options);
-}
-/**
- * Create a readable stream from an async iterable
- */
-export function createReadableFromAsyncIterable(iterable, options) {
-    const readable = new Readable({ ...options, objectMode: options?.objectMode ?? true });
-    pumpAsyncIterableToReadable(readable, iterable);
-    return readable;
-}
-/**
- * Create a readable stream from an array
- */
-export function createReadableFromArray(data, options) {
-    let index = 0;
-    const readable = new Readable({
-        ...options,
-        objectMode: options?.objectMode ?? true,
-        read() {
-            // Push data when read is called
-            while (index < data.length) {
-                const chunk = data[index++];
-                if (chunk === undefined) {
-                    continue; // see the note on the Node factory: not a value a stream carries
-                }
-                if (!this.push(chunk)) {
-                    // Backpressure - wait for next read
-                    return;
-                }
-            }
-            // All data pushed, end the stream
-            this.push(null);
-        }
-    });
-    return readable;
-}
-/**
- * Create a writable stream with custom write implementation
- */
-export function createWritable(options) {
-    // Writable already supports Node-style `write()` / `final()` via the constructor.
-    return new Writable(options);
-}
-/**
- * Create a transform stream from a transform function.
- *
- * The shorthand `transformFn` (1-2 params, returns value) is wrapped into
- * a proper Node.js-style callback-based transform so that the return value
- * is delivered via `callback(null, data)` — matching the Node.js factory.
- */
-export function createTransform(transformFn, options) {
-    return new Transform({
-        ...options,
-        transform(chunk, encoding, callback) {
-            try {
-                const result = transformFn(chunk, encoding);
-                if (result instanceof Promise) {
-                    result
-                        .then(data => {
-                        if (data !== undefined) {
-                            callback(null, data);
-                        }
-                        else {
-                            callback();
-                        }
-                    })
-                        .catch(err => callback(err));
-                }
-                else {
-                    if (result !== undefined) {
-                        callback(null, result);
-                    }
-                    else {
-                        callback();
-                    }
-                }
-            }
-            catch (err) {
-                callback(err);
-            }
-        },
-        flush: options?.flush
-            ? function (callback) {
-                try {
-                    const result = options.flush();
-                    if (result instanceof Promise) {
-                        result
-                            .then(data => {
-                            if (data !== undefined) {
-                                callback(null, data);
-                            }
-                            else {
-                                callback();
-                            }
-                        })
-                            .catch(err => callback(err));
-                    }
-                    else if (result !== undefined) {
-                        callback(null, result);
-                    }
-                    else {
-                        callback();
-                    }
-                }
-                catch (err) {
-                    callback(err);
-                }
-            }
-            : undefined
-    });
-}
-// createCollector is now defined in collector.ts and re-exported here for convenience.
-export { createCollector };
-/**
- * Create a passthrough stream
- */
-export function createPassThrough(options) {
-    return new PassThrough(options);
-}
-/**
- * Create a duplex stream from a pair of readable and writable streams
- */
-export function createDuplex(options) {
-    return new Duplex({
-        highWaterMark: options?.highWaterMark,
-        objectMode: options?.objectMode,
-        allowHalfOpen: options?.allowHalfOpen,
-        readableHighWaterMark: options?.readableHighWaterMark,
-        writableHighWaterMark: options?.writableHighWaterMark,
-        readableObjectMode: options?.readableObjectMode,
-        writableObjectMode: options?.writableObjectMode,
-        read: options?.read,
-        write: options?.write,
-        final: options?.final,
-        destroy: options?.destroy
-    });
-}
-/**
- * Create a readable stream from a generator function
- */
-export function createReadableFromGenerator(generator, options) {
-    const readable = new Readable({ ...options, objectMode: options?.objectMode ?? true });
-    pumpAsyncIterableToReadable(readable, generator());
-    return readable;
-}
-/**
- * Create a readable stream from a Promise
- */
-export function createReadableFromPromise(promise, options) {
-    const readable = new Readable({ ...options, objectMode: options?.objectMode ?? true });
-    promise
-        .then(value => {
-        readable.push(value);
-        readable.push(null);
-    })
-        .catch(err => {
-        readable.destroy(err);
-    });
-    return readable;
-}
-// Reusable read callback for createEmptyReadable (pull-based, matches Node behavior).
-// Boundary: this single shared hook is reused across every Readable<T>
-// instantiation, so its `this` is left open (Readable is invariant in T).
-function emptyRead() {
-    this.push(null);
-}
-/**
- * Create a readable stream that emits nothing and immediately ends
- */
-export function createEmptyReadable(options) {
-    return new Readable({
-        ...options,
-        read: emptyRead
-    });
-}
-// Reusable null write handler
-function nullWrite(_chunk, _encoding, callback) {
-    callback();
-}
-/**
- * Create a writable stream that discards all data (like /dev/null)
- */
-export function createNullWritable(options) {
-    return new Writable({
-        ...options,
-        write: nullWrite
-    });
-}
+ * Browser Stream - factory functions, built on the browser stream classes.
+ */
+import { makeCreateReadable, makeCreateReadableFromAsyncIterable, makeCreateReadableFromArray, makeCreateReadableFromGenerator, makeCreateReadableFromPromise, makeCreateEmptyReadable, makeCreateWritable, makeCreateNullWritable, makeCreateTransform, makeCreatePassThrough, makeCreateDuplex, makeFilter, makeFromBytes, makeFromJSON, makeFromString, makeTransform } from "../core/factories.js";
+import { Duplex, PassThrough, Readable, Transform } from "../kernel/classes.js";
+import { Writable } from "../kernel/writable.js";
+export { BufferedStream, createByteChunk, createStringChunk } from "../buffered-stream.js";
+export { createBufferedStream, createPullStream } from "../core/factories.js";
+export { PullStream } from "../pull-stream.js";
+export const createReadable = 
+/* @__PURE__ */ makeCreateReadable(Readable);
+export const createReadableFromAsyncIterable = 
+/* @__PURE__ */ makeCreateReadableFromAsyncIterable(Readable);
+export const createReadableFromArray = 
+/* @__PURE__ */ makeCreateReadableFromArray(Readable);
+export const createReadableFromGenerator = 
+/* @__PURE__ */ makeCreateReadableFromGenerator(Readable);
+export const createReadableFromPromise = 
+/* @__PURE__ */ makeCreateReadableFromPromise(Readable);
+export const createEmptyReadable = 
+/* @__PURE__ */ makeCreateEmptyReadable(Readable);
+export const createWritable = 
+/* @__PURE__ */ makeCreateWritable(Writable);
+export const createNullWritable = 
+/* @__PURE__ */ makeCreateNullWritable(Writable);
+export const createTransform = 
+/* @__PURE__ */ makeCreateTransform(Transform);
+export const createPassThrough = 
+/* @__PURE__ */ makeCreatePassThrough(PassThrough);
+export const createDuplex = 
+/* @__PURE__ */ makeCreateDuplex(Duplex);
+export const fromBytes = /* @__PURE__ */ makeFromBytes(Readable);
+export const fromString = /* @__PURE__ */ makeFromString(Readable);
+export const fromJSON = /* @__PURE__ */ makeFromJSON(Readable);
+export const transform = /* @__PURE__ */ makeTransform(Transform);
+export const filter = /* @__PURE__ */ makeFilter(Transform);