@tanstack/svelte-form 1.33.4 → 2.0.0-alpha.0

package/dist/AppForm/AppForm.svelte

@@ -0,0 +1,14 @@
+<script lang="ts">
+  import { setContext, untrack, type Snippet } from 'svelte'
+  import { formContextKey } from '../context-keys.js'
+
+  interface Props {
+    form: any
+    children: Snippet
+  }
+
+  const { children, form }: Props = $props()
+  setContext(formContextKey, untrack(() => form))
+</script>
+
+{@render children()}

package/dist/AppForm/Components.lib.d.ts

@@ -0,0 +1,7 @@
+import type { AnyInternalFormApi } from '@tanstack/form-core/internals';
+import type { Component } from 'svelte';
+import type { AnySvelteFormComponentMap } from './componentMap.public';
+import type { SvelteAppFormApi } from './SvelteAppFormApi.public';
+type AnySvelteAppFormApi = SvelteAppFormApi<any, any, AnySvelteFormComponentMap>;
+export declare function attachSvelteAppFormComponents(form: AnyInternalFormApi, formComponents: Record<string, Component<any>>, fieldComponents: Record<string, Component<any>>): AnySvelteAppFormApi;
+export {};

package/dist/AppForm/Components.lib.js

@@ -0,0 +1,8 @@
+import { attachSvelteFormComponents } from '../createForm.svelte';
+import { withComponentProps } from '../utils.lib.js';
+import AppForm from './AppForm.svelte';
+export function attachSvelteAppFormComponents(form, formComponents, fieldComponents) {
+    const result = attachSvelteFormComponents(form, fieldComponents);
+    result.AppForm = ((internals, props) => AppForm(internals, withComponentProps(props, { form: result })));
+    return Object.assign(result, formComponents);
+}

package/dist/AppForm/SvelteAppFormApi.public.d.ts

@@ -0,0 +1,10 @@
+import type { FormErrorTypes } from '@tanstack/form-core';
+import type { Component, Snippet } from 'svelte';
+import type { SvelteFormApi } from '../formApiTypes.public';
+import type { AnySvelteFormComponentMap } from './componentMap.public';
+export type AppFormComponent = Component<{
+    children: Snippet;
+}>;
+export type SvelteAppFormApi<TFormData, TFormErrorTypes extends FormErrorTypes, TComponents extends AnySvelteFormComponentMap> = SvelteFormApi<TFormData, TFormErrorTypes, TComponents> & {
+    AppForm: AppFormComponent;
+};

package/dist/AppForm/appFormOptions.public.d.ts

@@ -0,0 +1,12 @@
+import type { FormOptions, FormValidatorData, FormValidators, InferUnion, NullableSchemaData } from '@tanstack/form-core';
+import type { AnySvelteFormComponentMap } from './componentMap.public';
+declare const componentsSymbol: unique symbol;
+export interface AppFormOptions<TFormData, TFormValidators extends FormValidators<TFormData>, TSubmitReturn, TComponents extends AnySvelteFormComponentMap> extends FormOptions<TFormData, TFormValidators, TSubmitReturn> {
+    [componentsSymbol]: TComponents;
+}
+export interface AppFormOptionsApi<TComponents extends AnySvelteFormComponentMap> {
+    <TFormData, const TFormValidators extends FormValidators<TFormData>, TSubmitReturn>(options: FormOptions<TFormData, TFormValidators, TSubmitReturn>): AppFormOptions<TFormData, TFormValidators, TSubmitReturn, TComponents>;
+    strictSchema: <const TFormValidators extends FormValidators<any>, TFormData extends FormValidatorData<TFormValidators>, TSubmitReturn>(options: FormOptions<TFormData, TFormValidators, TSubmitReturn>) => AppFormOptions<FormValidatorData<TFormValidators>, TFormValidators, TSubmitReturn, TComponents>;
+    looseSchema: <const TFormValidators extends FormValidators<any>, const TFormData extends NullableSchemaData<TFormValidators>, TSubmitReturn>(options: FormOptions<TFormData, TFormValidators, TSubmitReturn>) => AppFormOptions<InferUnion<TFormData, FormValidatorData<TFormValidators>>, TFormValidators, TSubmitReturn, TComponents>;
+}
+export {};

