126 lines
3.4 KiB
JavaScript
126 lines
3.4 KiB
JavaScript
'use strict';
|
|
|
|
import utils from '../utils.js';
|
|
import AxiosError from '../core/AxiosError.js';
|
|
import { DEFAULT_FORM_DATA_MAX_DEPTH } from './toFormData.js';
|
|
|
|
const MAX_DEPTH = DEFAULT_FORM_DATA_MAX_DEPTH;
|
|
|
|
function throwIfDepthExceeded(index) {
|
|
if (index > MAX_DEPTH) {
|
|
throw new AxiosError(
|
|
'FormData field is too deeply nested (' + index + ' levels). Max depth: ' + MAX_DEPTH,
|
|
AxiosError.ERR_FORM_DATA_DEPTH_EXCEEDED
|
|
);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* It takes a string like `foo[x][y][z]` and returns an array like `['foo', 'x', 'y', 'z']
|
|
*
|
|
* @param {string} name - The name of the property to get.
|
|
*
|
|
* @returns An array of strings.
|
|
*/
|
|
function parsePropPath(name) {
|
|
// foo[x][y][z] -> ['foo', 'x', 'y', 'z']
|
|
// foo.x.y.z -> ['foo', 'x', 'y', 'z']
|
|
// A path is split on `.` and on `[...]` groups. A segment — whether written
|
|
// in dot notation or captured inside brackets — may contain any character
|
|
// except `.`, `[` and `]`, so a key like `user-name` or `user name` is kept
|
|
// literal instead of being split (#5402). `.`, `[` and `]` keep their existing
|
|
// meaning, e.g. `foo[bar.baz]` -> ['foo', 'bar', 'baz'] and `[]` is an array push.
|
|
// Excluding `[` from the bracket group also makes the match fail fast at the
|
|
// next `[`, so a malformed name cannot rescan to the end of the string from
|
|
// every unmatched `[` — parsing stays linear in the length of the name.
|
|
const path = [];
|
|
const pattern = /[^.[\]]+|\[([^.[\]]*)]/g;
|
|
let match;
|
|
|
|
while ((match = pattern.exec(name)) !== null) {
|
|
throwIfDepthExceeded(path.length);
|
|
path.push(match[0] === '[]' ? '' : match[1] || match[0]);
|
|
}
|
|
|
|
return path;
|
|
}
|
|
|
|
/**
|
|
* Convert an array to an object.
|
|
*
|
|
* @param {Array<any>} arr - The array to convert to an object.
|
|
*
|
|
* @returns An object with the same keys and values as the array.
|
|
*/
|
|
function arrayToObject(arr) {
|
|
const obj = {};
|
|
const keys = Object.keys(arr);
|
|
let i;
|
|
const len = keys.length;
|
|
let key;
|
|
for (i = 0; i < len; i++) {
|
|
key = keys[i];
|
|
obj[key] = arr[key];
|
|
}
|
|
return obj;
|
|
}
|
|
|
|
/**
|
|
* It takes a FormData object and returns a JavaScript object
|
|
*
|
|
* @param {string} formData The FormData object to convert to JSON.
|
|
*
|
|
* @returns {Object<string, any> | null} The converted object.
|
|
*/
|
|
function formDataToJSON(formData) {
|
|
function buildPath(path, value, target, index) {
|
|
throwIfDepthExceeded(index);
|
|
|
|
let name = path[index++];
|
|
|
|
if (name === '__proto__') return true;
|
|
|
|
const isNumericKey = Number.isFinite(+name);
|
|
const isLast = index >= path.length;
|
|
name = !name && utils.isArray(target) ? target.length : name;
|
|
|
|
if (isLast) {
|
|
if (utils.hasOwnProp(target, name)) {
|
|
target[name] = utils.isArray(target[name])
|
|
? target[name].concat(value)
|
|
: [target[name], value];
|
|
} else {
|
|
target[name] = value;
|
|
}
|
|
|
|
return !isNumericKey;
|
|
}
|
|
|
|
if (!utils.hasOwnProp(target, name) || !utils.isObject(target[name])) {
|
|
target[name] = [];
|
|
}
|
|
|
|
const result = buildPath(path, value, target[name], index);
|
|
|
|
if (result && utils.isArray(target[name])) {
|
|
target[name] = arrayToObject(target[name]);
|
|
}
|
|
|
|
return !isNumericKey;
|
|
}
|
|
|
|
if (utils.isFormData(formData) && utils.isFunction(formData.entries)) {
|
|
const obj = {};
|
|
|
|
utils.forEachEntry(formData, (name, value) => {
|
|
buildPath(parsePropPath(name), value, obj, 0);
|
|
});
|
|
|
|
return obj;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
export default formDataToJSON;
|