oxform-core 0.1.0 → 0.1.1

package/src/form-array-field-api.ts

@@ -1,233 +0,0 @@
-import { defaultMeta } from '#field-api.constants';
-import type { FieldChangeOptions } from '#form-api.types';
-import type { FormContextApi } from '#form-context-api';
-import type { FormFieldApi } from '#form-field-api';
-import type { DeepKeysOfType, DeepValue, UnwrapOneLevelOfArray } from '#more-types';
-import type { StandardSchema } from '#types';
-import { get } from '#utils/get';
-import { update, type Updater } from '#utils/update';
-import { stringToPath } from 'remeda';
-
-export class FormArrayFieldApi<
-  Schema extends StandardSchema<any>,
-  Values extends StandardSchema.InferInput<Schema> = StandardSchema.InferInput<Schema>,
-  ArrayField extends DeepKeysOfType<Values, any[] | null | undefined> = DeepKeysOfType<
-    Values,
-    any[] | null | undefined
-  >,
-> {
-  private context: FormContextApi<Schema>;
-  private field: FormFieldApi<Schema>;
-
-  constructor({ field, context }: { field: FormFieldApi<Schema>; context: FormContextApi<Schema> }) {
-    this.context = context;
-    this.field = field;
-  }
-
-  public insert = <Name extends ArrayField>(
-    name: Name,
-    index: number,
-    value: Updater<UnwrapOneLevelOfArray<DeepValue<Values, Name>>>,
-    options?: FieldChangeOptions,
-  ) => {
-    if (index < 0) index = 0;
-
-    this.field.change(
-      name,
-      current => {
-        const array = (current as any[]) ?? [];
-
-        return [
-          ...array.slice(0, index),
-          ...(Array.from({ length: index - array.length }, () => undefined) as any[]),
-          update(value, current as never),
-          ...array.slice(index),
-        ] as never;
-      },
-      options,
-    );
-
-    this.context.persisted.setState(current => {
-      const fields = { ...current.fields };
-      const value = get(current.values as never, stringToPath(name)) as any[] | undefined;
-      const length = value?.length;
-
-      if (length === undefined) return current;
-
-      for (let i = index; i < length; i++) {
-        const moving = current.fields[`${name}.${i}`];
-        fields[`${name}.${i + 1}`] = moving ?? defaultMeta;
-      }
-
-      fields[`${name}.${index}`] = defaultMeta;
-
-      return {
-        ...current,
-        fields,
-      };
-    });
-  };
-
-  public append = <Name extends ArrayField>(
-    name: Name,
-    value: UnwrapOneLevelOfArray<DeepValue<Values, Name>>,
-    options?: FieldChangeOptions,
-  ) => {
-    const current = this.field.get(name) as any[];
-    return this.insert(name, current?.length ?? 0, value, options);
-  };
-
-  public prepend = <Name extends ArrayField>(
-    name: Name,
-    value: UnwrapOneLevelOfArray<DeepValue<Values, Name>>,
-    options?: FieldChangeOptions,
-  ) => {
-    return this.insert(name, 0, value, options);
-  };
-
-  public swap = <Name extends ArrayField>(name: Name, from: number, to: number, options?: FieldChangeOptions) => {
-    const start = from >= 0 ? from : 0;
-    const end = to >= 0 ? to : 0;
-
-    this.field.change(
-      name,
-      current => {
-        const array = (current as any[]) ?? [];
-
-        if (start === end) return array as never; // no-op
-
-        const a = array[start];
-        const b = array[end];
-
-        return [...array.slice(0, start), b, ...array.slice(start + 1, end), a, ...array.slice(end + 1)] as never;
-      },
-      options,
-    );
-
-    this.context.persisted.setState(current => {
-      const fields = { ...current.fields };
-
-      fields[`${name}.${start}`] = current.fields[`${name}.${end}`] ?? defaultMeta;
-      fields[`${name}.${end}`] = current.fields[`${name}.${start}`] ?? defaultMeta;
-
-      return {
-        ...current,
-        fields,
-      };
-    });
-  };
-
-  public move<Name extends ArrayField>(name: Name, _from: number, _to: number, options?: FieldChangeOptions) {
-    const from = Math.max(_from, 0);
-    const to = Math.max(_to, 0);
-    const backwards = from > to;
-
-    this.field.change(
-      name,
-      current => {
-        const array: any[] = current ? [...(current as any[])] : [];
-
-        if (from === to) return array as never;
-
-        const moved = array[from];
-        return array.toSpliced(backwards ? to : to + 1, 0, moved).toSpliced(backwards ? from + 1 : from, 1) as never;
-      },
-      options,
-    );
-
-    this.context.persisted.setState(current => {
-      const fields = { ...current.fields };
-      const value = get(current.values as never, stringToPath(name)) as any[] | undefined;
-      const length = value?.length;
-
-      const start = Math.min(from, to);
-      const end = Math.max(from, to);
-
-      if (length === undefined) return current;
-
-      if (!backwards) {
-        fields[`${name}.${to}`] = current.fields[`${name}.${from}`] ?? defaultMeta;
-      }
-
-      for (let i = backwards ? start + 1 : start; i < end; i++) {
-        const shift = backwards ? -1 : 1;
-        const moving = current.fields[`${name}.${i + shift}`];
-        fields[`${name}.${i}`] = moving ?? defaultMeta;
-      }
-
-      return {
-        ...current,
-        fields,
-      };
-    });
-  }
-
-  public update = <Name extends ArrayField>(
-    name: Name,
-    index: number,
-    value: Updater<UnwrapOneLevelOfArray<DeepValue<Values, Name>>>,
-    options?: FieldChangeOptions,
-  ) => {
-    this.field.change(
-      name,
-      current => {
-        const array = (current as any[]) ?? [];
-        const position = Math.max(Math.min(index, array.length - 1), 0);
-
-        return [...array.slice(0, position), update(value, current as never), ...array.slice(position + 1)] as never;
-      },
-      options,
-    );
-
-    this.context.resetFieldMeta(`${name}.${index}`);
-    this.context.setFieldMeta(`${name}.${index}`, {
-      dirty: options?.should?.dirty !== false,
-      touched: options?.should?.touch !== false,
-    });
-  };
-
-  public remove<Name extends ArrayField>(name: Name, index: number, options?: FieldChangeOptions) {
-    let position = index;
-
-    this.field.change(
-      name,
-      current => {
-        const array = (current as any[]) ?? [];
-        position = Math.max(Math.min(index, array.length - 1), 0);
-
-        return [...array.slice(0, position), ...array.slice(position + 1)] as never;
-      },
-      { ...options, should: { ...options?.should, validate: false } },
-    );
-
-    this.context.persisted.setState(current => {
-      const fields = { ...current.fields };
-      const value = get(current.values as never, stringToPath(name)) as any[] | undefined;
-      const length = value?.length ?? 0;
-
-      for (let i = position; i < length; i++) {
-        const moving = current.fields[`${name}.${i + 1}`];
-        fields[`${name}.${i}`] = moving ?? defaultMeta;
-      }
-
-      delete fields[`${name}.${length}`];
-
-      return {
-        ...current,
-        fields,
-      };
-    });
-
-    const shouldValidate = options?.should?.validate !== false;
-    if (shouldValidate) void this.context.validate(name, { type: 'change' });
-  }
-
-  public replace<Name extends ArrayField>(
-    name: Name,
-    value: Updater<DeepValue<Values, Name>>,
-    options?: FieldChangeOptions,
-  ) {
-    this.context.resetFieldMeta(name);
-    this.field.change(name, value as never, options);
-  }
-}

