@inertiajs/react 1.0.0-beta.4 → 1.0.0-beta.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inertiajs/react",
-  "version": "1.0.0-beta.4",
+  "version": "1.0.0-beta.5",
   "license": "MIT",
   "description": "The React adapter for Inertia.js",
   "contributors": [
@@ -16,6 +16,10 @@
   "bugs": {
     "url": "https://github.com/inertiajs/inertia/issues"
   },
+  "files": [
+    "dist",
+    "types"
+  ],
   "source": "src/index.ts",
   "main": "dist/index.js",
   "types": "types/index.d.ts",
@@ -48,7 +52,7 @@
     "react": "^16.9.0 || ^17.0.0 || ^18.0.0"
   },
   "dependencies": {
-    "@inertiajs/core": "1.0.0-beta.4",
+    "@inertiajs/core": "1.0.0-beta.5",
     "lodash.isequal": "^4.5.0"
   }
 }

package/types/App.d.ts

@@ -0,0 +1,12 @@
+declare function App({ children, initialPage, initialComponent, resolveComponent, titleCallback, onHeadUpdate, }: {
+    children: any;
+    initialPage: any;
+    initialComponent: any;
+    resolveComponent: any;
+    titleCallback: any;
+    onHeadUpdate: any;
+}): import("react").FunctionComponentElement<import("react").ProviderProps<any>>;
+declare namespace App {
+    var displayName: string;
+}
+export default App;

package/types/Head.d.ts

@@ -0,0 +1,7 @@
+import { FunctionComponent } from 'react';
+type InertiaHeadProps = {
+    title?: string;
+};
+type InertiaHead = FunctionComponent<InertiaHeadProps>;
+declare const Head: InertiaHead;
+export default Head;

package/types/HeadContext.d.ts

@@ -0,0 +1,2 @@
+declare const headContext: import("react").Context<any>;
+export default headContext;

package/types/Link.d.ts

@@ -0,0 +1,26 @@
+import { FormDataConvertible, Method, PreserveStateOption, Progress } from '@inertiajs/core';
+interface BaseInertiaLinkProps {
+    as?: string;
+    data?: Record<string, FormDataConvertible>;
+    href: string;
+    method?: Method;
+    headers?: Record<string, string>;
+    onClick?: (event: React.MouseEvent<HTMLAnchorElement> | React.KeyboardEvent<HTMLAnchorElement>) => void;
+    preserveScroll?: PreserveStateOption;
+    preserveState?: PreserveStateOption;
+    replace?: boolean;
+    only?: string[];
+    onCancelToken?: (cancelToken: import('axios').CancelTokenSource) => void;
+    onBefore?: () => void;
+    onStart?: () => void;
+    onProgress?: (progress: Progress) => void;
+    onFinish?: () => void;
+    onCancel?: () => void;
+    onSuccess?: () => void;
+    onError?: () => void;
+    queryStringArrayFormat?: 'indices' | 'brackets';
+}
+type InertiaLinkProps = BaseInertiaLinkProps & Omit<React.HTMLAttributes<HTMLElement>, keyof BaseInertiaLinkProps> & Omit<React.AllHTMLAttributes<HTMLElement>, keyof BaseInertiaLinkProps>;
+type InertiaLink = React.FunctionComponent<InertiaLinkProps>;
+declare const Link: InertiaLink;
+export default Link;

package/types/PageContext.d.ts

@@ -0,0 +1,2 @@
+declare const pageContext: import("react").Context<any>;
+export default pageContext;

package/types/createInertiaApp.d.ts