package/dist/AppForm/appFormOptions.public.js

@@ -0,0 +1 @@
+export {};

package/dist/AppForm/componentMap.public.d.ts

@@ -0,0 +1,7 @@
+import type { Component } from 'svelte';
+export interface SvelteFormComponentMap<TFormComponents extends Record<string, Component<any>>, TFieldComponents extends Record<string, Component<any>>> {
+    formComponents: TFormComponents;
+    fieldComponents: TFieldComponents;
+}
+export type AnySvelteFormComponentMap = SvelteFormComponentMap<Record<string, Component<any>>, Record<string, Component<any>>>;
+export type DefaultSvelteFormComponentMap = SvelteFormComponentMap<Record<never, never>, Record<never, never>>;

package/dist/AppForm/componentMap.public.js

@@ -0,0 +1 @@
+export {};

package/dist/AppForm/contexts.lib.d.ts

@@ -0,0 +1,4 @@
+import type { AnyInternalFieldApi } from '@tanstack/form-core/internals';
+import type { InternalSvelteFormApi } from '../createForm.svelte.js';
+export declare function useFieldContext(): AnyInternalFieldApi;
+export declare function useFormContext(): InternalSvelteFormApi;

package/dist/AppForm/contexts.lib.js

@@ -0,0 +1,16 @@
+import { getContext } from 'svelte';
+import { fieldContextKey, formContextKey } from '../context-keys.js';
+export function useFieldContext() {
+    const field = getContext(fieldContextKey);
+    if (field === undefined) {
+        throw new Error('TanStack Form: Field components must be used within a `form.Field` component.');
+    }
+    return field;
+}
+export function useFormContext() {
+    const form = getContext(formContextKey);
+    if (form === undefined) {
+        throw new Error('TanStack Form: Form components must be used within a `form.AppForm` component.');
+    }
+    return form;
+}

package/dist/AppForm/createFormHook.public.d.ts

@@ -0,0 +1,3 @@
+import type { AnySvelteFormComponentMap } from './componentMap.public';
+import type { AppFormHookResult } from './createFormHookTypes.public';
+export declare function createFormHook<const TComponents extends AnySvelteFormComponentMap>(createOptions: TComponents): AppFormHookResult<TComponents>;

package/dist/AppForm/createFormHook.public.js

@@ -0,0 +1,20 @@
+import { createInternalForm } from '../createForm.svelte';
+import { defineFieldGroup } from '../FieldGroup/withFields.public';
+import { createAppFormInitializer } from './initializeAppForm.lib';
+import { useFormContext } from './contexts.lib';
+const appFormOptions = ((opts) => opts);
+appFormOptions.strictSchema = (opts) => opts;
+appFormOptions.looseSchema = (opts) => opts;
+export function createFormHook(createOptions) {
+    const initializeAppForm = createAppFormInitializer(createOptions);
+    function useExtendedForm(options) {
+        return createInternalForm(options, initializeAppForm);
+    }
+    const useAppForm = useExtendedForm;
+    return {
+        useFormContext: useFormContext,
+        appFormOptions,
+        defineAppFieldGroup: defineFieldGroup,
+        useAppForm,
+    };
+}

package/dist/AppForm/createFormHookTypes.public.d.ts

