mindee 2.1.1 → 3.0.1

package/src/inputs/sources.js

@@ -0,0 +1,121 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UrlInput = exports.BytesInput = exports.StreamInput = exports.Base64Input = exports.PathInput = void 0;
+const fs_1 = require("fs");
+const path = __importStar(require("path"));
+const handler_1 = require("../errors/handler");
+const node_buffer_1 = require("node:buffer");
+const logger_1 = require("../logger");
+const base_1 = require("./base");
+class PathInput extends base_1.InputSource {
+    constructor({ inputPath }) {
+        super({
+            inputType: base_1.INPUT_TYPE_PATH,
+        });
+        this.fileObject = node_buffer_1.Buffer.alloc(0);
+        this.inputPath = inputPath;
+        this.filename = path.basename(this.inputPath);
+    }
+    async init() {
+        logger_1.logger.debug(`Loading from: ${this.inputPath}`);
+        this.fileObject = node_buffer_1.Buffer.from(await fs_1.promises.readFile(this.inputPath));
+        this.mimeType = await this.checkMimetype();
+    }
+}
+exports.PathInput = PathInput;
+class Base64Input extends base_1.InputSource {
+    constructor({ inputString, filename }) {
+        super({
+            inputType: base_1.INPUT_TYPE_BASE64,
+        });
+        this.fileObject = node_buffer_1.Buffer.alloc(0);
+        this.filename = filename;
+        this.inputString = inputString;
+    }
+    async init() {
+        this.fileObject = node_buffer_1.Buffer.from(this.inputString, "base64");
+        this.mimeType = await this.checkMimetype();
+        // clear out the string
+        this.inputString = "";
+    }
+}
+exports.Base64Input = Base64Input;
+class StreamInput extends base_1.InputSource {
+    constructor({ inputStream, filename }) {
+        super({
+            inputType: base_1.INPUT_TYPE_STREAM,
+        });
+        this.fileObject = node_buffer_1.Buffer.alloc(0);
+        this.filename = filename;
+        this.inputStream = inputStream;
+    }
+    async init() {
+        this.fileObject = await this.stream2buffer(this.inputStream);
+        this.mimeType = await this.checkMimetype();
+    }
+    async stream2buffer(stream) {
+        return new Promise((resolve, reject) => {
+            const _buf = Array();
+            stream.on("data", (chunk) => _buf.push(chunk));
+            stream.on("end", () => resolve(node_buffer_1.Buffer.concat(_buf)));
+            stream.on("error", (err) => reject(`Error converting stream - ${err}`));
+        });
+    }
+}
+exports.StreamInput = StreamInput;
+class BytesInput extends base_1.InputSource {
+    constructor({ inputBytes, filename }) {
+        super({
+            inputType: base_1.INPUT_TYPE_BYTES,
+        });
+        this.fileObject = node_buffer_1.Buffer.alloc(0);
+        this.filename = filename;
+        this.inputBytes = inputBytes;
+    }
+    async init() {
+        this.fileObject = node_buffer_1.Buffer.from(this.inputBytes, "hex");
+        this.mimeType = await this.checkMimetype();
+        // clear out the string
+        this.inputBytes = "";
+    }
+}
+exports.BytesInput = BytesInput;
+class UrlInput extends base_1.InputSource {
+    constructor({ url }) {
+        super({
+            inputType: base_1.INPUT_TYPE_URL,
+        });
+        this.url = url;
+    }
+    async init() {
+        if (!this.url.toLowerCase().startsWith("https")) {
+            handler_1.errorHandler.throw(new Error("URL must be HTTPS"));
+        }
+        this.fileObject = this.url;
+        this.filename = "hello.jpg";
+    }
+}
+exports.UrlInput = UrlInput;

package/src/pdf/index.d.ts

@@ -0,0 +1 @@
+export { extractPages, countPages, SplitPdf } from "./pdfOperation";

