mindee 4.36.3 → 5.0.0-alpha2

package/src/index.js

@@ -1,66 +1,12 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.imageOperations = exports.internal = exports.LocalResponse = exports.PageOptionsOperation = exports.UrlInput = exports.StreamInput = exports.PathInput = exports.BytesInput = exports.BufferInput = exports.Base64Input = exports.InputSource = exports.RagMetadata = exports.RawText = exports.JobResponse = exports.InferenceResponse = exports.InferenceFile = exports.Page = exports.Document = exports.Prediction = exports.Inference = exports.PredictResponse = exports.AsyncPredictResponse = exports.ClientV2 = exports.Client = exports.product = void 0;
-exports.product = __importStar(require("./product"));
-var client_1 = require("./client");
-Object.defineProperty(exports, "Client", { enumerable: true, get: function () { return client_1.Client; } });
-var clientV2_1 = require("./clientV2");
-Object.defineProperty(exports, "ClientV2", { enumerable: true, get: function () { return clientV2_1.ClientV2; } });
-var common_1 = require("./parsing/common");
-Object.defineProperty(exports, "AsyncPredictResponse", { enumerable: true, get: function () { return common_1.AsyncPredictResponse; } });
-Object.defineProperty(exports, "PredictResponse", { enumerable: true, get: function () { return common_1.PredictResponse; } });
-Object.defineProperty(exports, "Inference", { enumerable: true, get: function () { return common_1.Inference; } });
-Object.defineProperty(exports, "Prediction", { enumerable: true, get: function () { return common_1.Prediction; } });
-Object.defineProperty(exports, "Document", { enumerable: true, get: function () { return common_1.Document; } });
-Object.defineProperty(exports, "Page", { enumerable: true, get: function () { return common_1.Page; } });
-var v2_1 = require("./parsing/v2");
-Object.defineProperty(exports, "InferenceFile", { enumerable: true, get: function () { return v2_1.InferenceFile; } });
-Object.defineProperty(exports, "InferenceResponse", { enumerable: true, get: function () { return v2_1.InferenceResponse; } });
-Object.defineProperty(exports, "JobResponse", { enumerable: true, get: function () { return v2_1.JobResponse; } });
-Object.defineProperty(exports, "RawText", { enumerable: true, get: function () { return v2_1.RawText; } });
-Object.defineProperty(exports, "RagMetadata", { enumerable: true, get: function () { return v2_1.RagMetadata; } });
-var input_1 = require("./input");
-Object.defineProperty(exports, "InputSource", { enumerable: true, get: function () { return input_1.InputSource; } });
-Object.defineProperty(exports, "Base64Input", { enumerable: true, get: function () { return input_1.Base64Input; } });
-Object.defineProperty(exports, "BufferInput", { enumerable: true, get: function () { return input_1.BufferInput; } });
-Object.defineProperty(exports, "BytesInput", { enumerable: true, get: function () { return input_1.BytesInput; } });
-Object.defineProperty(exports, "PathInput", { enumerable: true, get: function () { return input_1.PathInput; } });
-Object.defineProperty(exports, "StreamInput", { enumerable: true, get: function () { return input_1.StreamInput; } });
-Object.defineProperty(exports, "UrlInput", { enumerable: true, get: function () { return input_1.UrlInput; } });
-Object.defineProperty(exports, "PageOptionsOperation", { enumerable: true, get: function () { return input_1.PageOptionsOperation; } });
-Object.defineProperty(exports, "LocalResponse", { enumerable: true, get: function () { return input_1.LocalResponse; } });
-exports.internal = __importStar(require("./internal"));
-exports.imageOperations = __importStar(require("./imageOperations"));
+// Core
+export { InputSource, Base64Input, BufferInput, BytesInput, PathInput, StreamInput, UrlInput, PageOptionsOperation, } from "./input/index.js";
+export * as image from "./image/index.js";
+export * as pdf from "./pdf/index.js";
+export * as geometry from "./geometry/index.js";
+// V1
+export * as v1 from "./v1/index.js";
+// V2
+export * as v2 from "./v2/index.js";
+// Consider v2 the default
+export * as product from "./v2/product/index.js";
+export { Client, JobResponse, ErrorResponse, } from "./v2/index.js";

package/src/input/base64Input.d.ts