@@ -0,0 +1,12 @@
+import type { AppFormOptionsApi } from './appFormOptions.public';
+import type { AnySvelteFormComponentMap } from './componentMap.public';
+import type { SvelteAppFormApi } from './SvelteAppFormApi.public';
+import type { DefineFieldGroupFn } from '../FieldGroup/withFields.public';
+import type { FormOptions, FormValidators, ToFormErrorTypes } from '@tanstack/form-core';
+export type UseAppFormHook<TComponents extends AnySvelteFormComponentMap> = <TFormData, TFormValidators extends FormValidators<TFormData>, TSubmitReturn>(options: () => FormOptions<TFormData, TFormValidators, TSubmitReturn>) => SvelteAppFormApi<TFormData, ToFormErrorTypes<TFormValidators, TSubmitReturn>, TComponents>;
+export interface AppFormHookResult<TComponents extends AnySvelteFormComponentMap> {
+    appFormOptions: AppFormOptionsApi<TComponents>;
+    defineAppFieldGroup: DefineFieldGroupFn<TComponents['fieldComponents']>;
+    useAppForm: UseAppFormHook<TComponents>;
+    useFormContext: () => SvelteAppFormApi<any, any, TComponents>;
+}

package/dist/AppForm/createFormHookTypes.public.js

@@ -0,0 +1 @@
+export {};

package/dist/AppForm/fieldComponentHelpers.lib.d.ts

@@ -0,0 +1,5 @@
+import type { Component } from 'svelte';
+type AnyFieldComponent = Component<any>;
+export declare function wrapField(Component: AnyFieldComponent, fieldPropKey: string): AnyFieldComponent;
+export declare function brandComponentFactory(): (component: AnyFieldComponent) => AnyFieldComponent;
+export {};

package/dist/AppForm/fieldComponentHelpers.lib.js

@@ -0,0 +1,10 @@
+import { withComponentProps } from '../utils.lib.js';
+import { useFieldContext } from './contexts.lib';
+export function wrapField(Component, fieldPropKey) {
+    return ((internals, props) => Component(internals, withComponentProps(props, {
+        [fieldPropKey]: useFieldContext(),
+    })));
+}
+export function brandComponentFactory() {
+    return (component) => component;
+}

package/dist/AppForm/getFormHookHelpers.public.d.ts

@@ -0,0 +1,31 @@
+import type { Component, ComponentProps } from 'svelte';
+import type { FieldWithValue } from '@tanstack/form-core';
+type ExactFieldBrand<out TValue> = {
+    readonly __tanstackFieldExactType: TValue;
+};
+type AcceptsFieldBrand<out TAcceptedValue> = {
+    readonly __tanstackFieldAcceptsType: TAcceptedValue;
+};
+type AnyFieldComponent = Component<any>;
+type PropsOf<TComponent extends AnyFieldComponent> = ComponentProps<TComponent>;
+type FieldValuePropKeys<TProps> = {
+    [K in keyof TProps]-?: TProps[K] extends FieldWithValue<any> ? K : never;
+}[keyof TProps];
+type FieldValueFromProp<TProp> = TProp extends FieldWithValue<infer TValue> ? TValue : never;
+type PublicPropsReplacingField<TProps, TFieldPropKey extends keyof TProps> = Omit<TProps, TFieldPropKey>;
+type StrictInjectedFieldComponent<TComponent extends AnyFieldComponent, TProps = PropsOf<TComponent>, TFieldPropKey extends FieldValuePropKeys<TProps> = FieldValuePropKeys<TProps>> = Component<PublicPropsReplacingField<TProps, TFieldPropKey>> & ExactFieldBrand<FieldValueFromProp<TProps[TFieldPropKey]>>;
+type LooseInjectedFieldComponent<TComponent extends AnyFieldComponent, TProps = PropsOf<TComponent>, TFieldPropKey extends FieldValuePropKeys<TProps> = FieldValuePropKeys<TProps>> = Component<PublicPropsReplacingField<TProps, TFieldPropKey>> & AcceptsFieldBrand<FieldValueFromProp<TProps[TFieldPropKey]>>;
+interface FieldComponentHelper {
+    strict: <TComponent extends AnyFieldComponent, TProps = PropsOf<TComponent>, TFieldPropKey extends FieldValuePropKeys<TProps> = FieldValuePropKeys<TProps>>(Component: TComponent, fieldPropKey: TFieldPropKey) => StrictInjectedFieldComponent<TComponent, TProps, TFieldPropKey>;
+    loose: <TComponent extends AnyFieldComponent, TProps = PropsOf<TComponent>, TFieldPropKey extends FieldValuePropKeys<TProps> = FieldValuePropKeys<TProps>>(Component: TComponent, fieldPropKey: TFieldPropKey) => LooseInjectedFieldComponent<TComponent, TProps, TFieldPropKey>;
+}
+interface FieldBrandHelper {
+    strict: <TValue>() => <TComponent extends AnyFieldComponent>(component: TComponent) => TComponent & ExactFieldBrand<TValue>;
+    loose: <TValue>() => <TComponent extends AnyFieldComponent>(component: TComponent) => TComponent & AcceptsFieldBrand<TValue>;
+}
+export interface FormHookHelpers {
+    fieldBrand: FieldBrandHelper;
+    fieldComponent: FieldComponentHelper;
+}
+export declare function getFormHookHelpers(): FormHookHelpers;
+export {};