package/src/pdf/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.countPages = exports.extractPages = void 0;
+var pdfOperation_1 = require("./pdfOperation");
+Object.defineProperty(exports, "extractPages", { enumerable: true, get: function () { return pdfOperation_1.extractPages; } });
+Object.defineProperty(exports, "countPages", { enumerable: true, get: function () { return pdfOperation_1.countPages; } });

package/src/pdf/pdfOperation.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="node" />
+import { PageOptions } from "../inputs";
+export interface SplitPdf {
+    file: Buffer;
+    totalPagesRemoved: number;
+}
+/**
+ * Cut pages from a pdf file. If pages index are out of bound, it will throw an error.
+ * @param file
+ * @param pageOptions
+ * @returns the new cutted pdf file.
+ */
+export declare function extractPages(file: Buffer, pageOptions: PageOptions): Promise<SplitPdf>;
+export declare function countPages(file: Buffer): Promise<number>;

package/src/pdf/pdfOperation.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.countPages = exports.extractPages = void 0;
+const handler_1 = require("../errors/handler");
+const pdf_lib_1 = require("pdf-lib");
+const inputs_1 = require("../inputs");
+const errors_1 = require("../errors");
+/**
+ * Cut pages from a pdf file. If pages index are out of bound, it will throw an error.
+ * @param file
+ * @param pageOptions
+ * @returns the new cutted pdf file.
+ */
+async function extractPages(file, pageOptions) {
+    const currentPdf = await pdf_lib_1.PDFDocument.load(file, {
+        ignoreEncryption: true,
+    });
+    const newPdf = await pdf_lib_1.PDFDocument.create();
+    if (pageOptions.pageIndexes.length > currentPdf.getPageCount()) {
+        handler_1.errorHandler.throw(new errors_1.MindeeError(`The total indexes of pages to cut is superior to the total page count of the file (${currentPdf.getPageCount()}).`));
+    }
+    if (currentPdf.getPageCount() < pageOptions.onMinPages) {
+        return { file: file, totalPagesRemoved: 0 };
+    }
+    const pageIndexes = [];
+    pageOptions.pageIndexes.forEach((pageIndex) => {
+        if (pageIndex < 0) {
+            pageIndexes.push(currentPdf.getPageCount() - Math.abs(pageIndex));
+        }
+        else {
+            pageIndexes.push(pageIndex);
+        }
+    });
+    if (!pageIndexes.every((v) => currentPdf.getPageIndices().includes(v))) {
+        handler_1.errorHandler.throw(new errors_1.MindeeError(`Some indexes pages
+        (${pageIndexes.join(",")})
+        don't exist in the file
+        (${currentPdf.getPageIndices().join(", ")})`));
+    }
+    if (pageOptions.operation === inputs_1.PageOptionsOperation.KeepOnly) {
+        const keptPages = await newPdf.copyPages(currentPdf, pageIndexes);
+        keptPages.forEach((keptPage) => {
+            newPdf.addPage(keptPage);
+        });
+    }
+    else if (pageOptions.operation === inputs_1.PageOptionsOperation.Remove) {
+        const pagesToKeep = currentPdf
+            .getPageIndices()
+            .filter((v) => !pageIndexes.includes(v));
+        const keptPages = await newPdf.copyPages(currentPdf, pagesToKeep);
+        keptPages.forEach((keptPage) => {
+            newPdf.addPage(keptPage);
+        });
+    }
+    else {
+        throw new Error(`The operation ${pageOptions.operation} is not available.`);
+    }
+    const sumRemovedPages = currentPdf.getPageCount() - newPdf.getPageCount();
+    const fileBuffer = Buffer.from(await newPdf.save());
+    return { file: fileBuffer, totalPagesRemoved: sumRemovedPages };
+}
+exports.extractPages = extractPages;
+async function countPages(file) {
+    const currentPdf = await pdf_lib_1.PDFDocument.load(file, {
+        ignoreEncryption: true,
+    });
+    return currentPdf.getPageCount();
+}
+exports.countPages = countPages;

package/src/constants.d.ts

