@firtoz/router-toolkit 7.0.2 → 8.0.0

package/dist/types/RouteWithLoaderModule.d.ts

@@ -0,0 +1,10 @@
+import { Func } from './Func.js';
+import { RegisterPages } from './RegisterPages.js';
+import 'react-router';
+
+type RouteWithLoaderModule = {
+    route: keyof RegisterPages;
+    loader: Func;
+};
+
+export type { RouteWithLoaderModule };

package/dist/types/RouteWithLoaderModule.js

@@ -0,0 +1,3 @@
+import '../chunk-2W5QFQTE.js';
+//# sourceMappingURL=RouteWithLoaderModule.js.map
+//# sourceMappingURL=RouteWithLoaderModule.js.map

package/dist/types/RouteWithLoaderModule.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"RouteWithLoaderModule.js"}

package/dist/types/index.d.ts

@@ -0,0 +1,9 @@
+export * from '@firtoz/maybe-error';
+export { Func } from './Func.js';
+export { HrefArgs } from './HrefArgs.js';
+export { RegisterPages } from './RegisterPages.js';
+export { RoutePath } from './RoutePath.js';
+export { ActionResult, RouteWithActionModule } from './RouteWithActionModule.js';
+export { RouteWithLoaderModule } from './RouteWithLoaderModule.js';
+import 'react-router';
+import 'zod';

package/dist/types/index.js

@@ -0,0 +1,9 @@
+import '../chunk-2RLEUOSR.js';
+import '../chunk-2W5QFQTE.js';
+import '../chunk-YYJDSKJG.js';
+import '../chunk-ZMRGBYFH.js';
+import '../chunk-MKH4ZP5U.js';
+import '../chunk-S4QCJFVR.js';
+import '../chunk-R6HEJ5E5.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/types/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/dist/useCachedFetch.d.ts

@@ -0,0 +1,13 @@
+import { useLoaderData } from 'react-router';
+import { HrefArgs } from './types/HrefArgs.js';
+import { RouteWithLoaderModule } from './types/RouteWithLoaderModule.js';
+import './types/RegisterPages.js';
+import './types/Func.js';
+
+declare const useCachedFetch: <TInfo extends RouteWithLoaderModule>(path: TInfo["route"], ...args: TInfo["route"] extends "undefined" ? HrefArgs<"/"> : HrefArgs<TInfo["route"]>) => {
+    data: ReturnType<typeof useLoaderData<TInfo["loader"]>> | undefined;
+    isLoading: boolean;
+    error: Error | undefined;
+};
+
+export { useCachedFetch };

package/dist/useCachedFetch.js

@@ -0,0 +1,3 @@
+export { useCachedFetch } from './chunk-OQGTU34H.js';
+//# sourceMappingURL=useCachedFetch.js.map
+//# sourceMappingURL=useCachedFetch.js.map

package/dist/useCachedFetch.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"useCachedFetch.js"}

package/dist/useConcurrentSubmitter.d.ts

