@typed-web/form-utils 0.2.0 → 0.3.0

package/dist/index.d.ts

@@ -1,10 +1,12 @@
 export type { FlatObject, NestedObject } from "./lib/types.ts";
+export { arrayPathToStringPath } from "./lib/array-path-to-string-path.ts";
 export { setValueAtPath } from "./lib/set-value-at-path.ts";
 export { stringPathToArrayPath } from "./lib/string-path-to-array-path.ts";
-export { arrayPathToStringPath } from "./lib/array-path-to-string-path.ts";
 export { flatObjectToNestedObject } from "./lib/flat-object-to-nested-object.ts";
 export { nestedObjectToFlatObject } from "./lib/nested-object-to-flat-object.ts";
 export { getArraysDiff } from "./lib/get-arrays-diff.ts";
 export type { GetArraysDiffArgs } from "./lib/get-arrays-diff.ts";
+export { objectFromPathEntries } from "./lib/object-from-path-entries.ts";
+export type { PathEntry } from "./lib/object-from-path-entries.ts";
 export { preprocessFormData } from "./lib/preprocess-form-data.ts";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,YAAY,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAG/D,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAC5D,OAAO,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAC;AAC3E,OAAO,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAC;AAG3E,OAAO,EAAE,wBAAwB,EAAE,MAAM,uCAAuC,CAAC;AACjF,OAAO,EAAE,wBAAwB,EAAE,MAAM,uCAAuC,CAAC;AAGjF,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AACzD,YAAY,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAGlE,OAAO,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,YAAY,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAG/D,OAAO,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAC;AAC3E,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAC5D,OAAO,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAC;AAG3E,OAAO,EAAE,wBAAwB,EAAE,MAAM,uCAAuC,CAAC;AACjF,OAAO,EAAE,wBAAwB,EAAE,MAAM,uCAAuC,CAAC;AAGjF,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AACzD,YAAY,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAGlE,OAAO,EAAE,qBAAqB,EAAE,MAAM,mCAAmC,CAAC;AAC1E,YAAY,EAAE,SAAS,EAAE,MAAM,mCAAmC,CAAC;AACnE,OAAO,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAC"}

package/dist/index.js

@@ -1,31 +1,33 @@
+// src/lib/array-path-to-string-path.ts
+function arrayPathToStringPath(path) {
+  return path.reduce((str, item) => {
+    if (typeof item === "symbol") {
+      return str + (str === "" ? "" : ".") + item.toString();
+    }
+    if (typeof item === "number" || !Number.isNaN(Number(item))) {
+      return str + "[" + item + "]";
+    }
+    return str + (str === "" ? "" : ".") + item;
+  }, "");
+}
+
 // src/lib/string-path-to-array-path.ts
 var BRACKET_NOTATION_REGEX = /^\[(.+?)\](.*)$/;
 var DOT_NOTATION_REGEX = /^\.?([^\.\[\]]+)(.*)$/;
 var NUMERIC_KEY_REGEX = /^\d+$/;