@@ -0,0 +1,12 @@
+import { LocalInputSource } from "./localInputSource.js";
+interface Base64InputProps {
+    inputString: string;
+    filename: string;
+}
+export declare class Base64Input extends LocalInputSource {
+    private inputString;
+    fileObject: Buffer;
+    constructor({ inputString, filename }: Base64InputProps);
+    init(): Promise<void>;
+}
+export {};

package/src/input/base64Input.js

@@ -0,0 +1,24 @@
+import { LocalInputSource } from "./localInputSource.js";
+import { INPUT_TYPE_BASE64 } from "./inputSource.js";
+import { logger } from "../logger.js";
+export class Base64Input extends LocalInputSource {
+    constructor({ inputString, filename }) {
+        super({
+            inputType: INPUT_TYPE_BASE64,
+        });
+        this.fileObject = Buffer.alloc(0);
+        this.filename = filename;
+        this.inputString = inputString;
+    }
+    async init() {
+        if (this.initialized) {
+            return;
+        }
+        logger.debug("Loading from base64");
+        this.fileObject = Buffer.from(this.inputString, "base64");
+        this.mimeType = await this.checkMimetype();
+        // clear out the string
+        this.inputString = "";
+        this.initialized = true;
+    }
+}

package/src/input/bufferInput.d.ts

@@ -0,0 +1,10 @@
+import { LocalInputSource } from "./localInputSource.js";
+interface BufferInputProps {
+    buffer: Buffer;
+    filename: string;
+}
+export declare class BufferInput extends LocalInputSource {
+    constructor({ buffer, filename }: BufferInputProps);
+    init(): Promise<void>;
+}
+export {};

package/src/input/bufferInput.js

@@ -0,0 +1,20 @@
+import { LocalInputSource } from "./localInputSource.js";
+import { INPUT_TYPE_BUFFER } from "./inputSource.js";
+import { logger } from "../logger.js";
+export class BufferInput extends LocalInputSource {
+    constructor({ buffer, filename }) {
+        super({
+            inputType: INPUT_TYPE_BUFFER,
+        });
+        this.fileObject = buffer;
+        this.filename = filename;
+    }
+    async init() {
+        if (this.initialized) {
+            return;
+        }
+        logger.debug("Loading from buffer");
+        this.mimeType = await this.checkMimetype();
+        this.initialized = true;
+    }
+}

package/src/input/bytesInput.d.ts

@@ -0,0 +1,12 @@
+import { LocalInputSource } from "./localInputSource.js";
+interface BytesInputProps {
+    inputBytes: Uint8Array;
+    filename: string;
+}
+export declare class BytesInput extends LocalInputSource {
+    private inputBytes;
+    fileObject: Buffer;
+    constructor({ inputBytes, filename }: BytesInputProps);
+    init(): Promise<void>;
+}
+export {};

package/src/input/bytesInput.js

@@ -0,0 +1,23 @@
+import { INPUT_TYPE_BYTES } from "./inputSource.js";
+import { LocalInputSource } from "./localInputSource.js";
+import { logger } from "../logger.js";
+export class BytesInput extends LocalInputSource {
+    constructor({ inputBytes, filename }) {
+        super({
+            inputType: INPUT_TYPE_BYTES,
+        });
+        this.fileObject = Buffer.alloc(0);
+        this.filename = filename;
+        this.inputBytes = inputBytes;
+    }
+    async init() {
+        if (this.initialized) {
+            return;
+        }
+        logger.debug("Loading from bytes");
+        this.fileObject = Buffer.from(this.inputBytes);
+        this.mimeType = await this.checkMimetype();
+        this.inputBytes = new Uint8Array(0);
+        this.initialized = true;
+    }
+}

package/src/input/index.d.ts

@@ -1,4 +1,11 @@
-export { DataSchema, DataSchemaField, DataSchemaReplace } from "./dataSchema";
-export * from "./sources";
-export { LocalResponse } from "./localResponse";
-export { PageOptions, PageOptionsOperation } from "./pageOptions";
+export { Base64Input } from "./base64Input.js";
+export { BufferInput } from "./bufferInput.js";
+export { BytesInput } from "./bytesInput.js";
+export { InputSource, INPUT_TYPE_PATH, INPUT_TYPE_STREAM, INPUT_TYPE_BUFFER, INPUT_TYPE_BASE64, INPUT_TYPE_BYTES } from "./inputSource.js";
+export type { InputConstructor } from "./inputSource.js";
+export { LocalInputSource, MIMETYPES } from "./localInputSource.js";
+export { PathInput } from "./pathInput.js";
+export { StreamInput } from "./streamInput.js";
+export { UrlInput } from "./urlInput.js";
+export { PageOptionsOperation } from "./pageOptions.js";
+export type { PageOptions } from "./pageOptions.js";

