@depup/payload 3.79.1-depup.0

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

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

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

@@ -0,0 +1,27 @@
+// eslint-disable-next-line regexp/no-super-linear-backtracking, regexp/no-obscure-range
+const ACCEPTABLE_CONTENT_TYPE = /multipart\/['"()+-_]+(?:; ?['"()+-_]*)+$/i;
+const UNACCEPTABLE_METHODS = new Set([
+    'CONNECT',
+    'DELETE',
+    'GET',
+    'HEAD',
+    'OPTIONS',
+    '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 (ignore) {
+        return false;
+    }
+};
+
+//# sourceMappingURL=isEligibleRequest.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/uploads/fetchAPI-multipart/isEligibleRequest.ts"],"sourcesContent":["// eslint-disable-next-line regexp/no-super-linear-backtracking, regexp/no-obscure-range\nconst ACCEPTABLE_CONTENT_TYPE = /multipart\\/['\"()+-_]+(?:; ?['\"()+-_]*)+$/i\nconst UNACCEPTABLE_METHODS = new Set(['CONNECT', 'DELETE', 'GET', 'HEAD', 'OPTIONS', '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 (ignore) {\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","ignore"],"mappings":"AAAA,wFAAwF;AACxF,MAAMA,0BAA0B;AAChC,MAAMC,uBAAuB,IAAIC,IAAI;IAAC;IAAW;IAAU;IAAO;IAAQ;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,SAAUC,QAAQ,CAAC,gBAAgBb,wBAAwBc,IAAI,CAACF;AACzE;AAEA,OAAO,MAAMG,oBAAoB,CAACX;IAChC,IAAI;QACF,OAAOD,QAAQC,QAAQI,oBAAoBJ,QAAQO,yBAAyBP;IAC9E,EAAE,OAAOY,QAAQ;QACf,OAAO;IACT;AACF,EAAC"}

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

@@ -0,0 +1,15 @@
+import type { FetchAPIFileUploadOptions } from '../../config/types.js';
+import type { FetchAPIFileUploadResponse } from './index.js';
+declare const waitFlushProperty: unique symbol;
+declare global {
+    interface Request {
+        [waitFlushProperty]?: Promise<any>[];
+    }
+}
+type ProcessMultipart = (args: {
+    options: FetchAPIFileUploadOptions;
+    request: Request;
+}) => Promise<FetchAPIFileUploadResponse>;
+export declare const processMultipart: ProcessMultipart;
+export {};
+//# sourceMappingURL=processMultipart.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"processMultipart.d.ts","sourceRoot":"","sources":["../../../src/uploads/fetchAPI-multipart/processMultipart.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,uBAAuB,CAAA;AACtE,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,YAAY,CAAA;AAS5D,QAAA,MAAM,iBAAiB,eAAuC,CAAA;AAE9D,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,OAAO;QACf,CAAC,iBAAiB,CAAC,CAAC,EAAE,OAAO,CAAC,GAAG,CAAC,EAAE,CAAA;KACrC;CACF;AAED,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,gBAwM9B,CAAA"}

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

@@ -0,0 +1,162 @@
+import Busboy from 'busboy';
+import { status as httpStatus } from 'http-status';
+import { APIError } from '../../errors/APIError.js';
+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 shouldAbortProccessing = false;
+    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;
+    });
+    const reader = request.body?.getReader();
+    const busboy = Busboy({
+        ...options,
+        headers: headersObject
+    });
+    function abortAndDestroyFile(file, err) {
+        file.destroy();
+        shouldAbortProccessing = true;
+        failedResolvingFiles(err);
+    }
+    // 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);
+        const inferredMimeType = filename && filename.endsWith('.glb') && 'model/gltf-binary' || filename && filename.endsWith('.gltf') && 'model/gltf+json' || mime;
+        // 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(()=>{
+            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: inferredMimeType,
+                size,
+                tempFilePath: getFilePath(),
+                truncated: Boolean('truncated' in file && file.truncated) || false
+            }, 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`);
+        throw err;
+    });
+    while(parsingRequest){
+        const { done, value } = await reader.read();
+        if (done) {
+            parsingRequest = false;
+        }
+        if (value && !shouldAbortProccessing) {
+            busboy.write(value);
+        }
+    }
+    if (fileCount !== 0) {
+        await allFilesComplete.catch((e)=>{
+            throw e;
+        });
+    }
+    return result;
+};
+
+//# sourceMappingURL=processMultipart.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/uploads/fetchAPI-multipart/processMultipart.ts"],"sourcesContent":["import type { Readable } from 'stream'\n\nimport Busboy from 'busboy'\nimport { status as httpStatus } from 'http-status'\n\nimport type { FetchAPIFileUploadOptions } from '../../config/types.js'\nimport type { FetchAPIFileUploadResponse } from './index.js'\n\nimport { APIError } from '../../errors/APIError.js'\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\ndeclare global {\n  interface Request {\n    [waitFlushProperty]?: Promise<any>[]\n  }\n}\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 shouldAbortProccessing = false\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: Record<string, string> = {}\n  request.headers.forEach((value, name) => {\n    headersObject[name] = value\n  })\n\n  const reader = request.body?.getReader()\n\n  const busboy = Busboy({ ...options, headers: headersObject })\n\n  function abortAndDestroyFile(file: Readable, err: APIError) {\n    file.destroy()\n    shouldAbortProccessing = true\n    failedResolvingFiles(err)\n  }\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    const inferredMimeType =\n      (filename && filename.endsWith('.glb') && 'model/gltf-binary') ||\n      (filename && filename.endsWith('.gltf') && 'model/gltf+json') ||\n      mime\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(() => {\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: inferredMimeType,\n            size,\n            tempFilePath: getFilePath(),\n            truncated: Boolean('truncated' in file && file.truncated) || false,\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      throw err\n    },\n  )\n\n  while (parsingRequest) {\n    const { done, value } = await reader!.read()\n\n    if (done) {\n      parsingRequest = false\n    }\n\n    if (value && !shouldAbortProccessing) {\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","status","httpStatus","APIError","fileFactory","memHandler","tempFileHandler","processNested","createUploadTimer","buildFields","debugLog","isFunc","parseFileName","waitFlushProperty","Symbol","processMultipart","options","request","parsingRequest","shouldAbortProccessing","fileCount","filesCompleted","allFilesHaveResolved","failedResolvingFiles","allFilesComplete","Promise","res","rej","result","fields","undefined","files","headersObject","headers","forEach","value","name","reader","body","getReader","busboy","abortAndDestroyFile","file","err","destroy","on","field","val","info","encoding","filename","mimeType","mime","inferredMimeType","endsWith","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","done","read","write","e"],"mappings":"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"}

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

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

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

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

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

@@ -0,0 +1,29 @@
+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], keyParts = key?.replace(new RegExp(/\[/g), '.').replace(new RegExp(/\]/g), '').split('.'), value = data[key];
+        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/uploads/fetchAPI-multipart/processNested.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/uploads/fetchAPI-multipart/processNested.ts"],"sourcesContent":["import { isSafeFromPollution } from './utilities.js'\n\nexport const processNested = function (data: Record<string, any>) {\n  if (!data || data.length < 1) {\n    return Object.create(null)\n  }\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      keyParts = key?.replace(new RegExp(/\\[/g), '.').replace(new RegExp(/\\]/g), '').split('.'),\n      value = data[key]\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]) {\n          current[k] = !keyParts[index + 1] ? [] : Object.create(null)\n        }\n        current = current[k]\n      }\n    }\n  }\n  return d\n}\n"],"names":["isSafeFromPollution","processNested","data","length","Object","create","d","keys","i","key","keyParts","replace","RegExp","split","value","current","index","k"],"mappings":"AAAA,SAASA,mBAAmB,QAAQ,iBAAgB;AAEpD,OAAO,MAAMC,gBAAgB,SAAUC,IAAyB;IAC9D,IAAI,CAACA,QAAQA,KAAKC,MAAM,GAAG,GAAG;QAC5B,OAAOC,OAAOC,MAAM,CAAC;IACvB;IAEA,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,WAAWD,KAAKE,QAAQ,IAAIC,OAAO,QAAQ,KAAKD,QAAQ,IAAIC,OAAO,QAAQ,IAAIC,MAAM,MACrFC,QAAQZ,IAAI,CAACO,IAAI;QACnB,IAAIM,UAAUT;QAEd,IAAK,IAAIU,QAAQ,GAAGA,QAAQN,SAASP,MAAM,EAAEa,QAAS;YACpD,MAAMC,IAAIP,QAAQ,CAACM,MAAM;YAEzB,4CAA4C;YAC5C,IAAI,CAAChB,oBAAoBe,SAASE,IAAI;gBACpC;YACF;YAEA,IAAID,SAASN,SAASP,MAAM,GAAG,GAAG;gBAChCY,OAAO,CAACE,EAAE,GAAGH;YACf,OAAO;gBACL,IAAI,CAACC,OAAO,CAACE,EAAE,EAAE;oBACfF,OAAO,CAACE,EAAE,GAAG,CAACP,QAAQ,CAACM,QAAQ,EAAE,GAAG,EAAE,GAAGZ,OAAOC,MAAM,CAAC;gBACzD;gBACAU,UAAUA,OAAO,CAACE,EAAE;YACtB;QACF;IACF;IACA,OAAOX;AACT,EAAC"}

package/dist/uploads/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/uploads/fetchAPI-multipart/uploadTimer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uploadTimer.d.ts","sourceRoot":"","sources":["../../../src/uploads/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,iBAkB/B,CAAA"}

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

@@ -0,0 +1,21 @@
+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/uploads/fetchAPI-multipart/uploadTimer.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/uploads/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: NodeJS.Timeout | null | number = 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) {\n      return false\n    }\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,QAAwC;IAE5C,MAAMC,QAAQ;QACZC,aAAaF;IACf;IAEA,MAAMG,MAAM;QACV,8DAA8D;QAC9D,IAAI,CAACL,SAAS;YACZ,OAAO;QACT;QACAG;QACAD,QAAQI,WAAWL,UAAUD;QAC7B,OAAO;IACT;IAEA,OAAO;QAAEG;QAAOE;IAAI;AACtB,EAAC"}

package/dist/uploads/fetchAPI-multipart/utilities.d.ts

@@ -0,0 +1,65 @@
+import type { FetchAPIFileUploadOptions } from '../../config/types.js';
+/**
+ * Logs message to console if options.debug option set to true.
+ */
+export declare const debugLog: (options: FetchAPIFileUploadOptions, 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: FetchAPIFileUploadOptions, 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: Buffer, filePath: string, callback: (err?: Error) => void) => void;
+/**
+ * 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: FetchAPIFileUploadOptions, fileName: string) => string;
+export declare const parseFileName: ParseFileName;
+export {};
+//# sourceMappingURL=utilities.d.ts.map

package/dist/uploads/fetchAPI-multipart/utilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utilities.d.ts","sourceRoot":"","sources":["../../../src/uploads/fetchAPI-multipart/utilities.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,uBAAuB,CAAA;AAWtE;;GAEG;AACH,eAAO,MAAM,QAAQ,YAAa,yBAAyB,OAAO,MAAM,YAOvE,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,KAAG,KAAK,IAAI,QAE5C,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,WAsBzB,CAAA;AAED;;;GAGG;AACH,KAAK,eAAe,GAAG,CAAC,iBAAiB,EAAE,yBAAyB,EAAE,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAA;AAClG,eAAO,MAAM,eAAe,EAAE,eAY7B,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,UAAkE,CAAA;AA8B3F;;;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,WACnB,MAAM,YACJ,MAAM,YACN,CAAC,GAAG,CAAC,EAAE,KAAK,KAAK,IAAI,SAyBhC,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,sBA4BpC,CAAA;AAED;;GAEG;AACH,KAAK,aAAa,GAAG,CAAC,IAAI,EAAE,yBAAyB,EAAE,QAAQ,EAAE,MAAM,KAAK,MAAM,CAAA;AAClF,eAAO,MAAM,aAAa,EAAE,aAyB3B,CAAA"}

package/dist/uploads/fetchAPI-multipart/utilities.js

@@ -0,0 +1,226 @@
+import fs from 'fs';
+import path from 'path';
+import { Readable } from 'stream';
+// Parameters for safe file name parsing.
+const SAFE_FILE_NAME_REGEX = /[^\w-]/g;
+const MAX_EXTENSION_LENGTH = 3;
+// Parameters to generate unique temporary file names:
+const TEMP_COUNTER_MAX = 65536;
+const TEMP_PREFIX = 'tmp';
+let tempCounter = 0;
+/**
+ * Logs message to console if options.debug option set to true.
+ */ export const debugLog = (options, msg)=>{
+    const opts = options || {};
+    if (!opts.debug) {
+        return false;
+    }
+    console.log(`Next-file-upload: ${msg}`); // eslint-disable-line
+    return true;
+};
+/**
+ * Generates unique temporary file name. e.g. tmp-5000-156788789789.
+ */ export const getTempFilename = (prefix = TEMP_PREFIX)=>{
+    tempCounter = tempCounter >= TEMP_COUNTER_MAX ? 1 : tempCounter + 1;
+    return `${prefix}-${tempCounter}-${Date.now()}`;
+};
+export const isFunc = (value)=>{
+    return typeof value === 'function';
+};
+const errorFunc = (resolve, reject)=>isFunc(reject) ? reject : resolve;
+export const promiseCallback = (resolve, reject)=>{
+    let hasFired = false;
+    return (err)=>{
+        if (hasFired) {
+            return;
+        }
+        hasFired = true;
+        return err ? errorFunc(resolve, reject)(err) : resolve();
+    };
+};
+// The default prototypes for both objects and arrays.
+// Used by isSafeFromPollution
+const OBJECT_PROTOTYPE_KEYS = Object.getOwnPropertyNames(Object.prototype);
+const ARRAY_PROTOTYPE_KEYS = Object.getOwnPropertyNames(Array.prototype);
+export const isSafeFromPollution = (base, key)=>{
+    // We perform an instanceof check instead of Array.isArray as the former is more
+    // permissive for cases in which the object as an Array prototype but was not constructed
+    // via an Array constructor or literal.
+    const TOUCHES_ARRAY_PROTOTYPE = base instanceof Array && ARRAY_PROTOTYPE_KEYS.includes(key);
+    const TOUCHES_OBJECT_PROTOTYPE = OBJECT_PROTOTYPE_KEYS.includes(key);
+    return !TOUCHES_ARRAY_PROTOTYPE && !TOUCHES_OBJECT_PROTOTYPE;
+};
+export const buildFields = (instance, field, value)=>{
+    // Do nothing if value is not set.
+    if (value === null || value === undefined) {
+        return instance;
+    }
+    instance = instance || Object.create(null);
+    if (!isSafeFromPollution(instance, field)) {
+        return instance;
+    }
+    // Non-array fields
+    if (!instance[field]) {
+        instance[field] = value;
+        return instance;
+    }
+    // Array fields
+    if (instance[field] instanceof Array) {
+        instance[field].push(value);
+    } else {
+        instance[field] = [
+            instance[field],
+            value
+        ];
+    }
+    return instance;
+};
+export const checkAndMakeDir = (fileUploadOptions, filePath)=>{
+    if (!fileUploadOptions.createParentPath) {
+        return false;
+    }
+    // Check whether folder for the file exists.
+    const parentPath = path.dirname(path.resolve(filePath));
+    // Create folder if it doesn't exist.
+    if (!fs.existsSync(parentPath)) {
+        fs.mkdirSync(parentPath, {
+            recursive: true
+        });
+    }
+    // Checks folder again and return a results.
+    return fs.existsSync(parentPath);
+};
+export const deleteFile = (filePath, callback)=>fs.unlink(filePath, callback);
+const copyFile = (src, dst, callback)=>{
+    // cbCalled flag and runCb helps to run cb only once.
+    let cbCalled = false;
+    const runCb = (err)=>{
+        if (cbCalled) {
+            return;
+        }
+        cbCalled = true;
+        callback(err);
+    };
+    // Create read stream
+    const readable = fs.createReadStream(src);
+    readable.on('error', runCb);
+    // Create write stream
+    const writable = fs.createWriteStream(dst);
+    writable.on('error', (err)=>{
+        readable.destroy();
+        runCb(err);
+    });
+    writable.on('close', ()=>runCb());
+    // Copy file via piping streams.
+    readable.pipe(writable);
+};
+export const moveFile = (src, dst, callback)=>fs.rename(src, dst, (err)=>{
+        if (err) {
+            // Try to copy file if rename didn't work.
+            copyFile(src, dst, (cpErr)=>cpErr ? callback(cpErr) : deleteFile(src, callback));
+            return;
+        }
+        // File was renamed successfully: Add true to the callback to indicate that.
+        callback(null, true);
+    });
+/**
+ * Save buffer data to a file.
+ * @param {Buffer} buffer - buffer to save to a file.
+ * @param {string} filePath - path to a file.
+ */ export const saveBufferToFile = (buffer, filePath, callback)=>{
+    if (!Buffer.isBuffer(buffer)) {
+        return callback(new Error('buffer variable should be type of Buffer!'));
+    }
+    // Setup readable stream from buffer.
+    let streamData = buffer;
+    const readStream = new Readable();
+    readStream._read = ()=>{
+        readStream.push(streamData);
+        streamData = null;
+    };
+    // Setup file system writable stream.
+    const fstream = fs.createWriteStream(filePath);
+    // console.log("Calling saveBuffer");
+    fstream.on('error', (err)=>{
+        // console.log("err cb")
+        callback(err);
+    });
+    fstream.on('close', ()=>{
+        // console.log("close cb");
+        callback();
+    });
+    // Copy file via piping streams.
+    readStream.pipe(fstream);
+};
+/**
+ * Decodes uriEncoded file names.
+ * @param {Object} opts - middleware options.
+ * @param fileName {String} - file name to decode.
+ * @returns {String}
+ */ const uriDecodeFileName = (opts, fileName)=>{
+    if (!opts || !opts.uriDecodeFileNames) {
+        return fileName;
+    }
+    // Decode file name from URI with checking URI malformed errors.
+    // See Issue https://github.com/richardgirges/express-fileupload/issues/342.
+    try {
+        return decodeURIComponent(fileName);
+    } catch (ignore) {
+        const matcher = /(%[a-f\d]{2})/gi;
+        return fileName.split(matcher).map((str)=>{
+            try {
+                return decodeURIComponent(str);
+            } catch (ignore) {
+                return '';
+            }
+        }).join('');
+    }
+};
+export const parseFileNameExtension = (preserveExtension, fileName)=>{
+    const defaultResult = {
+        name: fileName,
+        extension: ''
+    };
+    if (!preserveExtension) {
+        return defaultResult;
+    }
+    // Define maximum extension length
+    const maxExtLength = typeof preserveExtension === 'boolean' ? MAX_EXTENSION_LENGTH : preserveExtension;
+    const nameParts = fileName.split('.');
+    if (nameParts.length < 2) {
+        return defaultResult;
+    }
+    let extension = nameParts.pop();
+    if (extension.length > maxExtLength && maxExtLength > 0) {
+        nameParts[nameParts.length - 1] += '.' + extension.substr(0, extension.length - maxExtLength);
+        extension = extension.substr(-maxExtLength);
+    }
+    return {
+        name: nameParts.join('.'),
+        extension: maxExtLength ? extension : ''
+    };
+};
+export const parseFileName = (opts, fileName)=>{
+    // Check fileName argument
+    if (!fileName || typeof fileName !== 'string') {
+        return getTempFilename();
+    }
+    // Cut off file name if it's length more then 255.
+    let parsedName = fileName.length <= 255 ? fileName : fileName.substr(0, 255);
+    // Decode file name if uriDecodeFileNames option set true.
+    parsedName = uriDecodeFileName(opts, parsedName);
+    // Stop parsing file name if safeFileNames options hasn't been set.
+    if (!opts.safeFileNames) {
+        return parsedName;
+    }
+    // Set regular expression for the file name.
+    const nameRegex = typeof opts.safeFileNames === 'object' && opts.safeFileNames instanceof RegExp ? opts.safeFileNames : SAFE_FILE_NAME_REGEX;
+    // Parse file name extension.
+    const parsedFileName = parseFileNameExtension(opts.preserveExtension, parsedName);
+    if (parsedFileName.extension.length) {
+        parsedFileName.extension = '.' + parsedFileName.extension.replace(nameRegex, '');
+    }
+    return parsedFileName.name.replace(nameRegex, '').concat(parsedFileName.extension);
+};
+
+//# sourceMappingURL=utilities.js.map