@hyperspan/framework 1.0.0-alpha.1 → 1.0.0-alpha.11

package/src/server.ts

@@ -1,15 +1,19 @@
 import { HSHtml, html, isHSHtml, renderStream, renderAsync, render } from '@hyperspan/html';
 import { executeMiddleware } from './middleware';
-import type { Hyperspan as HS } from './types';
 import { clientJSPlugin } from './plugins';
-export type { HS as Hyperspan };
+import { parsePath } from './utils';
+import { Cookies } from './cookies';
+
+import type { Hyperspan as HS } from './types';
+import { RequestOptions } from 'node:http';
 
 export const IS_PROD = process.env.NODE_ENV === 'production';
-const CWD = process.cwd();
 
-export class HTTPException extends Error {
-  constructor(public status: number, message?: string) {
-    super(message);
+export class HTTPResponseException extends Error {
+  public _response?: Response;
+  constructor(body: string | undefined, options?: ResponseInit) {
+    super(body);
+    this._response = new Response(body, options);
   }
 }
 
@@ -37,10 +41,25 @@ export function createContext(req: Request, route?: HS.Route): HS.Context {
   // @ts-ignore - Bun will put 'params' on the Request object even though it's not standardized
   const params: HS.RouteParamsParser<path> = req?.params || {};
 
+  const merge = (response: Response) => {
+    // Convert headers to plain objects and merge (response headers override context headers)
+    const mergedHeaders = {
+      ...Object.fromEntries(headers.entries()),
+      ...Object.fromEntries(response.headers.entries()),
+    };
+
+    return new Response(response.body, {
+      status: response.status,
+      headers: mergedHeaders,
+    });
+  };
+
   return {
+    vars: {},
     route: {
       path,
       params: params,
+      cssImports: route ? route._config.cssImports ?? [] : [],
     },
     req: {
       raw: req,
@@ -48,16 +67,23 @@ export function createContext(req: Request, route?: HS.Route): HS.Context {
       method,
       headers,
       query,
-      body: req.body,
+      cookies: new Cookies(req),
+      async text() { return req.text() },
+      async json<T = unknown>() { return await req.json() as T },
+      async formData<T = unknown>() { return await req.formData() as T },
+      async urlencoded() { return new URLSearchParams(await req.text()) },
     },
     res: {
+      cookies: new Cookies(req, headers),
+      headers,
       raw: new Response(),
-      html: (html: string, options?: { status?: number; headers?: Headers | Record<string, string> }) => new Response(html, { ...options, headers: { 'Content-Type': 'text/html; charset=UTF-8', ...options?.headers } }),
-      json: (json: any, options?: { status?: number; headers?: Headers | Record<string, string> }) => new Response(JSON.stringify(json), { ...options, headers: { 'Content-Type': 'application/json', ...options?.headers } }),
-      text: (text: string, options?: { status?: number; headers?: Headers | Record<string, string> }) => new Response(text, { ...options, headers: { 'Content-Type': 'text/plain; charset=UTF-8', ...options?.headers } }),
-      redirect: (url: string, options?: { status?: number; headers?: Headers | Record<string, string> }) => new Response(null, { status: 302, headers: { Location: url, ...options?.headers } }),
-      error: (error: Error, options?: { status?: number; headers?: Headers | Record<string, string> }) => new Response(error.message, { status: 500, ...options }),
-      notFound: (options?: { status?: number; headers?: Headers | Record<string, string> }) => new Response('Not Found', { status: 404, ...options }),
+      html: (html: string, options?: ResponseInit) => merge(new Response(html, { ...options, headers: { 'Content-Type': 'text/html; charset=UTF-8', ...options?.headers } })),
+      json: (json: any, options?: ResponseInit) => merge(new Response(JSON.stringify(json), { ...options, headers: { 'Content-Type': 'application/json', ...options?.headers } })),
+      text: (text: string, options?: ResponseInit) => merge(new Response(text, { ...options, headers: { 'Content-Type': 'text/plain; charset=UTF-8', ...options?.headers } })),
+      redirect: (url: string, options?: ResponseInit) => merge(new Response(null, { status: 302, headers: { Location: url, ...options?.headers } })),
+      error: (error: Error, options?: ResponseInit) => merge(new Response(error.message, { status: 500, ...options })),
+      notFound: (options?: ResponseInit) => merge(new Response('Not Found', { status: 404, ...options })),
+      merge,
     },
   };
 }
@@ -73,7 +99,6 @@ export function createRoute(config: HS.RouteConfig = {}): HS.Route {
 
   const api: HS.Route = {
     _kind: 'hsRoute',
-    _name: config.name,
     _config: config,
     _methods: () => Object.keys(_handlers),
     _path() {
@@ -132,6 +157,10 @@ export function createRoute(config: HS.RouteConfig = {}): HS.Route {
       _middleware['OPTIONS'] = handlerOptions?.middleware || [];
       return api;
     },
+    errorHandler(handler: HS.RouteHandler) {
+      _handlers['_ERROR'] = handler;
+      return api;
+    },
     /**
      * Add middleware specific to this route
      */
@@ -145,12 +174,11 @@ export function createRoute(config: HS.RouteConfig = {}): HS.Route {
      */
     async fetch(request: Request) {
       const context = createContext(request, api);
+      const method = context.req.method;
       const globalMiddleware = _middleware['*'] || [];
-      const methodMiddleware = _middleware[context.req.method] || [];
+      const methodMiddleware = _middleware[method] || [];
 
       const methodHandler = async (context: HS.Context) => {
-        const method = context.req.method;
-
         // Handle CORS preflight requests (if no OPTIONS handler is defined)
         if (method === 'OPTIONS' && !_handlers['OPTIONS']) {
           return context.res.html(
@@ -194,7 +222,16 @@ export function createRoute(config: HS.RouteConfig = {}): HS.Route {
         return routeContent;
       };
 
-      return executeMiddleware(context, [...globalMiddleware, ...methodMiddleware, methodHandler]);
+      // Run the route handler and any middleware
+      // If an error occurs, run the error handler if it exists
+      try {
+        return await executeMiddleware(context, [...globalMiddleware, ...methodMiddleware, methodHandler]);
+      } catch (e) {
+        if (_handlers['_ERROR']) {
+          return await (_handlers['_ERROR'](context) as Promise<Response>);
+        }
+        throw e;
+      }
     },
   };
 
@@ -327,11 +364,6 @@ export function getRunnableRoute(route: unknown, routeConfig?: HS.RouteConfig):
 
   const kind = typeof route;
 
-  // Plain function - wrap in createRoute()
-  if (kind === 'function') {
-    return createRoute(routeConfig).get(route as HS.RouteHandler);
-  }
-
   // Module - get default and use it
   // @ts-ignore
   if (kind === 'object' && 'default' in route) {
@@ -353,17 +385,7 @@ export function isRunnableRoute(route: unknown): boolean {
   }
 
   const obj = route as { _kind: string; fetch: (request: Request) => Promise<Response> };
-  return 'hsRoute' === obj?._kind && 'fetch' in obj;
-}
-
-/**
- * Is valid route path to add to server?
- */
-export function isValidRoutePath(path: string): boolean {
-  const isHiddenRoute = path.includes('/__');
-  const isTestFile = path.includes('.test') || path.includes('.spec');
-
-  return !isHiddenRoute && !isTestFile;
+  return typeof obj?._kind === 'string' && 'fetch' in obj;
 }
 
 /**
@@ -379,8 +401,8 @@ async function showErrorReponse(
   const message = err.message || 'Internal Server Error';
 
   // Send correct status code if HTTPException
-  if (err instanceof HTTPException) {
-    status = err.status;
+  if (err instanceof HTTPResponseException) {
+    status = err._response?.status ?? 500;
   }
 
   const stack = !IS_PROD && err.stack ? err.stack.split('\n').slice(1).join('\n') : '';
@@ -461,53 +483,3 @@ export function createReadableStreamFromAsyncGenerator(output: AsyncGenerator) {
     },
   });
 }
-
-/**
- * Normalize URL path
- * Removes trailing slash and lowercases path
- */
-const ROUTE_SEGMENT_REGEX = /(\[[a-zA-Z_\.]+\])/g;
-export function parsePath(urlPath: string): { path: string, params: string[] } {
-  const params: string[] = [];
-  urlPath = urlPath.replace('index', '').replace('.ts', '').replace('.js', '');
-
-  if (urlPath.startsWith('/')) {
-    urlPath = urlPath.substring(1);
-  }
-
-  if (urlPath.endsWith('/')) {
-    urlPath = urlPath.substring(0, urlPath.length - 1);
-  }
-
-  if (!urlPath) {
-    return { path: '/', params: [] };
-  }
-
-  // Dynamic params
-  if (ROUTE_SEGMENT_REGEX.test(urlPath)) {
-    urlPath = urlPath.replace(ROUTE_SEGMENT_REGEX, (match: string) => {
-      const paramName = match.replace(/[^a-zA-Z_\.]+/g, '');
-      params.push(paramName);
-
-      if (match.includes('...')) {
-        return '*';
-      } else {
-        return ':' + paramName;
-      }
-    });
-  }
-
-  // Only lowercase non-param segments (do not lowercase after ':')
-  return {
-    path: (
-      '/' +
-      urlPath
-        .split('/')
-        .map((segment) =>
-          segment.startsWith(':') || segment === '*' ? segment : segment.toLowerCase()
-        )
-        .join('/')
-    ),
-    params,
-  };
-}

package/src/types.ts

@@ -1,3 +1,6 @@
+import { HSHtml } from '@hyperspan/html';
+import * as z from 'zod/v4';
+
 /**
  * Hyperspan Types
  */
@@ -26,6 +29,52 @@ export namespace Hyperspan {
     afterRoutesAdded?: (server: Hyperspan.Server) => void;
   };
 
+  export type CookieOptions = {
+    maxAge?: number;
+    domain?: string;
+    path?: string;
+    expires?: Date;
+    httpOnly?: boolean;
+    secure?: boolean;
+    sameSite?: 'lax' | 'strict' | true;
+  };
+  export type Cookies = {
+    _req: Request;
+    _responseHeaders: Headers | undefined;
+    _parsedCookies: Record<string, any>;
+    _encrypt: ((str: string) => string) | undefined;
+    _decrypt: ((str: string) => string) | undefined;
+    get: (name: string) => string | undefined;
+    set: (name: string, value: string, options?: CookieOptions) => void;
+    delete: (name: string) => void;
+  }
+
+  export type HSRequest = {
+    url: URL;
+    raw: Request;
+    method: string; // Always uppercase
+    headers: Headers; // Case-insensitive
+    query: URLSearchParams;
+    cookies: Hyperspan.Cookies;
+    text: () => Promise<string>;
+    json<T = unknown>(): Promise<T>;
+    formData(): Promise<FormData>;
+    urlencoded(): Promise<URLSearchParams>;
+  };
+
+  export type HSResponse = {
+    cookies: Hyperspan.Cookies;
+    headers: Headers; // Headers to merge with final outgoing response
+    html: (html: string, options?: ResponseInit) => Response
+    json: (json: any, options?: ResponseInit) => Response;
+    text: (text: string, options?: ResponseInit) => Response;
+    redirect: (url: string, options?: ResponseInit) => Response;
+    error: (error: Error, options?: ResponseInit) => Response;
+    notFound: (options?: ResponseInit) => Response;
+    merge: (response: Response) => Response;
+    raw: Response;
+  };
+
   export interface Context {
     vars: Record<string, any>;
     route: {
@@ -33,24 +82,8 @@ export namespace Hyperspan {
       params: Record<string, string>;
       cssImports?: string[];
     }
-    req: {
-      url: URL;
-      raw: Request;
-      method: string; // Always uppercase
-      headers: Headers; // Case-insensitive
-      query: URLSearchParams;
-      body: any;
-    };
-    res: {
-      headers: Headers; // Headers to merge with final outgoing response
-      html: (html: string, options?: { status?: number; headers?: Record<string, string> }) => Response
-      json: (json: any, options?: { status?: number; headers?: Record<string, string> }) => Response;
-      text: (text: string, options?: { status?: number; headers?: Record<string, string> }) => Response;
-      redirect: (url: string, options?: { status?: number; headers?: Record<string, string> }) => Response;
-      error: (error: Error, options?: { status?: number; headers?: Record<string, string> }) => Response;
-      notFound: (options?: { status?: number; headers?: Record<string, string> }) => Response;
-      raw: Response;
-    };
+    req: HSRequest;
+    res: HSResponse;
   };
 
   export type ClientIslandOptions = {
@@ -94,7 +127,6 @@ export namespace Hyperspan {
 
   export interface Route {
     _kind: 'hsRoute';
-    _name: string | undefined;
     _config: Hyperspan.RouteConfig;
     _path(): string;
     _methods(): string[];
@@ -104,7 +136,29 @@ export namespace Hyperspan {
     patch: (handler: Hyperspan.RouteHandler, handlerOptions?: Hyperspan.RouteHandlerOptions) => Hyperspan.Route;
     delete: (handler: Hyperspan.RouteHandler, handlerOptions?: Hyperspan.RouteHandlerOptions) => Hyperspan.Route;
     options: (handler: Hyperspan.RouteHandler, handlerOptions?: Hyperspan.RouteHandlerOptions) => Hyperspan.Route;
+    errorHandler: (handler: Hyperspan.RouteHandler) => Hyperspan.Route;
     middleware: (middleware: Array<Hyperspan.MiddlewareFunction>) => Hyperspan.Route;
     fetch: (request: Request) => Promise<Response>;
   };
+
+  /**
+   * Action = Form + route handler
+   */
+  export type ActionResponse = HSHtml | void | null | Promise<HSHtml | void | null> | Response | Promise<Response>;
+  export type ActionProps<T extends z.ZodTypeAny> = { data?: Partial<z.infer<T>>; error?: z.ZodError | Error };
+  export type ActionFormHandler<T extends z.ZodTypeAny> = (
+    c: Context, props: ActionProps<T>
+  ) => ActionResponse;
+  export interface Action<T extends z.ZodTypeAny> {
+    _kind: 'hsAction';
+    _config: Hyperspan.RouteConfig;
+    _path(): string;
+    _form: null | ActionFormHandler<T>;
+    form(form: ActionFormHandler<T>): Action<T>;
+    render: (c: Context, props?: ActionProps<T>) => ActionResponse;
+    post: (handler: ActionFormHandler<T>) => Action<T>;
+    errorHandler: (handler: ActionFormHandler<T>) => Action<T>;
+    middleware: (middleware: Array<Hyperspan.MiddlewareFunction>) => Action<T>;
+    fetch: (request: Request) => Promise<Response>;
+  }
 }

package/src/utils.test.ts

@@ -0,0 +1,196 @@
+import { test, expect, describe } from 'bun:test';
+import { formDataToJSON, parsePath } from './utils';
+
+describe('formDataToJSON', () => {
+  test('formDataToJSON returns empty object for empty FormData', () => {
+    const formData = new FormData();
+    const result = formDataToJSON(formData);
+
+    expect(result).toEqual({});
+  });
+
+  test('formDataToJSON handles simple FormData object', () => {
+    const formData = new FormData();
+    formData.append('name', 'John Doe');
+    formData.append('email', 'john@example.com');
+    formData.append('age', '30');
+
+    const result = formDataToJSON(formData);
+
+    expect(result).toEqual({
+      name: 'John Doe',
+      email: 'john@example.com',
+      age: '30',
+    });
+  });
+
+  test('formDataToJSON handles complex FormData with nested fields', () => {
+    const formData = new FormData();
+    formData.append('user[firstName]', 'John');
+    formData.append('user[lastName]', 'Doe');
+    formData.append('user[email]', 'john@example.com');
+    formData.append('user[address][street]', '123 Main St');
+    formData.append('user[address][city]', 'New York');
+    formData.append('user[address][zip]', '10001');
+
+    const result = formDataToJSON(formData);
+
+    expect(result).toEqual({
+      user: {
+        firstName: 'John',
+        lastName: 'Doe',
+        email: 'john@example.com',
+        address: {
+          street: '123 Main St',
+          city: 'New York',
+          zip: '10001',
+        },
+      },
+    } as any);
+  });
+
+  test('formDataToJSON handles FormData with array of values', () => {
+    const formData = new FormData();
+    formData.append('tags', 'javascript');
+    formData.append('tags', 'typescript');
+    formData.append('tags', 'nodejs');
+    formData.append('colors[]', 'red');
+    formData.append('colors[]', 'green');
+    formData.append('colors[]', 'blue');
+
+    const result = formDataToJSON(formData);
+
+    expect(result).toEqual({
+      tags: ['javascript', 'typescript', 'nodejs'],
+      colors: ['red', 'green', 'blue'],
+    });
+  });
+});
+
+describe('parsePath', () => {
+  test('parsePath returns root path for empty string', () => {
+    const result = parsePath('');
+    expect(result.path).toBe('/');
+    expect(result.params).toEqual([]);
+  });
+
+  test('parsePath handles simple path', () => {
+    const result = parsePath('users');
+    expect(result.path).toBe('/users');
+    expect(result.params).toEqual([]);
+  });
+
+  test('parsePath removes leading slash', () => {
+    const result = parsePath('/users');
+    expect(result.path).toBe('/users');
+    expect(result.params).toEqual([]);
+  });
+
+  test('parsePath removes trailing slash', () => {
+    const result = parsePath('users/');
+    expect(result.path).toBe('/users');
+    expect(result.params).toEqual([]);
+  });
+
+  test('parsePath removes both leading and trailing slashes', () => {
+    const result = parsePath('/users/');
+    expect(result.path).toBe('/users');
+    expect(result.params).toEqual([]);
+  });
+
+  test('parsePath handles nested paths', () => {
+    const result = parsePath('users/posts');
+    expect(result.path).toBe('/users/posts');
+    expect(result.params).toEqual([]);
+  });
+
+  test('parsePath lowercases path segments', () => {
+    const result = parsePath('Users/Posts');
+    expect(result.path).toBe('/users/posts');
+    expect(result.params).toEqual([]);
+  });
+
+  test('parsePath removes .ts extension', () => {
+    const result = parsePath('users.ts');
+    expect(result.path).toBe('/users');
+    expect(result.params).toEqual([]);
+  });
+
+  test('parsePath removes .js extension', () => {
+    const result = parsePath('users.js');
+    expect(result.path).toBe('/users');
+    expect(result.params).toEqual([]);
+  });
+
+  test('parsePath removes index from path', () => {
+    const result = parsePath('index');
+    expect(result.path).toBe('/');
+    expect(result.params).toEqual([]);
+  });
+
+  test('parsePath removes index.ts from path', () => {
+    const result = parsePath('index.ts');
+    expect(result.path).toBe('/');
+    expect(result.params).toEqual([]);
+  });
+
+  test('parsePath handles dynamic param with brackets', () => {
+    const result = parsePath('users/[userId]');
+    expect(result.path).toBe('/users/:userId');
+    expect(result.params).toEqual(['userId']);
+  });
+
+  test('parsePath handles multiple dynamic params', () => {
+    const result = parsePath('users/[userId]/posts/[postId]');
+    expect(result.path).toBe('/users/:userId/posts/:postId');
+    expect(result.params).toEqual(['userId', 'postId']);
+  });
+
+  test('parsePath handles catch-all param with spread', () => {
+    const result = parsePath('users/[...slug]');
+    expect(result.path).toBe('/users/*');
+    expect(result.params).toEqual(['slug']);
+  });
+
+  test('parsePath handles catch-all param at root', () => {
+    const result = parsePath('[...slug]');
+    expect(result.path).toBe('/*');
+    expect(result.params).toEqual(['slug']);
+  });
+
+  test('parsePath preserves param names in path but converts format', () => {
+    const result = parsePath('users/[userId]');
+    expect(result.path).toBe('/users/:userId');
+    expect(result.params).toEqual(['userId']);
+    // Param segment should not be lowercased
+    expect(result.path).toContain(':userId');
+  });
+
+  test('parsePath handles complex nested path with params', () => {
+    const result = parsePath('/api/users/[userId]/posts/[postId]/comments');
+    expect(result.path).toBe('/api/users/:userId/posts/:postId/comments');
+    expect(result.params).toEqual(['userId', 'postId']);
+  });
+
+  test('parsePath handles path with dots in param name', () => {
+    const result = parsePath('users/[user.id]');
+    expect(result.path).toBe('/users/:user.id');
+    expect(result.params).toEqual(['user.id']);
+  });
+
+  test('parsePath handles mixed case with params', () => {
+    const result = parsePath('Users/[UserId]/Posts');
+    expect(result.path).toBe('/users/:UserId/posts');
+    expect(result.params).toEqual(['UserId']);
+    // Non-param segments should be lowercased, but param name preserved
+    expect(result.path).toContain('/users/');
+    expect(result.path).toContain('/posts');
+  });
+
+  test('parsePath handles file path format', () => {
+    const result = parsePath('/routes/users/[userId].ts');
+    expect(result.path).toBe('/routes/users/:userId');
+    expect(result.params).toEqual(['userId']);
+  });
+});
+

package/src/utils.ts

@@ -1,5 +1,139 @@
-import { createHash } from "node:crypto";
+import { createHash, randomBytes } from "node:crypto";
 
 export function assetHash(content: string): string {
   return createHash('md5').update(content).digest('hex');
+}
+
+export function randomHash(): string {
+  return createHash('md5').update(randomBytes(32).toString('hex')).digest('hex');
+}
+
+
+/**
+ * Normalize URL path
+ * Removes trailing slash and lowercases path
+ */
+const ROUTE_SEGMENT_REGEX = /(\[[a-zA-Z_\.]+\])/g;
+export function parsePath(urlPath: string): { path: string, params: string[] } {
+  const params: string[] = [];
+  urlPath = urlPath.replace('index', '').replace('.ts', '').replace('.js', '');
+
+  if (urlPath.startsWith('/')) {
+    urlPath = urlPath.substring(1);
+  }
+
+  if (urlPath.endsWith('/')) {
+    urlPath = urlPath.substring(0, urlPath.length - 1);
+  }
+
+  if (!urlPath) {
+    return { path: '/', params: [] };
+  }
+
+  // Dynamic params
+  if (ROUTE_SEGMENT_REGEX.test(urlPath)) {
+    urlPath = urlPath.replace(ROUTE_SEGMENT_REGEX, (match: string) => {
+      const paramName = match.replace(/[^a-zA-Z_\.]+/g, '').replace('...', '');
+      params.push(paramName);
+
+      if (match.includes('...')) {
+        return '*';
+      } else {
+        return ':' + paramName;
+      }
+    });
+  }
+
+  // Only lowercase non-param segments (do not lowercase after ':')
+  return {
+    path: (
+      '/' +
+      urlPath
+        .split('/')
+        .map((segment) =>
+          segment.startsWith(':') || segment === '*' ? segment : segment.toLowerCase()
+        )
+        .join('/')
+    ),
+    params,
+  };
+}
+
+/**
+ * Is valid route path to add to server?
+ */
+export function isValidRoutePath(path: string): boolean {
+  const isHiddenRoute = path.includes('/__');
+  const isTestFile = path.includes('.test') || path.includes('.spec');
+
+  return !isHiddenRoute && !isTestFile && Boolean(path);
+}
+
+/**
+ * Return JSON data structure for a given FormData or URLSearchParams object
+ * Accounts for array fields (e.g. name="options[]" or <select multiple>)
+ *
+ * @link https://stackoverflow.com/a/75406413
+ */
+export function formDataToJSON(formData: FormData | URLSearchParams): Record<string, string | string[]> {
+  let object = {};
+
+  /**
+   * Parses FormData key xxx`[x][x][x]` fields into array
+   */
+  const parseKey = (key: string) => {
+    const subKeyIdx = key.indexOf('[');
+
+    if (subKeyIdx !== -1) {
+      const keys = [key.substring(0, subKeyIdx)];
+      key = key.substring(subKeyIdx);
+
+      for (const match of key.matchAll(/\[(?<key>.*?)]/gm)) {
+        if (match.groups) {
+          keys.push(match.groups.key);
+        }
+      }
+      return keys;
+    } else {
+      return [key];
+    }
+  };
+
+  /**
+   * Recursively iterates over keys and assigns key/values to object
+   */
+  const assign = (keys: string[], value: FormDataEntryValue, object: any): void => {
+    const key = keys.shift();
+
+    // When last key in the iterations
+    if (key === '' || key === undefined) {
+      return object.push(value);
+    }
+
+    if (Reflect.has(object, key)) {
+      // If key has been found, but final pass - convert the value to array
+      if (keys.length === 0) {
+        if (!Array.isArray(object[key])) {
+          object[key] = [object[key], value];
+          return;
+        }
+      }
+      // Recurse again with found object
+      return assign(keys, value, object[key]);
+    }
+
+    // Create empty object for key, if next key is '' do array instead, otherwise set value
+    if (keys.length >= 1) {
+      object[key] = keys[0] === '' ? [] : {};
+      return assign(keys, value, object[key]);
+    } else {
+      object[key] = value;
+    }
+  };
+
+  for (const pair of formData.entries()) {
+    assign(parseKey(pair[0]), pair[1], object);
+  }
+
+  return object;
 }