@@ -0,0 +1,56 @@
+import { Page, PageProps, PageResolver } from '@inertiajs/core';
+import { ComponentType, FunctionComponent, Key, ReactElement, ReactNode } from 'react';
+import { renderToString } from 'react-dom/server';
+type ReactInstance = ReactElement;
+type ReactComponent = ReactNode;
+type HeadManagerOnUpdate = (elements: string[]) => void;
+type HeadManagerTitleCallback = (title: string) => string;
+type AppType<SharedProps = PageProps> = FunctionComponent<{
+    children?: (props: {
+        Component: ComponentType;
+        key: Key;
+        props: Page<SharedProps>['props'];
+    }) => ReactNode;
+} & SetupOptions<unknown, SharedProps>['props']>;
+export type SetupOptions<ElementType, SharedProps> = {
+    el: ElementType;
+    App: AppType;
+    props: {
+        initialPage: Page<SharedProps>;
+        initialComponent: ReactComponent;
+        resolveComponent: PageResolver;
+        titleCallback?: HeadManagerTitleCallback;
+        onHeadUpdate?: HeadManagerOnUpdate;
+    };
+};
+type BaseInertiaAppOptions = {
+    title?: HeadManagerTitleCallback;
+    resolve: PageResolver;
+};
+type CreateInertiaAppSetupReturnType = ReactInstance | void;
+type InertiaAppOptionsForCSR<SharedProps> = BaseInertiaAppOptions & {
+    id?: string;
+    page?: Page | string;
+    render?: undefined;
+    progress?: false | {
+        delay?: number;
+        color?: string;
+        includeCSS?: boolean;
+        showSpinner?: boolean;
+    };
+    setup(options: SetupOptions<HTMLElement, SharedProps>): CreateInertiaAppSetupReturnType;
+};
+type CreateInertiaAppSSRContent = {
+    head: string[];
+    body: string;
+};
+type InertiaAppOptionsForSSR<SharedProps> = BaseInertiaAppOptions & {
+    id?: undefined;
+    page: Page | string;
+    render: typeof renderToString;
+    progress: undefined;
+    setup(options: SetupOptions<null, SharedProps>): ReactInstance;
+};
+export default function createInertiaApp<SharedProps = PageProps>(options: InertiaAppOptionsForCSR<SharedProps>): Promise<CreateInertiaAppSetupReturnType>;
+export default function createInertiaApp<SharedProps = PageProps>(options: InertiaAppOptionsForSSR<SharedProps>): Promise<CreateInertiaAppSSRContent>;
+export {};

package/types/index.d.ts

@@ -0,0 +1,7 @@
+export declare const router: import("@inertiajs/core").Router;
+export { default as createInertiaApp } from './createInertiaApp';
+export { default as Head } from './Head';
+export { default as Link } from './Link';
+export { default as useForm } from './useForm';
+export { default as usePage } from './usePage';
+export { default as useRemember } from './useRemember';

package/types/useForm.d.ts

@@ -0,0 +1,33 @@
+import { Method, Progress, VisitOptions } from '@inertiajs/core';
+type setDataByObject<TForm> = (data: TForm) => void;
+type setDataByMethod<TForm> = (data: (previousData: TForm) => TForm) => void;
+type setDataByKeyValuePair<TForm> = <K extends keyof TForm>(key: K, value: TForm[K]) => void;
+export interface InertiaFormProps<TForm extends Record<string, unknown>> {
+    data: TForm;
+    isDirty: boolean;
+    errors: Partial<Record<keyof TForm, string>>;
+    hasErrors: boolean;
+    processing: boolean;
+    progress: Progress | null;
+    wasSuccessful: boolean;
+    recentlySuccessful: boolean;
+    setData: setDataByObject<TForm> & setDataByMethod<TForm> & setDataByKeyValuePair<TForm>;
+    transform: (callback: (data: TForm) => TForm) => void;
+    setDefaults(): void;
+    setDefaults(field: keyof TForm, value: string): void;
+    setDefaults(fields: Record<keyof TForm, string>): void;
+    reset: (...fields: (keyof TForm)[]) => void;
+    clearErrors: (...fields: (keyof TForm)[]) => void;
+    setError(field: keyof TForm, value: string): void;
+    setError(errors: Record<keyof TForm, string>): void;
+    submit: (method: Method, url: string, options?: VisitOptions) => void;
+    get: (url: string, options?: VisitOptions) => void;
+    patch: (url: string, options?: VisitOptions) => void;
+    post: (url: string, options?: VisitOptions) => void;
+    put: (url: string, options?: VisitOptions) => void;
+    delete: (url: string, options?: VisitOptions) => void;
+    cancel: () => void;
+}
+export default function useForm<TForm extends Record<string, unknown>>(initialValues?: TForm): InertiaFormProps<TForm>;
+export default function useForm<TForm extends Record<string, unknown>>(rememberKey: string, initialValues?: TForm): InertiaFormProps<TForm>;
+export {};

package/types/usePage.d.ts

@@ -0,0 +1,2 @@
+import { Page } from '@inertiajs/core';
+export default function usePage(): Page;

package/types/useRemember.d.ts

@@ -0,0 +1,3 @@
+import { Dispatch, SetStateAction } from 'react';
+export default function useRemember<State>(initialState: State, key?: string): [State, Dispatch<SetStateAction<State>>];
+export declare function useRememberedState<State>(initialState: State, key?: string): [State, Dispatch<SetStateAction<State>>];

