parse-nested-form-data 1.0.0

package/dist/parse-nested-form-data.umd.js

@@ -0,0 +1,398 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@remix-run/web-file')) :
+  typeof define === 'function' && define.amd ? define(['exports', '@remix-run/web-file'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.parseNestedFormData = {}, global.RemixRunWebFile));
+})(this, (function (exports, webFile) { 'use strict';
+
+  /**
+   * @name parse-nested-form-data
+   * @license MIT license.
+   * @copyright (c) 2022 Christian Schurr
+   * @author Christian Schurr <chris@schurr.dev>
+   */
+
+  /**
+   * Thrown when a path is used multiple times or has missmatching path parts.
+   *
+   * @example
+   * ```ts
+   * const formData = new FormData()
+   * formData.append('a[0]', 'b')
+   * formData.append('a[0]', 'c')
+   * parseFormData(formData)
+   * // throws DuplicateKeyError('a[0]')
+   * ```
+   *
+   * @example
+   * ```ts
+   * const formData = new FormData()
+   * formData.append('a', 'b')
+   * formData.append('a', 'c')
+   * parseFormData(formData)
+   * // throws DuplicateKeyError('a')
+   *
+   * @example
+   * ```ts
+   * const formData = new FormData()
+   * formData.append('a', 'b')
+   * formData.append('a[]', 'c')
+   * parseFormData(formData)
+   * // throws DuplicateKeyError('a[]')
+   * ```
+   *
+   */
+  class DuplicateKeyError extends Error {
+    constructor(key) {
+      super(`Duplicate key at path part ${key}`);
+      this.key = void 0;
+      this.key = key;
+    }
+  }
+  /**
+   * Thrown when an array is used at the same path with an order parameter and
+   * without an order parameter.
+   *
+   * @example
+   * ```ts
+   * const formData = new FormData()
+   * formData.append('a[0]', 'a')
+   * formData.append('a[]', 'b')
+   * parseFormData(formData)
+   * // => throws `MixedArrayError(a[])`
+   * ```
+   *
+   * @example
+   * ```ts
+   * const formData = new FormData()
+   * formData.append('a[]', 'a')
+   * formData.append('a[0]', 'b')
+   * parseFormData(formData)
+   * // => throws `MixedArrayError(a[0])`
+   * ```
+   */
+  class MixedArrayError extends Error {
+    constructor(key) {
+      super(`Mixed array at path part ${key}`);
+      this.key = void 0;
+      this.key = key;
+    }
+  }
+  function isJsonObject(val) {
+    return typeof val === 'object' && !Array.isArray(val) && val !== null && !(val instanceof webFile.File);
+  }
+
+  /**
+   * Default Transformer for `parseFormData`.
+   *
+   * Transforms a FormData Entry into a path and a `JsonLeafValue`.
+   *
+   * - `path` starts with `+` -> transform value to `number`
+   * - `path` starts with `&` -> transform value to `boolean`
+   * - `path` starts with `-` -> transform value to `null`
+   *
+   * @example
+   * ```ts
+   * const entry = ['a[0]', 'b']
+   * const result = defaultTransform(entry)
+   * // => {path: 'a[0]', value: 'b'}
+   * ```
+   *
+   * @example
+   * ```ts
+   * const entry = ['+a[0]', '1']
+   * const result = defaultTransform(entry)
+   * // => {path: 'a[0]', value: 1}
+   * ```
+   *
+   * @example
+   * ```ts
+   * const entry = ['&a[0]', 'true']
+   * const result = defaultTransform(entry)
+   * // => {path: 'a[0]', value: true}
+   * ```
+   *
+   * @example
+   * ```ts
+   * const entry = ['-a[0]', 'null']
+   * const result = defaultTransform(entry)
+   * // => {path: 'a[0]', value: null}
+   * ```
+   *
+   * @example
+   * ```ts
+   * const entry = ['a[0]', new File([''], 'file.txt')]
+   * const result = defaultTransform(entry)
+   * // => {path: 'a[0]', value: File}
+   * ```
+   *
+   *
+   * @param entry [path, value]: the FormData entry
+   * @returns the path and the transformed value
+   */
+  function defaultTransform(entry) {
+    let path = entry[0];
+    let value = entry[1];
+    if (path.startsWith('+')) {
+      path = path.slice(1);
+      value = Number(value);
+    } else if (path.startsWith('&')) {
+      path = path.slice(1);
+      value = value === 'on' || value === 'true' || Boolean(Number(value));
+    } else if (path.startsWith('-')) {
+      path = path.slice(1);
+      value = null;
+    }
+    return {
+      path,
+      value
+    };
+  }
+  /**
+   *
+   * Transforms a FormData path into an array of `PathPart`s.
+   *
+   * @param path - the path to extract the path parts from
+   * @returns {Array<PathPart>} the extracted path parts
+   *
+   * @example
+   * ```ts
+   * const path = 'a[0].b'
+   * const result = extractPathParts(path)
+   * // => [{path: 'a', type: 'object, default: [], pathToPart: 'a'},
+   * //     {path: '0', type: 'array', default: {}, pathToPart: 'a[0]'},
+   * //     {path: 'b', type: 'object', default: {}, pathToPart: 'a[0].b'}]
+   * ```
+   *
+   * @example
+   * ```ts
+   * const path = 'a.b'
+   * const result = extractPathParts(path)
+   * // => [{path: 'a', type: 'object, default: {}, pathToPart: 'a'},
+   * //     {path: 'b', type: 'object', default: {}, pathToPart: 'a.b'}]
+   * ```
+   *
+   * @example
+   * ```ts
+   * const path = 'a[][0]'
+   * const result = extractPathParts(path)
+   * // => [{path: 'a', type: 'object, default: [], pathToPart: 'a'},
+   * //     {path: '', type: 'array', default: [], pathToPart: 'a[]'},
+   * //     {path: '0', type: 'array', default: {}, pathToPart: 'a[][0]'}]
+   * ```
+   *
+   *
+   */
+  function extractPathParts(path) {
+    const re = /((?<array>\d*)\]|(?<pathPart>[^.[]+))(?<nextType>\[|\.|$)/g;
+    return Array.from(path.matchAll(re)).map(match => {
+      // self casted RegexExpMatchArray to custom
+      const typedMatch = match;
+      const {
+        array,
+        pathPart,
+        nextType
+      } = typedMatch.groups;
+      const type = array === undefined ? 'object' : 'array';
+      const nextDefault = nextType === '[' ? [] : {};
+      return {
+        path: array ?? pathPart,
+        type,
+        default: nextDefault,
+        pathToPart: path.slice(0, typedMatch.index + typedMatch[1].length)
+      };
+    });
+  }
+
+  /**
+   *
+   * Returns the value accessed via `pathPart` in the `currentPathObject`
+   * and a setter function to set the value in the `currentPathObject` via the
+   * provided `pathPart`.
+   *
+   * @param pathPart - the path part to get the setter and getter for
+   * @param currentPathObject - the object at the current path (before the path part)
+   * @param arraysWithOrder - a set of arrays that have an order
+   * @returns the setter and getter for the path part
+   *
+   * @example
+   * ```ts
+   * const pathPart = {path: 'a', type: 'object', default: {}, pathToPart: 'a'}
+   * const currentPathObject = {}
+   * const arraysWithOrder = new Set()
+   * const [value, setValue] = getSetterAndGetter(pathPart, currentPathObject, arraysWithOrder)
+   * setValue('b')
+   * // => currentPathObject = {a: 'b'}
+   * ```
+   *
+   * @example
+   * ```ts
+   * const pathPart = {path: '0', type: 'array', default: [], pathToPart: 'a[0]'}
+   * const currentPathObject = {a: []}
+   * const arraysWithOrder = new Set()
+   * const [value, setValue] = getSetterAndGetter(pathPart, currentPathObject, arraysWithOrder)
+   * setValue('b')
+   * // => currentPathObject = {a: ['b']}
+   * ```
+   *
+   */
+  function handlePathPart(pathPart, currentPathObject, arraysWithOrder) {
+    if (pathPart.type === 'object') {
+      if (Array.isArray(currentPathObject)) {
+        throw new DuplicateKeyError(pathPart.pathToPart);
+      }
+      const currentObject = currentPathObject;
+      return [currentObject[pathPart.path], val => currentObject[pathPart.path] = val];
+    }
+    if (!Array.isArray(currentPathObject)) {
+      throw new DuplicateKeyError(pathPart.pathToPart);
+    }
+    const currentArray = currentPathObject;
+    const isOrdered = pathPart.path !== '';
+    const isOrderedArray = arraysWithOrder.has(currentArray);
+    if (isOrdered) {
+      arraysWithOrder.add(currentArray);
+    }
+    if (!isOrdered && isOrderedArray || isOrdered && !isOrderedArray && currentArray.length > 0) {
+      throw new MixedArrayError(pathPart.pathToPart);
+    }
+    const order = isOrdered ? Number(pathPart.path) : currentArray.length;
+    return [currentArray[order], val => currentArray[order] = val];
+  }
+
+  /**
+   *
+   * Parses a FormData object to a JSON object. This is done by parsing the `name`
+   * attribute of each `FormDataEntryValue` and then inserting the value at the
+   * path. Also by default the start of the path is used to transform the value.
+   *
+   *
+   * In front of the whole `key`:
+   *  - `+` => parse to `Number`
+   *  - `-` => set value to `null`
+   *  - `&` => parse to `Boolean`
+   *
+   * - `.` between path parts => nest into `objects`
+   * - `[\d*]` after path part => push to array in order `\d` or push to end if `[]`
+   *
+
+   *
+   * @example
+   * ```ts
+   * const formData = new FormData()
+   * formData.append('+a', '1')
+   * formData.append('&b', 'true')
+   * formData.append('-c', 'null')
+   * formData.append('d', 'foo')
+   * parseFormData(formData, defaultTransform)
+   * // => {a: 1, b: true, c: null, d: 'foo'}
+   * ```
+   *
+   * @example
+   * ```ts
+   * const formData = new FormData()
+   * formData.append('a.b', 'foo')
+   * parseFormData(formData)
+   * // => {a: {b: 'foo'}}
+   * ```
+   *
+   * @example
+   * ```ts
+   * const formData = new FormData()
+   * formData.append('a[0]', 'foo')
+   * formData.append('a[1]', 'bar')
+   * parseFormData(formData)
+   * // => {a: ['foo', 'bar']}
+   * ```
+   * 
+   * @example
+   * ```ts
+   * const formData = new FormData()
+   * formData.append('a[]', 'foo')
+   * formData.append('a[]', 'bar')
+   * parseFormData(formData)
+   * // => {a: ['foo', 'bar']}
+   * ```
+   * 
+   * @example
+   * ```ts
+   * const formData = new FormData()
+   * formData.append('a[0]', 'foo')
+   * parseFormData(formData, {transformEntry: (path, value) => {path, value: value + 'bar'}})
+   * // => {a: ['foobar']}
+   * ```
+   * 
+   * @example
+   * ```ts
+   * const formData = new FormData()
+   * formData.append('a[0]', 'foo')
+   * formData.append('a[1]', '')
+   * parseFormData(formData, {removeEmptyString: true})
+   * // => {a: ['foo']}
+   * ```
+   *
+   * @param {Iterable<[string, string | File]>} formData - an iterator of an [`path`, `value`] tuple
+   * - `path` := `^(\+|\-|\&)?([^\.]+?(\[\d*\])*)(\.[^\.]+?(\[\d*\])*)*$` (e.g. `+a[][1].b`)
+   * - `value` := `string` or `File`
+   * @param {ParseFormDataOptions} options - options for parsing the form data
+   * - `transformEntry` - a function to transform the path and the value before
+   *    inserting the value at the path in the resulting object (default: `defaultTransform`)
+   * - `removeEmptyString` - if `true` removes all entries where the value is an empty string
+   * @returns {JsonObject} the parsed JSON object
+   * @throws `DuplicateKeyError` if
+   * - a path part is an object and the path part is already defined as an object
+   * - a path part is an array and the path part is already defined as an array
+   * @throws `MixedArrayError` if at a specific path part an unordered array is 
+   * defined and at a later path part an ordered array is defined or vice versa
+   * - e.g. `a[0]` and `a[]`
+   * - e.g. `a[]` and `a[0]`
+   */
+  function parseFormData(formData, _temp) {
+    let {
+      removeEmptyString = false,
+      transformEntry = defaultTransform
+    } = _temp === void 0 ? {} : _temp;
+    const result = {};
+
+    // all arrays we need to squash (in place) later
+    const arraysWithOrder = new Set();
+    for (const entry of Array.from(formData)) {
+      if (removeEmptyString && entry[1] === '') continue;
+      const {
+        path,
+        value
+      } = transformEntry(entry, defaultTransform);
+      const pathParts = extractPathParts(path);
+      let currentPathObject = result;
+      pathParts.forEach((pathPart, idx) => {
+        const [nextPathValue, setNextPathValue] = handlePathPart(pathPart, currentPathObject, arraysWithOrder);
+        if (pathParts.length - 1 === idx) {
+          if (nextPathValue !== undefined) {
+            throw new DuplicateKeyError(pathPart.pathToPart);
+          }
+          setNextPathValue(value);
+        } else {
+          if (nextPathValue !== undefined && !isJsonObject(nextPathValue) && !Array.isArray(nextPathValue)) {
+            throw new DuplicateKeyError(pathPart.pathToPart);
+          }
+          const nextPathObject = nextPathValue ?? pathPart.default;
+          currentPathObject = nextPathObject;
+          setNextPathValue(nextPathObject);
+        }
+      });
+    }
+    for (const orderedArray of Array.from(arraysWithOrder)) {
+      // replace array with a squashed array
+      // array.flat(0) will remove all empty slots (e.g. [0, , 1] => [0, 1])
+      orderedArray.splice(0, orderedArray.length, ...orderedArray.flat(0));
+    }
+    return result;
+  }
+
+  exports.DuplicateKeyError = DuplicateKeyError;
+  exports.MixedArrayError = MixedArrayError;
+  exports.parseFormData = parseFormData;
+
+  Object.defineProperty(exports, '__esModule', { value: true });
+
+}));
+//# sourceMappingURL=parse-nested-form-data.umd.js.map

package/dist/parse-nested-form-data.umd.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-nested-form-data.umd.js","sources":["../src/index.ts"],"sourcesContent":["/**\n * @name parse-nested-form-data\n * @license MIT license.\n * @copyright (c) 2022 Christian Schurr\n * @author Christian Schurr <chris@schurr.dev>\n */\n\nimport {File} from '@remix-run/web-file'\n\n/**\n * Thrown when a path is used multiple times or has missmatching path parts.\n *\n * @example\n * ```ts\n * const formData = new FormData()\n * formData.append('a[0]', 'b')\n * formData.append('a[0]', 'c')\n * parseFormData(formData)\n * // throws DuplicateKeyError('a[0]')\n * ```\n *\n * @example\n * ```ts\n * const formData = new FormData()\n * formData.append('a', 'b')\n * formData.append('a', 'c')\n * parseFormData(formData)\n * // throws DuplicateKeyError('a')\n *\n * @example\n * ```ts\n * const formData = new FormData()\n * formData.append('a', 'b')\n * formData.append('a[]', 'c')\n * parseFormData(formData)\n * // throws DuplicateKeyError('a[]')\n * ```\n *\n */\nexport class DuplicateKeyError extends Error {\n  key: string\n  constructor(key: string) {\n    super(`Duplicate key at path part ${key}`)\n    this.key = key\n  }\n}\n/**\n * Thrown when an array is used at the same path with an order parameter and\n * without an order parameter.\n *\n * @example\n * ```ts\n * const formData = new FormData()\n * formData.append('a[0]', 'a')\n * formData.append('a[]', 'b')\n * parseFormData(formData)\n * // => throws `MixedArrayError(a[])`\n * ```\n *\n * @example\n * ```ts\n * const formData = new FormData()\n * formData.append('a[]', 'a')\n * formData.append('a[0]', 'b')\n * parseFormData(formData)\n * // => throws `MixedArrayError(a[0])`\n * ```\n */\nexport class MixedArrayError extends Error {\n  key: string\n  constructor(key: string) {\n    super(`Mixed array at path part ${key}`)\n    this.key = key\n  }\n}\n\ntype JsonObject = {[Key in string]?: JsonValue}\ntype JsonArray = Array<JsonValue>\ntype JsonValue =\n  | string\n  | number\n  | JsonObject\n  | JsonArray\n  | boolean\n  | null\n  | File\ntype JsonLeafValue = Exclude<JsonValue, JsonArray | JsonObject>\n\nfunction isJsonObject(val: JsonValue): val is JsonObject {\n  return (\n    typeof val === 'object' &&\n    !Array.isArray(val) &&\n    val !== null &&\n    !(val instanceof File)\n  )\n}\n\n/**\n * Default Transformer for `parseFormData`.\n *\n * Transforms a FormData Entry into a path and a `JsonLeafValue`.\n *\n * - `path` starts with `+` -> transform value to `number`\n * - `path` starts with `&` -> transform value to `boolean`\n * - `path` starts with `-` -> transform value to `null`\n *\n * @example\n * ```ts\n * const entry = ['a[0]', 'b']\n * const result = defaultTransform(entry)\n * // => {path: 'a[0]', value: 'b'}\n * ```\n *\n * @example\n * ```ts\n * const entry = ['+a[0]', '1']\n * const result = defaultTransform(entry)\n * // => {path: 'a[0]', value: 1}\n * ```\n *\n * @example\n * ```ts\n * const entry = ['&a[0]', 'true']\n * const result = defaultTransform(entry)\n * // => {path: 'a[0]', value: true}\n * ```\n *\n * @example\n * ```ts\n * const entry = ['-a[0]', 'null']\n * const result = defaultTransform(entry)\n * // => {path: 'a[0]', value: null}\n * ```\n *\n * @example\n * ```ts\n * const entry = ['a[0]', new File([''], 'file.txt')]\n * const result = defaultTransform(entry)\n * // => {path: 'a[0]', value: File}\n * ```\n *\n *\n * @param entry [path, value]: the FormData entry\n * @returns the path and the transformed value\n */\nfunction defaultTransform(entry: [path: string, value: string | File]): {\n  path: string\n  value: JsonLeafValue\n} {\n  let path = entry[0]\n  let value: JsonLeafValue = entry[1]\n  if (path.startsWith('+')) {\n    path = path.slice(1)\n    value = Number(value)\n  } else if (path.startsWith('&')) {\n    path = path.slice(1)\n    value = value === 'on' || value === 'true' || Boolean(Number(value))\n  } else if (path.startsWith('-')) {\n    path = path.slice(1)\n    value = null\n  }\n  return {path, value}\n}\n\ntype DefaultTransform = typeof defaultTransform\n/**\n * Options to change the behavior of `parseFormData`.\n * @param transformEntry - a function to transform the FormData entry into a path and a value\n * (default: `defaultTransform`)\n * @param removeEmptyString - skip empty values '' (default: `false`)\n *\n * @example\n * ```ts\n * const formData = new FormData()\n * formData.append('a', '')\n * formData.append('b', 'b')\n * const result = parseFormData(formData, {removeEmptyString: true})\n * // => {b: 'b'}\n * ```\n *\n * @example\n * ```ts\n * const formData = new FormData()\n * formData.append('a', 'a')\n * formData.append('b', 'b')\n * parseFormData(formData, {\n *   transformEntry: ([path, value], defaultTransform) => {\n *     return {\n *       path,\n *       value:\n *         typeof value === 'string'\n *           ? value.toUpperCase()\n *           : defaultTransform(value),\n *     }\n *   },\n * })\n * // => {a: 'A', b: 'B'}\n * ```\n */\nexport type ParseFormDataOptions = {\n  removeEmptyString?: boolean\n  transformEntry?: (\n    entry: [path: string, value: string | File],\n    defaultTransform: DefaultTransform,\n  ) => {path: string; value: JsonLeafValue}\n}\n\n/**\n * A parsed part of a FormData path. It consists of four parts:\n * @param path - the key to access the value in the intermediate result\n * @param type - the type of the path part (array - e.g. [\\d*], or object .e.g. .key)\n * @param default - the default value of the next path part ([] for array, {} for object)\n * @param pathToPart - the full path to the current path part\n *\n * @example\n * ```ts\n * const path = 'a[0].b'\n * const result = extractPathParts(path)\n * // => [{path: 'a', type: 'object, default: [], pathToPart: 'a'},\n * //     {path: '0', type: 'array', default: {}, pathToPart: 'a[0]'},\n * //     {path: 'b', type: 'object', default: {}, pathToPart: 'a[0].b'}]\n * ```\n */\ntype PathPart = {\n  path: string\n  type: 'object' | 'array'\n  default: {} | []\n  pathToPart: string\n}\n/**\n *\n * Transforms a FormData path into an array of `PathPart`s.\n *\n * @param path - the path to extract the path parts from\n * @returns {Array<PathPart>} the extracted path parts\n *\n * @example\n * ```ts\n * const path = 'a[0].b'\n * const result = extractPathParts(path)\n * // => [{path: 'a', type: 'object, default: [], pathToPart: 'a'},\n * //     {path: '0', type: 'array', default: {}, pathToPart: 'a[0]'},\n * //     {path: 'b', type: 'object', default: {}, pathToPart: 'a[0].b'}]\n * ```\n *\n * @example\n * ```ts\n * const path = 'a.b'\n * const result = extractPathParts(path)\n * // => [{path: 'a', type: 'object, default: {}, pathToPart: 'a'},\n * //     {path: 'b', type: 'object', default: {}, pathToPart: 'a.b'}]\n * ```\n *\n * @example\n * ```ts\n * const path = 'a[][0]'\n * const result = extractPathParts(path)\n * // => [{path: 'a', type: 'object, default: [], pathToPart: 'a'},\n * //     {path: '', type: 'array', default: [], pathToPart: 'a[]'},\n * //     {path: '0', type: 'array', default: {}, pathToPart: 'a[][0]'}]\n * ```\n *\n *\n */\nfunction extractPathParts(path: string): Array<PathPart> {\n  const re = /((?<array>\\d*)\\]|(?<pathPart>[^.[]+))(?<nextType>\\[|\\.|$)/g\n\n  return Array.from(path.matchAll(re)).map<PathPart>(match => {\n    // self casted RegexExpMatchArray to custom\n    const typedMatch = match as unknown as [string, string] &\n      RegExpExecArray & {\n        groups:\n          | {\n              pathPart: undefined\n              array: string\n              nextType: '[' | '.' | ''\n            }\n          | {\n              pathPart: string\n              array: undefined\n              nextType: '[' | '.' | ''\n            }\n      }\n    const {array, pathPart, nextType} = typedMatch.groups\n    const type = array === undefined ? 'object' : 'array'\n    const nextDefault = nextType === '[' ? [] : {}\n    return {\n      path: array ?? pathPart,\n      type,\n      default: nextDefault,\n      pathToPart: path.slice(0, typedMatch.index + typedMatch[1].length),\n    }\n  })\n}\n\n/**\n *\n * Returns the value accessed via `pathPart` in the `currentPathObject`\n * and a setter function to set the value in the `currentPathObject` via the\n * provided `pathPart`.\n *\n * @param pathPart - the path part to get the setter and getter for\n * @param currentPathObject - the object at the current path (before the path part)\n * @param arraysWithOrder - a set of arrays that have an order\n * @returns the setter and getter for the path part\n *\n * @example\n * ```ts\n * const pathPart = {path: 'a', type: 'object', default: {}, pathToPart: 'a'}\n * const currentPathObject = {}\n * const arraysWithOrder = new Set()\n * const [value, setValue] = getSetterAndGetter(pathPart, currentPathObject, arraysWithOrder)\n * setValue('b')\n * // => currentPathObject = {a: 'b'}\n * ```\n *\n * @example\n * ```ts\n * const pathPart = {path: '0', type: 'array', default: [], pathToPart: 'a[0]'}\n * const currentPathObject = {a: []}\n * const arraysWithOrder = new Set()\n * const [value, setValue] = getSetterAndGetter(pathPart, currentPathObject, arraysWithOrder)\n * setValue('b')\n * // => currentPathObject = {a: ['b']}\n * ```\n *\n */\nfunction handlePathPart(\n  pathPart: PathPart,\n  currentPathObject: JsonArray | JsonObject,\n  arraysWithOrder: Set<JsonArray>,\n): [\n  nextPathValue: JsonValue | undefined,\n  setNextPathValue: (value: JsonValue) => void,\n] {\n  if (pathPart.type === 'object') {\n    if (Array.isArray(currentPathObject)) {\n      throw new DuplicateKeyError(pathPart.pathToPart)\n    }\n    const currentObject = currentPathObject\n    return [\n      currentObject[pathPart.path],\n      val => (currentObject[pathPart.path] = val),\n    ]\n  }\n  if (!Array.isArray(currentPathObject)) {\n    throw new DuplicateKeyError(pathPart.pathToPart)\n  }\n  const currentArray = currentPathObject\n  const isOrdered = pathPart.path !== ''\n\n  const isOrderedArray = arraysWithOrder.has(currentArray)\n  if (isOrdered) {\n    arraysWithOrder.add(currentArray)\n  }\n  if (\n    (!isOrdered && isOrderedArray) ||\n    (isOrdered && !isOrderedArray && currentArray.length > 0)\n  ) {\n    throw new MixedArrayError(pathPart.pathToPart)\n  }\n\n  const order = isOrdered ? Number(pathPart.path) : currentArray.length\n  return [currentArray[order], val => (currentArray[order] = val)]\n}\n\n/**\n *\n * Parses a FormData object to a JSON object. This is done by parsing the `name`\n * attribute of each `FormDataEntryValue` and then inserting the value at the\n * path. Also by default the start of the path is used to transform the value.\n *\n *\n * In front of the whole `key`:\n *  - `+` => parse to `Number`\n *  - `-` => set value to `null`\n *  - `&` => parse to `Boolean`\n *\n * - `.` between path parts => nest into `objects`\n * - `[\\d*]` after path part => push to array in order `\\d` or push to end if `[]`\n *\n\n *\n * @example\n * ```ts\n * const formData = new FormData()\n * formData.append('+a', '1')\n * formData.append('&b', 'true')\n * formData.append('-c', 'null')\n * formData.append('d', 'foo')\n * parseFormData(formData, defaultTransform)\n * // => {a: 1, b: true, c: null, d: 'foo'}\n * ```\n *\n * @example\n * ```ts\n * const formData = new FormData()\n * formData.append('a.b', 'foo')\n * parseFormData(formData)\n * // => {a: {b: 'foo'}}\n * ```\n *\n * @example\n * ```ts\n * const formData = new FormData()\n * formData.append('a[0]', 'foo')\n * formData.append('a[1]', 'bar')\n * parseFormData(formData)\n * // => {a: ['foo', 'bar']}\n * ```\n * \n * @example\n * ```ts\n * const formData = new FormData()\n * formData.append('a[]', 'foo')\n * formData.append('a[]', 'bar')\n * parseFormData(formData)\n * // => {a: ['foo', 'bar']}\n * ```\n * \n * @example\n * ```ts\n * const formData = new FormData()\n * formData.append('a[0]', 'foo')\n * parseFormData(formData, {transformEntry: (path, value) => {path, value: value + 'bar'}})\n * // => {a: ['foobar']}\n * ```\n * \n * @example\n * ```ts\n * const formData = new FormData()\n * formData.append('a[0]', 'foo')\n * formData.append('a[1]', '')\n * parseFormData(formData, {removeEmptyString: true})\n * // => {a: ['foo']}\n * ```\n *\n * @param {Iterable<[string, string | File]>} formData - an iterator of an [`path`, `value`] tuple\n * - `path` := `^(\\+|\\-|\\&)?([^\\.]+?(\\[\\d*\\])*)(\\.[^\\.]+?(\\[\\d*\\])*)*$` (e.g. `+a[][1].b`)\n * - `value` := `string` or `File`\n * @param {ParseFormDataOptions} options - options for parsing the form data\n * - `transformEntry` - a function to transform the path and the value before\n *    inserting the value at the path in the resulting object (default: `defaultTransform`)\n * - `removeEmptyString` - if `true` removes all entries where the value is an empty string\n * @returns {JsonObject} the parsed JSON object\n * @throws `DuplicateKeyError` if\n * - a path part is an object and the path part is already defined as an object\n * - a path part is an array and the path part is already defined as an array\n * @throws `MixedArrayError` if at a specific path part an unordered array is \n * defined and at a later path part an ordered array is defined or vice versa\n * - e.g. `a[0]` and `a[]`\n * - e.g. `a[]` and `a[0]`\n */\nexport function parseFormData(\n  formData: Iterable<[string, string | File]>,\n  {\n    removeEmptyString = false,\n    transformEntry = defaultTransform,\n  }: ParseFormDataOptions = {},\n): JsonObject {\n  const result: JsonObject = {}\n\n  // all arrays we need to squash (in place) later\n  const arraysWithOrder: Set<Array<JsonValue>> = new Set()\n\n  for (const entry of Array.from(formData)) {\n    if (removeEmptyString && entry[1] === '') continue\n\n    const {path, value} = transformEntry(entry, defaultTransform)\n    const pathParts = extractPathParts(path)\n\n    let currentPathObject: JsonObject | JsonArray = result\n    pathParts.forEach((pathPart, idx) => {\n      const [nextPathValue, setNextPathValue] = handlePathPart(\n        pathPart,\n        currentPathObject,\n        arraysWithOrder,\n      )\n\n      if (pathParts.length - 1 === idx) {\n        if (nextPathValue !== undefined) {\n          throw new DuplicateKeyError(pathPart.pathToPart)\n        }\n        setNextPathValue(value)\n      } else {\n        if (\n          nextPathValue !== undefined &&\n          !isJsonObject(nextPathValue) &&\n          !Array.isArray(nextPathValue)\n        ) {\n          throw new DuplicateKeyError(pathPart.pathToPart)\n        }\n\n        const nextPathObject = nextPathValue ?? pathPart.default\n        currentPathObject = nextPathObject\n        setNextPathValue(nextPathObject)\n      }\n    })\n  }\n\n  for (const orderedArray of Array.from(arraysWithOrder)) {\n    // replace array with a squashed array\n    // array.flat(0) will remove all empty slots (e.g. [0, , 1] => [0, 1])\n    orderedArray.splice(0, orderedArray.length, ...orderedArray.flat(0))\n  }\n\n  return result\n}\n"],"names":["DuplicateKeyError","Error","constructor","key","MixedArrayError","isJsonObject","val","Array","isArray","File","defaultTransform","entry","path","value","startsWith","slice","Number","Boolean","extractPathParts","re","from","matchAll","map","match","typedMatch","array","pathPart","nextType","groups","type","undefined","nextDefault","default","pathToPart","index","length","handlePathPart","currentPathObject","arraysWithOrder","currentObject","currentArray","isOrdered","isOrderedArray","has","add","order","parseFormData","formData","removeEmptyString","transformEntry","result","Set","pathParts","forEach","idx","nextPathValue","setNextPathValue","nextPathObject","orderedArray","splice","flat"],"mappings":";;;;;;EAAA;EACA;EACA;EACA;EACA;EACA;;EAIA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACO,MAAMA,iBAAiB,SAASC,KAAK,CAAC;IAE3CC,WAAW,CAACC,GAAW,EAAE;EACvB,IAAA,KAAK,CAAE,CAAA,2BAAA,EAA6BA,GAAI,CAAA,CAAC,CAAC,CAAA;EAAA,IAAA,IAAA,CAF5CA,GAAG,GAAA,KAAA,CAAA,CAAA;MAGD,IAAI,CAACA,GAAG,GAAGA,GAAG,CAAA;EAChB,GAAA;EACF,CAAA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACO,MAAMC,eAAe,SAASH,KAAK,CAAC;IAEzCC,WAAW,CAACC,GAAW,EAAE;EACvB,IAAA,KAAK,CAAE,CAAA,yBAAA,EAA2BA,GAAI,CAAA,CAAC,CAAC,CAAA;EAAA,IAAA,IAAA,CAF1CA,GAAG,GAAA,KAAA,CAAA,CAAA;MAGD,IAAI,CAACA,GAAG,GAAGA,GAAG,CAAA;EAChB,GAAA;EACF,CAAA;EAcA,SAASE,YAAY,CAACC,GAAc,EAAqB;IACvD,OACE,OAAOA,GAAG,KAAK,QAAQ,IACvB,CAACC,KAAK,CAACC,OAAO,CAACF,GAAG,CAAC,IACnBA,GAAG,KAAK,IAAI,IACZ,EAAEA,GAAG,YAAYG,YAAI,CAAC,CAAA;EAE1B,CAAA;;EAEA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA,SAASC,gBAAgB,CAACC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,CAACH,YAAY,CAAC,CAAA;EACxD,EAAA,IAAIC,SAAS,EAAE;EACbH,IAAAA,eAAe,CAACM,GAAG,CAACJ,YAAY,CAAC,CAAA;EACnC,GAAA;EACA,EAAA,IACG,CAACC,SAAS,IAAIC,cAAc,IAC5BD,SAAS,IAAI,CAACC,cAAc,IAAIF,YAAY,CAACL,MAAM,GAAG,CAAE,EACzD;EACA,IAAA,MAAM,IAAI/B,eAAe,CAACsB,QAAQ,CAACO,UAAU,CAAC,CAAA;EAChD,GAAA;EAEA,EAAA,MAAMY,KAAK,GAAGJ,SAAS,GAAGzB,MAAM,CAACU,QAAQ,CAACd,IAAI,CAAC,GAAG4B,YAAY,CAACL,MAAM,CAAA;EACrE,EAAA,OAAO,CAACK,YAAY,CAACK,KAAK,CAAC,EAAEvC,GAAG,IAAKkC,YAAY,CAACK,KAAK,CAAC,GAAGvC,GAAI,CAAC,CAAA;EAClE,CAAA;;EAEA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;AACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACO,SAASwC,aAAa,CAC3BC,QAA2C,EAK/B,KAAA,EAAA;IAAA,IAJZ;EACEC,IAAAA,iBAAiB,GAAG,KAAK;EACzBC,IAAAA,cAAc,GAAGvC,gBAAAA;KACI,GAAA,KAAA,KAAA,KAAA,CAAA,GAAG,EAAE,GAAA,KAAA,CAAA;IAE5B,MAAMwC,MAAkB,GAAG,EAAE,CAAA;;EAE7B;EACA,EAAA,MAAMZ,eAAsC,GAAG,IAAIa,GAAG,EAAE,CAAA;IAExD,KAAK,MAAMxC,KAAK,IAAIJ,KAAK,CAACa,IAAI,CAAC2B,QAAQ,CAAC,EAAE;MACxC,IAAIC,iBAAiB,IAAIrC,KAAK,CAAC,CAAC,CAAC,KAAK,EAAE,EAAE,SAAA;MAE1C,MAAM;QAACC,IAAI;EAAEC,MAAAA,KAAAA;EAAK,KAAC,GAAGoC,cAAc,CAACtC,KAAK,EAAED,gBAAgB,CAAC,CAAA;EAC7D,IAAA,MAAM0C,SAAS,GAAGlC,gBAAgB,CAACN,IAAI,CAAC,CAAA;MAExC,IAAIyB,iBAAyC,GAAGa,MAAM,CAAA;EACtDE,IAAAA,SAAS,CAACC,OAAO,CAAC,CAAC3B,QAAQ,EAAE4B,GAAG,KAAK;EACnC,MAAA,MAAM,CAACC,aAAa,EAAEC,gBAAgB,CAAC,GAAGpB,cAAc,CACtDV,QAAQ,EACRW,iBAAiB,EACjBC,eAAe,CAChB,CAAA;EAED,MAAA,IAAIc,SAAS,CAACjB,MAAM,GAAG,CAAC,KAAKmB,GAAG,EAAE;UAChC,IAAIC,aAAa,KAAKzB,SAAS,EAAE;EAC/B,UAAA,MAAM,IAAI9B,iBAAiB,CAAC0B,QAAQ,CAACO,UAAU,CAAC,CAAA;EAClD,SAAA;UACAuB,gBAAgB,CAAC3C,KAAK,CAAC,CAAA;EACzB,OAAC,MAAM;EACL,QAAA,IACE0C,aAAa,KAAKzB,SAAS,IAC3B,CAACzB,YAAY,CAACkD,aAAa,CAAC,IAC5B,CAAChD,KAAK,CAACC,OAAO,CAAC+C,aAAa,CAAC,EAC7B;EACA,UAAA,MAAM,IAAIvD,iBAAiB,CAAC0B,QAAQ,CAACO,UAAU,CAAC,CAAA;EAClD,SAAA;EAEA,QAAA,MAAMwB,cAAc,GAAGF,aAAa,IAAI7B,QAAQ,CAACM,OAAO,CAAA;EACxDK,QAAAA,iBAAiB,GAAGoB,cAAc,CAAA;UAClCD,gBAAgB,CAACC,cAAc,CAAC,CAAA;EAClC,OAAA;EACF,KAAC,CAAC,CAAA;EACJ,GAAA;IAEA,KAAK,MAAMC,YAAY,IAAInD,KAAK,CAACa,IAAI,CAACkB,eAAe,CAAC,EAAE;EACtD;EACA;EACAoB,IAAAA,YAAY,CAACC,MAAM,CAAC,CAAC,EAAED,YAAY,CAACvB,MAAM,EAAE,GAAGuB,YAAY,CAACE,IAAI,CAAC,CAAC,CAAC,CAAC,CAAA;EACtE,GAAA;EAEA,EAAA,OAAOV,MAAM,CAAA;EACf;;;;;;;;;;;;"}

package/dist/parse-nested-form-data.umd.min.js

@@ -0,0 +1,8 @@
+!function(t,r){"object"==typeof exports&&"undefined"!=typeof module?r(exports,require("@remix-run/web-file")):"function"==typeof define&&define.amd?define(["exports","@remix-run/web-file"],r):r((t="undefined"!=typeof globalThis?globalThis:t||self).parseNestedFormData={},t.RemixRunWebFile)}(this,(function(t,r){"use strict";
+/**
+   * @name parse-nested-form-data
+   * @license MIT license.
+   * @copyright (c) 2022 Christian Schurr
+   * @author Christian Schurr <chris@schurr.dev>
+   */class e extends Error{constructor(t){super(`Duplicate key at path part ${t}`),this.key=void 0,this.key=t}}class a extends Error{constructor(t){super(`Mixed array at path part ${t}`),this.key=void 0,this.key=t}}function o(t){let r=t[0],e=t[1];return r.startsWith("+")?(r=r.slice(1),e=Number(e)):r.startsWith("&")?(r=r.slice(1),e="on"===e||"true"===e||Boolean(Number(e))):r.startsWith("-")&&(r=r.slice(1),e=null),{path:r,value:e}}function n(t){return Array.from(t.matchAll(/((?<array>\d*)\]|(?<pathPart>[^.[]+))(?<nextType>\[|\.|$)/g)).map((r=>{const e=r,{array:a,pathPart:o,nextType:n}=e.groups;return{path:a??o,type:void 0===a?"object":"array",default:"["===n?[]:{},pathToPart:t.slice(0,e.index+e[1].length)}}))}function i(t,r,o){if("object"===t.type){if(Array.isArray(r))throw new e(t.pathToPart);const a=r;return[a[t.path],r=>a[t.path]=r]}if(!Array.isArray(r))throw new e(t.pathToPart);const n=r,i=""!==t.path,s=o.has(n);if(i&&o.add(n),!i&&s||i&&!s&&n.length>0)throw new a(t.pathToPart);const f=i?Number(t.path):n.length;return[n[f],t=>n[f]=t]}t.DuplicateKeyError=e,t.MixedArrayError=a,t.parseFormData=function(t,a){let{removeEmptyString:s=!1,transformEntry:f=o}=void 0===a?{}:a;const l={},p=new Set;for(const a of Array.from(t)){if(s&&""===a[1])continue;const{path:t,value:u}=f(a,o),c=n(t);let h=l;c.forEach(((t,a)=>{const[o,n]=i(t,h,p);if(c.length-1===a){if(void 0!==o)throw new e(t.pathToPart);n(u)}else{if(void 0!==o&&("object"!=typeof(s=o)||Array.isArray(s)||null===s||s instanceof r.File)&&!Array.isArray(o))throw new e(t.pathToPart);const a=o??t.default;h=a,n(a)}var s}))}for(const t of Array.from(p))t.splice(0,t.length,...t.flat(0));return l},Object.defineProperty(t,"__esModule",{value:!0})}));
+//# sourceMappingURL=parse-nested-form-data.umd.min.js.map

package/dist/parse-nested-form-data.umd.min.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-nested-form-data.umd.min.js","sources":["../src/index.ts"],"sourcesContent":["/**\n * @name parse-nested-form-data\n * @license MIT license.\n * @copyright (c) 2022 Christian Schurr\n * @author Christian Schurr <chris@schurr.dev>\n */\n\nimport {File} from '@remix-run/web-file'\n\n/**\n * Thrown when a path is used multiple times or has missmatching path parts.\n *\n * @example\n * ```ts\n * const formData = new FormData()\n * formData.append('a[0]', 'b')\n * formData.append('a[0]', 'c')\n * parseFormData(formData)\n * // throws DuplicateKeyError('a[0]')\n * ```\n *\n * @example\n * ```ts\n * const formData = new FormData()\n * formData.append('a', 'b')\n * formData.append('a', 'c')\n * parseFormData(formData)\n * // throws DuplicateKeyError('a')\n *\n * @example\n * ```ts\n * const formData = new FormData()\n * formData.append('a', 'b')\n * formData.append('a[]', 'c')\n * parseFormData(formData)\n * // throws DuplicateKeyError('a[]')\n * ```\n *\n */\nexport class DuplicateKeyError extends Error {\n  key: string\n  constructor(key: string) {\n    super(`Duplicate key at path part ${key}`)\n    this.key = key\n  }\n}\n/**\n * Thrown when an array is used at the same path with an order parameter and\n * without an order parameter.\n *\n * @example\n * ```ts\n * const formData = new FormData()\n * formData.append('a[0]', 'a')\n * formData.append('a[]', 'b')\n * parseFormData(formData)\n * // => throws `MixedArrayError(a[])`\n * ```\n *\n * @example\n * ```ts\n * const formData = new FormData()\n * formData.append('a[]', 'a')\n * formData.append('a[0]', 'b')\n * parseFormData(formData)\n * // => throws `MixedArrayError(a[0])`\n * ```\n */\nexport class MixedArrayError extends Error {\n  key: string\n  constructor(key: string) {\n    super(`Mixed array at path part ${key}`)\n    this.key = key\n  }\n}\n\ntype JsonObject = {[Key in string]?: JsonValue}\ntype JsonArray = Array<JsonValue>\ntype JsonValue =\n  | string\n  | number\n  | JsonObject\n  | JsonArray\n  | boolean\n  | null\n  | File\ntype JsonLeafValue = Exclude<JsonValue, JsonArray | JsonObject>\n\nfunction isJsonObject(val: JsonValue): val is JsonObject {\n  return (\n    typeof val === 'object' &&\n    !Array.isArray(val) &&\n    val !== null &&\n    !(val instanceof File)\n  )\n}\n\n/**\n * Default Transformer for `parseFormData`.\n *\n * Transforms a FormData Entry into a path and a `JsonLeafValue`.\n *\n * - `path` starts with `+` -> transform value to `number`\n * - `path` starts with `&` -> transform value to `boolean`\n * - `path` starts with `-` -> transform value to `null`\n *\n * @example\n * ```ts\n * const entry = ['a[0]', 'b']\n * const result = defaultTransform(entry)\n * // => {path: 'a[0]', value: 'b'}\n * ```\n *\n * @example\n * ```ts\n * const entry = ['+a[0]', '1']\n * const result = defaultTransform(entry)\n * // => {path: 'a[0]', value: 1}\n * ```\n *\n * @example\n * ```ts\n * const entry = ['&a[0]', 'true']\n * const result = defaultTransform(entry)\n * // => {path: 'a[0]', value: true}\n * ```\n *\n * @example\n * ```ts\n * const entry = ['-a[0]', 'null']\n * const result = defaultTransform(entry)\n * // => {path: 'a[0]', value: null}\n * ```\n *\n * @example\n * ```ts\n * const entry = ['a[0]', new File([''], 'file.txt')]\n * const result = defaultTransform(entry)\n * // => {path: 'a[0]', value: File}\n * ```\n *\n *\n * @param entry [path, value]: the FormData entry\n * @returns the path and the transformed value\n */\nfunction defaultTransform(entry: [path: string, value: string | File]): {\n  path: string\n  value: JsonLeafValue\n} {\n  let path = entry[0]\n  let value: JsonLeafValue = entry[1]\n  if (path.startsWith('+')) {\n    path = path.slice(1)\n    value = Number(value)\n  } else if (path.startsWith('&')) {\n    path = path.slice(1)\n    value = value === 'on' || value === 'true' || Boolean(Number(value))\n  } else if (path.startsWith('-')) {\n    path = path.slice(1)\n    value = null\n  }\n  return {path, value}\n}\n\ntype DefaultTransform = typeof defaultTransform\n/**\n * Options to change the behavior of `parseFormData`.\n * @param transformEntry - a function to transform the FormData entry into a path and a value\n * (default: `defaultTransform`)\n * @param removeEmptyString - skip empty values '' (default: `false`)\n *\n * @example\n * ```ts\n * const formData = new FormData()\n * formData.append('a', '')\n * formData.append('b', 'b')\n * const result = parseFormData(formData, {removeEmptyString: true})\n * // => {b: 'b'}\n * ```\n *\n * @example\n * ```ts\n * const formData = new FormData()\n * formData.append('a', 'a')\n * formData.append('b', 'b')\n * parseFormData(formData, {\n *   transformEntry: ([path, value], defaultTransform) => {\n *     return {\n *       path,\n *       value:\n *         typeof value === 'string'\n *           ? value.toUpperCase()\n *           : defaultTransform(value),\n *     }\n *   },\n * })\n * // => {a: 'A', b: 'B'}\n * ```\n */\nexport type ParseFormDataOptions = {\n  removeEmptyString?: boolean\n  transformEntry?: (\n    entry: [path: string, value: string | File],\n    defaultTransform: DefaultTransform,\n  ) => {path: string; value: JsonLeafValue}\n}\n\n/**\n * A parsed part of a FormData path. It consists of four parts:\n * @param path - the key to access the value in the intermediate result\n * @param type - the type of the path part (array - e.g. [\\d*], or object .e.g. .key)\n * @param default - the default value of the next path part ([] for array, {} for object)\n * @param pathToPart - the full path to the current path part\n *\n * @example\n * ```ts\n * const path = 'a[0].b'\n * const result = extractPathParts(path)\n * // => [{path: 'a', type: 'object, default: [], pathToPart: 'a'},\n * //     {path: '0', type: 'array', default: {}, pathToPart: 'a[0]'},\n * //     {path: 'b', type: 'object', default: {}, pathToPart: 'a[0].b'}]\n * ```\n */\ntype PathPart = {\n  path: string\n  type: 'object' | 'array'\n  default: {} | []\n  pathToPart: string\n}\n/**\n *\n * Transforms a FormData path into an array of `PathPart`s.\n *\n * @param path - the path to extract the path parts from\n * @returns {Array<PathPart>} the extracted path parts\n *\n * @example\n * ```ts\n * const path = 'a[0].b'\n * const result = extractPathParts(path)\n * // => [{path: 'a', type: 'object, default: [], pathToPart: 'a'},\n * //     {path: '0', type: 'array', default: {}, pathToPart: 'a[0]'},\n * //     {path: 'b', type: 'object', default: {}, pathToPart: 'a[0].b'}]\n * ```\n *\n * @example\n * ```ts\n * const path = 'a.b'\n * const result = extractPathParts(path)\n * // => [{path: 'a', type: 'object, default: {}, pathToPart: 'a'},\n * //     {path: 'b', type: 'object', default: {}, pathToPart: 'a.b'}]\n * ```\n *\n * @example\n * ```ts\n * const path = 'a[][0]'\n * const result = extractPathParts(path)\n * // => [{path: 'a', type: 'object, default: [], pathToPart: 'a'},\n * //     {path: '', type: 'array', default: [], pathToPart: 'a[]'},\n * //     {path: '0', type: 'array', default: {}, pathToPart: 'a[][0]'}]\n * ```\n *\n *\n */\nfunction extractPathParts(path: string): Array<PathPart> {\n  const re = /((?<array>\\d*)\\]|(?<pathPart>[^.[]+))(?<nextType>\\[|\\.|$)/g\n\n  return Array.from(path.matchAll(re)).map<PathPart>(match => {\n    // self casted RegexExpMatchArray to custom\n    const typedMatch = match as unknown as [string, string] &\n      RegExpExecArray & {\n        groups:\n          | {\n              pathPart: undefined\n              array: string\n              nextType: '[' | '.' | ''\n            }\n          | {\n              pathPart: string\n              array: undefined\n              nextType: '[' | '.' | ''\n            }\n      }\n    const {array, pathPart, nextType} = typedMatch.groups\n    const type = array === undefined ? 'object' : 'array'\n    const nextDefault = nextType === '[' ? [] : {}\n    return {\n      path: array ?? pathPart,\n      type,\n      default: nextDefault,\n      pathToPart: path.slice(0, typedMatch.index + typedMatch[1].length),\n    }\n  })\n}\n\n/**\n *\n * Returns the value accessed via `pathPart` in the `currentPathObject`\n * and a setter function to set the value in the `currentPathObject` via the\n * provided `pathPart`.\n *\n * @param pathPart - the path part to get the setter and getter for\n * @param currentPathObject - the object at the current path (before the path part)\n * @param arraysWithOrder - a set of arrays that have an order\n * @returns the setter and getter for the path part\n *\n * @example\n * ```ts\n * const pathPart = {path: 'a', type: 'object', default: {}, pathToPart: 'a'}\n * const currentPathObject = {}\n * const arraysWithOrder = new Set()\n * const [value, setValue] = getSetterAndGetter(pathPart, currentPathObject, arraysWithOrder)\n * setValue('b')\n * // => currentPathObject = {a: 'b'}\n * ```\n *\n * @example\n * ```ts\n * const pathPart = {path: '0', type: 'array', default: [], pathToPart: 'a[0]'}\n * const currentPathObject = {a: []}\n * const arraysWithOrder = new Set()\n * const [value, setValue] = getSetterAndGetter(pathPart, currentPathObject, arraysWithOrder)\n * setValue('b')\n * // => currentPathObject = {a: ['b']}\n * ```\n *\n */\nfunction handlePathPart(\n  pathPart: PathPart,\n  currentPathObject: JsonArray | JsonObject,\n  arraysWithOrder: Set<JsonArray>,\n): [\n  nextPathValue: JsonValue | undefined,\n  setNextPathValue: (value: JsonValue) => void,\n] {\n  if (pathPart.type === 'object') {\n    if (Array.isArray(currentPathObject)) {\n      throw new DuplicateKeyError(pathPart.pathToPart)\n    }\n    const currentObject = currentPathObject\n    return [\n      currentObject[pathPart.path],\n      val => (currentObject[pathPart.path] = val),\n    ]\n  }\n  if (!Array.isArray(currentPathObject)) {\n    throw new DuplicateKeyError(pathPart.pathToPart)\n  }\n  const currentArray = currentPathObject\n  const isOrdered = pathPart.path !== ''\n\n  const isOrderedArray = arraysWithOrder.has(currentArray)\n  if (isOrdered) {\n    arraysWithOrder.add(currentArray)\n  }\n  if (\n    (!isOrdered && isOrderedArray) ||\n    (isOrdered && !isOrderedArray && currentArray.length > 0)\n  ) {\n    throw new MixedArrayError(pathPart.pathToPart)\n  }\n\n  const order = isOrdered ? Number(pathPart.path) : currentArray.length\n  return [currentArray[order], val => (currentArray[order] = val)]\n}\n\n/**\n *\n * Parses a FormData object to a JSON object. This is done by parsing the `name`\n * attribute of each `FormDataEntryValue` and then inserting the value at the\n * path. Also by default the start of the path is used to transform the value.\n *\n *\n * In front of the whole `key`:\n *  - `+` => parse to `Number`\n *  - `-` => set value to `null`\n *  - `&` => parse to `Boolean`\n *\n * - `.` between path parts => nest into `objects`\n * - `[\\d*]` after path part => push to array in order `\\d` or push to end if `[]`\n *\n\n *\n * @example\n * ```ts\n * const formData = new FormData()\n * formData.append('+a', '1')\n * formData.append('&b', 'true')\n * formData.append('-c', 'null')\n * formData.append('d', 'foo')\n * parseFormData(formData, defaultTransform)\n * // => {a: 1, b: true, c: null, d: 'foo'}\n * ```\n *\n * @example\n * ```ts\n * const formData = new FormData()\n * formData.append('a.b', 'foo')\n * parseFormData(formData)\n * // => {a: {b: 'foo'}}\n * ```\n *\n * @example\n * ```ts\n * const formData = new FormData()\n * formData.append('a[0]', 'foo')\n * formData.append('a[1]', 'bar')\n * parseFormData(formData)\n * // => {a: ['foo', 'bar']}\n * ```\n * \n * @example\n * ```ts\n * const formData = new FormData()\n * formData.append('a[]', 'foo')\n * formData.append('a[]', 'bar')\n * parseFormData(formData)\n * // => {a: ['foo', 'bar']}\n * ```\n * \n * @example\n * ```ts\n * const formData = new FormData()\n * formData.append('a[0]', 'foo')\n * parseFormData(formData, {transformEntry: (path, value) => {path, value: value + 'bar'}})\n * // => {a: ['foobar']}\n * ```\n * \n * @example\n * ```ts\n * const formData = new FormData()\n * formData.append('a[0]', 'foo')\n * formData.append('a[1]', '')\n * parseFormData(formData, {removeEmptyString: true})\n * // => {a: ['foo']}\n * ```\n *\n * @param {Iterable<[string, string | File]>} formData - an iterator of an [`path`, `value`] tuple\n * - `path` := `^(\\+|\\-|\\&)?([^\\.]+?(\\[\\d*\\])*)(\\.[^\\.]+?(\\[\\d*\\])*)*$` (e.g. `+a[][1].b`)\n * - `value` := `string` or `File`\n * @param {ParseFormDataOptions} options - options for parsing the form data\n * - `transformEntry` - a function to transform the path and the value before\n *    inserting the value at the path in the resulting object (default: `defaultTransform`)\n * - `removeEmptyString` - if `true` removes all entries where the value is an empty string\n * @returns {JsonObject} the parsed JSON object\n * @throws `DuplicateKeyError` if\n * - a path part is an object and the path part is already defined as an object\n * - a path part is an array and the path part is already defined as an array\n * @throws `MixedArrayError` if at a specific path part an unordered array is \n * defined and at a later path part an ordered array is defined or vice versa\n * - e.g. `a[0]` and `a[]`\n * - e.g. `a[]` and `a[0]`\n */\nexport function parseFormData(\n  formData: Iterable<[string, string | File]>,\n  {\n    removeEmptyString = false,\n    transformEntry = defaultTransform,\n  }: ParseFormDataOptions = {},\n): JsonObject {\n  const result: JsonObject = {}\n\n  // all arrays we need to squash (in place) later\n  const arraysWithOrder: Set<Array<JsonValue>> = new Set()\n\n  for (const entry of Array.from(formData)) {\n    if (removeEmptyString && entry[1] === '') continue\n\n    const {path, value} = transformEntry(entry, defaultTransform)\n    const pathParts = extractPathParts(path)\n\n    let currentPathObject: JsonObject | JsonArray = result\n    pathParts.forEach((pathPart, idx) => {\n      const [nextPathValue, setNextPathValue] = handlePathPart(\n        pathPart,\n        currentPathObject,\n        arraysWithOrder,\n      )\n\n      if (pathParts.length - 1 === idx) {\n        if (nextPathValue !== undefined) {\n          throw new DuplicateKeyError(pathPart.pathToPart)\n        }\n        setNextPathValue(value)\n      } else {\n        if (\n          nextPathValue !== undefined &&\n          !isJsonObject(nextPathValue) &&\n          !Array.isArray(nextPathValue)\n        ) {\n          throw new DuplicateKeyError(pathPart.pathToPart)\n        }\n\n        const nextPathObject = nextPathValue ?? pathPart.default\n        currentPathObject = nextPathObject\n        setNextPathValue(nextPathObject)\n      }\n    })\n  }\n\n  for (const orderedArray of Array.from(arraysWithOrder)) {\n    // replace array with a squashed array\n    // array.flat(0) will remove all empty slots (e.g. [0, , 1] => [0, 1])\n    orderedArray.splice(0, orderedArray.length, ...orderedArray.flat(0))\n  }\n\n  return result\n}\n"],"names":["DuplicateKeyError","Error","constructor","key","super","this","MixedArrayError","defaultTransform","entry","path","value","startsWith","slice","Number","Boolean","extractPathParts","Array","from","matchAll","map","match","typedMatch","array","pathPart","nextType","groups","type","undefined","default","pathToPart","index","length","handlePathPart","currentPathObject","arraysWithOrder","isArray","currentObject","val","currentArray","isOrdered","isOrderedArray","has","add","order","formData","_temp","removeEmptyString","transformEntry","result","Set","pathParts","forEach","idx","nextPathValue","setNextPathValue","File","nextPathObject","orderedArray","splice","flat"],"mappings":"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"}

package/package.json

@@ -0,0 +1,77 @@
+{
+  "name": "parse-nested-form-data",
+  "version": "1.0.0",
+  "description": "A tiny node module for parsing FormData by name into objects and arrays",
+  "main": "dist/parse-nested-form-data.cjs.js",
+  "module": "dist/parse-nested-form-data.esm.js",
+  "types": "dist/index.d.ts",
+  "keywords": [
+    "FormData",
+    "parse",
+    "nested",
+    "form",
+    "array",
+    "object",
+    "parse"
+  ],
+  "author": "Christian Schurr <chris@schurr.dev>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/milamer/parse-nested-form-data"
+  },
+  "bugs": {
+    "url": "https://github.com/milamer/parse-nested-form-data/issues"
+  },
+  "homepage": "https://github.com/milamer/parse-nested-form-data#readme",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "clean": "rimraf dist coverage node_modules",
+    "build:toc": "npx doctoc .",
+    "build": "kcd-scripts build --bundle --environment BUILD_NAME:parseNestedFormData",
+    "lint": "kcd-scripts lint",
+    "setup": "npm install && npm run validate -s",
+    "test": "kcd-scripts test",
+    "typecheck": "kcd-scripts typecheck",
+    "test:update": "npm test -- --updateSnapshot --coverage",
+    "validate": "kcd-scripts validate"
+  },
+  "dependencies": {
+    "@babel/runtime": "^7.19.0"
+  },
+  "devDependencies": {
+    "@remix-run/web-file": "^3.0.2",
+    "@remix-run/web-form-data": "^3.0.3",
+    "kcd-scripts": "^12.3.0",
+    "rimraf": "^3.0.2",
+    "typescript": "^4.8.4"
+  },
+  "peerDependencies": {
+    "@remix-run/web-file": ">=3.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@remix-run/web-form-data": {
+      "optional": true
+    }
+  },
+  "eslintConfig": {
+    "extends": "./node_modules/kcd-scripts/eslint.js",
+    "rules": {
+      "import/extensions": "off",
+      "max-lines-per-function": "off",
+      "one-var": [
+        "error",
+        "never"
+      ],
+      "@typescript-eslint/no-unsafe-assignment": "off",
+      "@typescript-eslint/no-loop-func": "off"
+    }
+  },
+  "eslintIgnore": [
+    "node_modules",
+    "coverage",
+    "dist"
+  ]
+}