@@ -0,0 +1,34 @@
+import { z } from 'zod';
+import { RegisterPages } from './types/RegisterPages.js';
+import { RouteWithActionModule, ActionResult } from './types/RouteWithActionModule.js';
+import { Operation, FormDataSubmittedData, SubmitJsonOptions, SubmitJsonResult, SubmitFormDataOptions } from './ConcurrentSubmitterProvider.js';
+import 'react-router';
+import './types/Func.js';
+import 'react/jsx-runtime';
+import 'react';
+
+/**
+ * @fileoverview Typed hook for concurrent form submissions. Use within ConcurrentSubmitterProvider.
+ */
+
+type RouteParams<R extends keyof RegisterPages> = RegisterPages[R]["params"];
+/**
+ * True when the route has no dynamic segments (`params: {}` from React Router typegen).
+ * Uses `keyof … extends never` so real empty params stay distinct from the `RegisterPages`
+ * fallback (`AnyPages` → `params: Record<string, …>` has `keyof` = `string`, not `never`).
+ * That avoids mis-resolving `submitJson(path, data)` as the route-args overload (strings only).
+ */
+type HasNoParams<R extends keyof RegisterPages> = [
+    keyof RegisterPages[R]["params"]
+] extends [never] ? true : false;
+type HasOptionalParams<R extends keyof RegisterPages> = HasNoParams<R> extends true ? false : Partial<RouteParams<R>> extends RouteParams<R> ? true : false;
+type SubmitJsonFn<TInfo extends RouteWithActionModule> = HasNoParams<TInfo["route"]> extends true ? (path: TInfo["route"], data: z.infer<TInfo["formSchema"]>, options?: SubmitJsonOptions) => SubmitJsonResult<ActionResult<TInfo>> : HasOptionalParams<TInfo["route"]> extends true ? (path: TInfo["route"], args: RouteParams<TInfo["route"]> | undefined, data: z.infer<TInfo["formSchema"]>, options?: SubmitJsonOptions) => SubmitJsonResult<ActionResult<TInfo>> : (path: TInfo["route"], args: RouteParams<TInfo["route"]>, data: z.infer<TInfo["formSchema"]>, options?: SubmitJsonOptions) => SubmitJsonResult<ActionResult<TInfo>>;
+type SubmitFormDataFn<TInfo extends RouteWithActionModule> = HasNoParams<TInfo["route"]> extends true ? (path: TInfo["route"], formData: FormData, submittedData?: FormDataSubmittedData, options?: SubmitFormDataOptions) => SubmitJsonResult<ActionResult<TInfo>> : HasOptionalParams<TInfo["route"]> extends true ? (path: TInfo["route"], args: RouteParams<TInfo["route"]> | undefined, formData: FormData, submittedData?: FormDataSubmittedData, options?: SubmitFormDataOptions) => SubmitJsonResult<ActionResult<TInfo>> : (path: TInfo["route"], args: RouteParams<TInfo["route"]>, formData: FormData, submittedData?: FormDataSubmittedData, options?: SubmitFormDataOptions) => SubmitJsonResult<ActionResult<TInfo>>;
+type UseConcurrentSubmitterReturn<TInfo extends RouteWithActionModule> = {
+    operations: Record<string, Operation<ActionResult<TInfo>, z.infer<TInfo["formSchema"]> | FormDataSubmittedData>>;
+    submitJson: SubmitJsonFn<TInfo>;
+    submitFormData: SubmitFormDataFn<TInfo>;
+};
+declare function useConcurrentSubmitter<TInfo extends RouteWithActionModule>(): UseConcurrentSubmitterReturn<TInfo>;
+
+export { ActionResult, type UseConcurrentSubmitterReturn, useConcurrentSubmitter };

package/dist/useConcurrentSubmitter.js

@@ -0,0 +1,4 @@
+export { useConcurrentSubmitter } from './chunk-QZDEBX3D.js';
+import './chunk-ZC6U3MIB.js';
+//# sourceMappingURL=useConcurrentSubmitter.js.map
+//# sourceMappingURL=useConcurrentSubmitter.js.map

package/dist/useConcurrentSubmitter.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"useConcurrentSubmitter.js"}

package/dist/useDynamicFetcher.d.ts