@@ -1,13 +0,0 @@
-import { Response } from "./api";
-import { Document } from "./documents";
-export interface ProductConfig {
-    description: string;
-    docType: string;
-    responseClass: typeof Response<Document>;
-    fullText: boolean;
-}
-export declare class ProductConfigs {
-    private static configs;
-    static getByResponseClassName(responseClass: string): ProductConfig;
-    static getByDocType(docType: string): ProductConfig;
-}

package/src/constants.js

@@ -1,60 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ProductConfigs = void 0;
-const api_1 = require("./api");
-const documents_1 = require("./documents");
-class ProductConfigs {
-    static getByResponseClassName(responseClass) {
-        const config = this.configs.find((element) => element.responseClass.name === responseClass);
-        if (config === undefined) {
-            throw `Unknown response class: ${responseClass}`;
-        }
-        return config;
-    }
-    static getByDocType(docType) {
-        const config = this.configs.find((element) => element.docType === docType);
-        if (config === undefined) {
-            throw `Unknown document type: ${docType}`;
-        }
-        return config;
-    }
-}
-exports.ProductConfigs = ProductConfigs;
-ProductConfigs.configs = [
-    {
-        description: "Invoice",
-        docType: documents_1.DOC_TYPE_INVOICE,
-        responseClass: api_1.InvoiceResponse,
-        fullText: true,
-    },
-    {
-        description: "Expense Receipt",
-        docType: documents_1.DOC_TYPE_RECEIPT,
-        responseClass: api_1.ReceiptResponse,
-        fullText: true,
-    },
-    {
-        description: "Passport",
-        docType: documents_1.DOC_TYPE_PASSPORT,
-        responseClass: api_1.PassportResponse,
-        fullText: false,
-    },
-    {
-        description: "Financial Document (receipt or invoice)",
-        docType: documents_1.DOC_TYPE_FINANCIAL,
-        responseClass: api_1.FinancialDocResponse,
-        fullText: true,
-    },
-    {
-        description: "A custom document",
-        docType: documents_1.DOC_TYPE_CUSTOM,
-        responseClass: api_1.CustomResponse,
-        fullText: false,
-    },
-    {
-        description: "Cropper",
-        docType: documents_1.DOC_TYPE_CROPPER,
-        responseClass: api_1.CropperResponse,
-        fullText: false,
-    },
-];

package/src/documents/cropper.d.ts

@@ -1,7 +0,0 @@
-import { Document, DocumentConstructorProps } from "./document";
-import { CropperField } from "../fields";
-export declare class Cropper extends Document {
-    cropping: CropperField[];
-    constructor({ prediction, orientation, inputFile, pageId, }: DocumentConstructorProps);
-    toString(): string;
-}

package/src/documents/receipt.d.ts

@@ -1,17 +0,0 @@
-import { Document, DocumentConstructorProps } from "./document";
-import { TaxField, Field, Amount, Locale, DateField } from "../fields";
-export declare class Receipt extends Document {
-    #private;
-    locale: Locale;
-    totalIncl: Amount;
-    date: DateField;
-    /** Receipt category as seen on the receipt. */
-    category: Field;
-    merchantName: Field;
-    time: Field;
-    totalTax: Amount;
-    totalExcl: Amount;
-    taxes: TaxField[];
-    constructor({ prediction, orientation, extras, inputFile, fullText, pageId, }: DocumentConstructorProps);
-    toString(): string;
-}

package/src/inputs.d.ts