package/dist/AppForm/getFormHookHelpers.public.js

@@ -0,0 +1,13 @@
+import { brandComponentFactory, wrapField } from './fieldComponentHelpers.lib';
+export function getFormHookHelpers() {
+    return {
+        fieldComponent: {
+            strict: wrapField,
+            loose: wrapField,
+        },
+        fieldBrand: {
+            strict: brandComponentFactory,
+            loose: brandComponentFactory,
+        },
+    };
+}

package/dist/AppForm/initializeAppForm.lib.d.ts

@@ -0,0 +1,4 @@
+import type { FormOptions } from '@tanstack/form-core';
+import type { InternalSvelteFormApi } from '../createForm.svelte.js';
+import type { AnySvelteFormComponentMap } from './componentMap.public';
+export declare function createAppFormInitializer<TComponents extends AnySvelteFormComponentMap>(createOptions: TComponents): (options: FormOptions<any, any, any>) => InternalSvelteFormApi;

package/dist/AppForm/initializeAppForm.lib.js

@@ -0,0 +1,5 @@
+import { InternalFormApi } from '@tanstack/form-core/internals';
+import { attachSvelteAppFormComponents } from './Components.lib';
+export function createAppFormInitializer(createOptions) {
+    return (options) => attachSvelteAppFormComponents(new InternalFormApi(options), createOptions.formComponents, createOptions.fieldComponents);
+}

package/dist/Components.public.d.ts