@@ -0,0 +1,219 @@
+import { useFetcher } from 'react-router';
+import { HrefArgs } from './types/HrefArgs.js';
+import { RouteWithLoaderModule } from './types/RouteWithLoaderModule.js';
+import './types/RegisterPages.js';
+import './types/Func.js';
+
+/**
+ * @fileoverview Type-safe dynamic data fetching hook for React Router 7
+ *
+ * This module provides a hook that creates a type-safe fetcher for loading data
+ * from dynamic routes with full TypeScript inference for the loader response and route params.
+ *
+ * @example
+ * ### Route Setup (`app/routes/api.users.$userId.ts`)
+ *
+ * First, set up your route with the required exports:
+ *
+ * ```typescript
+ * import type { RoutePath } from "@firtoz/router-toolkit";
+ *
+ * // Export the route path for type inference
+ * export const route: RoutePath<"/api/users/:userId"> = "/api/users/:userId";
+ *
+ * // Define the loader with a typed return value
+ * export const loader = async ({ params }: LoaderFunctionArgs) => {
+ *   const user = await db.users.findUnique({ where: { id: params.userId } });
+ *   return {
+ *     user: {
+ *       id: user.id,
+ *       email: user.email,
+ *       displayName: user.displayName,
+ *       createdAt: user.createdAt.toISOString(),
+ *     },
+ *   };
+ * };
+ * ```
+ *
+ * @example
+ * ### Using the hook in a component
+ *
+ * ```tsx
+ * import { useDynamicFetcher } from "@firtoz/router-toolkit";
+ * import { useEffect } from "react";
+ *
+ * function UserProfile({ userId }: { userId: string }) {
+ *   // Type-safe fetcher with full inference
+ *   const fetcher = useDynamicFetcher<typeof import("./api.users.$userId")>(
+ *     "/api/users/:userId",
+ *     { userId }
+ *   );
+ *
+ *   // Load data on mount
+ *   useEffect(() => {
+ *     fetcher.load();
+ *   }, [fetcher.load]);
+ *
+ *   // fetcher.data is fully typed: { user: { id, email, displayName, createdAt } } | undefined
+ *   if (fetcher.state === "loading") {
+ *     return <div>Loading...</div>;
+ *   }
+ *
+ *   if (!fetcher.data) {
+ *     return <div>No user found</div>;
+ *   }
+ *
+ *   return (
+ *     <div>
+ *       <h1>{fetcher.data.user.displayName}</h1>
+ *       <p>{fetcher.data.user.email}</p>
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * ### Loading with query parameters
+ *
+ * ```tsx
+ * function SearchResults() {
+ *   const fetcher = useDynamicFetcher<typeof import("./api.search")>("/api/search");
+ *
+ *   const handleSearch = (query: string, page: number) => {
+ *     // Pass query params to the load function
+ *     fetcher.load({ q: query, page: String(page) });
+ *   };
+ *
+ *   return (
+ *     <div>
+ *       <input onChange={(e) => handleSearch(e.target.value, 1)} />
+ *       {fetcher.data?.results.map((result) => (
+ *         <div key={result.id}>{result.title}</div>
+ *       ))}
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * ### Combining with useDynamicSubmitter for full CRUD
+ *
+ * You can use `useDynamicFetcher` alongside `useDynamicSubmitter` to create
+ * complete CRUD interfaces with type safety:
+ *
+ * ```tsx
+ * import { useDynamicFetcher, useDynamicSubmitter } from "@firtoz/router-toolkit";
+ *
+ * function PostEditor({ postId }: { postId: string }) {
+ *   // Fetch post data
+ *   const fetcher = useDynamicFetcher<typeof import("./api.posts.$postId")>(
+ *     "/api/posts/:postId",
+ *     { postId }
+ *   );
+ *
+ *   // Submit updates
+ *   const submitter = useDynamicSubmitter<typeof import("./api.posts.$postId")>(
+ *     "/api/posts/:postId",
+ *     { postId }
+ *   );
+ *
+ *   useEffect(() => {
+ *     fetcher.load();
+ *   }, [fetcher.load]);
+ *
+ *   const handleSave = async (title: string, content: string) => {
+ *     await submitter.submitJson({ title, content }, { method: "PUT" });
+ *     // Reload after save
+ *     fetcher.load();
+ *   };
+ *
+ *   if (!fetcher.data) return <div>Loading...</div>;
+ *
+ *   return (
+ *     <form onSubmit={(e) => {
+ *       e.preventDefault();
+ *       const form = new FormData(e.currentTarget);
+ *       handleSave(form.get("title") as string, form.get("content") as string);
+ *     }}>
+ *       <input name="title" defaultValue={fetcher.data.post.title} />
+ *       <textarea name="content" defaultValue={fetcher.data.post.content} />
+ *       <button disabled={submitter.state !== "idle"}>
+ *         {submitter.state === "submitting" ? "Saving..." : "Save"}
+ *       </button>
+ *     </form>
+ *   );
+ * }
+ * ```
+ */
+
+/**
+ * Creates a type-safe fetcher for loading data from dynamic routes.
+ *
+ * This hook provides full TypeScript inference for:
+ * - Route parameters (from the route path)
+ * - Loader response type (from the route's loader export)
+ *
+ * @template TInfo - The route module type (use `typeof import("./route-file")`)
+ *
+ * @param path - The route path (must match the route's `route` export)
+ * @param args - Route parameters (if the route has dynamic segments like `:id`)
+ *
+ * @returns An extended fetcher object with:
+ * - `load` - Function to load data, optionally with query parameters
+ * - `data` - Response data from the loader (typed)
+ * - `state` - Fetcher state ("idle" | "loading" | "submitting")
+ * - All other useFetcher properties (except `submit`)
+ *
+ * @example
+ * ### Basic usage
+ *
+ * ```typescript
+ * // In your route file (app/routes/api.products.$productId.ts):
+ * export const route: RoutePath<"/api/products/:productId"> = "/api/products/:productId";
+ * export const loader = async ({ params }: LoaderFunctionArgs) => {
+ *   return { product: await getProduct(params.productId) };
+ * };
+ *
+ * // In your component:
+ * const fetcher = useDynamicFetcher<typeof import("./api.products.$productId")>(
+ *   "/api/products/:productId",
+ *   { productId: "abc123" }
+ * );
+ *
+ * useEffect(() => {
+ *   fetcher.load();
+ * }, [fetcher.load]);
+ *
+ * // fetcher.data is typed as { product: Product } | undefined
+ * ```
+ *
+ * @example
+ * ### With query parameters
+ *
+ * ```typescript
+ * const fetcher = useDynamicFetcher<typeof import("./api.search")>("/api/search");
+ *
+ * // Load with query params: /api/search?q=hello&limit=10
+ * fetcher.load({ q: "hello", limit: "10" });
+ * ```
+ */
+declare const useDynamicFetcher: <TInfo extends RouteWithLoaderModule>(path: TInfo["route"], ...args: TInfo["route"] extends "undefined" ? HrefArgs<"/"> : HrefArgs<TInfo["route"]>) => Omit<ReturnType<typeof useFetcher<TInfo["loader"]>>, "load" | "submit"> & {
+    /**
+     * Load data from the route's loader.
+     *
+     * @param queryParams - Optional query parameters to append to the URL
+     * @returns A promise that resolves when the load is complete
+     *
+     * @example
+     * ```typescript
+     * // Load without query params
+     * fetcher.load();
+     *
+     * // Load with query params
+     * fetcher.load({ page: "2", sort: "name" });
+     * ```
+     */
+    load: (queryParams?: Record<string, string>) => Promise<void>;
+};
+
+export { useDynamicFetcher };