package/build.js

@@ -1,40 +0,0 @@
-#!/usr/bin/env node
-const esbuild = require('esbuild')
-const { nodeExternalsPlugin } = require('esbuild-node-externals')
-
-const watch = process.argv.slice(1).includes('--watch')
-
-const config = {
-  bundle: true,
-  minify: true,
-  sourcemap: true,
-  target: 'es2020',
-  plugins: [nodeExternalsPlugin()],
-}
-
-const builds = [
-  { entryPoints: ['src/index.ts'], format: 'esm', outfile: 'dist/index.esm.js', platform: 'browser' },
-  { entryPoints: ['src/index.ts'], format: 'cjs', outfile: 'dist/index.js', platform: 'browser' },
-  { entryPoints: ['src/server.ts'], format: 'esm', outfile: 'dist/server.esm.js', platform: 'node' },
-  { entryPoints: ['src/server.ts'], format: 'cjs', outfile: 'dist/server.js', platform: 'node' },
-]
-
-builds.forEach((build) => {
-  esbuild
-    .build({ ...config, ...build, ...watcher(build) })
-    .then(() => console.log(`${watch ? 'Watching' : 'Built'} ${build.entryPoints} (${build.format})…`))
-    .catch(() => process.exit(1))
-})
-
-function watcher(build) {
-  return watch
-    ? {
-        watch: {
-          onRebuild: (error) =>
-            error
-              ? console.error('Watch failed:', error)
-              : console.log(`Rebuilding ${build.entryPoints} (${build.format})…`),
-        },
-      }
-    : {}
-}

package/src/App.ts

@@ -1,86 +0,0 @@
-import { createHeadManager, router } from '@inertiajs/core'
-import { createElement, useEffect, useMemo, useState } from 'react'
-import HeadContext from './HeadContext'
-import PageContext from './PageContext'
-
-export default function App({
-  children,
-  initialPage,
-  initialComponent,
-  resolveComponent,
-  titleCallback,
-  onHeadUpdate,
-}) {
-  const [current, setCurrent] = useState({
-    component: initialComponent || null,
-    page: initialPage,
-    key: null,
-  })
-
-  const headManager = useMemo(() => {
-    return createHeadManager(
-      typeof window === 'undefined',
-      titleCallback || ((title) => title),
-      onHeadUpdate || (() => {}),
-    )
-  }, [])
-
-  useEffect(() => {
-    router.init({
-      initialPage,
-      resolveComponent,
-      swapComponent: async ({ component, page, preserveState }) => {
-        setCurrent((current) => ({
-          component,
-          page,
-          key: preserveState ? current.key : Date.now(),
-        }))
-      },
-    })
-
-    router.on('navigate', () => headManager.forceUpdate())
-  }, [])
-
-  if (!current.component) {
-    return createElement(
-      HeadContext.Provider,
-      { value: headManager },
-      createElement(PageContext.Provider, { value: current.page }, null),
-    )
-  }
-
-  const renderChildren =
-    children ||
-    (({ Component, props, key }) => {
-      const child = createElement(Component, { key, ...props })
-
-      if (typeof Component.layout === 'function') {
-        return Component.layout(child)
-      }
-
-      if (Array.isArray(Component.layout)) {
-        return Component.layout
-          .concat(child)
-          .reverse()
-          .reduce((children, Layout) => createElement(Layout, { children, ...props }))
-      }
-
-      return child
-    })
-
-  return createElement(
-    HeadContext.Provider,
-    { value: headManager },
-    createElement(
-      PageContext.Provider,
-      { value: current.page },
-      renderChildren({
-        Component: current.component,
-        key: current.key,
-        props: current.page.props,
-      }),
-    ),
-  )
-}
-
-App.displayName = 'Inertia'

package/src/Head.ts

