@payloadcms/next 3.0.0-beta.66 → 3.0.0-beta.67

package/dist/fetchAPI-multipart/handlers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handlers.d.ts","sourceRoot":"","sources":["../../src/fetchAPI-multipart/handlers.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,YAAY,CAAA;AAI3D,KAAK,OAAO,GAAG,CACb,OAAO,EAAE,yBAAyB,EAClC,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,KACb;IACH,OAAO,EAAE,MAAM,IAAI,CAAA;IACnB,QAAQ,EAAE,MAAM,MAAM,CAAA;IACtB,WAAW,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;IACnC,WAAW,EAAE,MAAM,MAAM,CAAA;IACzB,WAAW,EAAE,MAAM,MAAM,CAAA;IACzB,OAAO,EAAE,MAAM,MAAM,CAAA;IACrB,eAAe,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,CAAA;CACxC,CAAA;AAED,eAAO,MAAM,eAAe,EAAE,OAsD7B,CAAA;AAED,eAAO,MAAM,UAAU,EAAE,OAgCxB,CAAA"}

package/dist/fetchAPI-multipart/handlers.js

@@ -0,0 +1,86 @@
+import crypto from 'crypto';
+import fs, { WriteStream } from 'fs';
+import path from 'path';
+import { checkAndMakeDir, debugLog, deleteFile, getTempFilename } from './utilities.js';
+export const tempFileHandler = (options, fieldname, filename)=>{
+    const dir = path.normalize(options.tempFileDir);
+    const tempFilePath = path.join(process.cwd(), dir, getTempFilename());
+    checkAndMakeDir({
+        createParentPath: true
+    }, tempFilePath);
+    debugLog(options, `Temporary file path is ${tempFilePath}`);
+    const hash = crypto.createHash('md5');
+    let fileSize = 0;
+    let completed = false;
+    debugLog(options, `Opening write stream for ${fieldname}->${filename}...`);
+    const writeStream = fs.createWriteStream(tempFilePath);
+    const writePromise = new Promise((resolve, reject)=>{
+        writeStream.on('finish', ()=>resolve(true));
+        writeStream.on('error', (err)=>{
+            debugLog(options, `Error write temp file: ${err}`);
+            reject(err);
+        });
+    });
+    return {
+        cleanup: ()=>{
+            completed = true;
+            debugLog(options, `Cleaning up temporary file ${tempFilePath}...`);
+            writeStream.end();
+            deleteFile(tempFilePath, (err)=>err ? debugLog(options, `Cleaning up temporary file ${tempFilePath} failed: ${err}`) : debugLog(options, `Cleaning up temporary file ${tempFilePath} done.`));
+        },
+        complete: ()=>{
+            completed = true;
+            debugLog(options, `Upload ${fieldname}->${filename} completed, bytes:${fileSize}.`);
+            if (writeStream instanceof WriteStream) writeStream.end();
+            // Return empty buff since data was uploaded into a temp file.
+            return Buffer.concat([]);
+        },
+        dataHandler: (data)=>{
+            if (completed === true) {
+                debugLog(options, `Error: got ${fieldname}->${filename} data chunk for completed upload!`);
+                return;
+            }
+            writeStream.write(data);
+            hash.update(data);
+            fileSize += data.length;
+            debugLog(options, `Uploading ${fieldname}->${filename}, bytes:${fileSize}...`);
+        },
+        getFilePath: ()=>tempFilePath,
+        getFileSize: ()=>fileSize,
+        getHash: ()=>hash.digest('hex'),
+        getWritePromise: ()=>writePromise
+    };
+};
+export const memHandler = (options, fieldname, filename)=>{
+    const buffers = [];
+    const hash = crypto.createHash('md5');
+    let fileSize = 0;
+    let completed = false;
+    const getBuffer = ()=>Buffer.concat(buffers, fileSize);
+    return {
+        cleanup: ()=>{
+            completed = true;
+        },
+        complete: ()=>{
+            debugLog(options, `Upload ${fieldname}->${filename} completed, bytes:${fileSize}.`);
+            completed = true;
+            return getBuffer();
+        },
+        dataHandler: (data)=>{
+            if (completed === true) {
+                debugLog(options, `Error: got ${fieldname}->${filename} data chunk for completed upload!`);
+                return;
+            }
+            buffers.push(data);
+            hash.update(data);
+            fileSize += data.length;
+            debugLog(options, `Uploading ${fieldname}->${filename}, bytes:${fileSize}...`);
+        },
+        getFilePath: ()=>'',
+        getFileSize: ()=>fileSize,
+        getHash: ()=>hash.digest('hex'),
+        getWritePromise: ()=>Promise.resolve(true)
+    };
+};
+
+//# sourceMappingURL=handlers.js.map