package/src/input/index.js

@@ -1,26 +1,9 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PageOptionsOperation = exports.LocalResponse = exports.DataSchemaReplace = exports.DataSchemaField = exports.DataSchema = void 0;
-var dataSchema_1 = require("./dataSchema");
-Object.defineProperty(exports, "DataSchema", { enumerable: true, get: function () { return dataSchema_1.DataSchema; } });
-Object.defineProperty(exports, "DataSchemaField", { enumerable: true, get: function () { return dataSchema_1.DataSchemaField; } });
-Object.defineProperty(exports, "DataSchemaReplace", { enumerable: true, get: function () { return dataSchema_1.DataSchemaReplace; } });
-__exportStar(require("./sources"), exports);
-var localResponse_1 = require("./localResponse");
-Object.defineProperty(exports, "LocalResponse", { enumerable: true, get: function () { return localResponse_1.LocalResponse; } });
-var pageOptions_1 = require("./pageOptions");
-Object.defineProperty(exports, "PageOptionsOperation", { enumerable: true, get: function () { return pageOptions_1.PageOptionsOperation; } });
+export { Base64Input } from "./base64Input.js";
+export { BufferInput } from "./bufferInput.js";
+export { BytesInput } from "./bytesInput.js";
+export { InputSource, INPUT_TYPE_PATH, INPUT_TYPE_STREAM, INPUT_TYPE_BUFFER, INPUT_TYPE_BASE64, INPUT_TYPE_BYTES } from "./inputSource.js";
+export { LocalInputSource, MIMETYPES } from "./localInputSource.js";
+export { PathInput } from "./pathInput.js";
+export { StreamInput } from "./streamInput.js";
+export { UrlInput } from "./urlInput.js";
+export { PageOptionsOperation } from "./pageOptions.js";

package/src/input/inputSource.js

@@ -0,0 +1,18 @@
+import { MindeeInputSourceError } from "../errors/index.js";
+export const INPUT_TYPE_STREAM = "stream";
+export const INPUT_TYPE_BASE64 = "base64";
+export const INPUT_TYPE_BYTES = "bytes";
+export const INPUT_TYPE_PATH = "path";
+export const INPUT_TYPE_BUFFER = "buffer";
+export class InputSource {
+    constructor() {
+        this.fileObject = "";
+        this.initialized = false;
+    }
+    async init() {
+        throw new MindeeInputSourceError("not Implemented");
+    }
+    isInitialized() {
+        return this.initialized;
+    }
+}

package/src/input/localInputSource.d.ts

@@ -0,0 +1,55 @@
+import { PageOptions } from "../input/pageOptions.js";
+import { InputSource, InputConstructor } from "./inputSource.js";
+export declare const MIMETYPES: Map<string, string>;
+export declare abstract class LocalInputSource extends InputSource {
+    inputType: string;
+    filename: string;
+    filepath?: string;
+    mimeType: string;
+    fileObject: Buffer | string;
+    /**
+     * @param {InputConstructor} constructor Constructor parameters.
+     */
+    protected constructor({ inputType }: InputConstructor);
+    protected checkMimetype(): Promise<string>;
+    /**
+     * Returns the file object as a Buffer.
+     * @returns Buffer representation of the file object
+     * @protected
+     */
+    protected getBuffer(): Buffer;
+    /**
+     * Determines whether the current file is a PDF.
+     * @returns {boolean} Returns true if the file is a PDF; otherwise, returns false.
+     */
+    isPdf(): boolean;
+    /**
+     * Cut PDF pages.
+     * @param pageOptions
+     */
+    applyPageOptions(pageOptions: PageOptions): Promise<void>;
+    /**
+     * Compresses the file object, either as a PDF or an image.
+     *
+     * @param quality Quality of the compression. For images, this is the JPEG quality.
+     * For PDFs, this affects image quality within the PDF.
+     * @param maxWidth Maximum width for image resizing. Ignored for PDFs.
+     * @param maxHeight Maximum height for image resizing. Ignored for PDFs.
+     * @param forceSourceText For PDFs, whether to force compression even if source text is present.
+     * @param disableSourceText For PDFs, whether to disable source text during compression.
+     *
+     * @returns A Promise that resolves when the compression is complete.
+     */
+    compress(quality?: number, maxWidth?: number | null, maxHeight?: number | null, forceSourceText?: boolean, disableSourceText?: boolean): Promise<void>;
+    /**
+     * Returns true if the object is a PDF and has source text. False otherwise.
+     * @return boolean
+     */
+    hasSourceText(): Promise<boolean>;
+    /**
+     * Returns the number of pages in the input source.
+     * For PDFs, returns the actual page count. For images, returns 1.
+     * @return Promise<number> The number of pages
+     */
+    getPageCount(): Promise<number>;
+}