package/dist/useDynamicFetcher.js

@@ -0,0 +1,3 @@
+export { useDynamicFetcher } from './chunk-HX57TC2S.js';
+//# sourceMappingURL=useDynamicFetcher.js.map
+//# sourceMappingURL=useDynamicFetcher.js.map

package/dist/useDynamicFetcher.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"useDynamicFetcher.js"}

package/dist/useDynamicSubmitter.d.ts

@@ -0,0 +1,256 @@
+import React from 'react';
+import { useFetcher, SubmitTarget, SubmitOptions, FetcherFormProps } from 'react-router';
+import { z } from 'zod';
+import { HrefArgs } from './types/HrefArgs.js';
+import { RouteWithActionModule } from './types/RouteWithActionModule.js';
+import './types/RegisterPages.js';
+import './types/Func.js';
+
+/**
+ * @fileoverview Type-safe dynamic form submission hook for React Router 7
+ *
+ * This module provides a hook that creates a type-safe fetcher for submitting forms
+ * to dynamic routes with full TypeScript inference for the form schema and route params.
+ *
+ * @example
+ * ### Route Setup (`app/routes/admin.posts.$id.tsx`)
+ *
+ * First, set up your route with the required exports:
+ *
+ * ```typescript
+ * import { z } from "zod";
+ * import { formAction, type RoutePath } from "@firtoz/router-toolkit";
+ * import { success, fail } from "@firtoz/maybe-error";
+ *
+ * // Export the route path for type inference
+ * export const route: RoutePath<"/admin/posts/:id"> = "/admin/posts/:id";
+ *
+ * // Define the form schema
+ * export const formSchema = z.object({
+ *   title: z.string().min(1, "Title is required"),
+ *   content: z.string().min(10, "Content must be at least 10 characters"),
+ *   published: z.boolean().optional().default(false),
+ * });
+ *
+ * // Create the action using formAction
+ * export const action = formAction({
+ *   schema: formSchema,
+ *   handler: async ({ request, params }, formData) => {
+ *     const postId = params.id;
+ *     const updated = await db.posts.update({
+ *       where: { id: postId },
+ *       data: formData,
+ *     });
+ *     return success(updated);
+ *   },
+ * });
+ * ```
+ *
+ * @example
+ * ### Using the hook in a component
+ *
+ * ```tsx
+ * import { useDynamicSubmitter } from "@firtoz/router-toolkit";
+ *
+ * function EditPostForm({ postId }: { postId: string }) {
+ *   // Type-safe submitter with full inference
+ *   const submitter = useDynamicSubmitter<typeof import("./admin.posts.$id")>(
+ *     "/admin/posts/:id",
+ *     { id: postId }
+ *   );
+ *
+ *   // submitter.data is the typed response from the action
+ *   // submitter.state is "idle" | "loading" | "submitting"
+ *
+ *   // Option 1: Submit as JSON (recommended for programmatic submissions)
+ *   // Defaults to POST if no options provided
+ *   const handleSubmitJson = async () => {
+ *     await submitter.submitJson({
+ *       title: "My Post",
+ *       content: "Post content here",
+ *       published: true,
+ *     });
+ *   };
+ *
+ *   // Option 2: Submit with FormData or SubmitTarget
+ *   const handleSubmit = async (formData: FormData) => {
+ *     await submitter.submit(formData, { method: "POST" });
+ *   };
+ *
+ *   // Option 3: Use the Form component (defaults to POST)
+ *   return (
+ *     <submitter.Form>
+ *       <input name="title" />
+ *       <textarea name="content" />
+ *       <button type="submit">Save</button>
+ *     </submitter.Form>
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * ### Handling responses
+ *
+ * ```tsx
+ * function LoginForm() {
+ *   const submitter = useDynamicSubmitter<typeof import("./auth.login")>("/auth/login");
+ *
+ *   useEffect(() => {
+ *     if (submitter.data?.success) {
+ *       // Handle success
+ *       console.log("Logged in as:", submitter.data.value.user.email);
+ *     } else if (submitter.data && !submitter.data.success) {
+ *       // Handle error
+ *       if (submitter.data.error.type === "validation") {
+ *         console.log("Validation errors:", submitter.data.error.error);
+ *       }
+ *     }
+ *   }, [submitter.data]);
+ *
+ *   return (
+ *     <submitter.Form>
+ *       <input name="email" type="email" />
+ *       <input name="password" type="password" />
+ *       <button disabled={submitter.state !== "idle"}>
+ *         {submitter.state === "submitting" ? "Logging in..." : "Login"}
+ *       </button>
+ *     </submitter.Form>
+ *   );
+ * }
+ * ```
+ */
+
+/**
+ * Function type for submitting form data with a SubmitTarget.
+ *
+ * Accepts the form schema data combined with SubmitTarget (FormData, HTMLFormElement, etc.)
+ * Use this when you have a FormData object or form element reference.
+ *
+ * @example
+ * ```typescript
+ * // With FormData
+ * submitter.submit(formData, { method: "POST" });
+ *
+ * // With form element reference
+ * submitter.submit(formRef.current, { method: "POST" });
+ * ```
+ */
+type SubmitFunc<TModule extends RouteWithActionModule> = (target: z.infer<TModule["formSchema"]> & SubmitTarget, options: Omit<SubmitOptions, "action" | "method" | "encType"> & {
+    method: Exclude<SubmitOptions["method"], "GET">;
+}) => Promise<void>;
+/**
+ * Options for submitJson function.
+ * Method defaults to "POST" if not specified.
+ */
+type SubmitJsonOptions = Omit<SubmitOptions, "action" | "method" | "encType"> & {
+    method?: Exclude<SubmitOptions["method"], "GET">;
+};
+/**
+ * Function type for submitting form data as JSON.
+ *
+ * Accepts only the inferred form schema type (plain object).
+ * Automatically serializes the data as JSON. This is the recommended
+ * approach for programmatic form submissions.
+ *
+ * Options are optional and default to `{ method: "POST" }`.
+ *
+ * @example
+ * ```typescript
+ * // Submit a plain object - fully type-safe (defaults to POST)
+ * await submitter.submitJson({
+ *   email: "user@example.com",
+ *   password: "secret123",
+ *   rememberMe: true,
+ * });
+ *
+ * // Or specify a different method
+ * await submitter.submitJson(data, { method: "PUT" });
+ * ```
+ */
+type SubmitJsonFunc<TModule extends RouteWithActionModule> = (data: z.infer<TModule["formSchema"]>, options?: SubmitJsonOptions) => Promise<void>;
+/**
+ * Form component type with pre-bound action URL.
+ *
+ * Renders a form element that automatically submits to the correct route.
+ * Method defaults to "POST" if not specified.
+ *
+ * @example
+ * ```typescript
+ * // Defaults to POST
+ * <submitter.Form>
+ *   <input name="title" />
+ *   <button type="submit">Submit</button>
+ * </submitter.Form>
+ *
+ * // Or specify a different method
+ * <submitter.Form method="PUT">
+ *   ...
+ * </submitter.Form>
+ * ```
+ */
+type SubmitForm = (props: Omit<FetcherFormProps & React.RefAttributes<HTMLFormElement>, "action" | "method"> & {
+    method?: Exclude<SubmitOptions["method"], "GET">;
+}) => React.ReactElement;
+/**
+ * Creates a type-safe fetcher for submitting forms to dynamic routes.
+ *
+ * This hook provides full TypeScript inference for:
+ * - Route parameters (from the route path)
+ * - Form data schema (from the route's formSchema export)
+ * - Action response type (from the route's action export)
+ *
+ * @template TInfo - The route module type (use `typeof import("./route-file")`)
+ *
+ * @param path - The route path (must match the route's `route` export)
+ * @param args - Route parameters (if the route has dynamic segments like `:id`)
+ *
+ * @returns An extended fetcher object with:
+ * - `submit` - Submit with FormData/SubmitTarget (includes schema type)
+ * - `submitJson` - Submit a plain object as JSON (schema type only)
+ * - `Form` - Pre-bound form component
+ * - `data` - Response data from the action (typed)
+ * - `state` - Fetcher state ("idle" | "loading" | "submitting")
+ * - All other useFetcher properties
+ *
+ * @example
+ * ### Basic usage with route parameters
+ *
+ * ```typescript
+ * // In your route file (app/routes/users.$userId.settings.tsx):
+ * export const route: RoutePath<"/users/:userId/settings"> = "/users/:userId/settings";
+ * export const formSchema = z.object({
+ *   displayName: z.string().min(2),
+ *   email: z.string().email(),
+ *   notifications: z.boolean().default(true),
+ * });
+ * export const action = formAction({ schema: formSchema, handler: ... });
+ *
+ * // In your component:
+ * const submitter = useDynamicSubmitter<typeof import("./users.$userId.settings")>(
+ *   "/users/:userId/settings",
+ *   { userId: "123" }
+ * );
+ *
+ * // Submit using submitJson (type-safe, no FormData needed, defaults to POST)
+ * await submitter.submitJson({
+ *   displayName: "John Doe",
+ *   email: "john@example.com",
+ *   notifications: true,
+ * });
+ *
+ * // Check the response
+ * if (submitter.data?.success) {
+ *   console.log("Settings updated!");
+ * }
+ * ```
+ */
+declare const useDynamicSubmitter: <TInfo extends RouteWithActionModule>(path: TInfo["route"], ...args: TInfo["route"] extends "undefined" ? HrefArgs<"/"> : HrefArgs<TInfo["route"]>) => Omit<ReturnType<typeof useFetcher<TInfo["action"]>>, "load" | "submit" | "Form"> & {
+    /** Submit with FormData or SubmitTarget (schema type & SubmitTarget) */
+    submit: SubmitFunc<TInfo>;
+    /** Submit a plain object as JSON (schema type only, defaults to POST) */
+    submitJson: SubmitJsonFunc<TInfo>;
+    /** Pre-bound Form component with action URL already set (defaults to POST) */
+    Form: SubmitForm;
+};
+
+export { useDynamicSubmitter };

