@payloadcms/next 3.0.0-alpha.0

package/dist/next-fileupload/index.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "nextFileUpload", {
+    enumerable: true,
+    get: function() {
+        return nextFileUpload;
+    }
+});
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _isEligibleRequest = require("./isEligibleRequest");
+const _processMultipart = require("./processMultipart");
+const _utilities = require("./utilities");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+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.default.join(process.cwd(), 'tmp'),
+    uploadTimeout: 60000,
+    uriDecodeFileNames: false,
+    useTempFiles: false
+};
+const nextFileUpload = async ({ options, request })=>{
+    const uploadOptions = {
+        ...DEFAULT_OPTIONS,
+        ...options
+    };
+    if (!(0, _isEligibleRequest.isEligibleRequest)(request)) {
+        (0, _utilities.debugLog)(uploadOptions, 'Request is not eligible for file upload!');
+        return {
+            error: {
+                code: 500,
+                message: 'Request is not eligible for file upload'
+            },
+            fields: undefined,
+            files: undefined
+        };
+    } else {
+        return (0, _processMultipart.processMultipart)({
+            options: uploadOptions,
+            request
+        });
+    }
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/next-fileupload/index.ts"],"sourcesContent":["import type { BusboyConfig } from 'busboy'\n\nimport path from 'path'\n\nimport { isEligibleRequest } from './isEligibleRequest'\nimport { processMultipart } from './processMultipart'\nimport { debugLog } from './utilities'\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 NextFileUploadOptions = {\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 NextFileUploadResponseFile = {\n  data: Buffer\n  mimetype: string\n  name: string\n  size: number\n  tempFilePath?: string\n}\n\nexport type NextFileUploadResponse = {\n  error?: {\n    code: number\n    message: string\n  }\n  fields: Record<string, string>\n  files: Record<string, NextFileUploadResponseFile>\n}\n\ntype NextFileUpload = (args: {\n  options?: NextFileUploadOptions\n  request: Request\n}) => Promise<NextFileUploadResponse>\nexport const nextFileUpload: NextFileUpload = async ({ options, request }) => {\n  const uploadOptions = { ...DEFAULT_OPTIONS, ...options }\n  if (!isEligibleRequest(request)) {\n    debugLog(uploadOptions, 'Request is not eligible for file upload!')\n    return {\n      error: {\n        code: 500,\n        message: 'Request is not eligible for file upload',\n      },\n      fields: undefined,\n      files: undefined,\n    }\n  } else {\n    return processMultipart({ options: uploadOptions, request })\n  }\n}\n"],"names":["nextFileUpload","DEFAULT_OPTIONS","abortOnLimit","createParentPath","debug","fileHandler","limitHandler","parseNested","preserveExtension","responseOnLimit","safeFileNames","tempFileDir","path","join","process","cwd","uploadTimeout","uriDecodeFileNames","useTempFiles","options","request","uploadOptions","isEligibleRequest","debugLog","error","code","message","fields","undefined","files","processMultipart"],"mappings":";;;;+BA2JaA;;;eAAAA;;;6DAzJI;mCAEiB;kCACD;2BACR;;;;;;AAEzB,MAAMC,kBAAkB;IACtBC,cAAc;IACdC,kBAAkB;IAClBC,OAAO;IACPC,aAAa;IACbC,cAAc;IACdC,aAAa;IACbC,mBAAmB;IACnBC,iBAAiB;IACjBC,eAAe;IACfC,aAAaC,aAAI,CAACC,IAAI,CAACC,QAAQC,GAAG,IAAI;IACtCC,eAAe;IACfC,oBAAoB;IACpBC,cAAc;AAChB;AAqIO,MAAMlB,iBAAiC,OAAO,EAAEmB,OAAO,EAAEC,OAAO,EAAE;IACvE,MAAMC,gBAAgB;QAAE,GAAGpB,eAAe;QAAE,GAAGkB,OAAO;IAAC;IACvD,IAAI,CAACG,IAAAA,oCAAiB,EAACF,UAAU;QAC/BG,IAAAA,mBAAQ,EAACF,eAAe;QACxB,OAAO;YACLG,OAAO;gBACLC,MAAM;gBACNC,SAAS;YACX;YACAC,QAAQC;YACRC,OAAOD;QACT;IACF,OAAO;QACL,OAAOE,IAAAA,kCAAgB,EAAC;YAAEX,SAASE;YAAeD;QAAQ;IAC5D;AACF"}

package/dist/next-fileupload/isEligibleRequest.d.ts

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

package/dist/next-fileupload/isEligibleRequest.d.ts.map

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

package/dist/next-fileupload/isEligibleRequest.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "isEligibleRequest", {
+    enumerable: true,
+    get: function() {
+        return isEligibleRequest;
+    }
+});
+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);
+};
+const isEligibleRequest = (req)=>{
+    try {
+        return hasBody(req) && hasAcceptableMethod(req) && hasAcceptableContentType(req);
+    } catch (e) {
+        return false;
+    }
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/next-fileupload/processMultipart.d.ts

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

package/dist/next-fileupload/processMultipart.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"processMultipart.d.ts","sourceRoot":"","sources":["../../src/next-fileupload/processMultipart.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,MAAM,GAAG,CAAA;AAUtE,KAAK,gBAAgB,GAAG,CAAC,IAAI,EAAE;IAC7B,OAAO,EAAE,qBAAqB,CAAA;IAC9B,OAAO,EAAE,OAAO,CAAA;CACjB,KAAK,OAAO,CAAC,sBAAsB,CAAC,CAAA;AACrC,eAAO,MAAM,gBAAgB,EAAE,gBAmJ9B,CAAA"}

package/dist/next-fileupload/processMultipart.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "processMultipart", {
+    enumerable: true,
+    get: function() {
+        return processMultipart;
+    }
+});
+const _busboy = /*#__PURE__*/ _interop_require_default(require("busboy"));
+const _errors = require("payload/errors");
+const _fileFactory = require("./fileFactory");
+const _handlers = require("./handlers");
+const _processNested = require("./processNested");
+const _uploadTimer = require("./uploadTimer");
+const _utilities = require("./utilities");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const waitFlushProperty = Symbol('wait flush property symbol');
+const processMultipart = async ({ options, request })=>{
+    let parsingRequest = true;
+    const result = {
+        fields: undefined,
+        files: undefined
+    };
+    const headersObject = {};
+    request.headers.forEach((value, name)=>{
+        headersObject[name] = value;
+    });
+    const busboy = (0, _busboy.default)({
+        ...options,
+        headers: headersObject
+    });
+    // Build multipart req.body fields
+    busboy.on('field', (field, val)=>{
+        result.fields = (0, _utilities.buildFields)(result.fields, field, val);
+    });
+    // Build req.files fields
+    busboy.on('file', (field, file, info)=>{
+        // Parse file name(cutting huge names, decoding, etc..).
+        const { encoding, filename: name, mimeType: mime } = info;
+        const filename = (0, _utilities.parseFileName)(options, name);
+        // Define methods and handlers for upload process.
+        const { cleanup, complete, dataHandler, getFilePath, getFileSize, getHash, getWritePromise } = options.useTempFiles ? (0, _handlers.tempFileHandler)(options, field, filename) // Upload into temporary file.
+         : (0, _handlers.memHandler)(options, field, filename) // Upload into RAM.
+        ;
+        const writePromise = options.useTempFiles ? getWritePromise().catch((err)=>{
+            busboy.end();
+            cleanup();
+        }) : getWritePromise();
+        const uploadTimer = (0, _uploadTimer.createUploadTimer)(options.uploadTimeout, ()=>{
+            file.removeAllListeners('data');
+            file.resume();
+            const err = new Error(`Upload timeout for ${field}->${filename}, bytes:${getFileSize()}`);
+            return file.destroy(err);
+        });
+        file.on('limit', ()=>{
+            (0, _utilities.debugLog)(options, `Size limit reached for ${field}->${filename}, bytes:${getFileSize()}`);
+            uploadTimer.clear();
+            if ((0, _utilities.isFunc)(options.limitHandler)) {
+                options.limitHandler({
+                    request,
+                    size: getFileSize()
+                });
+            }
+            // Return error and cleanup files if abortOnLimit set.
+            if (options.abortOnLimit) {
+                (0, _utilities.debugLog)(options, `Aborting upload because of size limit ${field}->${filename}.`);
+                cleanup();
+                parsingRequest = false;
+                throw new _errors.APIError(options.responseOnLimit, 413, {
+                    size: getFileSize()
+                });
+            }
+        });
+        file.on('data', (data)=>{
+            uploadTimer.set();
+            dataHandler(data);
+        });
+        file.on('end', ()=>{
+            const size = getFileSize();
+            (0, _utilities.debugLog)(options, `Upload finished ${field}->${filename}, bytes:${size}`);
+            uploadTimer.clear();
+            if (!name && size === 0) {
+                if (options.useTempFiles) {
+                    cleanup();
+                    (0, _utilities.debugLog)(options, `Removing the empty file ${field}->${filename}`);
+                }
+                return (0, _utilities.debugLog)(options, `Don't add file instance if original name and size are empty`);
+            }
+            result.files = (0, _utilities.buildFields)(result.files, field, (0, _fileFactory.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);
+        });
+        file.on('error', (err)=>{
+            uploadTimer.clear();
+            (0, _utilities.debugLog)(options, `File Error: ${err.message}`);
+            cleanup();
+        });
+        (0, _utilities.debugLog)(options, `New upload started ${field}->${filename}, bytes:${getFileSize()}`);
+        uploadTimer.set();
+    });
+    busboy.on('finish', ()=>{
+        (0, _utilities.debugLog)(options, `Busboy finished parsing request.`);
+        if (options.parseNested) {
+            result.fields = (0, _processNested.processNested)(result.fields);
+            result.files = (0, _processNested.processNested)(result.files);
+        }
+        if (request[waitFlushProperty]) {
+            Promise.all(request[waitFlushProperty]).then(()=>{
+                delete request[waitFlushProperty];
+            });
+        }
+    });
+    busboy.on('error', (err)=>{
+        (0, _utilities.debugLog)(options, `Busboy error`);
+        parsingRequest = false;
+        throw new _errors.APIError('Busboy error parsing multipart request', 500);
+    });
+    const reader = request.body.getReader();
+    while(parsingRequest){
+        const { done, value } = await reader.read();
+        if (done) {
+            parsingRequest = false;
+        }
+        busboy.write(value);
+    }
+    return result;
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/next-fileupload/processMultipart.ts"],"sourcesContent":["import Busboy from 'busboy'\nimport { APIError } from 'payload/errors'\n\nimport type { NextFileUploadOptions, NextFileUploadResponse } from '.'\n\nimport { fileFactory } from './fileFactory'\nimport { memHandler, tempFileHandler } from './handlers'\nimport { processNested } from './processNested'\nimport { createUploadTimer } from './uploadTimer'\nimport { buildFields, debugLog, isFunc, parseFileName } from './utilities'\n\nconst waitFlushProperty = Symbol('wait flush property symbol')\n\ntype ProcessMultipart = (args: {\n  options: NextFileUploadOptions\n  request: Request\n}) => Promise<NextFileUploadResponse>\nexport const processMultipart: ProcessMultipart = async ({ options, request }) => {\n  let parsingRequest = true\n  const result: NextFileUploadResponse = {\n    fields: undefined,\n    files: undefined,\n  }\n\n  const headersObject = {}\n  request.headers.forEach((value, name) => {\n    headersObject[name] = value\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    // 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      file.removeAllListeners('data')\n      file.resume()\n      const err = new Error(`Upload timeout for ${field}->${filename}, bytes:${getFileSize()}`)\n      return file.destroy(err)\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, `Aborting upload because of size limit ${field}->${filename}.`)\n        cleanup()\n        parsingRequest = false\n        throw new APIError(options.responseOnLimit, 413, { size: getFileSize() })\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        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      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\n    file.on('error', (err) => {\n      uploadTimer.clear()\n      debugLog(options, `File Error: ${err.message}`)\n      cleanup()\n    })\n\n    debugLog(options, `New upload started ${field}->${filename}, bytes:${getFileSize()}`)\n    uploadTimer.set()\n  })\n\n  busboy.on('finish', () => {\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      Promise.all(request[waitFlushProperty]).then(() => {\n        delete request[waitFlushProperty]\n      })\n    }\n  })\n\n  busboy.on('error', (err) => {\n    debugLog(options, `Busboy error`)\n    parsingRequest = false\n    throw new APIError('Busboy error parsing multipart request', 500)\n  })\n\n  const reader = request.body.getReader()\n\n  while (parsingRequest) {\n    const { done, value } = await reader.read()\n\n    if (done) {\n      parsingRequest = false\n    }\n\n    busboy.write(value)\n  }\n\n  return result\n}\n"],"names":["processMultipart","waitFlushProperty","Symbol","options","request","parsingRequest","result","fields","undefined","files","headersObject","headers","forEach","value","name","busboy","Busboy","on","field","val","buildFields","file","info","encoding","filename","mimeType","mime","parseFileName","cleanup","complete","dataHandler","getFilePath","getFileSize","getHash","getWritePromise","useTempFiles","tempFileHandler","memHandler","writePromise","catch","err","end","uploadTimer","createUploadTimer","uploadTimeout","removeAllListeners","resume","Error","destroy","debugLog","clear","isFunc","limitHandler","size","abortOnLimit","APIError","responseOnLimit","data","set","fileFactory","buffer","hash","mimetype","tempFilePath","truncated","Boolean","push","message","parseNested","processNested","Promise","all","then","reader","body","getReader","done","read","write"],"mappings":"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"}

package/dist/next-fileupload/processNested.d.ts

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

package/dist/next-fileupload/processNested.d.ts.map

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

package/dist/next-fileupload/processNested.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "processNested", {
+    enumerable: true,
+    get: function() {
+        return processNested;
+    }
+});
+const _utilities = require("./utilities");
+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++){
+        let key = keys[i], value = data[key], current = d, keyParts = key.replace(new RegExp(/\[/g), '.').replace(new RegExp(/\]/g), '').split('.');
+        for(let index = 0; index < keyParts.length; index++){
+            const k = keyParts[index];
+            // Ensure we don't allow prototype pollution
+            if (!(0, _utilities.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=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9uZXh0LWZpbGV1cGxvYWQvcHJvY2Vzc05lc3RlZC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBpc1NhZmVGcm9tUG9sbHV0aW9uIH0gZnJvbSAnLi91dGlsaXRpZXMnXG5cbmV4cG9ydCBjb25zdCBwcm9jZXNzTmVzdGVkID0gZnVuY3Rpb24gKGRhdGEpIHtcbiAgaWYgKCFkYXRhIHx8IGRhdGEubGVuZ3RoIDwgMSkgcmV0dXJuIE9iamVjdC5jcmVhdGUobnVsbClcblxuICBjb25zdCBkID0gT2JqZWN0LmNyZWF0ZShudWxsKSxcbiAgICBrZXlzID0gT2JqZWN0LmtleXMoZGF0YSlcblxuICBmb3IgKGxldCBpID0gMDsgaSA8IGtleXMubGVuZ3RoOyBpKyspIHtcbiAgICBsZXQga2V5ID0ga2V5c1tpXSxcbiAgICAgIHZhbHVlID0gZGF0YVtrZXldLFxuICAgICAgY3VycmVudCA9IGQsXG4gICAgICBrZXlQYXJ0cyA9IGtleS5yZXBsYWNlKG5ldyBSZWdFeHAoL1xcWy9nKSwgJy4nKS5yZXBsYWNlKG5ldyBSZWdFeHAoL1xcXS9nKSwgJycpLnNwbGl0KCcuJylcblxuICAgIGZvciAobGV0IGluZGV4ID0gMDsgaW5kZXggPCBrZXlQYXJ0cy5sZW5ndGg7IGluZGV4KyspIHtcbiAgICAgIGNvbnN0IGsgPSBrZXlQYXJ0c1tpbmRleF1cblxuICAgICAgLy8gRW5zdXJlIHdlIGRvbid0IGFsbG93IHByb3RvdHlwZSBwb2xsdXRpb25cbiAgICAgIGlmICghaXNTYWZlRnJvbVBvbGx1dGlvbihjdXJyZW50LCBrKSkge1xuICAgICAgICBjb250aW51ZVxuICAgICAgfVxuXG4gICAgICBpZiAoaW5kZXggPj0ga2V5UGFydHMubGVuZ3RoIC0gMSkge1xuICAgICAgICBjdXJyZW50W2tdID0gdmFsdWVcbiAgICAgIH0gZWxzZSB7XG4gICAgICAgIGlmICghY3VycmVudFtrXSkgY3VycmVudFtrXSA9ICFrZXlQYXJ0c1tpbmRleCArIDFdID8gW10gOiBPYmplY3QuY3JlYXRlKG51bGwpXG4gICAgICAgIGN1cnJlbnQgPSBjdXJyZW50W2tdXG4gICAgICB9XG4gICAgfVxuICB9XG4gIHJldHVybiBkXG59XG4iXSwibmFtZXMiOlsicHJvY2Vzc05lc3RlZCIsImRhdGEiLCJsZW5ndGgiLCJPYmplY3QiLCJjcmVhdGUiLCJkIiwia2V5cyIsImkiLCJrZXkiLCJ2YWx1ZSIsImN1cnJlbnQiLCJrZXlQYXJ0cyIsInJlcGxhY2UiLCJSZWdFeHAiLCJzcGxpdCIsImluZGV4IiwiayIsImlzU2FmZUZyb21Qb2xsdXRpb24iXSwibWFwcGluZ3MiOiI7Ozs7K0JBRWFBOzs7ZUFBQUE7OzsyQkFGdUI7QUFFN0IsTUFBTUEsZ0JBQWdCLFNBQVVDLElBQUk7SUFDekMsSUFBSSxDQUFDQSxRQUFRQSxLQUFLQyxNQUFNLEdBQUcsR0FBRyxPQUFPQyxPQUFPQyxNQUFNLENBQUM7SUFFbkQsTUFBTUMsSUFBSUYsT0FBT0MsTUFBTSxDQUFDLE9BQ3RCRSxPQUFPSCxPQUFPRyxJQUFJLENBQUNMO0lBRXJCLElBQUssSUFBSU0sSUFBSSxHQUFHQSxJQUFJRCxLQUFLSixNQUFNLEVBQUVLLElBQUs7UUFDcEMsSUFBSUMsTUFBTUYsSUFBSSxDQUFDQyxFQUFFLEVBQ2ZFLFFBQVFSLElBQUksQ0FBQ08sSUFBSSxFQUNqQkUsVUFBVUwsR0FDVk0sV0FBV0gsSUFBSUksT0FBTyxDQUFDLElBQUlDLE9BQU8sUUFBUSxLQUFLRCxPQUFPLENBQUMsSUFBSUMsT0FBTyxRQUFRLElBQUlDLEtBQUssQ0FBQztRQUV0RixJQUFLLElBQUlDLFFBQVEsR0FBR0EsUUFBUUosU0FBU1QsTUFBTSxFQUFFYSxRQUFTO1lBQ3BELE1BQU1DLElBQUlMLFFBQVEsQ0FBQ0ksTUFBTTtZQUV6Qiw0Q0FBNEM7WUFDNUMsSUFBSSxDQUFDRSxJQUFBQSw4QkFBbUIsRUFBQ1AsU0FBU00sSUFBSTtnQkFDcEM7WUFDRjtZQUVBLElBQUlELFNBQVNKLFNBQVNULE1BQU0sR0FBRyxHQUFHO2dCQUNoQ1EsT0FBTyxDQUFDTSxFQUFFLEdBQUdQO1lBQ2YsT0FBTztnQkFDTCxJQUFJLENBQUNDLE9BQU8sQ0FBQ00sRUFBRSxFQUFFTixPQUFPLENBQUNNLEVBQUUsR0FBRyxDQUFDTCxRQUFRLENBQUNJLFFBQVEsRUFBRSxHQUFHLEVBQUUsR0FBR1osT0FBT0MsTUFBTSxDQUFDO2dCQUN4RU0sVUFBVUEsT0FBTyxDQUFDTSxFQUFFO1lBQ3RCO1FBQ0Y7SUFDRjtJQUNBLE9BQU9YO0FBQ1QifQ==

package/dist/next-fileupload/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/next-fileupload/uploadTimer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uploadTimer.d.ts","sourceRoot":"","sources":["../../src/next-fileupload/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/next-fileupload/uploadTimer.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createUploadTimer", {
+    enumerable: true,
+    get: function() {
+        return createUploadTimer;
+    }
+});
+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=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9uZXh0LWZpbGV1cGxvYWQvdXBsb2FkVGltZXIudHMiXSwic291cmNlc0NvbnRlbnQiOlsidHlwZSBDcmVhdGVVcGxvYWRUaW1lciA9IChcbiAgdGltZW91dD86IG51bWJlcixcbiAgY2FsbGJhY2s/OiAoKSA9PiB2b2lkLFxuKSA9PiB7XG4gIGNsZWFyOiAoKSA9PiB2b2lkXG4gIHNldDogKCkgPT4gYm9vbGVhblxufVxuXG5leHBvcnQgY29uc3QgY3JlYXRlVXBsb2FkVGltZXI6IENyZWF0ZVVwbG9hZFRpbWVyID0gKHRpbWVvdXQgPSAwLCBjYWxsYmFjayA9ICgpID0+IHt9KSA9PiB7XG4gIGxldCB0aW1lciA9IG51bGxcblxuICBjb25zdCBjbGVhciA9ICgpID0+IHtcbiAgICBjbGVhclRpbWVvdXQodGltZXIpXG4gIH1cblxuICBjb25zdCBzZXQgPSAoKSA9PiB7XG4gICAgLy8gRG8gbm90IHN0YXJ0IGEgdGltZXIgaWYgemVybyB0aW1lb3V0IG9yIGl0IGhhc24ndCBiZWVuIHNldC5cbiAgICBpZiAoIXRpbWVvdXQpIHJldHVybiBmYWxzZVxuICAgIGNsZWFyKClcbiAgICB0aW1lciA9IHNldFRpbWVvdXQoY2FsbGJhY2ssIHRpbWVvdXQpXG4gICAgcmV0dXJuIHRydWVcbiAgfVxuXG4gIHJldHVybiB7IGNsZWFyLCBzZXQgfVxufVxuIl0sIm5hbWVzIjpbImNyZWF0ZVVwbG9hZFRpbWVyIiwidGltZW91dCIsImNhbGxiYWNrIiwidGltZXIiLCJjbGVhciIsImNsZWFyVGltZW91dCIsInNldCIsInNldFRpbWVvdXQiXSwibWFwcGluZ3MiOiI7Ozs7K0JBUWFBOzs7ZUFBQUE7OztBQUFOLE1BQU1BLG9CQUF1QyxDQUFDQyxVQUFVLENBQUMsRUFBRUMsV0FBVyxLQUFPLENBQUM7SUFDbkYsSUFBSUMsUUFBUTtJQUVaLE1BQU1DLFFBQVE7UUFDWkMsYUFBYUY7SUFDZjtJQUVBLE1BQU1HLE1BQU07UUFDViw4REFBOEQ7UUFDOUQsSUFBSSxDQUFDTCxTQUFTLE9BQU87UUFDckJHO1FBQ0FELFFBQVFJLFdBQVdMLFVBQVVEO1FBQzdCLE9BQU87SUFDVDtJQUVBLE9BQU87UUFBRUc7UUFBT0U7SUFBSTtBQUN0QiJ9

package/dist/next-fileupload/utilities.d.ts

@@ -0,0 +1,65 @@
+import type { NextFileUploadOptions } from '.';
+/**
+ * Logs message to console if options.debug option set to true.
+ */
+export declare const debugLog: (options: NextFileUploadOptions, msg: string) => boolean;
+/**
+ * Generates unique temporary file name. e.g. tmp-5000-156788789789.
+ */
+export declare const getTempFilename: (prefix?: string) => string;
+type FuncType = (...args: any[]) => any;
+export declare const isFunc: (value: any) => value is FuncType;
+/**
+ * Return a callback function for promise resole/reject args.
+ * Ensures that callback is called only once.
+ */
+type PromiseCallback = (resolve: () => void, reject: (err: Error) => void) => (err: Error) => void;
+export declare const promiseCallback: PromiseCallback;
+/**
+ * Determines whether a key insertion into an object could result in a prototype pollution
+ */
+type IsSafeFromPollution = (base: any, key: string) => boolean;
+export declare const isSafeFromPollution: IsSafeFromPollution;
+/**
+ * Build request field/file objects to return
+ */
+type BuildFields = (instance: any, field: string, value: any) => any;
+export declare const buildFields: BuildFields;
+/**
+ * Creates a folder if it does not exist
+ * for file specified in the path variable
+ */
+type CheckAndMakeDir = (fileUploadOptions: NextFileUploadOptions, filePath: string) => boolean;
+export declare const checkAndMakeDir: CheckAndMakeDir;
+/**
+ * Delete a file.
+ */
+type DeleteFile = (filePath: string, callback: (args: any) => void) => void;
+export declare const deleteFile: DeleteFile;
+/**
+ * moveFile: moves the file from src to dst.
+ * Firstly trying to rename the file if no luck copying it to dst and then deleting src.
+ */
+type MoveFile = (src: string, dst: string, callback: (err: Error, renamed?: boolean) => void) => void;
+export declare const moveFile: MoveFile;
+/**
+ * Save buffer data to a file.
+ * @param {Buffer} buffer - buffer to save to a file.
+ * @param {string} filePath - path to a file.
+ */
+export declare const saveBufferToFile: (buffer: any, filePath: any, callback: any) => any;
+/**
+ * Parses filename and extension and returns object {name, extension}.
+ */
+type ParseFileNameExtension = (preserveExtension: boolean | number, fileName: string) => {
+    extension: string;
+    name: string;
+};
+export declare const parseFileNameExtension: ParseFileNameExtension;
+/**
+ * Parse file name and extension.
+ */
+type ParseFileName = (opts: NextFileUploadOptions, fileName: string) => string;
+export declare const parseFileName: ParseFileName;
+export {};
+//# sourceMappingURL=utilities.d.ts.map

package/dist/next-fileupload/utilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utilities.d.ts","sourceRoot":"","sources":["../../src/next-fileupload/utilities.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,GAAG,CAAA;AAW9C;;GAEG;AACH,eAAO,MAAM,QAAQ,YAAa,qBAAqB,OAAO,MAAM,YAKnE,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,eAAe,YAAY,MAAM,WAG7C,CAAA;AAED,KAAK,QAAQ,GAAG,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CAAA;AACvC,eAAO,MAAM,MAAM,UAAW,GAAG,sBAEhC,CAAA;AAQD;;;GAGG;AACH,KAAK,eAAe,GAAG,CAAC,OAAO,EAAE,MAAM,IAAI,EAAE,MAAM,EAAE,CAAC,GAAG,EAAE,KAAK,KAAK,IAAI,KAAK,CAAC,GAAG,EAAE,KAAK,KAAK,IAAI,CAAA;AAClG,eAAO,MAAM,eAAe,EAAE,eAU7B,CAAA;AAOD;;GAEG;AACH,KAAK,mBAAmB,GAAG,CAAC,IAAI,EAAE,GAAG,EAAE,GAAG,EAAE,MAAM,KAAK,OAAO,CAAA;AAC9D,eAAO,MAAM,mBAAmB,EAAE,mBAQjC,CAAA;AAED;;GAEG;AACH,KAAK,WAAW,GAAG,CAAC,QAAQ,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,KAAK,GAAG,CAAA;AACpE,eAAO,MAAM,WAAW,EAAE,WAoBzB,CAAA;AAED;;;GAGG;AACH,KAAK,eAAe,GAAG,CAAC,iBAAiB,EAAE,qBAAqB,EAAE,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAA;AAC9F,eAAO,MAAM,eAAe,EAAE,eAQ7B,CAAA;AAED;;GAEG;AACH,KAAK,UAAU,GAAG,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,IAAI,KAAK,IAAI,CAAA;AAC3E,eAAO,MAAM,UAAU,EAAE,UACM,CAAA;AA4B/B;;;GAGG;AACH,KAAK,QAAQ,GAAG,CACd,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,CAAC,GAAG,EAAE,KAAK,EAAE,OAAO,CAAC,EAAE,OAAO,KAAK,IAAI,KAC9C,IAAI,CAAA;AACT,eAAO,MAAM,QAAQ,EAAE,QASnB,CAAA;AAEJ;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,oDAwB5B,CAAA;AA+BD;;GAEG;AACH,KAAK,sBAAsB,GAAG,CAC5B,iBAAiB,EAAE,OAAO,GAAG,MAAM,EACnC,QAAQ,EAAE,MAAM,KACb;IACH,SAAS,EAAE,MAAM,CAAA;IACjB,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AACD,eAAO,MAAM,sBAAsB,EAAE,sBAwBpC,CAAA;AAED;;GAEG;AACH,KAAK,aAAa,GAAG,CAAC,IAAI,EAAE,qBAAqB,EAAE,QAAQ,EAAE,MAAM,KAAK,MAAM,CAAA;AAC9E,eAAO,MAAM,aAAa,EAAE,aAmB3B,CAAA"}