@@ -1,69 +0,0 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import { ReadStream } from "fs";
-import { Buffer } from "node:buffer";
-interface InputProps {
-    inputType: string;
-}
-export declare const INPUT_TYPE_STREAM = "stream";
-export declare const INPUT_TYPE_BASE64 = "base64";
-export declare const INPUT_TYPE_BYTES = "bytes";
-export declare const INPUT_TYPE_PATH = "path";
-export declare class Input {
-    MAX_DOC_PAGES: number;
-    inputType: string;
-    filename: string;
-    filepath?: string;
-    mimeType: string;
-    fileObject: Buffer;
-    /**
-     * @param {String} inputType - the type of input used in file ("base64", "path", "dummy").
-     *                             NB: dummy is only used for tests purposes
-     * @param {Boolean} cutPages
-     * NB: Because of async calls, init() should be called after creating the object
-     */
-    constructor({ inputType }: InputProps);
-    init(): Promise<void>;
-    isPdf(): boolean;
-    checkMimetype(): Promise<string>;
-    countPages(): Promise<number>;
-    /** Merge PDF pages */
-    cutPdf(): Promise<void>;
-}
-interface PathInputProps {
-    inputPath: string;
-}
-export declare class PathInput extends Input {
-    readonly inputPath: string;
-    constructor({ inputPath }: PathInputProps);
-    init(): Promise<void>;
-}
-interface Base64InputProps {
-    inputString: string;
-    filename: string;
-}
-export declare class Base64Input extends Input {
-    private inputString;
-    constructor({ inputString, filename }: Base64InputProps);
-    init(): Promise<void>;
-}
-interface StreamInputProps {
-    inputStream: ReadStream;
-    filename: string;
-}
-export declare class StreamInput extends Input {
-    private inputStream;
-    constructor({ inputStream, filename }: StreamInputProps);
-    init(): Promise<void>;
-    stream2buffer(stream: ReadStream): Promise<Buffer>;
-}
-interface BytesInputProps {
-    inputBytes: string;
-    filename: string;
-}
-export declare class BytesInput extends Input {
-    private inputBytes;
-    constructor({ inputBytes, filename }: BytesInputProps);
-    init(): Promise<void>;
-}
-export {};

package/src/inputs.js