@@ -1,99 +0,0 @@
-import React, { FunctionComponent, useContext, useEffect, useMemo } from 'react'
-import HeadContext from './HeadContext'
-
-type InertiaHeadProps = {
-  title?: string
-}
-
-type InertiaHead = FunctionComponent<InertiaHeadProps>
-
-const Head: InertiaHead = function ({ children, title }) {
-  const headManager = useContext(HeadContext)
-  const provider = useMemo(() => headManager.createProvider(), [headManager])
-
-  useEffect(() => {
-    return () => {
-      provider.disconnect()
-    }
-  }, [provider])
-
-  function isUnaryTag(node) {
-    return (
-      [
-        'area',
-        'base',
-        'br',
-        'col',
-        'embed',
-        'hr',
-        'img',
-        'input',
-        'keygen',
-        'link',
-        'meta',
-        'param',
-        'source',
-        'track',
-        'wbr',
-      ].indexOf(node.type) > -1
-    )
-  }
-
-  function renderTagStart(node) {
-    const attrs = Object.keys(node.props).reduce((carry, name) => {
-      if (['head-key', 'children', 'dangerouslySetInnerHTML'].includes(name)) {
-        return carry
-      }
-      const value = node.props[name]
-      if (value === '') {
-        return carry + ` ${name}`
-      } else {
-        return carry + ` ${name}="${value}"`
-      }
-    }, '')
-    return `<${node.type}${attrs}>`
-  }
-
-  function renderTagChildren(node) {
-    return typeof node.props.children === 'string'
-      ? node.props.children
-      : node.props.children.reduce((html, child) => html + renderTag(child), '')
-  }
-
-  function renderTag(node) {
-    let html = renderTagStart(node)
-    if (node.props.children) {
-      html += renderTagChildren(node)
-    }
-    if (node.props.dangerouslySetInnerHTML) {
-      html += node.props.dangerouslySetInnerHTML.__html
-    }
-    if (!isUnaryTag(node)) {
-      html += `</${node.type}>`
-    }
-    return html
-  }
-
-  function ensureNodeHasInertiaProp(node) {
-    return React.cloneElement(node, {
-      inertia: node.props['head-key'] !== undefined ? node.props['head-key'] : '',
-    })
-  }
-
-  function renderNode(node) {
-    return renderTag(ensureNodeHasInertiaProp(node))
-  }
-
-  function renderNodes(nodes) {
-    const computed = (Array.isArray(nodes) ? nodes : [nodes]).filter((node) => node).map((node) => renderNode(node))
-    if (title && !computed.find((tag) => tag.startsWith('<title'))) {
-      computed.push(`<title inertia>${title}</title>`)
-    }
-    return computed
-  }
-
-  provider.update(renderNodes(children))
-
-  return null
-}
-export default Head

package/src/HeadContext.ts

@@ -1,6 +0,0 @@
-import { createContext } from 'react'
-
-const headContext = createContext(undefined)
-headContext.displayName = 'InertiaHeadContext'
-
-export default headContext

package/src/Link.ts

@@ -1,141 +0,0 @@
-import {
-  FormDataConvertible,
-  mergeDataIntoQueryString,
-  Method,
-  PreserveStateOption,
-  Progress,
-  router,
-  shouldIntercept,
-} from '@inertiajs/core'
-import { createElement, forwardRef, useCallback } from 'react'
-
-const noop = () => undefined
-
-interface BaseInertiaLinkProps {
-  as?: string
-  data?: Record<string, FormDataConvertible>
-  href: string
-  method?: Method
-  headers?: Record<string, string>
-  onClick?: (event: React.MouseEvent<HTMLAnchorElement> | React.KeyboardEvent<HTMLAnchorElement>) => void
-  preserveScroll?: PreserveStateOption
-  preserveState?: PreserveStateOption
-  replace?: boolean
-  only?: string[]
-  onCancelToken?: (cancelToken: import('axios').CancelTokenSource) => void
-  onBefore?: () => void
-  onStart?: () => void
-  onProgress?: (progress: Progress) => void
-  onFinish?: () => void
-  onCancel?: () => void
-  onSuccess?: () => void
-  onError?: () => void
-  queryStringArrayFormat?: 'indices' | 'brackets'
-}
-
-type InertiaLinkProps = BaseInertiaLinkProps &
-  Omit<React.HTMLAttributes<HTMLElement>, keyof BaseInertiaLinkProps> &
-  Omit<React.AllHTMLAttributes<HTMLElement>, keyof BaseInertiaLinkProps>
-
-type InertiaLink = React.FunctionComponent<InertiaLinkProps>
-
-const Link: InertiaLink = forwardRef<unknown, InertiaLinkProps>(
-  (
-    {
-      children,
-      as = 'a',
-      data = {},
-      href,
-      method = Method.GET,
-      preserveScroll = false,
-      preserveState = null,
-      replace = false,
-      only = [],
-      headers = {},
-      queryStringArrayFormat = 'brackets',
-      onClick = noop,
-      onCancelToken = noop,
-      onBefore = noop,
-      onStart = noop,
-      onProgress = noop,
-      onFinish = noop,
-      onCancel = noop,
-      onSuccess = noop,
-      onError = noop,
-      ...props
-    },
-    ref,
-  ) => {
-    const visit = useCallback(
-      (event) => {
-        onClick(event)
-
-        if (shouldIntercept(event)) {
-          event.preventDefault()
-
-          router.visit(href, {
-            data,
-            method,
-            preserveScroll,
-            preserveState: preserveState ?? method !== 'get',
-            replace,
-            only,
-            headers,
-            onCancelToken,
-            onBefore,
-            onStart,
-            onProgress,
-            onFinish,
-            onCancel,
-            onSuccess,
-            onError,
-          })
-        }
-      },
-      [
-        data,
-        href,
-        method,
-        preserveScroll,
-        preserveState,
-        replace,
-        only,
-        headers,
-        onClick,
-        onCancelToken,
-        onBefore,
-        onStart,
-        onProgress,
-        onFinish,
-        onCancel,
-        onSuccess,
-        onError,
-      ],
-    )
-
-    as = as.toLowerCase()
-    method = method.toLowerCase() as Method
-    const [_href, _data] = mergeDataIntoQueryString(method, href || '', data, queryStringArrayFormat)
-    href = _href
-    data = _data
-
-    if (as === 'a' && method !== 'get') {
-      console.warn(
-        `Creating POST/PUT/PATCH/DELETE <a> links is discouraged as it causes "Open Link in New Tab/Window" accessibility issues.\n\nPlease specify a more appropriate element using the "as" attribute. For example:\n\n<Link href="${href}" method="${method}" as="button">...</Link>`,
-      )
-    }
-
-    return createElement(
-      as,
-      {
-        ...props,
-        ...(as === 'a' ? { href } : {}),
-        ref,
-        onClick: visit,
-      },
-      children,
-    )
-  },
-)
-
-export default Link