package/src/input/localInputSource.js

@@ -0,0 +1,146 @@
+import path from "path";
+import { MindeeInputSourceError } from "../errors/index.js";
+import { errorHandler } from "../errors/handler.js";
+import { logger } from "../logger.js";
+import { compressImage } from "../image/index.js";
+import { compressPdf, countPages, extractPages, hasSourceText } from "../pdf/index.js";
+import { fileTypeFromBuffer } from "file-type";
+import { InputSource, INPUT_TYPE_STREAM, INPUT_TYPE_BASE64, INPUT_TYPE_BYTES, INPUT_TYPE_PATH, INPUT_TYPE_BUFFER } from "./inputSource.js";
+export const MIMETYPES = new Map([
+    [".pdf", "application/pdf"],
+    [".heic", "image/heic"],
+    [".jpg", "image/jpeg"],
+    [".jpeg", "image/jpeg"],
+    [".png", "image/png"],
+    [".tif", "image/tiff"],
+    [".tiff", "image/tiff"],
+    [".webp", "image/webp"],
+]);
+const ALLOWED_INPUT_TYPES = [
+    INPUT_TYPE_STREAM,
+    INPUT_TYPE_BASE64,
+    INPUT_TYPE_BYTES,
+    INPUT_TYPE_PATH,
+    INPUT_TYPE_BUFFER,
+];
+export class LocalInputSource extends InputSource {
+    /**
+     * @param {InputConstructor} constructor Constructor parameters.
+     */
+    constructor({ inputType }) {
+        super();
+        this.filename = "";
+        this.mimeType = "";
+        // Check if inputType is valid
+        if (!ALLOWED_INPUT_TYPES.includes(inputType)) {
+            const allowed = Array.from(ALLOWED_INPUT_TYPES.keys()).join(", ");
+            errorHandler.throw(new MindeeInputSourceError(`Invalid input type, must be one of ${allowed}.`));
+        }
+        this.inputType = inputType;
+        logger.debug(`Initialized local input source of type: ${inputType}`);
+    }
+    async checkMimetype() {
+        if (!(this.fileObject instanceof Buffer)) {
+            throw new MindeeInputSourceError(`MIME type cannot be verified on input source of type ${this.inputType}.`);
+        }
+        let mimeType;
+        const fileExt = path.extname(this.filename);
+        if (fileExt) {
+            mimeType = MIMETYPES.get(fileExt.toLowerCase()) || "";
+        }
+        else {
+            const guess = await fileTypeFromBuffer(this.fileObject);
+            if (guess !== undefined) {
+                mimeType = guess.mime;
+            }
+            else {
+                throw "Could not determine the MIME type of the file";
+            }
+        }
+        if (!mimeType) {
+            const allowed = Array.from(MIMETYPES.keys()).join(", ");
+            const err = new MindeeInputSourceError(`Invalid file type, must be one of ${allowed}.`);
+            errorHandler.throw(err);
+        }
+        logger.debug(`File is of type: ${mimeType}`);
+        return mimeType;
+    }
+    /**
+     * Returns the file object as a Buffer.
+     * @returns Buffer representation of the file object
+     * @protected
+     */
+    getBuffer() {
+        if (typeof this.fileObject === "string") {
+            return Buffer.from(this.fileObject);
+        }
+        return this.fileObject;
+    }
+    /**
+     * Determines whether the current file is a PDF.
+     * @returns {boolean} Returns true if the file is a PDF; otherwise, returns false.
+     */
+    isPdf() {
+        if (!this.initialized) {
+            throw new MindeeInputSourceError("The `init()` method must be called before calling `isPdf()`.");
+        }
+        return this.mimeType === "application/pdf";
+    }
+    /**
+     * Cut PDF pages.
+     * @param pageOptions
+     */
+    async applyPageOptions(pageOptions) {
+        await this.init();
+        const buffer = this.getBuffer();
+        const processedPdf = await extractPages(buffer, pageOptions);
+        this.fileObject = processedPdf.file;
+    }
+    /**
+     * Compresses the file object, either as a PDF or an image.
+     *
+     * @param quality Quality of the compression. For images, this is the JPEG quality.
+     * For PDFs, this affects image quality within the PDF.
+     * @param maxWidth Maximum width for image resizing. Ignored for PDFs.
+     * @param maxHeight Maximum height for image resizing. Ignored for PDFs.
+     * @param forceSourceText For PDFs, whether to force compression even if source text is present.
+     * @param disableSourceText For PDFs, whether to disable source text during compression.
+     *
+     * @returns A Promise that resolves when the compression is complete.
+     */
+    async compress(quality = 85, maxWidth = null, maxHeight = null, forceSourceText = false, disableSourceText = true) {
+        await this.init();
+        const buffer = this.getBuffer();
+        if (this.isPdf()) {
+            this.fileObject = await compressPdf(buffer, quality, forceSourceText, disableSourceText);
+        }
+        else {
+            this.fileObject = await compressImage(buffer, quality, maxWidth, maxHeight);
+        }
+    }
+    /**
+     * Returns true if the object is a PDF and has source text. False otherwise.
+     * @return boolean
+     */
+    async hasSourceText() {
+        await this.init();
+        if (!this.isPdf()) {
+            return false;
+        }
+        const buffer = this.getBuffer();
+        return hasSourceText(buffer);
+    }
+    /**
+     * Returns the number of pages in the input source.
+     * For PDFs, returns the actual page count. For images, returns 1.
+     * @return Promise<number> The number of pages
+     */
+    async getPageCount() {
+        await this.init();
+        if (!this.isPdf()) {
+            return 1;
+        }
+        const buffer = this.getBuffer();
+        return countPages(buffer);
+    }
+}