@@ -0,0 +1,52 @@
+import type { DeepKeys, DeepKeysWhereValueIncludes, DeepValue, FieldApi, FieldApiOptions, FieldValidators, FormErrorTypes, FormGroupApi, FormGroupOptions, FormGroupState, FormGroupValidators, FormState, ToFieldError, ToFormGroupErrorTypes } from '@tanstack/form-core';
+import type { Component, ComponentConstructorOptions, Snippet, SvelteComponent } from 'svelte';
+export type WithoutFunction<T> = {
+    [K in keyof T as T[K] extends Function ? never : K]: T[K];
+};
+type ExactFieldBrand<out TValue> = {
+    readonly __tanstackFieldExactType: TValue;
+};
+type AcceptsFieldBrand<out TAcceptedValue> = {
+    readonly __tanstackFieldAcceptsType: TAcceptedValue;
+};
+type CompatibleFieldKey<TKey, TComponent, TTargetValue> = TComponent extends ExactFieldBrand<infer TExact> ? [TExact] extends [TTargetValue] ? [TTargetValue] extends [TExact] ? TKey : never : never : TComponent extends AcceptsFieldBrand<infer TLoose> ? [TTargetValue] extends [TLoose] ? TKey : never : TKey;
+type FilteredFieldComponents<TFieldComponents extends Record<string, Component<any>>, TTargetValue> = {
+    [K in keyof TFieldComponents as CompatibleFieldKey<K, TFieldComponents[K], TTargetValue>]: TFieldComponents[K];
+};
+type FieldComponentsMatchingType<TFieldComponents extends Record<string, Component<any>>, TTargetValue> = unknown extends TTargetValue ? TFieldComponents : string extends keyof TFieldComponents ? TFieldComponents : FilteredFieldComponents<TFieldComponents, TTargetValue>;
+export type SvelteFieldApi<TFieldName, TFieldValue, TFieldError, TFormData, TFormErrorTypes extends FormErrorTypes, TFieldComponents extends Record<string, Component<any>>> = FieldApi<TFieldName, TFieldValue, TFieldError, TFormData, TFormErrorTypes> & FieldComponentsMatchingType<TFieldComponents, TFieldValue>;
+interface SvelteSubscribeProps<TSourceData, TSelected> {
+    selector: (state: TSourceData) => TSelected;
+    when?: (selected: NoInfer<TSelected>) => boolean;
+    children: Snippet<[NoInfer<TSelected>]>;
+}
+export type SvelteFormSubscribeProps<TFormData, TFormErrorTypes extends FormErrorTypes, TSelected> = SvelteSubscribeProps<FormState<TFormData, TFormErrorTypes>, TSelected>;
+export type SvelteFormSubscribeComponent<TFormData, TFormErrorTypes extends FormErrorTypes> = (new <TSelected>(options: ComponentConstructorOptions<SvelteFormSubscribeProps<TFormData, TFormErrorTypes, TSelected>>) => SvelteComponent) & Component<any> & WithoutFunction<Component>;
+export interface SvelteFormFieldProps<TFieldData, TFieldName, TFieldValue, TFieldValidators extends FieldValidators<TFieldData, TFieldName, TFieldValue>, TGroupFieldError, TFormData, TFormErrorTypes extends FormErrorTypes, TFieldComponents extends Record<string, Component<any>>> extends FieldApiOptions<TFieldData, TFieldName, TFieldValue, TFieldValidators, TGroupFieldError, TFormData, TFormErrorTypes> {
+    children: Snippet<[
+        SvelteFieldApi<TFieldName, TFieldValue, ToFieldError<NoInfer<TFieldValidators>, TGroupFieldError, TFormErrorTypes>, TFormData, TFormErrorTypes, TFieldComponents>
+    ]>;
+}
+export type SvelteFormFieldComponent<TFormData, TFormErrorTypes extends FormErrorTypes, TFieldComponents extends Record<string, Component<any>>> = (new <TFieldName extends DeepKeys<TFormData>, const TFieldValidators extends FieldValidators<TFormData, TFieldName, DeepValue<TFormData, TFieldName>>>(options: ComponentConstructorOptions<SvelteFormFieldProps<TFormData, TFieldName, DeepValue<TFormData, TFieldName>, TFieldValidators, never, TFormData, TFormErrorTypes, TFieldComponents>>) => SvelteComponent) & Component<any> & WithoutFunction<Component>;
+export type SvelteFormArrayFieldComponent<TFormData, TFormErrorTypes extends FormErrorTypes, TFieldComponents extends Record<string, Component<any>>> = (new <TFieldName extends DeepKeysWhereValueIncludes<TFormData, Array<any>>, const TFieldValidators extends FieldValidators<TFormData, TFieldName, DeepValue<TFormData, TFieldName>>>(options: ComponentConstructorOptions<SvelteFormFieldProps<TFormData, TFieldName, DeepValue<TFormData, TFieldName>, TFieldValidators, never, TFormData, TFormErrorTypes, TFieldComponents>>) => SvelteComponent) & Component<any> & WithoutFunction<Component>;
+export type SvelteFormGroupSubscribeComponent<TGroupValue, TGroupErrorTypes extends FormErrorTypes> = (new <TSelected>(options: ComponentConstructorOptions<SvelteSubscribeProps<FormGroupState<TGroupValue, TGroupErrorTypes>, TSelected>>) => SvelteComponent) & Component<any> & WithoutFunction<Component>;
+export type SvelteFormGroupFieldComponent<TFormData, TGroupValue, TGroupErrorTypes extends FormErrorTypes, TFormErrorTypes extends FormErrorTypes, TFieldComponents extends Record<string, Component<any>>> = (new <TFieldName extends DeepKeys<TGroupValue>, const TFieldValidators extends FieldValidators<TGroupValue, TFieldName, DeepValue<TGroupValue, TFieldName>>>(options: ComponentConstructorOptions<SvelteFormFieldProps<TGroupValue, TFieldName, DeepValue<TGroupValue, TFieldName>, TFieldValidators, TGroupErrorTypes['fieldError'], TFormData, TFormErrorTypes, TFieldComponents>>) => SvelteComponent) & Component<any> & WithoutFunction<Component>;
+export type SvelteFormGroupArrayFieldComponent<TFormData, TGroupValue, TGroupErrorTypes extends FormErrorTypes, TFormErrorTypes extends FormErrorTypes, TFieldComponents extends Record<string, Component<any>>> = (new <TFieldName extends DeepKeysWhereValueIncludes<TGroupValue, Array<any>>, const TFieldValidators extends FieldValidators<TGroupValue, TFieldName, DeepValue<TGroupValue, TFieldName>>>(options: ComponentConstructorOptions<SvelteFormFieldProps<TGroupValue, TFieldName, DeepValue<TGroupValue, TFieldName>, TFieldValidators, TGroupErrorTypes['fieldError'], TFormData, TFormErrorTypes, TFieldComponents>>) => SvelteComponent) & Component<any> & WithoutFunction<Component>;
+export interface SvelteFormGroupApi<TFormData, TGroupName, TGroupValue, TGroupErrorTypes extends FormErrorTypes, TFormErrorTypes extends FormErrorTypes, TFieldComponents extends Record<string, Component<any>>> extends FormGroupApi<TFormData, TGroupName, TGroupValue, TGroupErrorTypes, TFormErrorTypes> {
+    Field: SvelteFormGroupFieldComponent<TFormData, TGroupValue, TGroupErrorTypes, TFormErrorTypes, TFieldComponents>;
+    ArrayField: SvelteFormGroupArrayFieldComponent<TFormData, TGroupValue, TGroupErrorTypes, TFormErrorTypes, TFieldComponents>;
+    Subscribe: SvelteFormGroupSubscribeComponent<TGroupValue, TGroupErrorTypes>;
+}
+export interface SvelteFormGroupProps<TFormData, TGroupName, TGroupValue, TGroupValidators extends FormGroupValidators<TGroupValue>, TFormErrorTypes extends FormErrorTypes, TFieldComponents extends Record<string, Component<any>>> extends Omit<FormGroupOptions<TFormData, TGroupName, TGroupValue, TGroupValidators, TFormErrorTypes>, 'form'> {
+    children: Snippet<[
+        SvelteFormGroupApi<TFormData, TGroupName, TGroupValue, ToFormGroupErrorTypes<NoInfer<TGroupValidators>>, TFormErrorTypes, TFieldComponents>
+    ]>;
+}
+export type SvelteFormGroupComponent<TFormData, TFormErrorTypes extends FormErrorTypes, TFieldComponents extends Record<string, Component<any>>> = (new <TGroupName extends DeepKeys<TFormData>, TGroupValue extends DeepValue<TFormData, TGroupName>, const TGroupValidators extends FormGroupValidators<TGroupValue>>(options: ComponentConstructorOptions<SvelteFormGroupProps<TFormData, TGroupName, TGroupValue, TGroupValidators, TFormErrorTypes, TFieldComponents>>) => SvelteComponent) & Component<any> & WithoutFunction<Component>;
+export interface SvelteTanStackFormComponents<TFormData, TFormErrorTypes extends FormErrorTypes, TFieldComponents extends Record<string, Component<any>> = Record<never, never>> {
+    Field: SvelteFormFieldComponent<TFormData, TFormErrorTypes, TFieldComponents>;
+    ArrayField: SvelteFormArrayFieldComponent<TFormData, TFormErrorTypes, TFieldComponents>;
+    Subscribe: SvelteFormSubscribeComponent<TFormData, TFormErrorTypes>;
+    FormGroup: SvelteFormGroupComponent<TFormData, TFormErrorTypes, TFieldComponents>;
+}
+export {};

package/dist/Components.public.js

@@ -0,0 +1 @@
+export {};