package/src/form-context-api.ts

@@ -1,232 +0,0 @@
-import { defaultMeta, defaultStatus } from '#field-api.constants';
-import type {
-  FieldMeta,
-  FormBaseStore,
-  FormIssue,
-  FormOptions,
-  FormStore,
-  PersistedFieldMeta,
-  PersistedFormStatus,
-  ValidateOptions,
-} from '#form-api.types';
-import type { DeepKeys } from '#more-types';
-import type { StandardSchema } from '#types';
-import { get } from '#utils/get';
-import { validate } from '#utils/validate';
-import { Derived, Store } from '@tanstack/store';
-import { isDeepEqual, isFunction, mergeDeep, stringToPath } from 'remeda';
-
-export class FormContextApi<
-  Schema extends StandardSchema,
-  Values extends StandardSchema.InferInput<Schema> = StandardSchema.InferInput<Schema>,
-  Field extends DeepKeys<Values> = DeepKeys<Values>,
-> {
-  public options!: FormOptions<Schema>;
-  public persisted: Store<FormBaseStore<Schema>>;
-  public store!: Derived<FormStore<Schema>>;
-
-  constructor(options: FormOptions<Schema>) {
-    const values = mergeDeep(options.defaultValues as never, options.values ?? {}) as Values;
-
-    this.options = options;
-
-    this.persisted = new Store<FormBaseStore<Schema>>({
-      values,
-      fields: {},
-      refs: {},
-      status: defaultStatus,
-      errors: {},
-    });
-
-    this.store = new Derived<FormStore<Schema>>({
-      deps: [this.persisted],
-      fn: ({ currDepVals }) => {
-        const persisted = currDepVals[0] as FormBaseStore<Schema>;
-
-        const invalid = Object.values(persisted.errors).some(issues => issues.length > 0);
-        const dirty = Object.values(persisted.fields).some(meta => meta.dirty);
-        const fields = Object.fromEntries(
-          Object.entries(persisted.fields).map(([key, meta]) => {
-            return [key, this.buildFieldMeta(key, meta, persisted.values as Values, persisted.errors)];
-          }),
-        );
-
-        return {
-          ...persisted,
-          fields,
-          status: {
-            ...persisted.status,
-            submitted: persisted.status.submits > 0,
-            valid: !invalid,
-            dirty: persisted.status.dirty || dirty,
-          },
-        };
-      },
-    });
-  }
-
-  public get status() {
-    return this.store.state.status;
-  }
-
-  public get values() {
-    return this.store.state.values;
-  }
-
-  private get validator() {
-    const store = this.store.state;
-    const validate = this.options.validate;
-
-    return {
-      change: isFunction(validate?.change) ? validate.change(store) : validate?.change,
-      submit: isFunction(validate?.submit) ? validate.submit(store) : (validate?.submit ?? this.options.schema),
-      blur: isFunction(validate?.blur) ? validate.blur(store) : validate?.blur,
-      focus: isFunction(validate?.focus) ? validate.focus(store) : validate?.focus,
-    };
-  }
-
-  public buildFieldMeta = (
-    fieldName: string,
-    persistedMeta: PersistedFieldMeta | undefined,
-    values: Values,
-    errors: Record<string, FormIssue[]>,
-  ): FieldMeta => {
-    const path = stringToPath(fieldName);
-    const value = get(values as never, path);
-    const defaultValue = get(this.options.defaultValues, path);
-    const invalid = errors[fieldName]?.length > 0;
-    const baseMeta = persistedMeta ?? defaultMeta;
-
-    return {
-      ...baseMeta,
-      default: isDeepEqual(value, defaultValue),
-      pristine: !baseMeta.dirty,
-      valid: !invalid,
-    } satisfies FieldMeta;
-  };
-
-  public setFieldMeta = (name: string, meta: Partial<PersistedFieldMeta>) => {
-    this.persisted.setState(current => {
-      return {
-        ...current,
-        fields: {
-          ...current.fields,
-          [name]: {
-            ...defaultMeta,
-            ...this.persisted.state.fields[name],
-            ...meta,
-          },
-        },
-      };
-    });
-  };
-
-  public resetFieldMeta = (name: string) => {
-    this.persisted.setState(current => {
-      const fields = { ...current.fields };
-      const all = Object.keys(current.fields);
-      const affected = all.filter(key => key.startsWith(name));
-
-      for (const key of affected) {
-        delete fields[key];
-      }
-
-      return {
-        ...current,
-        fields,
-      };
-    });
-  };
-
-  public recomputeFieldMeta = (name: string) => {
-    this.persisted.setState(current => {
-      const related: string[] = this.options.related?.[name as never] ?? [];
-      const all = Object.keys(current.fields);
-      const affected = all.filter(key => key.startsWith(name) || related.includes(key));
-      const updated = affected.reduce(
-        (acc, key) => {
-          return {
-            ...acc,
-            [key]: this.buildFieldMeta(key, current.fields[key], current.values as Values, current.errors),
-          };
-        },
-        {} as Record<string, FieldMeta>,
-      );
-
-      return {
-        ...current,
-        fields: {
-          ...current.fields,
-          ...updated,
-        },
-      };
-    });
-  };
-
-  public setStatus = (status: Partial<PersistedFormStatus>) => {
-    this.persisted.setState(current => {
-      return {
-        ...current,
-        status: {
-          ...current.status,
-          ...status,
-        },
-      };
-    });
-  };
-
-  public validate = async (field?: Field | Field[], options?: ValidateOptions) => {
-    const validator = options?.type ? this.validator[options.type] : this.options.schema;
-
-    if (!validator) return [];
-
-    this.setStatus({ validating: true });
-
-    const { issues: allIssues } = await validate(validator, this.store.state.values);
-
-    if (!allIssues) {
-      this.persisted.setState(current => {
-        return { ...current, errors: {}, status: { ...current.status, validating: false } };
-      });
-
-      return [];
-    }
-
-    const fields = field ? (Array.isArray(field) ? field : [field]) : undefined;
-    const related: string[] = fields?.flatMap(field => this.options.related?.[field as never] ?? []) ?? [];
-    const affected = [...(fields ?? []), ...related];
-
-    const issues = allIssues.filter(issue => {
-      const path = issue.path?.join('.') ?? 'root';
-      return !fields || affected.some(key => path.startsWith(key));
-    });
-
-    const errors = issues.reduce((acc, issue) => {
-      const path = issue.path?.join('.') ?? 'root';
-      return {
-        ...acc,
-        [path]: [...(acc[path] ?? []), issue],
-      };
-    }, {} as any);
-
-    this.persisted.setState(current => {
-      const existing = { ...current.errors };
-
-      for (const key of affected) {
-        delete existing[key];
-      }
-
-      return {
-        ...current,
-        errors: {
-          ...(fields ? existing : {}), // when validating a specific set of fields, keep the existing errors
-          ...errors,
-        },
-      };
-    });
-
-    this.setStatus({ validating: false });
-
-    return issues;
-  };
-}