package/dist/fetchAPI-multipart/handlers.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/fetchAPI-multipart/handlers.ts"],"sourcesContent":["import crypto from 'crypto'\nimport fs, { WriteStream } from 'fs'\nimport path from 'path'\n\nimport type { FetchAPIFileUploadOptions } from './index.js'\n\nimport { checkAndMakeDir, debugLog, deleteFile, getTempFilename } from './utilities.js'\n\ntype Handler = (\n  options: FetchAPIFileUploadOptions,\n  fieldname: string,\n  filename: string,\n) => {\n  cleanup: () => void\n  complete: () => Buffer\n  dataHandler: (data: Buffer) => void\n  getFilePath: () => string\n  getFileSize: () => number\n  getHash: () => string\n  getWritePromise: () => Promise<boolean>\n}\n\nexport const tempFileHandler: Handler = (options, fieldname, filename) => {\n  const dir = path.normalize(options.tempFileDir)\n  const tempFilePath = path.join(process.cwd(), dir, getTempFilename())\n  checkAndMakeDir({ createParentPath: true }, tempFilePath)\n\n  debugLog(options, `Temporary file path is ${tempFilePath}`)\n\n  const hash = crypto.createHash('md5')\n  let fileSize = 0\n  let completed = false\n\n  debugLog(options, `Opening write stream for ${fieldname}->${filename}...`)\n  const writeStream = fs.createWriteStream(tempFilePath)\n  const writePromise = new Promise<boolean>((resolve, reject) => {\n    writeStream.on('finish', () => resolve(true))\n    writeStream.on('error', (err) => {\n      debugLog(options, `Error write temp file: ${err}`)\n      reject(err)\n    })\n  })\n\n  return {\n    cleanup: () => {\n      completed = true\n      debugLog(options, `Cleaning up temporary file ${tempFilePath}...`)\n      writeStream.end()\n      deleteFile(tempFilePath, (err) =>\n        err\n          ? debugLog(options, `Cleaning up temporary file ${tempFilePath} failed: ${err}`)\n          : debugLog(options, `Cleaning up temporary file ${tempFilePath} done.`),\n      )\n    },\n    complete: () => {\n      completed = true\n      debugLog(options, `Upload ${fieldname}->${filename} completed, bytes:${fileSize}.`)\n      if (writeStream instanceof WriteStream) writeStream.end()\n      // Return empty buff since data was uploaded into a temp file.\n      return Buffer.concat([])\n    },\n    dataHandler: (data) => {\n      if (completed === true) {\n        debugLog(options, `Error: got ${fieldname}->${filename} data chunk for completed upload!`)\n        return\n      }\n      writeStream.write(data)\n      hash.update(data)\n      fileSize += data.length\n      debugLog(options, `Uploading ${fieldname}->${filename}, bytes:${fileSize}...`)\n    },\n    getFilePath: () => tempFilePath,\n    getFileSize: () => fileSize,\n    getHash: () => hash.digest('hex'),\n    getWritePromise: () => writePromise,\n  }\n}\n\nexport const memHandler: Handler = (options, fieldname, filename) => {\n  const buffers: Buffer[] = []\n  const hash = crypto.createHash('md5')\n  let fileSize = 0\n  let completed = false\n\n  const getBuffer = () => Buffer.concat(buffers, fileSize)\n\n  return {\n    cleanup: () => {\n      completed = true\n    },\n    complete: () => {\n      debugLog(options, `Upload ${fieldname}->${filename} completed, bytes:${fileSize}.`)\n      completed = true\n      return getBuffer()\n    },\n    dataHandler: (data) => {\n      if (completed === true) {\n        debugLog(options, `Error: got ${fieldname}->${filename} data chunk for completed upload!`)\n        return\n      }\n      buffers.push(data)\n      hash.update(data)\n      fileSize += data.length\n      debugLog(options, `Uploading ${fieldname}->${filename}, bytes:${fileSize}...`)\n    },\n    getFilePath: () => '',\n    getFileSize: () => fileSize,\n    getHash: () => hash.digest('hex'),\n    getWritePromise: () => Promise.resolve(true),\n  }\n}\n"],"names":["crypto","fs","WriteStream","path","checkAndMakeDir","debugLog","deleteFile","getTempFilename","tempFileHandler","options","fieldname","filename","dir","normalize","tempFileDir","tempFilePath","join","process","cwd","createParentPath","hash","createHash","fileSize","completed","writeStream","createWriteStream","writePromise","Promise","resolve","reject","on","err","cleanup","end","complete","Buffer","concat","dataHandler","data","write","update","length","getFilePath","getFileSize","getHash","digest","getWritePromise","memHandler","buffers","getBuffer","push"],"mappings":"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"}

package/dist/fetchAPI-multipart/index.d.ts

@@ -0,0 +1,132 @@
+import type { BusboyConfig } from 'busboy';
+import { APIError } from 'payload';
+export type FileShape = {
+    data: Buffer;
+    encoding: string;
+    md5: Buffer | string;
+    mimetype: string;
+    mv: (filePath: string, callback: () => void) => Promise<void> | void;
+    name: string;
+    size: number;
+    tempFilePath: string;
+    truncated: boolean;
+};
+export type FetchAPIFileUploadOptions = {
+    /**
+     * Returns a HTTP 413 when the file is bigger than the size limit if `true`.
+     * Otherwise, it will add a `truncated = true` to the resulting file structure.
+     * @default false
+     */
+    abortOnLimit?: boolean | undefined;
+    /**
+     * Automatically creates the directory path specified in `.mv(filePathName)`
+     * @default false
+     */
+    createParentPath?: boolean | undefined;
+    /**
+     * Turn on/off upload process logging. Can be useful for troubleshooting.
+     * @default false
+     */
+    debug?: boolean | undefined;
+    /**
+     * User defined limit handler which will be invoked if the file is bigger than configured limits.
+     * @default false
+     */
+    limitHandler?: ((args: {
+        request: Request;
+        size: number;
+    }) => void) | boolean | undefined;
+    /**
+     * By default, `req.body` and `req.files` are flattened like this:
+     * `{'name': 'John', 'hobbies[0]': 'Cinema', 'hobbies[1]': 'Bike'}
+     *
+     * When this option is enabled they are parsed in order to be nested like this:
+     * `{'name': 'John', 'hobbies': ['Cinema', 'Bike']}`
+     * @default false
+     */
+    parseNested?: boolean | undefined;
+    /**
+     * Preserves filename extension when using `safeFileNames` option.
+     * If set to `true`, will default to an extension length of `3`.
+     * If set to `number`, this will be the max allowable extension length.
+     * If an extension is smaller than the extension length, it remains untouched. If the extension is longer,
+     * it is shifted.
+     * @default false
+     *
+     * @example
+     * // true
+     * app.use(fileUpload({ safeFileNames: true, preserveExtension: true }));
+     * // myFileName.ext --> myFileName.ext
+     *
+     * @example
+     * // max extension length 2, extension shifted
+     * app.use(fileUpload({ safeFileNames: true, preserveExtension: 2 }));
+     * // myFileName.ext --> myFileNamee.xt
+     */
+    preserveExtension?: boolean | number | undefined;
+    /**
+     * Response which will be send to client if file size limit exceeded when `abortOnLimit` set to `true`.
+     * @default 'File size limit has been reached'
+     */
+    responseOnLimit?: string | undefined;
+    /**
+     * Strips characters from the upload's filename.
+     * You can use custom regex to determine what to strip.
+     * If set to `true`, non-alphanumeric characters _except_ dashes and underscores will be stripped.
+     * This option is off by default.
+     * @default false
+     *
+     * @example
+     * // strip slashes from file names
+     * app.use(fileUpload({ safeFileNames: /\\/g }))
+     *
+     * @example
+     * app.use(fileUpload({ safeFileNames: true }))
+     */
+    safeFileNames?: RegExp | boolean | undefined;
+    /**
+     * Path to store temporary files.
+     * Used along with the `useTempFiles` option. By default this module uses `'tmp'` folder
+     * in the current working directory.
+     * You can use trailing slash, but it is not necessary.
+     * @default './tmp'
+     */
+    tempFileDir?: string | undefined;
+    /**
+     * This defines how long to wait for data before aborting. Set to `0` if you want to turn off timeout checks.
+     * @default 60_000
+     */
+    uploadTimeout?: number | undefined;
+    /**
+     * Applies uri decoding to file names if set `true`.
+     * @default false
+     */
+    uriDecodeFileNames?: boolean | undefined;
+    /**
+     * By default this module uploads files into RAM.
+     * Setting this option to `true` turns on using temporary files instead of utilising RAM.
+     * This avoids memory overflow issues when uploading large files or in case of uploading
+     * lots of files at same time.
+     * @default false
+     */
+    useTempFiles?: boolean | undefined;
+} & Partial<BusboyConfig>;
+type FetchAPIFileUploadResponseFile = {
+    data: Buffer;
+    mimetype: string;
+    name: string;
+    size: number;
+    tempFilePath?: string;
+};
+export type FetchAPIFileUploadResponse = {
+    error?: APIError;
+    fields: Record<string, string>;
+    files: Record<string, FetchAPIFileUploadResponseFile>;
+};
+type FetchAPIFileUpload = (args: {
+    options?: FetchAPIFileUploadOptions;
+    request: Request;
+}) => Promise<FetchAPIFileUploadResponse>;
+export declare const fetchAPIFileUpload: FetchAPIFileUpload;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/fetchAPI-multipart/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/fetchAPI-multipart/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAA;AAG1C,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAA;AAsBlC,MAAM,MAAM,SAAS,GAAG;IACtB,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,MAAM,CAAA;IAChB,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;IACpB,QAAQ,EAAE,MAAM,CAAA;IAChB,EAAE,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,IAAI,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAA;IACpE,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,YAAY,EAAE,MAAM,CAAA;IACpB,SAAS,EAAE,OAAO,CAAA;CACnB,CAAA;AAED,MAAM,MAAM,yBAAyB,GAAG;IACtC;;;;OAIG;IACH,YAAY,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;IAClC;;;OAGG;IACH,gBAAgB,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;IACtC;;;OAGG;IACH,KAAK,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;IAC3B;;;OAGG;IACH,YAAY,CAAC,EAAE,CAAC,CAAC,IAAI,EAAE;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,CAAC,GAAG,OAAO,GAAG,SAAS,CAAA;IACzF;;;;;;;OAOG;IACH,WAAW,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;IACjC;;;;;;;;;;;;;;;;;OAiBG;IACH,iBAAiB,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAAA;IAChD;;;OAGG;IACH,eAAe,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IACpC;;;;;;;;;;;;;OAaG;IACH,aAAa,CAAC,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS,CAAA;IAC5C;;;;;;OAMG;IACH,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAChC;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAClC;;;OAGG;IACH,kBAAkB,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;IACxC;;;;;;OAMG;IACH,YAAY,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;CACnC,GAAG,OAAO,CAAC,YAAY,CAAC,CAAA;AAEzB,KAAK,8BAA8B,GAAG;IACpC,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,MAAM,CAAA;IAChB,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB,CAAA;AAED,MAAM,MAAM,0BAA0B,GAAG;IACvC,KAAK,CAAC,EAAE,QAAQ,CAAA;IAChB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC9B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,8BAA8B,CAAC,CAAA;CACtD,CAAA;AAED,KAAK,kBAAkB,GAAG,CAAC,IAAI,EAAE;IAC/B,OAAO,CAAC,EAAE,yBAAyB,CAAA;IACnC,OAAO,EAAE,OAAO,CAAA;CACjB,KAAK,OAAO,CAAC,0BAA0B,CAAC,CAAA;AACzC,eAAO,MAAM,kBAAkB,EAAE,kBAYhC,CAAA"}

package/dist/fetchAPI-multipart/index.js

@@ -0,0 +1,41 @@
+import path from 'path';
+import { APIError } from 'payload';
+import { isEligibleRequest } from './isEligibleRequest.js';
+import { processMultipart } from './processMultipart.js';
+import { debugLog } from './utilities.js';
+const DEFAULT_OPTIONS = {
+    abortOnLimit: false,
+    createParentPath: false,
+    debug: false,
+    fileHandler: false,
+    limitHandler: false,
+    parseNested: false,
+    preserveExtension: false,
+    responseOnLimit: 'File size limit has been reached',
+    safeFileNames: false,
+    tempFileDir: path.join(process.cwd(), 'tmp'),
+    uploadTimeout: 60000,
+    uriDecodeFileNames: false,
+    useTempFiles: false
+};
+export const fetchAPIFileUpload = async ({ options, request })=>{
+    const uploadOptions = {
+        ...DEFAULT_OPTIONS,
+        ...options
+    };
+    if (!isEligibleRequest(request)) {
+        debugLog(uploadOptions, 'Request is not eligible for file upload!');
+        return {
+            error: new APIError('Request is not eligible for file upload', 500),
+            fields: undefined,
+            files: undefined
+        };
+    } else {
+        return processMultipart({
+            options: uploadOptions,
+            request
+        });
+    }
+};
+
+//# sourceMappingURL=index.js.map

package/dist/fetchAPI-multipart/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/fetchAPI-multipart/index.ts"],"sourcesContent":["import type { BusboyConfig } from 'busboy'\n\nimport path from 'path'\nimport { APIError } from 'payload'\n\nimport { isEligibleRequest } from './isEligibleRequest.js'\nimport { processMultipart } from './processMultipart.js'\nimport { debugLog } from './utilities.js'\n\nconst DEFAULT_OPTIONS = {\n  abortOnLimit: false,\n  createParentPath: false,\n  debug: false,\n  fileHandler: false,\n  limitHandler: false,\n  parseNested: false,\n  preserveExtension: false,\n  responseOnLimit: 'File size limit has been reached',\n  safeFileNames: false,\n  tempFileDir: path.join(process.cwd(), 'tmp'),\n  uploadTimeout: 60000,\n  uriDecodeFileNames: false,\n  useTempFiles: false,\n}\n\nexport type FileShape = {\n  data: Buffer\n  encoding: string\n  md5: Buffer | string\n  mimetype: string\n  mv: (filePath: string, callback: () => void) => Promise<void> | void\n  name: string\n  size: number\n  tempFilePath: string\n  truncated: boolean\n}\n\nexport type FetchAPIFileUploadOptions = {\n  /**\n   * Returns a HTTP 413 when the file is bigger than the size limit if `true`.\n   * Otherwise, it will add a `truncated = true` to the resulting file structure.\n   * @default false\n   */\n  abortOnLimit?: boolean | undefined\n  /**\n   * Automatically creates the directory path specified in `.mv(filePathName)`\n   * @default false\n   */\n  createParentPath?: boolean | undefined\n  /**\n   * Turn on/off upload process logging. Can be useful for troubleshooting.\n   * @default false\n   */\n  debug?: boolean | undefined\n  /**\n   * User defined limit handler which will be invoked if the file is bigger than configured limits.\n   * @default false\n   */\n  limitHandler?: ((args: { request: Request; size: number }) => void) | boolean | undefined\n  /**\n   * By default, `req.body` and `req.files` are flattened like this:\n   * `{'name': 'John', 'hobbies[0]': 'Cinema', 'hobbies[1]': 'Bike'}\n   *\n   * When this option is enabled they are parsed in order to be nested like this:\n   * `{'name': 'John', 'hobbies': ['Cinema', 'Bike']}`\n   * @default false\n   */\n  parseNested?: boolean | undefined\n  /**\n   * Preserves filename extension when using `safeFileNames` option.\n   * If set to `true`, will default to an extension length of `3`.\n   * If set to `number`, this will be the max allowable extension length.\n   * If an extension is smaller than the extension length, it remains untouched. If the extension is longer,\n   * it is shifted.\n   * @default false\n   *\n   * @example\n   * // true\n   * app.use(fileUpload({ safeFileNames: true, preserveExtension: true }));\n   * // myFileName.ext --> myFileName.ext\n   *\n   * @example\n   * // max extension length 2, extension shifted\n   * app.use(fileUpload({ safeFileNames: true, preserveExtension: 2 }));\n   * // myFileName.ext --> myFileNamee.xt\n   */\n  preserveExtension?: boolean | number | undefined\n  /**\n   * Response which will be send to client if file size limit exceeded when `abortOnLimit` set to `true`.\n   * @default 'File size limit has been reached'\n   */\n  responseOnLimit?: string | undefined\n  /**\n   * Strips characters from the upload's filename.\n   * You can use custom regex to determine what to strip.\n   * If set to `true`, non-alphanumeric characters _except_ dashes and underscores will be stripped.\n   * This option is off by default.\n   * @default false\n   *\n   * @example\n   * // strip slashes from file names\n   * app.use(fileUpload({ safeFileNames: /\\\\/g }))\n   *\n   * @example\n   * app.use(fileUpload({ safeFileNames: true }))\n   */\n  safeFileNames?: RegExp | boolean | undefined\n  /**\n   * Path to store temporary files.\n   * Used along with the `useTempFiles` option. By default this module uses `'tmp'` folder\n   * in the current working directory.\n   * You can use trailing slash, but it is not necessary.\n   * @default './tmp'\n   */\n  tempFileDir?: string | undefined\n  /**\n   * This defines how long to wait for data before aborting. Set to `0` if you want to turn off timeout checks.\n   * @default 60_000\n   */\n  uploadTimeout?: number | undefined\n  /**\n   * Applies uri decoding to file names if set `true`.\n   * @default false\n   */\n  uriDecodeFileNames?: boolean | undefined\n  /**\n   * By default this module uploads files into RAM.\n   * Setting this option to `true` turns on using temporary files instead of utilising RAM.\n   * This avoids memory overflow issues when uploading large files or in case of uploading\n   * lots of files at same time.\n   * @default false\n   */\n  useTempFiles?: boolean | undefined\n} & Partial<BusboyConfig>\n\ntype FetchAPIFileUploadResponseFile = {\n  data: Buffer\n  mimetype: string\n  name: string\n  size: number\n  tempFilePath?: string\n}\n\nexport type FetchAPIFileUploadResponse = {\n  error?: APIError\n  fields: Record<string, string>\n  files: Record<string, FetchAPIFileUploadResponseFile>\n}\n\ntype FetchAPIFileUpload = (args: {\n  options?: FetchAPIFileUploadOptions\n  request: Request\n}) => Promise<FetchAPIFileUploadResponse>\nexport const fetchAPIFileUpload: FetchAPIFileUpload = async ({ options, request }) => {\n  const uploadOptions: FetchAPIFileUploadOptions = { ...DEFAULT_OPTIONS, ...options }\n  if (!isEligibleRequest(request)) {\n    debugLog(uploadOptions, 'Request is not eligible for file upload!')\n    return {\n      error: new APIError('Request is not eligible for file upload', 500),\n      fields: undefined,\n      files: undefined,\n    }\n  } else {\n    return processMultipart({ options: uploadOptions, request })\n  }\n}\n"],"names":["path","APIError","isEligibleRequest","processMultipart","debugLog","DEFAULT_OPTIONS","abortOnLimit","createParentPath","debug","fileHandler","limitHandler","parseNested","preserveExtension","responseOnLimit","safeFileNames","tempFileDir","join","process","cwd","uploadTimeout","uriDecodeFileNames","useTempFiles","fetchAPIFileUpload","options","request","uploadOptions","error","fields","undefined","files"],"mappings":"AAEA,OAAOA,UAAU,OAAM;AACvB,SAASC,QAAQ,QAAQ,UAAS;AAElC,SAASC,iBAAiB,QAAQ,yBAAwB;AAC1D,SAASC,gBAAgB,QAAQ,wBAAuB;AACxD,SAASC,QAAQ,QAAQ,iBAAgB;AAEzC,MAAMC,kBAAkB;IACtBC,cAAc;IACdC,kBAAkB;IAClBC,OAAO;IACPC,aAAa;IACbC,cAAc;IACdC,aAAa;IACbC,mBAAmB;IACnBC,iBAAiB;IACjBC,eAAe;IACfC,aAAaf,KAAKgB,IAAI,CAACC,QAAQC,GAAG,IAAI;IACtCC,eAAe;IACfC,oBAAoB;IACpBC,cAAc;AAChB;AAkIA,OAAO,MAAMC,qBAAyC,OAAO,EAAEC,OAAO,EAAEC,OAAO,EAAE;IAC/E,MAAMC,gBAA2C;QAAE,GAAGpB,eAAe;QAAE,GAAGkB,OAAO;IAAC;IAClF,IAAI,CAACrB,kBAAkBsB,UAAU;QAC/BpB,SAASqB,eAAe;QACxB,OAAO;YACLC,OAAO,IAAIzB,SAAS,2CAA2C;YAC/D0B,QAAQC;YACRC,OAAOD;QACT;IACF,OAAO;QACL,OAAOzB,iBAAiB;YAAEoB,SAASE;YAAeD;QAAQ;IAC5D;AACF,EAAC"}

package/dist/fetchAPI-multipart/isEligibleRequest.d.ts

@@ -0,0 +1,2 @@
+export declare const isEligibleRequest: (req: Request) => boolean;
+//# sourceMappingURL=isEligibleRequest.d.ts.map

package/dist/fetchAPI-multipart/isEligibleRequest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isEligibleRequest.d.ts","sourceRoot":"","sources":["../../src/fetchAPI-multipart/isEligibleRequest.ts"],"names":[],"mappings":"AAiBA,eAAO,MAAM,iBAAiB,QAAS,OAAO,KAAG,OAMhD,CAAA"}

package/dist/fetchAPI-multipart/isEligibleRequest.js

@@ -0,0 +1,26 @@
+const ACCEPTABLE_CONTENT_TYPE = /multipart\/['"()+-_]+(?:; ?['"()+-_]*)+$/i;
+const UNACCEPTABLE_METHODS = new Set([
+    'GET',
+    'HEAD',
+    'DELETE',
+    'OPTIONS',
+    'CONNECT',
+    'TRACE'
+]);
+const hasBody = (req)=>{
+    return Boolean(req.headers.get('transfer-encoding') || req.headers.get('content-length') && req.headers.get('content-length') !== '0');
+};
+const hasAcceptableMethod = (req)=>!UNACCEPTABLE_METHODS.has(req.method);
+const hasAcceptableContentType = (req)=>{
+    const contType = req.headers.get('content-type');
+    return contType.includes('boundary=') && ACCEPTABLE_CONTENT_TYPE.test(contType);
+};
+export const isEligibleRequest = (req)=>{
+    try {
+        return hasBody(req) && hasAcceptableMethod(req) && hasAcceptableContentType(req);
+    } catch (e) {
+        return false;
+    }
+};
+
+//# sourceMappingURL=isEligibleRequest.js.map

package/dist/fetchAPI-multipart/isEligibleRequest.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/fetchAPI-multipart/isEligibleRequest.ts"],"sourcesContent":["const ACCEPTABLE_CONTENT_TYPE = /multipart\\/['\"()+-_]+(?:; ?['\"()+-_]*)+$/i\nconst UNACCEPTABLE_METHODS = new Set(['GET', 'HEAD', 'DELETE', 'OPTIONS', 'CONNECT', 'TRACE'])\n\nconst hasBody = (req: Request): boolean => {\n  return Boolean(\n    req.headers.get('transfer-encoding') ||\n      (req.headers.get('content-length') && req.headers.get('content-length') !== '0'),\n  )\n}\n\nconst hasAcceptableMethod = (req: Request): boolean => !UNACCEPTABLE_METHODS.has(req.method)\n\nconst hasAcceptableContentType = (req: Request): boolean => {\n  const contType = req.headers.get('content-type')\n  return contType.includes('boundary=') && ACCEPTABLE_CONTENT_TYPE.test(contType)\n}\n\nexport const isEligibleRequest = (req: Request): boolean => {\n  try {\n    return hasBody(req) && hasAcceptableMethod(req) && hasAcceptableContentType(req)\n  } catch (e) {\n    return false\n  }\n}\n"],"names":["ACCEPTABLE_CONTENT_TYPE","UNACCEPTABLE_METHODS","Set","hasBody","req","Boolean","headers","get","hasAcceptableMethod","has","method","hasAcceptableContentType","contType","includes","test","isEligibleRequest","e"],"mappings":"AAAA,MAAMA,0BAA0B;AAChC,MAAMC,uBAAuB,IAAIC,IAAI;IAAC;IAAO;IAAQ;IAAU;IAAW;IAAW;CAAQ;AAE7F,MAAMC,UAAU,CAACC;IACf,OAAOC,QACLD,IAAIE,OAAO,CAACC,GAAG,CAAC,wBACbH,IAAIE,OAAO,CAACC,GAAG,CAAC,qBAAqBH,IAAIE,OAAO,CAACC,GAAG,CAAC,sBAAsB;AAElF;AAEA,MAAMC,sBAAsB,CAACJ,MAA0B,CAACH,qBAAqBQ,GAAG,CAACL,IAAIM,MAAM;AAE3F,MAAMC,2BAA2B,CAACP;IAChC,MAAMQ,WAAWR,IAAIE,OAAO,CAACC,GAAG,CAAC;IACjC,OAAOK,SAASC,QAAQ,CAAC,gBAAgBb,wBAAwBc,IAAI,CAACF;AACxE;AAEA,OAAO,MAAMG,oBAAoB,CAACX;IAChC,IAAI;QACF,OAAOD,QAAQC,QAAQI,oBAAoBJ,QAAQO,yBAAyBP;IAC9E,EAAE,OAAOY,GAAG;QACV,OAAO;IACT;AACF,EAAC"}

package/dist/fetchAPI-multipart/processMultipart.d.ts

@@ -0,0 +1,8 @@
+import type { FetchAPIFileUploadOptions, FetchAPIFileUploadResponse } from './index.js';
+type ProcessMultipart = (args: {
+    options: FetchAPIFileUploadOptions;
+    request: Request;
+}) => Promise<FetchAPIFileUploadResponse>;
+export declare const processMultipart: ProcessMultipart;
+export {};
+//# sourceMappingURL=processMultipart.d.ts.map

package/dist/fetchAPI-multipart/processMultipart.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"processMultipart.d.ts","sourceRoot":"","sources":["../../src/fetchAPI-multipart/processMultipart.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,yBAAyB,EAAE,0BAA0B,EAAE,MAAM,YAAY,CAAA;AAUvF,KAAK,gBAAgB,GAAG,CAAC,IAAI,EAAE;IAC7B,OAAO,EAAE,yBAAyB,CAAA;IAClC,OAAO,EAAE,OAAO,CAAA;CACjB,KAAK,OAAO,CAAC,0BAA0B,CAAC,CAAA;AACzC,eAAO,MAAM,gBAAgB,EAAE,gBAoM9B,CAAA"}

package/dist/fetchAPI-multipart/processMultipart.js

@@ -0,0 +1,162 @@
+import Busboy from 'busboy';
+import httpStatus from 'http-status';
+import { APIError } from 'payload';
+import { fileFactory } from './fileFactory.js';
+import { memHandler, tempFileHandler } from './handlers.js';
+import { processNested } from './processNested.js';
+import { createUploadTimer } from './uploadTimer.js';
+import { buildFields, debugLog, isFunc, parseFileName } from './utilities.js';
+const waitFlushProperty = Symbol('wait flush property symbol');
+export const processMultipart = async ({ options, request })=>{
+    let parsingRequest = true;
+    let fileCount = 0;
+    let filesCompleted = 0;
+    let allFilesHaveResolved;
+    let failedResolvingFiles;
+    const allFilesComplete = new Promise((res, rej)=>{
+        allFilesHaveResolved = res;
+        failedResolvingFiles = rej;
+    });
+    const result = {
+        fields: undefined,
+        files: undefined
+    };
+    const headersObject = {};
+    request.headers.forEach((value, name)=>{
+        headersObject[name] = value;
+    });
+    function abortAndDestroyFile(file, err) {
+        file.destroy();
+        parsingRequest = false;
+        failedResolvingFiles(err);
+    }
+    const busboy = Busboy({
+        ...options,
+        headers: headersObject
+    });
+    // Build multipart req.body fields
+    busboy.on('field', (field, val)=>{
+        result.fields = buildFields(result.fields, field, val);
+    });
+    // Build req.files fields
+    busboy.on('file', (field, file, info)=>{
+        fileCount += 1;
+        // Parse file name(cutting huge names, decoding, etc..).
+        const { encoding, filename: name, mimeType: mime } = info;
+        const filename = parseFileName(options, name);
+        // Define methods and handlers for upload process.
+        const { cleanup, complete, dataHandler, getFilePath, getFileSize, getHash, getWritePromise } = options.useTempFiles ? tempFileHandler(options, field, filename) // Upload into temporary file.
+         : memHandler(options, field, filename) // Upload into RAM.
+        ;
+        const writePromise = options.useTempFiles ? getWritePromise().catch((err)=>{
+            busboy.end();
+            cleanup();
+        }) : getWritePromise();
+        const uploadTimer = createUploadTimer(options.uploadTimeout, ()=>{
+            return abortAndDestroyFile(file, new APIError(`Upload timeout for ${field}->${filename}, bytes:${getFileSize()}`));
+        });
+        file.on('limit', ()=>{
+            debugLog(options, `Size limit reached for ${field}->${filename}, bytes:${getFileSize()}`);
+            uploadTimer.clear();
+            if (isFunc(options.limitHandler)) {
+                options.limitHandler({
+                    request,
+                    size: getFileSize()
+                });
+            }
+            // Return error and cleanup files if abortOnLimit set.
+            if (options.abortOnLimit) {
+                debugLog(options, `Upload file size limit reached ${field}->${filename}.`);
+                cleanup();
+                abortAndDestroyFile(file, new APIError(options.responseOnLimit, httpStatus.REQUEST_ENTITY_TOO_LARGE, {
+                    size: getFileSize()
+                }));
+            }
+        });
+        file.on('data', (data)=>{
+            uploadTimer.set();
+            dataHandler(data);
+        });
+        file.on('end', ()=>{
+            const size = getFileSize();
+            debugLog(options, `Upload finished ${field}->${filename}, bytes:${size}`);
+            uploadTimer.clear();
+            if (!name && size === 0) {
+                fileCount -= 1;
+                if (options.useTempFiles) {
+                    cleanup();
+                    debugLog(options, `Removing the empty file ${field}->${filename}`);
+                }
+                return debugLog(options, `Don't add file instance if original name and size are empty`);
+            }
+            filesCompleted += 1;
+            result.files = buildFields(result.files, field, fileFactory({
+                name: filename,
+                buffer: complete(),
+                encoding,
+                hash: getHash(),
+                mimetype: mime,
+                size,
+                tempFilePath: getFilePath(),
+                truncated: Boolean('truncated' in file && file.truncated)
+            }, options));
+            if (!request[waitFlushProperty]) {
+                request[waitFlushProperty] = [];
+            }
+            request[waitFlushProperty].push(writePromise);
+            if (filesCompleted === fileCount) {
+                allFilesHaveResolved();
+            }
+        });
+        file.on('error', (err)=>{
+            uploadTimer.clear();
+            debugLog(options, `File Error: ${err.message}`);
+            cleanup();
+            failedResolvingFiles(err);
+        });
+        // Start upload process.
+        debugLog(options, `New upload started ${field}->${filename}, bytes:${getFileSize()}`);
+        uploadTimer.set();
+    });
+    busboy.on('finish', async ()=>{
+        debugLog(options, `Busboy finished parsing request.`);
+        if (options.parseNested) {
+            result.fields = processNested(result.fields);
+            result.files = processNested(result.files);
+        }
+        if (request[waitFlushProperty]) {
+            try {
+                await Promise.all(request[waitFlushProperty]).then(()=>{
+                    delete request[waitFlushProperty];
+                });
+            } catch (err) {
+                debugLog(options, `Error waiting for file write promises: ${err}`);
+            }
+        }
+        return result;
+    });
+    busboy.on('error', (err = new APIError('Busboy error parsing multipart request', httpStatus.BAD_REQUEST))=>{
+        debugLog(options, `Busboy error`);
+        parsingRequest = false;
+        throw err;
+    });
+    const reader = request.body.getReader();
+    // Start parsing request
+    while(parsingRequest){
+        const { done, value } = await reader.read();
+        if (done) {
+            parsingRequest = false;
+        }
+        if (value) {
+            busboy.write(value);
+        }
+    }
+    if (fileCount !== 0) {
+        await allFilesComplete.catch((e)=>{
+            throw e;
+        });
+    }
+    return result;
+};
+
+//# sourceMappingURL=processMultipart.js.map

package/dist/fetchAPI-multipart/processMultipart.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/fetchAPI-multipart/processMultipart.ts"],"sourcesContent":["import type { Readable } from 'stream'\n\nimport Busboy from 'busboy'\nimport httpStatus from 'http-status'\nimport { APIError } from 'payload'\n\nimport type { FetchAPIFileUploadOptions, FetchAPIFileUploadResponse } from './index.js'\n\nimport { fileFactory } from './fileFactory.js'\nimport { memHandler, tempFileHandler } from './handlers.js'\nimport { processNested } from './processNested.js'\nimport { createUploadTimer } from './uploadTimer.js'\nimport { buildFields, debugLog, isFunc, parseFileName } from './utilities.js'\n\nconst waitFlushProperty = Symbol('wait flush property symbol')\n\ntype ProcessMultipart = (args: {\n  options: FetchAPIFileUploadOptions\n  request: Request\n}) => Promise<FetchAPIFileUploadResponse>\nexport const processMultipart: ProcessMultipart = async ({ options, request }) => {\n  let parsingRequest = true\n\n  let fileCount = 0\n  let filesCompleted = 0\n  let allFilesHaveResolved: (value?: unknown) => void\n  let failedResolvingFiles: (err: Error) => void\n\n  const allFilesComplete = new Promise((res, rej) => {\n    allFilesHaveResolved = res\n    failedResolvingFiles = rej\n  })\n\n  const result: FetchAPIFileUploadResponse = {\n    fields: undefined,\n    files: undefined,\n  }\n\n  const headersObject = {}\n  request.headers.forEach((value, name) => {\n    headersObject[name] = value\n  })\n\n  function abortAndDestroyFile(file: Readable, err: APIError) {\n    file.destroy()\n    parsingRequest = false\n    failedResolvingFiles(err)\n  }\n\n  const busboy = Busboy({ ...options, headers: headersObject })\n\n  // Build multipart req.body fields\n  busboy.on('field', (field, val) => {\n    result.fields = buildFields(result.fields, field, val)\n  })\n\n  // Build req.files fields\n  busboy.on('file', (field, file, info) => {\n    fileCount += 1\n    // Parse file name(cutting huge names, decoding, etc..).\n    const { encoding, filename: name, mimeType: mime } = info\n    const filename = parseFileName(options, name)\n\n    // Define methods and handlers for upload process.\n    const { cleanup, complete, dataHandler, getFilePath, getFileSize, getHash, getWritePromise } =\n      options.useTempFiles\n        ? tempFileHandler(options, field, filename) // Upload into temporary file.\n        : memHandler(options, field, filename) // Upload into RAM.\n\n    const writePromise = options.useTempFiles\n      ? getWritePromise().catch((err) => {\n          busboy.end()\n          cleanup()\n        })\n      : getWritePromise()\n\n    const uploadTimer = createUploadTimer(options.uploadTimeout, () => {\n      return abortAndDestroyFile(\n        file,\n        new APIError(`Upload timeout for ${field}->${filename}, bytes:${getFileSize()}`),\n      )\n    })\n\n    file.on('limit', () => {\n      debugLog(options, `Size limit reached for ${field}->${filename}, bytes:${getFileSize()}`)\n      uploadTimer.clear()\n\n      if (isFunc(options.limitHandler)) {\n        options.limitHandler({ request, size: getFileSize() })\n      }\n\n      // Return error and cleanup files if abortOnLimit set.\n      if (options.abortOnLimit) {\n        debugLog(options, `Upload file size limit reached ${field}->${filename}.`)\n        cleanup()\n        abortAndDestroyFile(\n          file,\n          new APIError(options.responseOnLimit, httpStatus.REQUEST_ENTITY_TOO_LARGE, {\n            size: getFileSize(),\n          }),\n        )\n      }\n    })\n\n    file.on('data', (data) => {\n      uploadTimer.set()\n      dataHandler(data)\n    })\n\n    file.on('end', () => {\n      const size = getFileSize()\n      debugLog(options, `Upload finished ${field}->${filename}, bytes:${size}`)\n      uploadTimer.clear()\n\n      if (!name && size === 0) {\n        fileCount -= 1\n        if (options.useTempFiles) {\n          cleanup()\n          debugLog(options, `Removing the empty file ${field}->${filename}`)\n        }\n        return debugLog(options, `Don't add file instance if original name and size are empty`)\n      }\n\n      filesCompleted += 1\n\n      result.files = buildFields(\n        result.files,\n        field,\n        fileFactory(\n          {\n            name: filename,\n            buffer: complete(),\n            encoding,\n            hash: getHash(),\n            mimetype: mime,\n            size,\n            tempFilePath: getFilePath(),\n            truncated: Boolean('truncated' in file && file.truncated),\n          },\n          options,\n        ),\n      )\n\n      if (!request[waitFlushProperty]) {\n        request[waitFlushProperty] = []\n      }\n      request[waitFlushProperty].push(writePromise)\n\n      if (filesCompleted === fileCount) {\n        allFilesHaveResolved()\n      }\n    })\n\n    file.on('error', (err) => {\n      uploadTimer.clear()\n      debugLog(options, `File Error: ${err.message}`)\n      cleanup()\n      failedResolvingFiles(err)\n    })\n\n    // Start upload process.\n    debugLog(options, `New upload started ${field}->${filename}, bytes:${getFileSize()}`)\n    uploadTimer.set()\n  })\n\n  busboy.on('finish', async () => {\n    debugLog(options, `Busboy finished parsing request.`)\n    if (options.parseNested) {\n      result.fields = processNested(result.fields)\n      result.files = processNested(result.files)\n    }\n\n    if (request[waitFlushProperty]) {\n      try {\n        await Promise.all(request[waitFlushProperty]).then(() => {\n          delete request[waitFlushProperty]\n        })\n      } catch (err) {\n        debugLog(options, `Error waiting for file write promises: ${err}`)\n      }\n    }\n\n    return result\n  })\n\n  busboy.on(\n    'error',\n    (err = new APIError('Busboy error parsing multipart request', httpStatus.BAD_REQUEST)) => {\n      debugLog(options, `Busboy error`)\n      parsingRequest = false\n      throw err\n    },\n  )\n\n  const reader = request.body.getReader()\n\n  // Start parsing request\n  while (parsingRequest) {\n    const { done, value } = await reader.read()\n\n    if (done) {\n      parsingRequest = false\n    }\n\n    if (value) {\n      busboy.write(value)\n    }\n  }\n\n  if (fileCount !== 0) {\n    await allFilesComplete.catch((e) => {\n      throw e\n    })\n  }\n\n  return result\n}\n"],"names":["Busboy","httpStatus","APIError","fileFactory","memHandler","tempFileHandler","processNested","createUploadTimer","buildFields","debugLog","isFunc","parseFileName","waitFlushProperty","Symbol","processMultipart","options","request","parsingRequest","fileCount","filesCompleted","allFilesHaveResolved","failedResolvingFiles","allFilesComplete","Promise","res","rej","result","fields","undefined","files","headersObject","headers","forEach","value","name","abortAndDestroyFile","file","err","destroy","busboy","on","field","val","info","encoding","filename","mimeType","mime","cleanup","complete","dataHandler","getFilePath","getFileSize","getHash","getWritePromise","useTempFiles","writePromise","catch","end","uploadTimer","uploadTimeout","clear","limitHandler","size","abortOnLimit","responseOnLimit","REQUEST_ENTITY_TOO_LARGE","data","set","buffer","hash","mimetype","tempFilePath","truncated","Boolean","push","message","parseNested","all","then","BAD_REQUEST","reader","body","getReader","done","read","write","e"],"mappings":"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"}

package/dist/fetchAPI-multipart/processNested.d.ts

@@ -0,0 +1,2 @@
+export declare const processNested: (data: any) => any;
+//# sourceMappingURL=processNested.d.ts.map

package/dist/fetchAPI-multipart/processNested.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"processNested.d.ts","sourceRoot":"","sources":["../../src/fetchAPI-multipart/processNested.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,aAAa,oBA6BzB,CAAA"}

package/dist/fetchAPI-multipart/processNested.js

@@ -0,0 +1,25 @@
+import { isSafeFromPollution } from './utilities.js';
+export const processNested = function(data) {
+    if (!data || data.length < 1) return Object.create(null);
+    const d = Object.create(null), keys = Object.keys(data);
+    for(let i = 0; i < keys.length; i++){
+        const key = keys[i], value = data[key], keyParts = key.replace(new RegExp(/\[/g), '.').replace(new RegExp(/\]/g), '').split('.');
+        let current = d;
+        for(let index = 0; index < keyParts.length; index++){
+            const k = keyParts[index];
+            // Ensure we don't allow prototype pollution
+            if (!isSafeFromPollution(current, k)) {
+                continue;
+            }
+            if (index >= keyParts.length - 1) {
+                current[k] = value;
+            } else {
+                if (!current[k]) current[k] = !keyParts[index + 1] ? [] : Object.create(null);
+                current = current[k];
+            }
+        }
+    }
+    return d;
+};
+
+//# sourceMappingURL=processNested.js.map

package/dist/fetchAPI-multipart/processNested.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/fetchAPI-multipart/processNested.ts"],"sourcesContent":["import { isSafeFromPollution } from './utilities.js'\n\nexport const processNested = function (data) {\n  if (!data || data.length < 1) return Object.create(null)\n\n  const d = Object.create(null),\n    keys = Object.keys(data)\n\n  for (let i = 0; i < keys.length; i++) {\n    const key = keys[i],\n      value = data[key],\n      keyParts = key.replace(new RegExp(/\\[/g), '.').replace(new RegExp(/\\]/g), '').split('.')\n    let current = d\n\n    for (let index = 0; index < keyParts.length; index++) {\n      const k = keyParts[index]\n\n      // Ensure we don't allow prototype pollution\n      if (!isSafeFromPollution(current, k)) {\n        continue\n      }\n\n      if (index >= keyParts.length - 1) {\n        current[k] = value\n      } else {\n        if (!current[k]) current[k] = !keyParts[index + 1] ? [] : Object.create(null)\n        current = current[k]\n      }\n    }\n  }\n  return d\n}\n"],"names":["isSafeFromPollution","processNested","data","length","Object","create","d","keys","i","key","value","keyParts","replace","RegExp","split","current","index","k"],"mappings":"AAAA,SAASA,mBAAmB,QAAQ,iBAAgB;AAEpD,OAAO,MAAMC,gBAAgB,SAAUC,IAAI;IACzC,IAAI,CAACA,QAAQA,KAAKC,MAAM,GAAG,GAAG,OAAOC,OAAOC,MAAM,CAAC;IAEnD,MAAMC,IAAIF,OAAOC,MAAM,CAAC,OACtBE,OAAOH,OAAOG,IAAI,CAACL;IAErB,IAAK,IAAIM,IAAI,GAAGA,IAAID,KAAKJ,MAAM,EAAEK,IAAK;QACpC,MAAMC,MAAMF,IAAI,CAACC,EAAE,EACjBE,QAAQR,IAAI,CAACO,IAAI,EACjBE,WAAWF,IAAIG,OAAO,CAAC,IAAIC,OAAO,QAAQ,KAAKD,OAAO,CAAC,IAAIC,OAAO,QAAQ,IAAIC,KAAK,CAAC;QACtF,IAAIC,UAAUT;QAEd,IAAK,IAAIU,QAAQ,GAAGA,QAAQL,SAASR,MAAM,EAAEa,QAAS;YACpD,MAAMC,IAAIN,QAAQ,CAACK,MAAM;YAEzB,4CAA4C;YAC5C,IAAI,CAAChB,oBAAoBe,SAASE,IAAI;gBACpC;YACF;YAEA,IAAID,SAASL,SAASR,MAAM,GAAG,GAAG;gBAChCY,OAAO,CAACE,EAAE,GAAGP;YACf,OAAO;gBACL,IAAI,CAACK,OAAO,CAACE,EAAE,EAAEF,OAAO,CAACE,EAAE,GAAG,CAACN,QAAQ,CAACK,QAAQ,EAAE,GAAG,EAAE,GAAGZ,OAAOC,MAAM,CAAC;gBACxEU,UAAUA,OAAO,CAACE,EAAE;YACtB;QACF;IACF;IACA,OAAOX;AACT,EAAC"}

package/dist/fetchAPI-multipart/uploadTimer.d.ts

@@ -0,0 +1,7 @@
+type CreateUploadTimer = (timeout?: number, callback?: () => void) => {
+    clear: () => void;
+    set: () => boolean;
+};
+export declare const createUploadTimer: CreateUploadTimer;
+export {};
+//# sourceMappingURL=uploadTimer.d.ts.map

package/dist/fetchAPI-multipart/uploadTimer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uploadTimer.d.ts","sourceRoot":"","sources":["../../src/fetchAPI-multipart/uploadTimer.ts"],"names":[],"mappings":"AAAA,KAAK,iBAAiB,GAAG,CACvB,OAAO,CAAC,EAAE,MAAM,EAChB,QAAQ,CAAC,EAAE,MAAM,IAAI,KAClB;IACH,KAAK,EAAE,MAAM,IAAI,CAAA;IACjB,GAAG,EAAE,MAAM,OAAO,CAAA;CACnB,CAAA;AAED,eAAO,MAAM,iBAAiB,EAAE,iBAgB/B,CAAA"}

package/dist/fetchAPI-multipart/uploadTimer.js

@@ -0,0 +1,19 @@
+export const createUploadTimer = (timeout = 0, callback = ()=>{})=>{
+    let timer = null;
+    const clear = ()=>{
+        clearTimeout(timer);
+    };
+    const set = ()=>{
+        // Do not start a timer if zero timeout or it hasn't been set.
+        if (!timeout) return false;
+        clear();
+        timer = setTimeout(callback, timeout);
+        return true;
+    };
+    return {
+        clear,
+        set
+    };
+};
+
+//# sourceMappingURL=uploadTimer.js.map

package/dist/fetchAPI-multipart/uploadTimer.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/fetchAPI-multipart/uploadTimer.ts"],"sourcesContent":["type CreateUploadTimer = (\n  timeout?: number,\n  callback?: () => void,\n) => {\n  clear: () => void\n  set: () => boolean\n}\n\nexport const createUploadTimer: CreateUploadTimer = (timeout = 0, callback = () => {}) => {\n  let timer = null\n\n  const clear = () => {\n    clearTimeout(timer)\n  }\n\n  const set = () => {\n    // Do not start a timer if zero timeout or it hasn't been set.\n    if (!timeout) return false\n    clear()\n    timer = setTimeout(callback, timeout)\n    return true\n  }\n\n  return { clear, set }\n}\n"],"names":["createUploadTimer","timeout","callback","timer","clear","clearTimeout","set","setTimeout"],"mappings":"AAQA,OAAO,MAAMA,oBAAuC,CAACC,UAAU,CAAC,EAAEC,WAAW,KAAO,CAAC;IACnF,IAAIC,QAAQ;IAEZ,MAAMC,QAAQ;QACZC,aAAaF;IACf;IAEA,MAAMG,MAAM;QACV,8DAA8D;QAC9D,IAAI,CAACL,SAAS,OAAO;QACrBG;QACAD,QAAQI,WAAWL,UAAUD;QAC7B,OAAO;IACT;IAEA,OAAO;QAAEG;QAAOE;IAAI;AACtB,EAAC"}