package/src/PageContext.ts

@@ -1,6 +0,0 @@
-import { createContext } from 'react'
-
-const pageContext = createContext(undefined)
-pageContext.displayName = 'InertiaPageContext'
-
-export default pageContext

package/src/createInertiaApp.ts

@@ -1,119 +0,0 @@
-import { Page, PageProps, PageResolver, setupProgress } from '@inertiajs/core'
-import { ComponentType, createElement, FunctionComponent, Key, ReactElement, ReactNode } from 'react'
-import { renderToString } from 'react-dom/server'
-import App from './App'
-
-type ReactInstance = ReactElement
-type ReactComponent = ReactNode
-
-type HeadManagerOnUpdate = (elements: string[]) => void // TODO: When shipped, replace with: Inertia.HeadManagerOnUpdate
-type HeadManagerTitleCallback = (title: string) => string // TODO: When shipped, replace with: Inertia.HeadManagerTitleCallback
-
-type AppType<SharedProps = PageProps> = FunctionComponent<
-  {
-    children?: (props: { Component: ComponentType; key: Key; props: Page<SharedProps>['props'] }) => ReactNode
-  } & SetupOptions<unknown, SharedProps>['props']
->
-
-export type SetupOptions<ElementType, SharedProps> = {
-  el: ElementType
-  App: AppType
-  props: {
-    initialPage: Page<SharedProps>
-    initialComponent: ReactComponent
-    resolveComponent: PageResolver
-    titleCallback?: HeadManagerTitleCallback
-    onHeadUpdate?: HeadManagerOnUpdate
-  }
-}
-
-type BaseInertiaAppOptions = {
-  title?: HeadManagerTitleCallback
-  resolve: PageResolver
-}
-
-type CreateInertiaAppSetupReturnType = ReactInstance | void
-type InertiaAppOptionsForCSR<SharedProps> = BaseInertiaAppOptions & {
-  id?: string
-  page?: Page | string
-  render?: undefined
-  progress?:
-    | false
-    | {
-        delay?: number
-        color?: string
-        includeCSS?: boolean
-        showSpinner?: boolean
-      }
-  setup(options: SetupOptions<HTMLElement, SharedProps>): CreateInertiaAppSetupReturnType
-}
-
-type CreateInertiaAppSSRContent = { head: string[]; body: string }
-type InertiaAppOptionsForSSR<SharedProps> = BaseInertiaAppOptions & {
-  id?: undefined
-  page: Page | string
-  render: typeof renderToString
-  progress: undefined
-  setup(options: SetupOptions<null, SharedProps>): ReactInstance
-}
-
-export default async function createInertiaApp<SharedProps = PageProps>(
-  options: InertiaAppOptionsForCSR<SharedProps>,
-): Promise<CreateInertiaAppSetupReturnType>
-export default async function createInertiaApp<SharedProps = PageProps>(
-  options: InertiaAppOptionsForSSR<SharedProps>,
-): Promise<CreateInertiaAppSSRContent>
-export default async function createInertiaApp<SharedProps = PageProps>({
-  id = 'app',
-  resolve,
-  setup,
-  title,
-  progress = {},
-  page,
-  render,
-}: InertiaAppOptionsForCSR<SharedProps> | InertiaAppOptionsForSSR<SharedProps>): Promise<
-  CreateInertiaAppSetupReturnType | CreateInertiaAppSSRContent
-> {
-  const isServer = typeof window === 'undefined'
-  const el = isServer ? null : document.getElementById(id)
-  const initialPage = page || JSON.parse(el.dataset.page)
-  // @ts-expect-error
-  const resolveComponent = (name) => Promise.resolve(resolve(name)).then((module) => module.default || module)
-
-  let head = []
-
-  const reactApp = await resolveComponent(initialPage.component).then((initialComponent) => {
-    return setup({
-      // @ts-expect-error
-      el,
-      App,
-      props: {
-        initialPage,
-        initialComponent,
-        resolveComponent,
-        titleCallback: title,
-        onHeadUpdate: isServer ? (elements) => (head = elements) : null,
-      },
-    })
-  })
-
-  if (!isServer && progress) {
-    setupProgress(progress)
-  }
-
-  if (isServer) {
-    const body = await render(
-      createElement(
-        'div',
-        {
-          id,
-          'data-page': JSON.stringify(initialPage),
-        },
-        // @ts-expect-error
-        reactApp,
-      ),
-    )
-
-    return { head, body }
-  }
-}