package/src/input/pageOptions.d.ts

@@ -7,13 +7,13 @@ export interface PageOptions {
      *
      * A negative index can be used, indicating an offset from the end of the document.
      *
-     * [0, -1] represents the fist and last pages of the document.
+     * [0, -1] represents the first and last pages of the document.
      */
     pageIndexes: number[];
     /** Operation to apply on the document, given the `pageIndexes` specified. */
     operation: PageOptionsOperation;
     /**
-     * Apply the operation only if document has at least this many pages.
+     * Apply the operation only if the document has at least this many pages.
      */
     onMinPages: number;
 }

package/src/input/pageOptions.js

@@ -1,13 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PageOptionsOperation = void 0;
 /**
  * Operation to apply on the document, given the page indexes specified.
  */
-var PageOptionsOperation;
+/* eslint-disable @typescript-eslint/naming-convention */
+export var PageOptionsOperation;
 (function (PageOptionsOperation) {
     /** Only keep pages matching the provided indexes. */
     PageOptionsOperation["KeepOnly"] = "KEEP_ONLY";
     /** Remove pages matching the provided indexes. */
     PageOptionsOperation["Remove"] = "REMOVE";
-})(PageOptionsOperation || (exports.PageOptionsOperation = PageOptionsOperation = {}));
+})(PageOptionsOperation || (PageOptionsOperation = {}));

package/src/input/pathInput.d.ts

@@ -0,0 +1,11 @@
+import { LocalInputSource } from "./localInputSource.js";
+interface PathInputProps {
+    inputPath: string;
+}
+export declare class PathInput extends LocalInputSource {
+    readonly inputPath: string;
+    fileObject: Buffer;
+    constructor({ inputPath }: PathInputProps);
+    init(): Promise<void>;
+}
+export {};

package/src/input/pathInput.js

