server-act 1.6.0 → 1.6.1

package/README.md

@@ -91,57 +91,137 @@ export const sayHelloAction = serverAct
 >
 > - https://react.dev/reference/react/useActionState
 
-We recommend using [zod-form-data](https://www.npmjs.com/package/zod-form-data) for input validation.
-
 ```ts
 // action.ts;
 "use server";
 
 import { serverAct } from "server-act";
+import { formDataToObject } from "server-act/utils";
 import { z } from "zod";
-import { zfd } from "zod-form-data";
+
+function zodFormData<T extends z.ZodType>(
+  schema: T,
+): z.ZodPipe<z.ZodTransform<Record<string, unknown>, FormData>, T> {
+  return z.preprocess<Record<string, unknown>, T, FormData>(
+    (v) => formDataToObject(v),
+    schema,
+  );
+}
 
 export const sayHelloAction = serverAct
   .input(
-    zfd.formData({
-      name: zfd.text(
-        z
-          .string({ required_error: `You haven't told me your name` })
-          .max(20, { message: "Any shorter name? You name is too long 😬" }),
-      ),
-    }),
+    zodFormData(
+      z.object({
+        name: z
+          .string()
+          .min(1, { error: `You haven't told me your name` })
+          .max(20, { error: "Any shorter name? You name is too long 😬" }),
+      }),
+    ),
   )