package/src/index.ts

@@ -1,9 +0,0 @@
-import { router as Router } from '@inertiajs/core'
-
-export const router = Router
-export { default as createInertiaApp } from './createInertiaApp'
-export { default as Head } from './Head'
-export { default as Link } from './Link'
-export { default as useForm } from './useForm'
-export { default as usePage } from './usePage'
-export { default as useRemember } from './useRemember'

package/src/server.ts

@@ -1 +0,0 @@
-export { default as default } from '@inertiajs/core/server'

package/src/useForm.ts

@@ -1,263 +0,0 @@
-import { Method, Progress, router, VisitOptions } from '@inertiajs/core'
-import isEqual from 'lodash.isequal'
-import { useCallback, useEffect, useRef, useState } from 'react'
-import useRemember from './useRemember'
-
-type setDataByObject<TForm> = (data: TForm) => void
-type setDataByMethod<TForm> = (data: (previousData: TForm) => TForm) => void
-type setDataByKeyValuePair<TForm> = <K extends keyof TForm>(key: K, value: TForm[K]) => void
-
-export interface InertiaFormProps<TForm extends Record<string, unknown>> {
-  data: TForm
-  isDirty: boolean
-  errors: Partial<Record<keyof TForm, string>>
-  hasErrors: boolean
-  processing: boolean
-  progress: Progress | null
-  wasSuccessful: boolean
-  recentlySuccessful: boolean
-  setData: setDataByObject<TForm> & setDataByMethod<TForm> & setDataByKeyValuePair<TForm>
-  transform: (callback: (data: TForm) => TForm) => void
-  setDefaults(): void
-  setDefaults(field: keyof TForm, value: string): void
-  setDefaults(fields: Record<keyof TForm, string>): void
-  reset: (...fields: (keyof TForm)[]) => void
-  clearErrors: (...fields: (keyof TForm)[]) => void
-  setError(field: keyof TForm, value: string): void
-  setError(errors: Record<keyof TForm, string>): void
-  submit: (method: Method, url: string, options?: VisitOptions) => void
-  get: (url: string, options?: VisitOptions) => void
-  patch: (url: string, options?: VisitOptions) => void
-  post: (url: string, options?: VisitOptions) => void
-  put: (url: string, options?: VisitOptions) => void
-  delete: (url: string, options?: VisitOptions) => void
-  cancel: () => void
-}
-export default function useForm<TForm extends Record<string, unknown>>(initialValues?: TForm): InertiaFormProps<TForm>
-export default function useForm<TForm extends Record<string, unknown>>(
-  rememberKey: string,
-  initialValues?: TForm,
-): InertiaFormProps<TForm>
-export default function useForm<TForm extends Record<string, unknown>>(
-  rememberKeyOrInitialValues?: string | TForm,
-  maybeInitialValues?: TForm,
-): InertiaFormProps<TForm> {
-  const isMounted = useRef(null)
-  const rememberKey = typeof rememberKeyOrInitialValues === 'string' ? rememberKeyOrInitialValues : null
-  const [defaults, setDefaults] = useState(
-    (typeof rememberKeyOrInitialValues === 'string' ? maybeInitialValues : rememberKeyOrInitialValues) || ({} as TForm),
-  )
-  const cancelToken = useRef(null)
-  const recentlySuccessfulTimeoutId = useRef(null)
-  const [data, setData] = rememberKey ? useRemember(defaults, `${rememberKey}:data`) : useState(defaults)
-  const [errors, setErrors] = rememberKey
-    ? useRemember({} as Partial<Record<keyof TForm, string>>, `${rememberKey}:errors`)
-    : useState({} as Partial<Record<keyof TForm, string>>)
-  const [hasErrors, setHasErrors] = useState(false)
-  const [processing, setProcessing] = useState(false)
-  const [progress, setProgress] = useState(null)
-  const [wasSuccessful, setWasSuccessful] = useState(false)
-  const [recentlySuccessful, setRecentlySuccessful] = useState(false)
-  let transform = (data) => data
-
-  useEffect(() => {
-    isMounted.current = true
-    return () => {
-      isMounted.current = false
-    }
-  }, [])
-
-  const submit = useCallback(
-    (method, url, options = {}) => {
-      const _options = {
-        ...options,
-        onCancelToken: (token) => {
-          cancelToken.current = token
-
-          if (options.onCancelToken) {
-            return options.onCancelToken(token)
-          }
-        },
-        onBefore: (visit) => {
-          setWasSuccessful(false)
-          setRecentlySuccessful(false)
-          clearTimeout(recentlySuccessfulTimeoutId.current)
-
-          if (options.onBefore) {
-            return options.onBefore(visit)
-          }
-        },
-        onStart: (visit) => {
-          setProcessing(true)
-
-          if (options.onStart) {
-            return options.onStart(visit)
-          }
-        },
-        onProgress: (event) => {
-          setProgress(event)
-
-          if (options.onProgress) {
-            return options.onProgress(event)
-          }
-        },
-        onSuccess: (page) => {
-          if (isMounted.current) {
-            setProcessing(false)
-            setProgress(null)
-            setErrors({})
-            setHasErrors(false)
-            setWasSuccessful(true)
-            setRecentlySuccessful(true)
-            recentlySuccessfulTimeoutId.current = setTimeout(() => {
-              if (isMounted.current) {
-                setRecentlySuccessful(false)
-              }
-            }, 2000)
-          }
-
-          if (options.onSuccess) {
-            return options.onSuccess(page)
-          }
-        },
-        onError: (errors) => {
-          if (isMounted.current) {
-            setProcessing(false)
-            setProgress(null)
-            setErrors(errors)
-            setHasErrors(true)
-          }
-
-          if (options.onError) {
-            return options.onError(errors)
-          }
-        },
-        onCancel: () => {
-          if (isMounted.current) {
-            setProcessing(false)
-            setProgress(null)
-          }
-
-          if (options.onCancel) {
-            return options.onCancel()
-          }
-        },
-        onFinish: () => {
-          if (isMounted.current) {
-            setProcessing(false)
-            setProgress(null)
-          }
-
-          cancelToken.current = null
-
-          if (options.onFinish) {
-            return options.onFinish()
-          }
-        },
-      }
-
-      if (method === 'delete') {
-        router.delete(url, { ..._options, data: transform(data) })
-      } else {
-        router[method](url, transform(data), _options)
-      }
-    },
-    [data, setErrors],
-  )
-
-  return {
-    data,
-    setData(keyOrData: keyof TForm | Function | TForm, maybeValue?: TForm[keyof TForm]) {
-      if (typeof keyOrData === 'string') {
-        setData({ ...data, [keyOrData]: maybeValue })
-      } else if (typeof keyOrData === 'function') {
-        setData((data) => keyOrData(data))
-      } else {
-        setData(keyOrData as TForm)
-      }
-    },
-    isDirty: !isEqual(data, defaults),
-    errors,
-    hasErrors,
-    processing,
-    progress,
-    wasSuccessful,
-    recentlySuccessful,
-    transform(callback) {
-      transform = callback
-    },
-    setDefaults(fieldOrFields?: keyof TForm | Record<keyof TForm, string>, maybeValue?: string) {
-      if (typeof fieldOrFields === 'undefined') {
-        setDefaults(() => data)
-      } else {
-        setDefaults((defaults) => ({
-          ...defaults,
-          ...(typeof fieldOrFields === 'string' ? { [fieldOrFields]: maybeValue } : (fieldOrFields as TForm)),
-        }))
-      }
-    },
-    reset(...fields) {
-      if (fields.length === 0) {
-        setData(defaults)
-      } else {
-        setData(
-          (Object.keys(defaults) as Array<keyof TForm>)
-            .filter((key) => fields.includes(key))
-            .reduce(
-              (carry, key) => {
-                carry[key] = defaults[key]
-                return carry
-              },
-              { ...data },
-            ),
-        )
-      }
-    },
-    setError(fieldOrFields: keyof TForm | Record<keyof TForm, string>, maybeValue?: string) {
-      setErrors((errors) => {
-        const newErrors = {
-          ...errors,
-          ...(typeof fieldOrFields === 'string'
-            ? { [fieldOrFields]: maybeValue }
-            : (fieldOrFields as Record<keyof TForm, string>)),
-        }
-        setHasErrors(Object.keys(newErrors).length > 0)
-        return newErrors
-      })
-    },
-    clearErrors(...fields) {
-      setErrors((errors) => {
-        const newErrors = (Object.keys(errors) as Array<keyof TForm>).reduce(
-          (carry, field) => ({
-            ...carry,
-            ...(fields.length > 0 && !fields.includes(field) ? { [field]: errors[field] } : {}),
-          }),
-          {},
-        )
-        setHasErrors(Object.keys(newErrors).length > 0)
-        return newErrors
-      })
-    },
-    submit,
-    get(url, options) {
-      submit('get', url, options)
-    },
-    post(url, options) {
-      submit('post', url, options)
-    },
-    put(url, options) {
-      submit('put', url, options)
-    },
-    patch(url, options) {
-      submit('patch', url, options)
-    },
-    delete(url, options) {
-      submit('delete', url, options)
-    },
-    cancel() {
-      if (cancelToken.current) {
-        cancelToken.current.cancel()
-      }
-    },
-  }
-}