-function parsePath(currentPath) {
-  if (currentPath.length === 0) {
-    return [];
-  }
-  const bracketMatch = currentPath.match(BRACKET_NOTATION_REGEX);
-  const dotMatch = currentPath.match(DOT_NOTATION_REGEX);
-  if (bracketMatch) {
-    const [, key = "", rest = ""] = bracketMatch;
-    const parsedKey = NUMERIC_KEY_REGEX.test(key) ? Number(key) : key;
-    const restResult = parsePath(rest);
-    if (restResult === null) {
-      return null;
-    }
-    return [parsedKey, ...restResult];
-  } else if (dotMatch) {
-    const [, key = "", rest = ""] = dotMatch;
-    const parsedKey = NUMERIC_KEY_REGEX.test(key) ? Number(key) : key;
-    const restResult = parsePath(rest);
-    if (restResult === null) {
+function parsePath(path) {
+  const result = [];
+  let remaining = path;
+  while (remaining.length > 0) {
+    const match = remaining.match(BRACKET_NOTATION_REGEX) ?? remaining.match(DOT_NOTATION_REGEX);
+    if (match === null) {
       return null;
     }
-    return [parsedKey, ...restResult];
+    const [, key = "", rest = ""] = match;
+    result.push(NUMERIC_KEY_REGEX.test(key) ? Number(key) : key);
+    remaining = rest;
   }
-  return null;
+  return result;
 }
 function stringPathToArrayPath(path) {
   if (path.length === 0) {
@@ -71,19 +73,6 @@ function setValueAtPath(object, path, value) {
   return object;
 }
 
-// src/lib/array-path-to-string-path.ts
-function arrayPathToStringPath(path) {
-  return path.reduce((str, item) => {
-    if (typeof item === "symbol") {
-      return str + (str === "" ? "" : ".") + item.toString();
-    }
-    if (typeof item === "number" || !Number.isNaN(Number(item))) {
-      return str + "[" + item + "]";
-    }
-    return str + (str === "" ? "" : ".") + item;
-  }, "");
-}
-
 // src/lib/flat-object-to-nested-object.ts
 function flatObjectToNestedObject(flatStructure) {
   const result = {};
@@ -132,9 +121,8 @@ function getArraysDiff(args) {
   return { added, removed, modified };
 }
 
-// src/lib/preprocess-form-data.ts
-function preprocessFormData(formData) {
-  const entries = [...formData];
+// src/lib/object-from-path-entries.ts
+function objectFromPathEntries(entries) {
   const map = /* @__PURE__ */ new Map();
   for (const [key, value] of entries) {
     if (map.has(key)) {
@@ -149,11 +137,20 @@ function preprocessFormData(formData) {
   }, {});
   return result;
 }
+
+// src/lib/preprocess-form-data.ts
+function preprocessFormData(data) {
+  if ("entries" in data && typeof data.entries === "function") {
+    return objectFromPathEntries([...data.entries()]);
+  }
+  return objectFromPathEntries(Object.entries(data));
+}
 export {
   arrayPathToStringPath,
   flatObjectToNestedObject,
   getArraysDiff,
   nestedObjectToFlatObject,
+  objectFromPathEntries,
   preprocessFormData,
   setValueAtPath,
   stringPathToArrayPath

package/dist/index.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
-  "sources": ["../src/lib/string-path-to-array-path.ts", "../src/lib/set-value-at-path.ts", "../src/lib/array-path-to-string-path.ts", "../src/lib/flat-object-to-nested-object.ts", "../src/lib/nested-object-to-flat-object.ts", "../src/lib/get-arrays-diff.ts", "../src/lib/preprocess-form-data.ts"],
-  "sourcesContent": ["// Regular expression to match bracket notation: [key] followed by rest of path.\nconst BRACKET_NOTATION_REGEX = /^\\[(.+?)\\](.*)$/;\n\n// Regular expression to match dot notation: optional dot followed by property\n// name and rest of path.\nconst DOT_NOTATION_REGEX = /^\\.?([^\\.\\[\\]]+)(.*)$/;\n\n// Regular expression to test if a string contains only digits\n// (for array indices).\nconst NUMERIC_KEY_REGEX = /^\\d+$/;\n\n/**\n * Internal recursive parser for path segments.\n * Returns null if the path contains invalid syntax that cannot be parsed.\n *\n * @param currentPath - The remaining path to parse\n * @returns Array of path segments, or null if parsing fails\n */\nfunction parsePath(currentPath: string): Array<string | number> | null {\n  // Base case: empty path\n  if (currentPath.length === 0) {\n    return [];\n  }\n\n  // Try to match bracket notation first, then dot notation.\n  const bracketMatch = currentPath.match(BRACKET_NOTATION_REGEX);\n  const dotMatch = currentPath.match(DOT_NOTATION_REGEX);\n\n  if (bracketMatch) {\n    const [, key = \"\", rest = \"\"] = bracketMatch;\n    // Convert numeric keys to numbers, keep string keys as strings.\n    const parsedKey = NUMERIC_KEY_REGEX.test(key) ? Number(key) : key;\n\n    // Recursively process the rest of the path.\n    const restResult = parsePath(rest);\n\n    // If rest parsing failed (returned null), propagate failure\n    if (restResult === null) {\n      return null;\n    }\n\n    return [parsedKey, ...restResult];\n  } else if (dotMatch) {\n    const [, key = \"\", rest = \"\"] = dotMatch;\n    // Convert numeric keys to numbers, keep string keys as strings.\n    const parsedKey = NUMERIC_KEY_REGEX.test(key) ? Number(key) : key;\n\n    // Recursively process the rest of the path.\n    const restResult = parsePath(rest);\n\n    // If rest parsing failed (returned null), propagate failure\n    if (restResult === null) {\n      return null;\n    }\n\n    return [parsedKey, ...restResult];\n  }\n\n  // No pattern matched but we still have content - invalid path\n  // Return null to signal failure\n  return null;\n}\n\n/**\n * Converts a string path to an array of path segments.\n * Supports both bracket notation (e.g., \"[0]\", \"[key]\") and dot notation (e.g., \".prop\", \"prop\").\n * All numeric strings are converted to numbers regardless of notation type.\n * If the path contains invalid syntax, returns the entire path as a single segment.\n *\n * @param path - The string path to convert (e.g., \"user.profile[0].name\")\n * @returns Array of path segments where numeric strings become numbers\n *\n * @example\n * stringPathToArrayPath(\"user.profile[0].name\") // [\"user\", \"profile\", 0, \"name\"]\n * stringPathToArrayPath(\"users.0[name]\") // [\"users\", 0, \"name\"]\n * stringPathToArrayPath(\"[0].title\") // [0, \"title\"]\n * stringPathToArrayPath(\"\") // []\n * stringPathToArrayPath(\"invalid[[path\") // [\"invalid[[path\"] (invalid syntax)\n */\nexport function stringPathToArrayPath(path: string): Array<string | number> {\n  // Handle empty path.\n  if (path.length === 0) {\n    return [];\n  }\n\n  // Attempt to parse the path\n  const result = parsePath(path);\n\n  // If parsing failed, return the entire path as a single segment\n  if (result === null) {\n    return [path];\n  }\n\n  return result;\n}\n", "import { stringPathToArrayPath } from \"./string-path-to-array-path.ts\";\n\n/**\n * Sets a value at a specific path within an object, creating nested objects/arrays as needed.\n * The path is parsed using dot notation and bracket notation to navigate through the object structure.\n * Missing intermediate objects are automatically created as objects or arrays based on the next segment type.\n *\n * @param object - The target object to modify (will be mutated)\n * @param path - The path string indicating where to set the value (e.g., \"user.profile[0].name\")\n * @param value - The value to set at the specified path\n * @returns The modified input object (same reference, mutated)\n *\n * @example\n * const obj = {};\n * setValueAtPath(obj, \"user.profile.name\", \"John\");\n * // obj becomes { user: { profile: { name: \"John\" } } }\n *\n * @example\n * const obj = {};\n * setValueAtPath(obj, \"users[0].name\", \"Alice\");\n * // obj becomes { users: [{ name: \"Alice\" }] }\n *\n * @example\n * const obj = {};\n * setValueAtPath(obj, \"config[database][host]\", \"localhost\");\n * // obj becomes { config: { database: { host: \"localhost\" } } }\n */\nexport function setValueAtPath<T extends Record<string | number, unknown>>(\n  object: T,\n  path: string,\n  value: unknown,\n): T {\n  const pathSegments = stringPathToArrayPath(path);\n\n  // Handle empty path - cannot set value on empty path.\n  if (pathSegments.length === 0) {\n    throw new Error(\"Cannot set value on empty path\");\n  }\n\n  // Extract leading segments (all but last) and the final segment.\n  const leadingSegments = pathSegments.slice(0, -1);\n  const lastSegment = pathSegments[pathSegments.length - 1];\n\n  // Type guard for lastSegment.\n  if (lastSegment === undefined) {\n    throw new Error(\"Invalid path: last segment is undefined\");\n  }\n\n  // Navigate through the object, creating intermediate objects/arrays as needed.\n  let currentObject: Record<string | number, unknown> = object;\n\n  for (let i = 0; i < leadingSegments.length; i++) {\n    const currentSegment = leadingSegments[i];\n\n    // Type guard for currentSegment.\n    if (currentSegment === undefined) {\n      throw new Error(`Invalid path: segment at index ${i} is undefined`);\n    }\n\n    // If the current property doesn't exist, create it.\n    if (!(currentSegment in currentObject)) {\n      // Determine the next segment to decide whether to create an object or array.\n      const nextSegment = leadingSegments[i + 1] ?? lastSegment;\n      // Create array if next segment is a number, otherwise create object.\n      currentObject[currentSegment] = typeof nextSegment === \"number\" ? [] : {};\n    }\n\n    // Move deeper into the structure.\n    const nextValue = currentObject[currentSegment];\n\n    // Type guard to ensure we have an object-like structure to navigate into.\n    if (typeof nextValue !== \"object\" || nextValue === null) {\n      throw new Error(\n        `Cannot navigate through path: expected object at segment \"${currentSegment}\", got ${typeof nextValue}`,\n      );\n    }\n\n    currentObject = nextValue as Record<string | number, unknown>;\n  }\n\n  // Set the final value.\n  currentObject[lastSegment] = value;\n\n  return object;\n}\n", "/**\n * Convert array path to string format.\n * Examples: [\"user\", \"name\"] -> \"user.name\", [\"items\", 0] -> \"items[0]\"\n *\n * @param path - Array of path segments (strings, numbers, or symbols)\n * @returns String path with dot notation for object properties and bracket notation for array indices\n *\n * @example\n * arrayPathToStringPath([\"user\", \"name\"]) // \"user.name\"\n * arrayPathToStringPath([\"items\", 0]) // \"items[0]\"\n * arrayPathToStringPath([\"addresses\", 0, \"city\"]) // \"addresses[0].city\"\n * arrayPathToStringPath([]) // \"\"\n */\nexport function arrayPathToStringPath(path: Array<PropertyKey>): string {\n  return path.reduce((str: string, item) => {\n    if (typeof item === \"symbol\") {\n      return str + (str === \"\" ? \"\" : \".\") + item.toString();\n    }\n    if (typeof item === \"number\" || !Number.isNaN(Number(item))) {\n      return str + \"[\" + item + \"]\";\n    }\n    return str + (str === \"\" ? \"\" : \".\") + item;\n  }, \"\");\n}\n", "import { setValueAtPath } from \"./set-value-at-path.ts\";\nimport type { FlatObject, NestedObject } from \"./types.ts\";\n\n/**\n * Converts a flat structure object to a nested structure object.\n * Uses path strings like \"user.name\" or \"addresses[0].city\" to create nested structure.\n *\n * @param flatStructure - Flat structure object with string paths as keys\n * @returns Nested structure object with hierarchical structure\n *\n * @example\n * const flat = {\n *   \"user.name\": \"John\",\n *   \"addresses[0].city\": \"San Francisco\"\n * };\n * const nested = flatObjectToNestedObject(flat);\n * // {\n * //   user: { name: \"John\" },\n * //   addresses: [{ city: \"San Francisco\" }]\n * // }\n */\nexport function flatObjectToNestedObject<T = unknown, V = unknown>(\n  flatStructure: FlatObject<V>,\n): NestedObject<T> {\n  const result = {} as Record<string | number, unknown>;\n\n  for (const [path, value] of Object.entries(flatStructure)) {\n    setValueAtPath(result, path, value);\n  }\n\n  return result as NestedObject<T>;\n}\n", "import type { FlatObject, NestedObject } from \"./types.ts\";\n\n/**\n * Converts a nested structure object to a flat structure object.\n * Recursively walks the nested structure and creates path strings.\n *\n * @param nestedStructure - Nested structure object with hierarchical structure\n * @returns Flat structure object with string paths as keys\n *\n * @example\n * const nested = {\n *   user: { name: \"John\" },\n *   addresses: [{ city: \"San Francisco\" }]\n * };\n * const flat = nestedObjectToFlatObject(nested);\n * // {\n * //   \"user.name\": \"John\",\n * //   \"addresses[0].city\": \"San Francisco\"\n * // }\n */\nexport function nestedObjectToFlatObject<T = unknown, V = unknown>(\n  nestedStructure: NestedObject<T>,\n): FlatObject<V> {\n  const result: FlatObject<V> = {};\n\n  function walk(obj: unknown, currentPath: string) {\n    if (typeof obj !== \"object\" || obj === null) {\n      // Leaf node - this is a value\n      result[currentPath] = obj as V;\n      return;\n    }\n\n    if (Array.isArray(obj)) {\n      // Handle arrays\n      obj.forEach((item, index) => {\n        const newPath = currentPath ? `${currentPath}[${index}]` : `[${index}]`;\n        walk(item, newPath);\n      });\n    } else {\n      // Handle objects\n      for (const [key, value] of Object.entries(obj)) {\n        const newPath = currentPath ? `${currentPath}.${key}` : key;\n        walk(value, newPath);\n      }\n    }\n  }\n\n  walk(nestedStructure, \"\");\n\n  return result;\n}\n", "export interface GetArraysDiffArgs<T extends Record<string, unknown>> {\n  before: Array<T>;\n  after: Array<T>;\n  key: (item: T) => PropertyKey;\n  equals: (a: T, b: T) => boolean;\n}\n\nexport function getArraysDiff<T extends Record<string, unknown>>(\n  args: GetArraysDiffArgs<T>,\n): {\n  added: Array<T>;\n  removed: Array<T>;\n  modified: Array<{ before: T; after: T }>;\n} {\n  const { before, after, key, equals } = args;\n  const isEqual = equals;\n\n  // Build lookup maps/sets for efficient comparisons by key.\n  const beforeMap = new Map(before.map((b) => [key(b), b]));\n  const afterMap = new Map(after.map((a) => [key(a), a]));\n\n  const added = after.filter((a) => !beforeMap.has(key(a)));\n  const removed = before.filter((b) => !afterMap.has(key(b)));\n\n  const modified = after\n    .map((a): { before: T; after: T } | undefined => {\n      const b = beforeMap.get(key(a));\n      return b !== undefined && !isEqual(b, a) ? { before: b, after: a } : undefined;\n    })\n    .filter((x): x is { before: T; after: T } => x !== undefined);\n\n  return { added, removed, modified };\n}\n", "import { setValueAtPath } from \"./set-value-at-path.ts\";\n\n/**\n * Transforms flat FormData/URLSearchParams entries into a nested object structure.\n * Handles dot notation (e.g., \"address.street\") and bracket notation (e.g., \"items[0].name\").\n * Multiple values for the same key are automatically grouped into arrays.\n *\n * @param formData - Iterable of key-value pairs (FormData or URLSearchParams)\n * @returns Nested object with grouped values\n *\n * @example\n * const formData = new URLSearchParams([\n *   [\"name\", \"John\"],\n *   [\"address.street\", \"123 Main St\"],\n *   [\"hobbies\", \"reading\"],\n *   [\"hobbies\", \"coding\"]\n * ]);\n * const result = preprocessFormData(formData);\n * // Result: { name: \"John\", address: { street: \"123 Main St\" }, hobbies: [\"reading\", \"coding\"] }\n */\nexport function preprocessFormData(\n  formData: Iterable<unknown>,\n): Record<string, unknown> {\n  const entries = [...formData] as Array<[string, unknown]>;\n\n  // Group values by key (handling multiple values for same key)\n  const map = new Map<string, Array<unknown>>();\n  for (const [key, value] of entries) {\n    if (map.has(key)) {\n      map.get(key)?.push(value);\n    } else {\n      map.set(key, [value]);\n    }\n  }\n\n  // Build nested object using setValueAtPath for dot/bracket notation\n  const result = [...map].reduce<Record<string, unknown>>((acc, [key, list]) => {\n    // Single value stays as single value, multiple values become array\n    const value = list.length === 1 ? list[0] : list;\n    return setValueAtPath(acc, key, value);\n  }, {});\n\n  return result;\n}\n"],
-  "mappings": "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",
+  "sources": ["../src/lib/array-path-to-string-path.ts", "../src/lib/string-path-to-array-path.ts", "../src/lib/set-value-at-path.ts", "../src/lib/flat-object-to-nested-object.ts", "../src/lib/nested-object-to-flat-object.ts", "../src/lib/get-arrays-diff.ts", "../src/lib/object-from-path-entries.ts", "../src/lib/preprocess-form-data.ts"],
+  "sourcesContent": ["/**\n * Convert array path to string format.\n * Examples: [\"user\", \"name\"] -> \"user.name\", [\"items\", 0] -> \"items[0]\"\n *\n * @param path - Array of path segments (strings, numbers, or symbols)\n * @returns String path with dot notation for object properties and bracket notation for array indices\n *\n * @example\n * arrayPathToStringPath([\"user\", \"name\"]) // \"user.name\"\n * arrayPathToStringPath([\"items\", 0]) // \"items[0]\"\n * arrayPathToStringPath([\"addresses\", 0, \"city\"]) // \"addresses[0].city\"\n * arrayPathToStringPath([]) // \"\"\n */\nexport function arrayPathToStringPath(path: Array<PropertyKey>): string {\n  return path.reduce((str: string, item) => {\n    if (typeof item === \"symbol\") {\n      return str + (str === \"\" ? \"\" : \".\") + item.toString();\n    }\n    if (typeof item === \"number\" || !Number.isNaN(Number(item))) {\n      return str + \"[\" + item + \"]\";\n    }\n    return str + (str === \"\" ? \"\" : \".\") + item;\n  }, \"\");\n}\n", "// Regular expression to match bracket notation: [key] followed by rest of path.\nconst BRACKET_NOTATION_REGEX = /^\\[(.+?)\\](.*)$/;\n\n// Regular expression to match dot notation: optional dot followed by property\n// name and rest of path.\nconst DOT_NOTATION_REGEX = /^\\.?([^\\.\\[\\]]+)(.*)$/;\n\n// Regular expression to test if a string contains only digits\n// (for array indices).\nconst NUMERIC_KEY_REGEX = /^\\d+$/;\n\n/**\n * Internal iterative parser for path segments.\n * Consumes the path string segment by segment, trying bracket notation first,\n * then dot notation. Returns null if any remaining portion cannot be parsed.\n *\n * @param path - The path string to parse\n * @returns Array of path segments, or null if parsing fails\n */\nfunction parsePath(path: string): Array<string | number> | null {\n  const result: Array<string | number> = [];\n  let remaining = path;\n\n  while (remaining.length > 0) {\n    // Try bracket notation first (e.g. \"[0]\", \"[key]\"), fall back to dot notation (e.g. \".prop\", \"prop\").\n    const match = remaining.match(BRACKET_NOTATION_REGEX) ?? remaining.match(DOT_NOTATION_REGEX);\n\n    // No pattern matched but we still have content \u2014 invalid path.\n    if (match === null) {\n      return null;\n    }\n\n    const [, key = \"\", rest = \"\"] = match;\n    // Convert numeric keys to numbers, keep string keys as strings.\n    result.push(NUMERIC_KEY_REGEX.test(key) ? Number(key) : key);\n    remaining = rest;\n  }\n\n  return result;\n}\n\n/**\n * Converts a string path to an array of path segments.\n * Supports both bracket notation (e.g., \"[0]\", \"[key]\") and dot notation (e.g., \".prop\", \"prop\").\n * All numeric strings are converted to numbers regardless of notation type.\n * If the path contains invalid syntax, returns the entire path as a single segment.\n *\n * @param path - The string path to convert (e.g., \"user.profile[0].name\")\n * @returns Array of path segments where numeric strings become numbers\n *\n * @example\n * stringPathToArrayPath(\"user.profile[0].name\") // [\"user\", \"profile\", 0, \"name\"]\n * stringPathToArrayPath(\"users.0[name]\") // [\"users\", 0, \"name\"]\n * stringPathToArrayPath(\"[0].title\") // [0, \"title\"]\n * stringPathToArrayPath(\"\") // []\n * stringPathToArrayPath(\"invalid[[path\") // [\"invalid[[path\"] (invalid syntax)\n */\nexport function stringPathToArrayPath(path: string): Array<string | number> {\n  // Handle empty path.\n  if (path.length === 0) {\n    return [];\n  }\n\n  // Attempt to parse the path\n  const result = parsePath(path);\n\n  // If parsing failed, return the entire path as a single segment\n  if (result === null) {\n    return [path];\n  }\n\n  return result;\n}\n", "import { stringPathToArrayPath } from \"./string-path-to-array-path.ts\";\n\n/**\n * Sets a value at a specific path within an object, creating nested objects/arrays as needed.\n * The path is parsed using dot notation and bracket notation to navigate through the object structure.\n * Missing intermediate objects are automatically created as objects or arrays based on the next segment type.\n *\n * @param object - The target object to modify (will be mutated)\n * @param path - The path string indicating where to set the value (e.g., \"user.profile[0].name\")\n * @param value - The value to set at the specified path\n * @returns The modified input object (same reference, mutated)\n *\n * @example\n * const obj = {};\n * setValueAtPath(obj, \"user.profile.name\", \"John\");\n * // obj becomes { user: { profile: { name: \"John\" } } }\n *\n * @example\n * const obj = {};\n * setValueAtPath(obj, \"users[0].name\", \"Alice\");\n * // obj becomes { users: [{ name: \"Alice\" }] }\n *\n * @example\n * const obj = {};\n * setValueAtPath(obj, \"config[database][host]\", \"localhost\");\n * // obj becomes { config: { database: { host: \"localhost\" } } }\n */\nexport function setValueAtPath<T extends Record<string | number, unknown>>(\n  object: T,\n  path: string,\n  value: unknown,\n): T {\n  const pathSegments = stringPathToArrayPath(path);\n\n  // Handle empty path - cannot set value on empty path.\n  if (pathSegments.length === 0) {\n    throw new Error(\"Cannot set value on empty path\");\n  }\n\n  // Extract leading segments (all but last) and the final segment.\n  const leadingSegments = pathSegments.slice(0, -1);\n  const lastSegment = pathSegments[pathSegments.length - 1];\n\n  // Type guard for lastSegment.\n  if (lastSegment === undefined) {\n    throw new Error(\"Invalid path: last segment is undefined\");\n  }\n\n  // Navigate through the object, creating intermediate objects/arrays as needed.\n  let currentObject: Record<string | number, unknown> = object;\n\n  for (let i = 0; i < leadingSegments.length; i++) {\n    const currentSegment = leadingSegments[i];\n\n    // Type guard for currentSegment.\n    if (currentSegment === undefined) {\n      throw new Error(`Invalid path: segment at index ${i} is undefined`);\n    }\n\n    // If the current property doesn't exist, create it.\n    if (!(currentSegment in currentObject)) {\n      // Determine the next segment to decide whether to create an object or array.\n      const nextSegment = leadingSegments[i + 1] ?? lastSegment;\n      // Create array if next segment is a number, otherwise create object.\n      currentObject[currentSegment] = typeof nextSegment === \"number\" ? [] : {};\n    }\n\n    // Move deeper into the structure.\n    const nextValue = currentObject[currentSegment];\n\n    // Type guard to ensure we have an object-like structure to navigate into.\n    if (typeof nextValue !== \"object\" || nextValue === null) {\n      throw new Error(\n        `Cannot navigate through path: expected object at segment \"${currentSegment}\", got ${typeof nextValue}`,\n      );\n    }\n\n    currentObject = nextValue as Record<string | number, unknown>;\n  }\n\n  // Set the final value.\n  currentObject[lastSegment] = value;\n\n  return object;\n}\n", "import { setValueAtPath } from \"./set-value-at-path.ts\";\nimport type { FlatObject, NestedObject } from \"./types.ts\";\n\n/**\n * Converts a flat structure object to a nested structure object.\n * Uses path strings like \"user.name\" or \"addresses[0].city\" to create nested structure.\n *\n * @param flatStructure - Flat structure object with string paths as keys\n * @returns Nested structure object with hierarchical structure\n *\n * @example\n * const flat = {\n *   \"user.name\": \"John\",\n *   \"addresses[0].city\": \"San Francisco\"\n * };\n * const nested = flatObjectToNestedObject(flat);\n * // {\n * //   user: { name: \"John\" },\n * //   addresses: [{ city: \"San Francisco\" }]\n * // }\n */\nexport function flatObjectToNestedObject<T = unknown, V = unknown>(\n  flatStructure: FlatObject<V>,\n): NestedObject<T> {\n  const result = {} as Record<string | number, unknown>;\n\n  for (const [path, value] of Object.entries(flatStructure)) {\n    setValueAtPath(result, path, value);\n  }\n\n  return result as NestedObject<T>;\n}\n", "import type { FlatObject, NestedObject } from \"./types.ts\";\n\n/**\n * Converts a nested structure object to a flat structure object.\n * Recursively walks the nested structure and creates path strings.\n *\n * @param nestedStructure - Nested structure object with hierarchical structure\n * @returns Flat structure object with string paths as keys\n *\n * @example\n * const nested = {\n *   user: { name: \"John\" },\n *   addresses: [{ city: \"San Francisco\" }]\n * };\n * const flat = nestedObjectToFlatObject(nested);\n * // {\n * //   \"user.name\": \"John\",\n * //   \"addresses[0].city\": \"San Francisco\"\n * // }\n */\nexport function nestedObjectToFlatObject<T = unknown, V = unknown>(\n  nestedStructure: NestedObject<T>,\n): FlatObject<V> {\n  const result: FlatObject<V> = {};\n\n  function walk(obj: unknown, currentPath: string) {\n    if (typeof obj !== \"object\" || obj === null) {\n      // Leaf node - this is a value\n      result[currentPath] = obj as V;\n      return;\n    }\n\n    if (Array.isArray(obj)) {\n      // Handle arrays\n      obj.forEach((item, index) => {\n        const newPath = currentPath ? `${currentPath}[${index}]` : `[${index}]`;\n        walk(item, newPath);\n      });\n    } else {\n      // Handle objects\n      for (const [key, value] of Object.entries(obj)) {\n        const newPath = currentPath ? `${currentPath}.${key}` : key;\n        walk(value, newPath);\n      }\n    }\n  }\n\n  walk(nestedStructure, \"\");\n\n  return result;\n}\n", "export interface GetArraysDiffArgs<T extends Record<string, unknown>> {\n  before: Array<T>;\n  after: Array<T>;\n  key: (item: T) => PropertyKey;\n  equals: (a: T, b: T) => boolean;\n}\n\nexport function getArraysDiff<T extends Record<string, unknown>>(\n  args: GetArraysDiffArgs<T>,\n): {\n  added: Array<T>;\n  removed: Array<T>;\n  modified: Array<{ before: T; after: T }>;\n} {\n  const { before, after, key, equals } = args;\n  const isEqual = equals;\n\n  // Build lookup maps/sets for efficient comparisons by key.\n  const beforeMap = new Map(before.map((b) => [key(b), b]));\n  const afterMap = new Map(after.map((a) => [key(a), a]));\n\n  const added = after.filter((a) => !beforeMap.has(key(a)));\n  const removed = before.filter((b) => !afterMap.has(key(b)));\n\n  const modified = after\n    .map((a): { before: T; after: T } | undefined => {\n      const b = beforeMap.get(key(a));\n      return b !== undefined && !isEqual(b, a) ? { before: b, after: a } : undefined;\n    })\n    .filter((x): x is { before: T; after: T } => x !== undefined);\n\n  return { added, removed, modified };\n}\n", "import { setValueAtPath } from \"./set-value-at-path.ts\";\n\n/**\n * Entry type for path-based key-value pairs.\n */\nexport type PathEntry = [string, unknown];\n\n/**\n * Transforms an array of path entries into a nested object structure.\n * Handles dot notation (e.g., \"address.street\") and bracket notation (e.g., \"items[0].name\").\n * Multiple values for the same key are automatically grouped into arrays.\n *\n * @param entries - Array of [key, value] pairs where keys can use path notation\n * @returns Nested object with grouped values\n *\n * @example\n * const entries = [\n *   [\"name\", \"John\"],\n *   [\"address.street\", \"123 Main St\"],\n *   [\"hobbies\", \"reading\"],\n *   [\"hobbies\", \"coding\"]\n * ];\n * const result = objectFromPathEntries(entries);\n * // Result: { name: \"John\", address: { street: \"123 Main St\" }, hobbies: [\"reading\", \"coding\"] }\n */\nexport function objectFromPathEntries(entries: Array<PathEntry>): Record<string, unknown> {\n  // Group values by key (handling multiple values for same key)\n  const map = new Map<string, Array<unknown>>();\n  for (const [key, value] of entries) {\n    if (map.has(key)) {\n      map.get(key)?.push(value);\n    } else {\n      map.set(key, [value]);\n    }\n  }\n\n  // Build nested object using setValueAtPath for dot/bracket notation\n  const result = [...map].reduce<Record<string, unknown>>((acc, [key, list]) => {\n    // Single value stays as single value, multiple values become array\n    const value = list.length === 1 ? list[0] : list;\n    return setValueAtPath(acc, key, value);\n  }, {});\n\n  return result;\n}\n", "import { objectFromPathEntries } from \"./object-from-path-entries.ts\";\n\n/**\n * Transforms FormData, URLSearchParams, or plain objects into a nested object structure.\n * Handles dot notation (e.g., \"address.street\") and bracket notation (e.g., \"items[0].name\").\n * Multiple values for the same key are automatically grouped into arrays.\n *\n * @param data - FormData, URLSearchParams, or plain object to transform\n * @returns Nested object with grouped values\n *\n * @example\n * const formData = new URLSearchParams([\n *   [\"name\", \"John\"],\n *   [\"address.street\", \"123 Main St\"],\n *   [\"hobbies\", \"reading\"],\n *   [\"hobbies\", \"coding\"]\n * ]);\n * const result = preprocessFormData(formData);\n * // Result: { name: \"John\", address: { street: \"123 Main St\" }, hobbies: [\"reading\", \"coding\"] }\n *\n * @example\n * const data = { name: \"John\", age: \"30\" };\n * const result = preprocessFormData(data);\n * // Result: { name: \"John\", age: \"30\" }\n */\nexport function preprocessFormData(\n  data: FormData | URLSearchParams | Record<string, unknown>,\n): Record<string, unknown> {\n  // Check if data has entries method (FormData, URLSearchParams, Map, etc.)\n  if (\"entries\" in data && typeof data.entries === \"function\") {\n    return objectFromPathEntries([...data.entries()]);\n  }\n  // Plain object - use Object.entries\n  return objectFromPathEntries(Object.entries(data));\n}\n"],
+  "mappings": "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",
   "names": []
 }

package/dist/lib/object-from-path-entries.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Entry type for path-based key-value pairs.
+ */
+export type PathEntry = [string, unknown];
+/**
+ * Transforms an array of path entries into a nested object structure.
+ * Handles dot notation (e.g., "address.street") and bracket notation (e.g., "items[0].name").
+ * Multiple values for the same key are automatically grouped into arrays.
+ *
+ * @param entries - Array of [key, value] pairs where keys can use path notation
+ * @returns Nested object with grouped values
+ *
+ * @example
+ * const entries = [
+ *   ["name", "John"],
+ *   ["address.street", "123 Main St"],
+ *   ["hobbies", "reading"],
+ *   ["hobbies", "coding"]
+ * ];
+ * const result = objectFromPathEntries(entries);
+ * // Result: { name: "John", address: { street: "123 Main St" }, hobbies: ["reading", "coding"] }
+ */
+export declare function objectFromPathEntries(entries: Array<PathEntry>): Record<string, unknown>;
+//# sourceMappingURL=object-from-path-entries.d.ts.map

package/dist/lib/object-from-path-entries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"object-from-path-entries.d.ts","sourceRoot":"","sources":["../../src/lib/object-from-path-entries.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAE1C;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,KAAK,CAAC,SAAS,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAmBxF"}

package/dist/lib/preprocess-form-data.d.ts

@@ -1,9 +1,9 @@
 /**
- * Transforms flat FormData/URLSearchParams entries into a nested object structure.
+ * Transforms FormData, URLSearchParams, or plain objects into a nested object structure.
  * Handles dot notation (e.g., "address.street") and bracket notation (e.g., "items[0].name").
  * Multiple values for the same key are automatically grouped into arrays.
  *
- * @param formData - Iterable of key-value pairs (FormData or URLSearchParams)
+ * @param data - FormData, URLSearchParams, or plain object to transform
  * @returns Nested object with grouped values
  *
  * @example
@@ -15,6 +15,11 @@
  * ]);
  * const result = preprocessFormData(formData);
  * // Result: { name: "John", address: { street: "123 Main St" }, hobbies: ["reading", "coding"] }
+ *
+ * @example
+ * const data = { name: "John", age: "30" };
+ * const result = preprocessFormData(data);
+ * // Result: { name: "John", age: "30" }
  */
-export declare function preprocessFormData(formData: Iterable<unknown>): Record<string, unknown>;
+export declare function preprocessFormData(data: FormData | URLSearchParams | Record<string, unknown>): Record<string, unknown>;
 //# sourceMappingURL=preprocess-form-data.d.ts.map

package/dist/lib/preprocess-form-data.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"preprocess-form-data.d.ts","sourceRoot":"","sources":["../../src/lib/preprocess-form-data.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,QAAQ,CAAC,OAAO,CAAC,GAC1B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAqBzB"}
+{"version":3,"file":"preprocess-form-data.d.ts","sourceRoot":"","sources":["../../src/lib/preprocess-form-data.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,QAAQ,GAAG,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACzD,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAOzB"}

package/dist/lib/string-path-to-array-path.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"string-path-to-array-path.d.ts","sourceRoot":"","sources":["../../src/lib/string-path-to-array-path.ts"],"names":[],"mappings":"AA+DA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,CAe1E"}
+{"version":3,"file":"string-path-to-array-path.d.ts","sourceRoot":"","sources":["../../src/lib/string-path-to-array-path.ts"],"names":[],"mappings":"AAyCA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,CAe1E"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typed-web/form-utils",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Shared utilities for form handling: path parsing, error conversion, and array diffing",
   "author": "Łukasz Jagodziński <luke.jagodzinski@gmail.com>",
   "license": "MIT",

package/src/index.ts

@@ -2,9 +2,9 @@
 export type { FlatObject, NestedObject } from "./lib/types.ts";
 
 // Path utilities
+export { arrayPathToStringPath } from "./lib/array-path-to-string-path.ts";
 export { setValueAtPath } from "./lib/set-value-at-path.ts";
 export { stringPathToArrayPath } from "./lib/string-path-to-array-path.ts";
-export { arrayPathToStringPath } from "./lib/array-path-to-string-path.ts";
 
 // Structure conversion
 export { flatObjectToNestedObject } from "./lib/flat-object-to-nested-object.ts";
@@ -15,4 +15,6 @@ export { getArraysDiff } from "./lib/get-arrays-diff.ts";
 export type { GetArraysDiffArgs } from "./lib/get-arrays-diff.ts";
 
 // FormData utilities
+export { objectFromPathEntries } from "./lib/object-from-path-entries.ts";
+export type { PathEntry } from "./lib/object-from-path-entries.ts";
 export { preprocessFormData } from "./lib/preprocess-form-data.ts";

package/src/lib/object-from-path-entries.ts

@@ -0,0 +1,45 @@
+import { setValueAtPath } from "./set-value-at-path.ts";
+
+/**
+ * Entry type for path-based key-value pairs.
+ */
+export type PathEntry = [string, unknown];
+
+/**
+ * Transforms an array of path entries into a nested object structure.
+ * Handles dot notation (e.g., "address.street") and bracket notation (e.g., "items[0].name").
+ * Multiple values for the same key are automatically grouped into arrays.
+ *
+ * @param entries - Array of [key, value] pairs where keys can use path notation
+ * @returns Nested object with grouped values
+ *
+ * @example
+ * const entries = [
+ *   ["name", "John"],
+ *   ["address.street", "123 Main St"],
+ *   ["hobbies", "reading"],
+ *   ["hobbies", "coding"]
+ * ];
+ * const result = objectFromPathEntries(entries);
+ * // Result: { name: "John", address: { street: "123 Main St" }, hobbies: ["reading", "coding"] }
+ */
+export function objectFromPathEntries(entries: Array<PathEntry>): Record<string, unknown> {
+  // Group values by key (handling multiple values for same key)
+  const map = new Map<string, Array<unknown>>();
+  for (const [key, value] of entries) {
+    if (map.has(key)) {
+      map.get(key)?.push(value);
+    } else {
+      map.set(key, [value]);
+    }
+  }
+
+  // Build nested object using setValueAtPath for dot/bracket notation
+  const result = [...map].reduce<Record<string, unknown>>((acc, [key, list]) => {
+    // Single value stays as single value, multiple values become array
+    const value = list.length === 1 ? list[0] : list;
+    return setValueAtPath(acc, key, value);
+  }, {});
+
+  return result;
+}

package/src/lib/preprocess-form-data.ts

@@ -1,11 +1,11 @@
-import { setValueAtPath } from "./set-value-at-path.ts";
+import { objectFromPathEntries } from "./object-from-path-entries.ts";
 
 /**
- * Transforms flat FormData/URLSearchParams entries into a nested object structure.
+ * Transforms FormData, URLSearchParams, or plain objects into a nested object structure.
  * Handles dot notation (e.g., "address.street") and bracket notation (e.g., "items[0].name").
  * Multiple values for the same key are automatically grouped into arrays.
  *
- * @param formData - Iterable of key-value pairs (FormData or URLSearchParams)
+ * @param data - FormData, URLSearchParams, or plain object to transform
  * @returns Nested object with grouped values
  *
  * @example
@@ -17,28 +17,19 @@ import { setValueAtPath } from "./set-value-at-path.ts";
  * ]);
  * const result = preprocessFormData(formData);
  * // Result: { name: "John", address: { street: "123 Main St" }, hobbies: ["reading", "coding"] }
+ *
+ * @example
+ * const data = { name: "John", age: "30" };
+ * const result = preprocessFormData(data);
+ * // Result: { name: "John", age: "30" }
  */
 export function preprocessFormData(
-  formData: Iterable<unknown>,
+  data: FormData | URLSearchParams | Record<string, unknown>,
 ): Record<string, unknown> {
-  const entries = [...formData] as Array<[string, unknown]>;
-
-  // Group values by key (handling multiple values for same key)
-  const map = new Map<string, Array<unknown>>();
-  for (const [key, value] of entries) {
-    if (map.has(key)) {
-      map.get(key)?.push(value);
-    } else {
-      map.set(key, [value]);
-    }
+  // Check if data has entries method (FormData, URLSearchParams, Map, etc.)
+  if ("entries" in data && typeof data.entries === "function") {
+    return objectFromPathEntries([...data.entries()]);
   }
-
-  // Build nested object using setValueAtPath for dot/bracket notation
-  const result = [...map].reduce<Record<string, unknown>>((acc, [key, list]) => {
-    // Single value stays as single value, multiple values become array
-    const value = list.length === 1 ? list[0] : list;
-    return setValueAtPath(acc, key, value);
-  }, {});
-
-  return result;
+  // Plain object - use Object.entries
+  return objectFromPathEntries(Object.entries(data));
 }

package/src/lib/string-path-to-array-path.ts

@@ -10,55 +10,33 @@ const DOT_NOTATION_REGEX = /^\.?([^\.\[\]]+)(.*)$/;
 const NUMERIC_KEY_REGEX = /^\d+$/;
 
 /**
- * Internal recursive parser for path segments.
- * Returns null if the path contains invalid syntax that cannot be parsed.
+ * Internal iterative parser for path segments.
+ * Consumes the path string segment by segment, trying bracket notation first,
+ * then dot notation. Returns null if any remaining portion cannot be parsed.
  *
- * @param currentPath - The remaining path to parse
+ * @param path - The path string to parse
  * @returns Array of path segments, or null if parsing fails
  */
-function parsePath(currentPath: string): Array<string | number> | null {
-  // Base case: empty path
-  if (currentPath.length === 0) {
-    return [];
-  }
-
-  // Try to match bracket notation first, then dot notation.
-  const bracketMatch = currentPath.match(BRACKET_NOTATION_REGEX);
-  const dotMatch = currentPath.match(DOT_NOTATION_REGEX);
+function parsePath(path: string): Array<string | number> | null {
+  const result: Array<string | number> = [];
+  let remaining = path;
 
-  if (bracketMatch) {
-    const [, key = "", rest = ""] = bracketMatch;
-    // Convert numeric keys to numbers, keep string keys as strings.
-    const parsedKey = NUMERIC_KEY_REGEX.test(key) ? Number(key) : key;
-
-    // Recursively process the rest of the path.
-    const restResult = parsePath(rest);
+  while (remaining.length > 0) {
+    // Try bracket notation first (e.g. "[0]", "[key]"), fall back to dot notation (e.g. ".prop", "prop").
+    const match = remaining.match(BRACKET_NOTATION_REGEX) ?? remaining.match(DOT_NOTATION_REGEX);
 
-    // If rest parsing failed (returned null), propagate failure
-    if (restResult === null) {
+    // No pattern matched but we still have content — invalid path.
+    if (match === null) {
       return null;
     }
 
-    return [parsedKey, ...restResult];
-  } else if (dotMatch) {
-    const [, key = "", rest = ""] = dotMatch;
+    const [, key = "", rest = ""] = match;
     // Convert numeric keys to numbers, keep string keys as strings.
-    const parsedKey = NUMERIC_KEY_REGEX.test(key) ? Number(key) : key;
-
-    // Recursively process the rest of the path.
-    const restResult = parsePath(rest);
-
-    // If rest parsing failed (returned null), propagate failure
-    if (restResult === null) {
-      return null;
-    }
-
-    return [parsedKey, ...restResult];
+    result.push(NUMERIC_KEY_REGEX.test(key) ? Number(key) : key);
+    remaining = rest;
   }
 
-  // No pattern matched but we still have content - invalid path
-  // Return null to signal failure
-  return null;
+  return result;
 }
 
 /**