package/dist/useDynamicSubmitter.js

@@ -0,0 +1,3 @@
+export { useDynamicSubmitter } from './chunk-JJN6GBJL.js';
+//# sourceMappingURL=useDynamicSubmitter.js.map
+//# sourceMappingURL=useDynamicSubmitter.js.map

package/dist/useDynamicSubmitter.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"useDynamicSubmitter.js"}

package/dist/useFetcherStateChanged.d.ts

@@ -0,0 +1,10 @@
+import { useFetcher } from 'react-router';
+
+/**
+ * A hook that tracks changes in a fetcher's state and calls a callback when it changes.
+ * @param fetcher The fetcher instance to track
+ * @param onChange Callback that receives the previous state and new state when the state changes
+ */
+declare const useFetcherStateChanged: (fetcher: Pick<ReturnType<typeof useFetcher>, "state">, onChange: (lastState: typeof fetcher.state | undefined, newState: typeof fetcher.state) => void) => void;
+
+export { useFetcherStateChanged };

package/dist/useFetcherStateChanged.js

@@ -0,0 +1,3 @@
+export { useFetcherStateChanged } from './chunk-W5R7YYHR.js';
+//# sourceMappingURL=useFetcherStateChanged.js.map
+//# sourceMappingURL=useFetcherStateChanged.js.map

package/dist/useFetcherStateChanged.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"useFetcherStateChanged.js"}