package/src/form-field-api.ts

@@ -1,174 +0,0 @@
-import { defaultMeta } from '#field-api.constants';
-import type { FieldChangeOptions, FormIssue, FormResetFieldOptions, FormSetErrorsOptions } from '#form-api.types';
-import type { FormContextApi } from '#form-context-api';
-import type { DeepKeys, DeepValue } from '#more-types';
-import type { StandardSchema } from '#types';
-import { get } from '#utils/get';
-import { update, type Updater } from '#utils/update';
-import { batch } from '@tanstack/store';
-import { setPath, stringToPath } from 'remeda';
-
-export class FormFieldApi<
-  Schema extends StandardSchema,
-  Values extends StandardSchema.InferInput<Schema> = StandardSchema.InferInput<Schema>,
-  Field extends DeepKeys<Values> = DeepKeys<Values>,
-> {
-  constructor(private context: FormContextApi<Schema>) {}
-
-  /**
-   * Changes the value of a specific field with optional control over side effects.
-   * @param name - The name of the field to change
-   * @param value - The new value to set for the field
-   * @param options - Optional configuration for controlling validation, dirty state, and touched state
-   */
-  public change = <Name extends Field>(
-    name: Name,
-    updater: Updater<DeepValue<Values, Name>>,
-    options?: FieldChangeOptions,
-  ) => {
-    const shouldDirty = options?.should?.dirty !== false;
-    const shouldTouch = options?.should?.touch !== false;
-    const shouldValidate = options?.should?.validate !== false;
-
-    this.context.persisted.setState(current => {
-      const value = get(current.values as never, stringToPath(name)) as DeepValue<Values, Name>;
-
-      const values = setPath(
-        current.values as never,
-        stringToPath(name) as never,
-        update(updater, value) as never,
-      ) as Values;
-
-      return {
-        ...current,
-        values,
-      };
-    });
-
-    if (shouldValidate) void this.context.validate(name, { type: 'change' });
-
-    batch(() => {
-      if (shouldDirty) this.context.setFieldMeta(name, { dirty: true });
-      if (shouldTouch) this.context.setFieldMeta(name, { touched: true });
-    });
-  };
-
-  public focus = <Name extends Field>(name: Name) => {
-    const ref = this.context.store.state.refs[name as never];
-
-    if (ref) ref.focus();
-
-    this.context.setFieldMeta(name as never, { touched: true });
-    void this.context.validate(name as never, { type: 'focus' });
-  };
-
-  public blur = <Name extends Field>(name: Name) => {
-    const ref = this.context.store.state.refs[name as never];
-
-    if (ref) ref.blur();
-
-    this.context.setFieldMeta(name as never, { blurred: true });
-    void this.context.validate(name as never, { type: 'blur' });
-  };
-
-  public get = <Name extends Field>(name: Name) => {
-    return get(this.context.store.state.values as never, stringToPath(name)) as DeepValue<Values, Name>;
-  };
-
-  public meta = <Name extends Field>(name: Name) => {
-    const meta = this.context.store.state.fields[name];
-
-    if (meta) return meta;
-
-    const updated = this.context.buildFieldMeta(
-      name,
-      undefined,
-      this.context.store.state.values as Values,
-      this.context.store.state.errors,
-    );
-
-    this.context.setFieldMeta(name, updated);
-
-    return updated;
-  };
-
-  public register = <Name extends Field>(name: Name) => {
-    return (element: HTMLElement | null) => {
-      if (!element) return;
-
-      this.context.persisted.setState(current => {
-        return {
-          ...current,
-          refs: {
-            ...current.refs,
-            [name]: element,
-          },
-        };
-      });
-    };
-  };
-
-  public errors = <Name extends Field>(name: Name) => {
-    return this.context.store.state.errors[name] ?? [];
-  };
-
-  public setErrors = <Name extends Field>(name: Name, errors: FormIssue[], options?: FormSetErrorsOptions) => {
-    this.context.persisted.setState(current => {
-      const existing = current.errors[name] ?? [];
-      let updated: FormIssue[];
-
-      switch (options?.mode) {
-        case 'append':
-          updated = [...existing, ...errors];
-          break;
-        case 'keep':
-          updated = existing.length > 0 ? existing : errors;
-          break;
-        case 'replace':
-        default:
-          updated = errors;
-          break;
-      }
-
-      return {
-        ...current,
-        errors: {
-          ...current.errors,
-          [name]: updated,
-        },
-      };
-    });
-  };
-
-  public reset = <Name extends Field>(name: Name, options?: FormResetFieldOptions<DeepValue<Values, Name>>) => {
-    const path = stringToPath(name as never);
-    const defaultValue = get(this.context.options.defaultValues, path) as DeepValue<Values, Name>;
-    const value = options?.value ?? defaultValue;
-
-    this.context.persisted.setState(current => {
-      const values = setPath(current.values as never, path as never, value as never);
-      const fields = { ...current.fields };
-      const refs = { ...current.refs };
-      const errors = { ...current.errors };
-
-      if (options?.meta) {
-        const currentMeta = options?.keep?.meta ? (fields[name as string] ?? defaultMeta) : defaultMeta;
-        fields[name as string] = {
-          ...currentMeta,
-          ...options.meta,
-        };
-      } else if (!options?.keep?.meta) delete fields[name as string];
-
-      if (!options?.keep?.refs) delete refs[name as string];
-      if (!options?.keep?.errors) delete errors[name as string];
-
-      return {
-        ...current,
-        values,
-        fields,
-        refs,
-        errors,
-      };
-    });
-  };
-}