@@ -0,0 +1,24 @@
+import { INPUT_TYPE_PATH } from "./inputSource.js";
+import { LocalInputSource } from "./localInputSource.js";
+import path from "path";
+import { logger } from "../logger.js";
+import { promises as fs } from "fs";
+export class PathInput extends LocalInputSource {
+    constructor({ inputPath }) {
+        super({
+            inputType: INPUT_TYPE_PATH,
+        });
+        this.fileObject = Buffer.alloc(0);
+        this.inputPath = inputPath;
+        this.filename = path.basename(this.inputPath);
+    }
+    async init() {
+        if (this.initialized) {
+            return;
+        }
+        logger.debug(`Loading from path: ${this.inputPath}`);
+        this.fileObject = Buffer.from(await fs.readFile(this.inputPath));
+        this.mimeType = await this.checkMimetype();
+        this.initialized = true;
+    }
+}

package/src/input/streamInput.d.ts

@@ -0,0 +1,14 @@
+import { Readable } from "stream";
+import { LocalInputSource } from "./localInputSource.js";
+interface StreamInputProps {
+    inputStream: Readable;
+    filename: string;
+}
+export declare class StreamInput extends LocalInputSource {
+    private readonly inputStream;
+    fileObject: Buffer;
+    constructor({ inputStream, filename }: StreamInputProps);
+    init(): Promise<void>;
+    stream2buffer(stream: Readable, signal?: AbortSignal): Promise<Buffer>;
+}
+export {};

package/src/input/streamInput.js

@@ -0,0 +1,55 @@
+import { LocalInputSource } from "./localInputSource.js";
+import { INPUT_TYPE_STREAM } from "./inputSource.js";
+import { logger } from "../logger.js";
+import { MindeeInputSourceError } from "../errors/index.js";
+export class StreamInput extends LocalInputSource {
+    constructor({ inputStream, filename }) {
+        super({
+            inputType: INPUT_TYPE_STREAM,
+        });
+        this.fileObject = Buffer.alloc(0);
+        this.filename = filename;
+        this.inputStream = inputStream;
+    }
+    async init() {
+        if (this.initialized) {
+            return;
+        }
+        logger.debug("Loading from stream");
+        this.fileObject = await this.stream2buffer(this.inputStream);
+        this.mimeType = await this.checkMimetype();
+        this.initialized = true;
+    }
+    async stream2buffer(stream, signal) {
+        return new Promise((resolve, reject) => {
+            if (stream.closed || stream.destroyed) {
+                return reject(new MindeeInputSourceError("Stream is already closed"));
+            }
+            if (signal?.aborted) {
+                return reject(new MindeeInputSourceError("Operation aborted"));
+            }
+            const onAbort = () => {
+                stream.destroy();
+                reject(new MindeeInputSourceError("Operation aborted"));
+            };
+            if (signal) {
+                signal.addEventListener("abort", onAbort, { once: true });
+            }
+            const cleanup = () => {
+                signal?.removeEventListener("abort", onAbort);
+            };
+            const _buf = [];
+            stream.pause();
+            stream.on("data", (chunk) => _buf.push(chunk));
+            stream.on("end", () => {
+                cleanup();
+                resolve(Buffer.concat(_buf));
+            });
+            stream.on("error", (err) => {
+                cleanup();
+                reject(new MindeeInputSourceError(`Error converting stream - ${err}`));
+            });
+            stream.resume();
+        });
+    }
+}

package/src/input/urlInput.d.ts

@@ -0,0 +1,35 @@
+import { InputSource } from "./inputSource.js";
+import { Dispatcher } from "undici";
+import { BytesInput } from "./bytesInput.js";
+export declare class UrlInput extends InputSource {
+    readonly url: string;
+    readonly dispatcher: Dispatcher;
+    constructor({ url, dispatcher }: {
+        url: string;
+        dispatcher?: Dispatcher;
+    });
+    init(): Promise<void>;
+    private fetchFileContent;
+    saveToFile(options: {
+        filepath: string;
+        filename?: string;
+        username?: string;
+        password?: string;
+        token?: string;
+        headers?: Record<string, string>;
+        maxRedirects?: number;
+    }): Promise<string>;
+    asLocalInputSource(options?: {
+        filename?: string;
+        username?: string;
+        password?: string;
+        token?: string;
+        headers?: Record<string, string>;
+        maxRedirects?: number;
+    }): Promise<BytesInput>;
+    private static extractFilenameFromUrl;
+    private static generateFileName;
+    private static getFileExtension;
+    private fillFilename;
+    private makeRequest;
+}