-  .stateAction(async ({ formData, input, formErrors, ctx }) => {
-    if (formErrors) {
-      return { formData, formErrors: formErrors.fieldErrors };
+  .stateAction(async ({ rawInput, input, inputErrors, ctx }) => {
+    if (inputErrors) {
+      return { formData: rawInput, inputErrors: inputErrors.fieldErrors };
     }
     return { message: `Hello, ${input.name}!` };
   });
 ```
 
-```tsx
-// client-component.tsx
-"use client";
+## Utilities
 
-import { useActionState } from "react";
-import { sayHelloAction } from "./action";
+### `formDataToObject`
 
-export const ClientComponent = () => {
-  const [state, dispatch] = useActionState(sayHelloAction, undefined);
+The `formDataToObject` utility converts FormData to a structured JavaScript object, supporting nested objects, arrays, and complex form structures.
 
-  return (
-    <form action={dispatch}>
-      <input
-        name="name"
-        required
-        defaultValue={state?.formData?.get("name")?.toString()}
-      />
-      {state?.formErrors?.name?.map((error) => <p key={error}>{error}</p>)}
-
-      <button type="submit">Submit</button>
-
-      {!!state?.message && <p>{state.message}</p>}
-    </form>
+```ts
+import { formDataToObject } from "server-act/utils";
+```
+
+#### Basic Usage
+
+```ts
+const formData = new FormData();
+formData.append('name', 'John');
+
+const result = formDataToObject(formData);
+// Result: { name: 'John' }
+```
+
+#### Nested Objects and Arrays
+
+```ts
+const formData = new FormData();
+formData.append('user.name', 'John');
+
+const result = formDataToObject(formData);
+// Result: { user: { name: 'John' } }
+```
+
+#### With Zod
+
+```ts
+"use server";
+
+import { serverAct } from "server-act";
+import { formDataToObject } from "server-act/utils";
+import { z } from "zod";
+
+function zodFormData<T extends z.ZodType>(
+  schema: T,
+): z.ZodPipe<z.ZodTransform<Record<string, unknown>, FormData>, T> {
+  return z.preprocess<Record<string, unknown>, T, FormData>(
+    (v) => formDataToObject(v),
+    schema,
   );
-};
+}
+
+export const createUserAction = serverAct
+  .input(
+    zodFormData(
+      z.object({
+        name: z.string().min(1, "Name is required"),
+      }),
+    ),
+  )
+  .stateAction(async ({ rawInput, input, inputErrors }) => {
+    if (inputErrors) {
+      return { formData: rawInput, errors: inputErrors.fieldErrors };
+    }
+
+    // Process the validated input
+    console.log("User:", input.name);
+
+    return { success: true, userId: "123" };
+  });
+```
+
+#### With Valibot
+
+```ts
+"use server";
+
+import { serverAct } from "server-act";
+import { formDataToObject } from "server-act/utils";
+import * as v from "valibot";
+
+export const createPostAction = serverAct
+  .input(
+    v.pipe(
+      v.custom<FormData>((value) => value instanceof FormData),
+      v.transform(formDataToObject),
+      v.object({
+        title: v.pipe(v.string(), v.minLength(1, "Title is required")),
+      }),
+    ),
+  )
+  .stateAction(async ({ rawInput, input, inputErrors }) => {
+    if (inputErrors) {
+      return { formData: rawInput, errors: inputErrors.fieldErrors };
+    }
+
+    // Process the validated input
+    console.log("Post:", input.title);
+
+    return { success: true, postId: "456" };
+  });
 ```

package/dist/index.d.mts

@@ -1,7 +1,7 @@
 import { StandardSchemaV1 } from "@standard-schema/spec";
 
-//#region src/utils.d.ts
-declare function getFormErrors(issues: ReadonlyArray<StandardSchemaV1.Issue>): {
+//#region src/internal/schema.d.ts
+declare function getInputErrors(issues: ReadonlyArray<StandardSchemaV1.Issue>): {
   messages: string[];
   fieldErrors: Record<string, string[]>;
 };
@@ -48,6 +48,22 @@ interface ActionBuilder<TParams extends ActionParams> {
    * Create an action for React `useActionState`
    */
   stateAction: <TState, TPrevState = UnsetMarker>(action: (params: Prettify<{
+    ctx: InferContextType<TParams["_context"]>;
+    prevState: RemoveUnsetMarker<TPrevState>;
+    rawInput: InferInputType<TParams["_input"], "in">;
+  } & ({
+    input: InferInputType<TParams["_input"], "out">;
+    inputErrors?: undefined;
+  } | {
+    input?: undefined;
+    inputErrors: ReturnType<typeof getInputErrors>;
+  })>) => Promise<TState>) => (prevState: TState | RemoveUnsetMarker<TPrevState>, input: InferInputType<TParams["_input"], "in">) => Promise<TState | RemoveUnsetMarker<TPrevState>>;
+  /**
+   * Create an action for React `useActionState`
+   *
+   * @deprecated Use `stateAction` instead.
+   */
+  formAction: <TState, TPrevState = UnsetMarker>(action: (params: Prettify<{
     ctx: InferContextType<TParams["_context"]>;
     prevState: RemoveUnsetMarker<TPrevState>;
     formData: FormData;
@@ -56,7 +72,7 @@ interface ActionBuilder<TParams extends ActionParams> {
     formErrors?: undefined;
   } | {
     input?: undefined;
-    formErrors: ReturnType<typeof getFormErrors>;
+    formErrors: ReturnType<typeof getInputErrors>;
   })>) => Promise<TState>) => (prevState: TState | RemoveUnsetMarker<TPrevState>, formData: InferInputType<TParams["_input"], "in">) => Promise<TState | RemoveUnsetMarker<TPrevState>>;
 }
 /**

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import { StandardSchemaV1 } from "@standard-schema/spec";
 
-//#region src/utils.d.ts
-declare function getFormErrors(issues: ReadonlyArray<StandardSchemaV1.Issue>): {
+//#region src/internal/schema.d.ts
+declare function getInputErrors(issues: ReadonlyArray<StandardSchemaV1.Issue>): {
   messages: string[];
   fieldErrors: Record<string, string[]>;
 };
@@ -48,6 +48,22 @@ interface ActionBuilder<TParams extends ActionParams> {
    * Create an action for React `useActionState`
    */
   stateAction: <TState, TPrevState = UnsetMarker>(action: (params: Prettify<{
+    ctx: InferContextType<TParams["_context"]>;
+    prevState: RemoveUnsetMarker<TPrevState>;
+    rawInput: InferInputType<TParams["_input"], "in">;
+  } & ({
+    input: InferInputType<TParams["_input"], "out">;
+    inputErrors?: undefined;
+  } | {
+    input?: undefined;
+    inputErrors: ReturnType<typeof getInputErrors>;
+  })>) => Promise<TState>) => (prevState: TState | RemoveUnsetMarker<TPrevState>, input: InferInputType<TParams["_input"], "in">) => Promise<TState | RemoveUnsetMarker<TPrevState>>;
+  /**
+   * Create an action for React `useActionState`
+   *
+   * @deprecated Use `stateAction` instead.
+   */
+  formAction: <TState, TPrevState = UnsetMarker>(action: (params: Prettify<{
     ctx: InferContextType<TParams["_context"]>;
     prevState: RemoveUnsetMarker<TPrevState>;
     formData: FormData;
@@ -56,7 +72,7 @@ interface ActionBuilder<TParams extends ActionParams> {
     formErrors?: undefined;
   } | {
     input?: undefined;
-    formErrors: ReturnType<typeof getFormErrors>;
+    formErrors: ReturnType<typeof getInputErrors>;
   })>) => Promise<TState>) => (prevState: TState | RemoveUnsetMarker<TPrevState>, formData: InferInputType<TParams["_input"], "in">) => Promise<TState | RemoveUnsetMarker<TPrevState>>;
 }
 /**

package/dist/index.js

@@ -23,13 +23,13 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 //#endregion
 const __standard_schema_utils = __toESM(require("@standard-schema/utils"));
 
-//#region src/utils.ts
+//#region src/internal/schema.ts
 async function standardValidate(schema, input) {
 	let result = schema["~standard"].validate(input);
 	if (result instanceof Promise) result = await result;
 	return result;
 }
-function getFormErrors(issues) {
+function getInputErrors(issues) {
 	const messages = [];
 	const fieldErrors = {};
 	for (const issue of issues) {
@@ -84,6 +84,33 @@ function createServerActionBuilder(initDef = {}) {
 			};
 		},
 		stateAction: (action) => {
+			return async (prevState, rawInput) => {
+				const ctx = await _def.middleware?.();
+				if (_def.input) {
+					const inputSchema = typeof _def.input === "function" ? await _def.input({ ctx }) : _def.input;
+					const result = await standardValidate(inputSchema, rawInput);
+					if (result.issues) return await action({
+						ctx,
+						prevState,
+						rawInput,
+						inputErrors: getInputErrors(result.issues)
+					});
+					return await action({
+						ctx,
+						prevState,
+						rawInput,
+						input: result.value
+					});
+				}
+				return await action({
+					ctx,
+					prevState,
+					rawInput,
+					input: void 0
+				});
+			};
+		},
+		formAction: (action) => {
 			return async (prevState, formData) => {
 				const ctx = await _def.middleware?.();
 				if (_def.input) {
@@ -93,7 +120,7 @@ function createServerActionBuilder(initDef = {}) {
 						ctx,
 						prevState,
 						formData,
-						formErrors: getFormErrors(result.issues)
+						formErrors: getInputErrors(result.issues)
 					});
 					return await action({
 						ctx,

package/dist/index.mjs

@@ -1,12 +1,12 @@
 import { SchemaError, getDotPath } from "@standard-schema/utils";
 
-//#region src/utils.ts
+//#region src/internal/schema.ts
 async function standardValidate(schema, input) {
 	let result = schema["~standard"].validate(input);
 	if (result instanceof Promise) result = await result;
 	return result;
 }
-function getFormErrors(issues) {
+function getInputErrors(issues) {
 	const messages = [];
 	const fieldErrors = {};
 	for (const issue of issues) {
@@ -61,6 +61,33 @@ function createServerActionBuilder(initDef = {}) {
 			};
 		},
 		stateAction: (action) => {
+			return async (prevState, rawInput) => {
+				const ctx = await _def.middleware?.();
+				if (_def.input) {
+					const inputSchema = typeof _def.input === "function" ? await _def.input({ ctx }) : _def.input;
+					const result = await standardValidate(inputSchema, rawInput);
+					if (result.issues) return await action({
+						ctx,
+						prevState,
+						rawInput,
+						inputErrors: getInputErrors(result.issues)
+					});
+					return await action({
+						ctx,
+						prevState,
+						rawInput,
+						input: result.value
+					});
+				}
+				return await action({
+					ctx,
+					prevState,
+					rawInput,
+					input: void 0
+				});
+			};
+		},
+		formAction: (action) => {
 			return async (prevState, formData) => {
 				const ctx = await _def.middleware?.();
 				if (_def.input) {
@@ -70,7 +97,7 @@ function createServerActionBuilder(initDef = {}) {
 						ctx,
 						prevState,
 						formData,
-						formErrors: getFormErrors(result.issues)
+						formErrors: getInputErrors(result.issues)
 					});
 					return await action({
 						ctx,

package/dist/utils.d.mts

@@ -0,0 +1,74 @@
+//#region src/utils.d.ts
+/**
+ * Converts FormData to a structured JavaScript object
+ *
+ * This function parses FormData entries and converts them into a nested object structure.
+ * It supports dot notation, array notation, and mixed nested structures.
+ *
+ * @param formData - The FormData object to convert
+ * @returns A structured object representing the form data
+ *
+ * @example
+ * Basic usage:
+ * ```ts
+ * const formData = new FormData();
+ * formData.append('name', 'John');
+ * formData.append('email', 'john@example.com');
+ *
+ * const result = formDataToObject(formData);
+ * // Result: { name: 'John', email: 'john@example.com' }
+ * ```
+ *
+ * @example
+ * Nested objects with dot notation:
+ * ```ts
+ * const formData = new FormData();
+ * formData.append('user.name', 'John');
+ * formData.append('user.profile.age', '30');
+ *
+ * const result = formDataToObject(formData);
+ * // Result: { user: { name: 'John', profile: { age: '30' } } }
+ * ```
+ *
+ * @example
+ * Arrays with bracket notation:
+ * ```ts
+ * const formData = new FormData();
+ * formData.append('items[0]', 'apple');
+ * formData.append('items[1]', 'banana');
+ *
+ * const result = formDataToObject(formData);
+ * // Result: { items: ['apple', 'banana'] }
+ * ```
+ *
+ * @example
+ * Multiple values for the same key:
+ * ```ts
+ * const formData = new FormData();
+ * formData.append('tags', 'javascript');
+ * formData.append('tags', 'typescript');
+ *
+ * const result = formDataToObject(formData);
+ * // Result: { tags: ['javascript', 'typescript'] }
+ * ```
+ *
+ * @example
+ * Mixed nested structures:
+ * ```ts
+ * const formData = new FormData();
+ * formData.append('users[0].name', 'John');
+ * formData.append('users[0].emails[0]', 'john@work.com');
+ * formData.append('users[0].emails[1]', 'john@personal.com');
+ *
+ * const result = formDataToObject(formData);
+ * // Result: {
+ * //   users: [{
+ * //     name: 'John',
+ * //     emails: ['john@work.com', 'john@personal.com']
+ * //   }]
+ * // }
+ * ```
+ */
+declare function formDataToObject(formData: FormData): Record<string, unknown>;
+//#endregion
+export { formDataToObject };

package/dist/utils.d.ts

@@ -0,0 +1,74 @@
+//#region src/utils.d.ts
+/**
+ * Converts FormData to a structured JavaScript object
+ *
+ * This function parses FormData entries and converts them into a nested object structure.
+ * It supports dot notation, array notation, and mixed nested structures.
+ *
+ * @param formData - The FormData object to convert
+ * @returns A structured object representing the form data
+ *
+ * @example
+ * Basic usage:
+ * ```ts
+ * const formData = new FormData();
+ * formData.append('name', 'John');
+ * formData.append('email', 'john@example.com');
+ *
+ * const result = formDataToObject(formData);
+ * // Result: { name: 'John', email: 'john@example.com' }
+ * ```
+ *
+ * @example
+ * Nested objects with dot notation:
+ * ```ts
+ * const formData = new FormData();
+ * formData.append('user.name', 'John');
+ * formData.append('user.profile.age', '30');
+ *
+ * const result = formDataToObject(formData);
+ * // Result: { user: { name: 'John', profile: { age: '30' } } }
+ * ```
+ *
+ * @example
+ * Arrays with bracket notation:
+ * ```ts
+ * const formData = new FormData();
+ * formData.append('items[0]', 'apple');
+ * formData.append('items[1]', 'banana');
+ *
+ * const result = formDataToObject(formData);
+ * // Result: { items: ['apple', 'banana'] }
+ * ```
+ *
+ * @example
+ * Multiple values for the same key:
+ * ```ts
+ * const formData = new FormData();
+ * formData.append('tags', 'javascript');
+ * formData.append('tags', 'typescript');
+ *
+ * const result = formDataToObject(formData);
+ * // Result: { tags: ['javascript', 'typescript'] }
+ * ```
+ *
+ * @example
+ * Mixed nested structures:
+ * ```ts
+ * const formData = new FormData();
+ * formData.append('users[0].name', 'John');
+ * formData.append('users[0].emails[0]', 'john@work.com');
+ * formData.append('users[0].emails[1]', 'john@personal.com');
+ *
+ * const result = formDataToObject(formData);
+ * // Result: {
+ * //   users: [{
+ * //     name: 'John',
+ * //     emails: ['john@work.com', 'john@personal.com']
+ * //   }]
+ * // }
+ * ```
+ */
+declare function formDataToObject(formData: FormData): Record<string, unknown>;
+//#endregion
+export { formDataToObject };

package/dist/utils.js

@@ -0,0 +1,110 @@
+
+//#region src/internal/assert.ts
+function assert(condition, message) {
+	if (!condition) throw new Error(message || "Assertion failed");
+}
+
+//#endregion
+//#region src/utils.ts
+function isNumberString(str) {
+	return /^\d+$/.test(str);
+}
+function set(obj, path, value) {
+	if (path.length > 1) {
+		const newPath = [...path];
+		const key = newPath.shift();
+		assert(key != null);
+		const nextKey = newPath[0];
+		assert(nextKey != null);
+		if (!obj[key]) obj[key] = isNumberString(nextKey) ? [] : {};
+		else if (Array.isArray(obj[key]) && !isNumberString(nextKey)) obj[key] = Object.fromEntries(Object.entries(obj[key]));
+		set(obj[key], newPath, value);
+		return;
+	}
+	const p = path[0];
+	assert(p != null);
+	if (obj[p] === void 0) obj[p] = value;
+	else if (Array.isArray(obj[p])) obj[p].push(value);
+	else obj[p] = [obj[p], value];
+}
+/**
+* Converts FormData to a structured JavaScript object
+*
+* This function parses FormData entries and converts them into a nested object structure.
+* It supports dot notation, array notation, and mixed nested structures.
+*
+* @param formData - The FormData object to convert
+* @returns A structured object representing the form data
+*
+* @example
+* Basic usage:
+* ```ts
+* const formData = new FormData();
+* formData.append('name', 'John');
+* formData.append('email', 'john@example.com');
+*
+* const result = formDataToObject(formData);
+* // Result: { name: 'John', email: 'john@example.com' }
+* ```
+*
+* @example
+* Nested objects with dot notation:
+* ```ts
+* const formData = new FormData();
+* formData.append('user.name', 'John');
+* formData.append('user.profile.age', '30');
+*
+* const result = formDataToObject(formData);
+* // Result: { user: { name: 'John', profile: { age: '30' } } }
+* ```
+*
+* @example
+* Arrays with bracket notation:
+* ```ts
+* const formData = new FormData();
+* formData.append('items[0]', 'apple');
+* formData.append('items[1]', 'banana');
+*
+* const result = formDataToObject(formData);
+* // Result: { items: ['apple', 'banana'] }
+* ```
+*
+* @example
+* Multiple values for the same key:
+* ```ts
+* const formData = new FormData();
+* formData.append('tags', 'javascript');
+* formData.append('tags', 'typescript');
+*
+* const result = formDataToObject(formData);
+* // Result: { tags: ['javascript', 'typescript'] }
+* ```
+*
+* @example
+* Mixed nested structures:
+* ```ts
+* const formData = new FormData();
+* formData.append('users[0].name', 'John');
+* formData.append('users[0].emails[0]', 'john@work.com');
+* formData.append('users[0].emails[1]', 'john@personal.com');
+*
+* const result = formDataToObject(formData);
+* // Result: {
+* //   users: [{
+* //     name: 'John',
+* //     emails: ['john@work.com', 'john@personal.com']
+* //   }]
+* // }
+* ```
+*/
+function formDataToObject(formData) {
+	const obj = {};
+	for (const [key, value] of formData.entries()) {
+		const parts = key.split(/[\.\[\]]/).filter(Boolean);
+		set(obj, parts, value);
+	}
+	return obj;
+}
+
+//#endregion
+exports.formDataToObject = formDataToObject;

package/dist/utils.mjs

@@ -0,0 +1,109 @@
+//#region src/internal/assert.ts
+function assert(condition, message) {
+	if (!condition) throw new Error(message || "Assertion failed");
+}
+
+//#endregion
+//#region src/utils.ts
+function isNumberString(str) {
+	return /^\d+$/.test(str);
+}
+function set(obj, path, value) {
+	if (path.length > 1) {
+		const newPath = [...path];
+		const key = newPath.shift();
+		assert(key != null);
+		const nextKey = newPath[0];
+		assert(nextKey != null);
+		if (!obj[key]) obj[key] = isNumberString(nextKey) ? [] : {};
+		else if (Array.isArray(obj[key]) && !isNumberString(nextKey)) obj[key] = Object.fromEntries(Object.entries(obj[key]));
+		set(obj[key], newPath, value);
+		return;
+	}
+	const p = path[0];
+	assert(p != null);
+	if (obj[p] === void 0) obj[p] = value;
+	else if (Array.isArray(obj[p])) obj[p].push(value);
+	else obj[p] = [obj[p], value];
+}
+/**
+* Converts FormData to a structured JavaScript object
+*
+* This function parses FormData entries and converts them into a nested object structure.
+* It supports dot notation, array notation, and mixed nested structures.
+*
+* @param formData - The FormData object to convert
+* @returns A structured object representing the form data
+*
+* @example
+* Basic usage:
+* ```ts
+* const formData = new FormData();
+* formData.append('name', 'John');
+* formData.append('email', 'john@example.com');
+*
+* const result = formDataToObject(formData);
+* // Result: { name: 'John', email: 'john@example.com' }
+* ```
+*
+* @example
+* Nested objects with dot notation:
+* ```ts
+* const formData = new FormData();
+* formData.append('user.name', 'John');
+* formData.append('user.profile.age', '30');
+*
+* const result = formDataToObject(formData);
+* // Result: { user: { name: 'John', profile: { age: '30' } } }
+* ```
+*
+* @example
+* Arrays with bracket notation:
+* ```ts
+* const formData = new FormData();
+* formData.append('items[0]', 'apple');
+* formData.append('items[1]', 'banana');
+*
+* const result = formDataToObject(formData);
+* // Result: { items: ['apple', 'banana'] }
+* ```
+*
+* @example
+* Multiple values for the same key:
+* ```ts
+* const formData = new FormData();
+* formData.append('tags', 'javascript');
+* formData.append('tags', 'typescript');
+*
+* const result = formDataToObject(formData);
+* // Result: { tags: ['javascript', 'typescript'] }
+* ```
+*
+* @example
+* Mixed nested structures:
+* ```ts
+* const formData = new FormData();
+* formData.append('users[0].name', 'John');
+* formData.append('users[0].emails[0]', 'john@work.com');
+* formData.append('users[0].emails[1]', 'john@personal.com');
+*
+* const result = formDataToObject(formData);
+* // Result: {
+* //   users: [{
+* //     name: 'John',
+* //     emails: ['john@work.com', 'john@personal.com']
+* //   }]
+* // }
+* ```
+*/
+function formDataToObject(formData) {
+	const obj = {};
+	for (const [key, value] of formData.entries()) {
+		const parts = key.split(/[\.\[\]]/).filter(Boolean);
+		set(obj, parts, value);
+	}
+	return obj;
+}
+
+//#endregion
+export { formDataToObject };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "server-act",
-  "version": "1.6.0",
+  "version": "1.6.1",
   "homepage": "https://github.com/chungweileong94/server-act#readme",
   "author": "chungweileong94",
   "license": "MIT",
@@ -11,20 +11,18 @@
   "bugs": {
     "url": "https://github.com/chungweileong94/server-act/issues"
   },
-  "main": "dist/index.js",
-  "module": "dist/index.mjs",
-  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "import": {
-        "types": "./dist/index.d.mts",
-        "default": "./dist/index.mjs"
-      },
-      "require": {
-        "types": "./dist/index.d.ts",
-        "default": "./dist/index.js"
-      }
-    }
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    },
+    "./utils": {
+      "types": "./dist/utils.d.ts",
+      "import": "./dist/utils.mjs",
+      "require": "./dist/utils.js"
+    },
+    "./package.json": "./package.json"
   },
   "files": [
     "dist",