package/src/usePage.ts

@@ -1,13 +0,0 @@
-import { Page } from '@inertiajs/core'
-import { useContext } from 'react'
-import PageContext from './PageContext'
-
-export default function usePage(): Page {
-  const page = useContext(PageContext)
-
-  if (!page) {
-    throw new Error('usePage must be used within the Inertia component')
-  }
-
-  return page
-}

package/src/useRemember.ts

@@ -1,27 +0,0 @@
-import { router } from '@inertiajs/core'
-import { Dispatch, SetStateAction, useEffect, useState } from 'react'
-
-export default function useRemember<State>(
-  initialState: State,
-  key?: string,
-): [State, Dispatch<SetStateAction<State>>] {
-  const [state, setState] = useState(() => {
-    const restored = router.restore(key) as State
-
-    return restored !== undefined ? restored : initialState
-  })
-
-  useEffect(() => {
-    router.remember(state, key)
-  }, [state, key])
-
-  return [state, setState]
-}
-
-/** @deprecated use `useRemember` instead */
-export function useRememberedState<State>(initialState: State, key?: string): [State, Dispatch<SetStateAction<State>>] {
-  console.warn(
-    'The "useRememberedState" hook has been deprecated and will be removed in a future release. Use "useRemember" instead.',
-  )
-  return useRemember(initialState, key)
-}

package/tsconfig.json

@@ -1,27 +0,0 @@
-{
-  "include": ["src/index.ts"],
-  "compilerOptions": {
-    "rootDir": "src",
-    "noEmitOnError": true,
-
-    "lib": ["DOM", "DOM.Iterable", "ES2020"],
-    "target": "ES2020",
-    "types": ["node"],
-
-    "declaration": true,
-    "declarationDir": "types",
-
-    "module": "ES2020",
-    "moduleResolution": "Node",
-    "resolveJsonModule": true,
-    "allowSyntheticDefaultImports": true,
-
-    "noImplicitThis": false,
-    "noUnusedLocals": true,
-    "noUnusedParameters": true,
-    "preserveConstEnums": true,
-    "removeComments": true,
-    "typeRoots": ["./node_modules/@types"]
-    // "strict": true
-  }
-}