@@ -1,196 +0,0 @@
-"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 (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BytesInput = exports.StreamInput = exports.Base64Input = exports.PathInput = exports.Input = exports.INPUT_TYPE_PATH = exports.INPUT_TYPE_BYTES = exports.INPUT_TYPE_BASE64 = exports.INPUT_TYPE_STREAM = void 0;
-const fs_1 = require("fs");
-const path = __importStar(require("path"));
-const fileType = __importStar(require("file-type"));
-const handler_1 = require("./errors/handler");
-const pdf_lib_1 = require("pdf-lib");
-const node_buffer_1 = require("node:buffer");
-const logger_1 = require("./logger");
-exports.INPUT_TYPE_STREAM = "stream";
-exports.INPUT_TYPE_BASE64 = "base64";
-exports.INPUT_TYPE_BYTES = "bytes";
-exports.INPUT_TYPE_PATH = "path";
-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 = [
-    exports.INPUT_TYPE_STREAM,
-    exports.INPUT_TYPE_BASE64,
-    exports.INPUT_TYPE_BYTES,
-    exports.INPUT_TYPE_PATH,
-];
-class Input {
-    /**
-     * @param {String} inputType - the type of input used in file ("base64", "path", "dummy").
-     *                             NB: dummy is only used for tests purposes
-     * @param {Boolean} cutPages
-     * NB: Because of async calls, init() should be called after creating the object
-     */
-    constructor({ inputType }) {
-        this.MAX_DOC_PAGES = 3;
-        this.filename = "";
-        this.mimeType = "";
-        this.fileObject = node_buffer_1.Buffer.alloc(0);
-        // Check if inputType is valid
-        if (!ALLOWED_INPUT_TYPES.includes(inputType)) {
-            const allowed = Array.from(MIMETYPES.keys()).join(", ");
-            handler_1.errorHandler.throw(new Error(`Invalid input type, must be one of ${allowed}.`));
-        }
-        this.inputType = inputType;
-        logger_1.logger.debug(`Loading file from: ${inputType}`);
-    }
-    async init() {
-        throw new Error("not Implemented");
-    }
-    isPdf() {
-        return this.mimeType === "application/pdf";
-    }
-    async checkMimetype() {
-        let mimeType;
-        const fileExt = path.extname(this.filename);
-        if (fileExt) {
-            mimeType = MIMETYPES.get(fileExt.toLowerCase()) || "";
-        }
-        else {
-            const guess = await fileType.fromBuffer(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 Error(`Invalid file type, must be one of ${allowed}.`);
-            handler_1.errorHandler.throw(err);
-        }
-        logger_1.logger.debug(`File is of type: ${mimeType}`);
-        return mimeType;
-    }
-    async countPages() {
-        const pdfDocument = await pdf_lib_1.PDFDocument.load(this.fileObject, {
-            ignoreEncryption: true,
-        });
-        return pdfDocument.getPageCount();
-    }
-    /** Merge PDF pages */
-    async cutPdf() {
-        const currentPdf = await pdf_lib_1.PDFDocument.load(this.fileObject, {
-            ignoreEncryption: true,
-        });
-        const pdfLength = currentPdf.getPageCount();
-        if (pdfLength <= this.MAX_DOC_PAGES) {
-            return;
-        }
-        const newPdf = await pdf_lib_1.PDFDocument.create();
-        const pagesNumbers = [0, pdfLength - 2, pdfLength - 1].slice(0, this.MAX_DOC_PAGES);
-        logger_1.logger.debug(`Cutting PDF, keeping pages: ${pagesNumbers}`);
-        const pages = await newPdf.copyPages(currentPdf, pagesNumbers);
-        pages.forEach((page) => newPdf.addPage(page));
-        const data = await newPdf.save();
-        this.fileObject = node_buffer_1.Buffer.from(data);
-    }
-}
-exports.Input = Input;
-class PathInput extends Input {
-    constructor({ inputPath }) {
-        super({
-            inputType: exports.INPUT_TYPE_PATH,
-        });
-        this.inputPath = inputPath;
-        this.filename = path.basename(this.inputPath);
-    }
-    async init() {
-        logger_1.logger.debug(`Loading from: ${this.inputPath}`);
-        this.fileObject = node_buffer_1.Buffer.from(await fs_1.promises.readFile(this.inputPath));
-        this.mimeType = await this.checkMimetype();
-    }
-}
-exports.PathInput = PathInput;
-class Base64Input extends Input {
-    constructor({ inputString, filename }) {
-        super({
-            inputType: exports.INPUT_TYPE_BASE64,
-        });
-        this.filename = filename;
-        this.inputString = inputString;
-    }
-    async init() {
-        this.fileObject = node_buffer_1.Buffer.from(this.inputString, "base64");
-        this.mimeType = await this.checkMimetype();
-        // clear out the string
-        this.inputString = "";
-    }
-}
-exports.Base64Input = Base64Input;
-class StreamInput extends Input {
-    constructor({ inputStream, filename }) {
-        super({
-            inputType: exports.INPUT_TYPE_STREAM,
-        });
-        this.filename = filename;
-        this.inputStream = inputStream;
-    }
-    async init() {
-        this.fileObject = await this.stream2buffer(this.inputStream);
-        this.mimeType = await this.checkMimetype();
-    }
-    async stream2buffer(stream) {
-        return new Promise((resolve, reject) => {
-            const _buf = Array();
-            stream.on("data", (chunk) => _buf.push(chunk));
-            stream.on("end", () => resolve(node_buffer_1.Buffer.concat(_buf)));
-            stream.on("error", (err) => reject(`Error converting stream - ${err}`));
-        });
-    }
-}
-exports.StreamInput = StreamInput;
-class BytesInput extends Input {
-    constructor({ inputBytes, filename }) {
-        super({
-            inputType: exports.INPUT_TYPE_BYTES,
-        });
-        this.filename = filename;
-        this.inputBytes = inputBytes;
-    }
-    async init() {
-        this.fileObject = node_buffer_1.Buffer.from(this.inputBytes, "hex");
-        this.mimeType = await this.checkMimetype();
-        // clear out the string
-        this.inputBytes = "";
-    }
-}
-exports.BytesInput = BytesInput;