Seriya: React Hook Form Dars 84

FieldPath<T> — Type-safe field path'lar

TypeScript utility tipi FieldPath<T>, ichma-ich (nested) obyekt va massiv yo'llarini avtomatik hisoblash, FieldPathValue<T, P> va type-safe reusable inputlar.

84-dars

FieldPath<T> — Type-safe field path'lar

FieldPath<T> — bu T form qiymatlari obyektidagi barcha mumkin bo'lgan to'g'ri maydon yo'llarini (string path union) TypeScript darajasida avtomatik hisoblab beruvchi utility tipdir.

React Hook Form formadagi barcha darajadagi maydonlarni nuqta bilan ajratilgan satrlar (dot-notation) orqali boshqaradi. FieldPath<T> sizga ushbu yo'llarni yozishda 100% tip xavfsizligi va to'liq avtotaklif (Intellisense) imkoniyatini beradi.


1. FieldPath<T> qanday ishlaydi?

Aytaylik, bizda quyidagi ierarxik buyurtma tipi mavjud:

type OrderFormValues = {
  customer: {
    name: string;
    phone: string;
  };
  items: {
    title: string;
    quantity: number;
  }[];
};

TypeScript FieldPath<OrderFormValues> tipini hisoblaganda avtomatik ravishda quyidagi union turlarni hosil qiladi:

type Paths = FieldPath<OrderFormValues>;
// Natija:
// | "customer"
// | "customer.name"
// | "customer.phone"
// | "items"
// | `items.${number}`
// | `items.${number}.title`
// | `items.${number}.quantity`

Agar siz register("customer.fulName") deb harf adashtirsangiz yoki mavjud bo'lmagan yo'l yozsangiz, TypeScript darhol kod ishga tushmasidanoq xatolik ko'rsatadi.


2. Bog'liq tip: FieldPathValue<T, P>

Agar sizga nafaqat maydonning yo'li (path), balki o'sha yo'lda turgan qiymatning tipi ham kerak bo'lsa, FieldPathValue<T, P> ishlatiladi:

// "contact.telegram" yo'lidagi qiymat tipi nima? -> string
type TelegramType = FieldPathValue<ProfileSettingsFormValues, "contact.telegram">; // string

// "items.0.quantity" yo'lidagi qiymat tipi nima? -> number
type QuantityType = FieldPathValue<OrderFormValues, "items.0.quantity">; // number

3. Real misol: FieldPath<T> bilan universal Type-safe Input komponenti

Qayta ishlatiluvchi maxsus input komponenti yozayotganda name propini string emas, balki TName extends FieldPath<TFormValues> qilib belgilash lozim:

import React from "react";
import {
  useForm,
  type FieldPath,
  type FieldPathValue,
  type RegisterOptions,
  type UseFormRegister,
  type FieldErrors,
  type SubmitHandler,
} from "react-hook-form";

// 1. Ierarxik sozlamalar tipi
type ProfileSettingsFormValues = {
  username: string;
  contact: {
    email: string;
    telegram: string;
  };
  links: {
    label: string;
    url: string;
  }[];
};

// 2. Universal Type-safe Input komponentining prop interfeysi
type TypedTextInputProps<
  TFormValues extends Record<string, unknown>,
  TName extends FieldPath<TFormValues>
> = {
  label: string;
  name: TName;
  register: UseFormRegister<TFormValues>;
  errors: FieldErrors<TFormValues>;
  rules?: RegisterOptions<TFormValues, TName>;
  placeholder?: string;
};

// 3. Qayta ishlatiluvchi universal input komponenti
function TypedTextInput<
  TFormValues extends Record<string, unknown>,
  TName extends FieldPath<TFormValues>
>({
  label,
  name,
  register,
  errors,
  rules,
  placeholder,
}: TypedTextInputProps<TFormValues, TName>) {
  // errors obyektidan chuqur yo'l bo'yicha xatoni xavfsiz qidirib topish
  const fieldError = name.split(".").reduce<unknown>((acc, key) => {
    if (acc && typeof acc === "object" && key in acc) {
      return (acc as Record<string, unknown>)[key];
    }
    return undefined;
  }, errors) as { message?: string } | undefined;

  return (
    <div style={{ marginBottom: "12px" }}>
      <label style={{ display: "block", fontSize: "13px", fontWeight: 600, marginBottom: "4px" }}>
        {label}
      </label>
      <input
        {...register(name, rules)}
        placeholder={placeholder}
        style={{
          width: "100%",
          padding: "7px 10px",
          boxSizing: "border-box",
          borderColor: fieldError ? "#e11d48" : "#cbd5e1",
          borderWidth: "1px",
          borderRadius: "4px",
        }}
        aria-invalid={Boolean(fieldError)}
      />
      {fieldError?.message && (
        <p role="alert" style={{ color: "#e11d48", fontSize: "12px", margin: "2px 0 0 2px" }}>
          {fieldError.message}
        </p>
      )}
    </div>
  );
}

// 4. Asosiy forma komponenti
export function FieldPathDemoForm() {
  const {
    register,
    handleSubmit,
    setValue,
    reset,
    formState: { errors, isSubmitting },
  } = useForm<ProfileSettingsFormValues>({
    defaultValues: {
      username: "",
      contact: {
        email: "",
        telegram: "",
      },
      links: [{ label: "GitHub", url: "https://github.com" }],
    },
  });

  // FieldPathValue orqali qat'iy tipdagi yordamchi
  const fillDefaultTelegram = () => {
    const path: FieldPath<ProfileSettingsFormValues> = "contact.telegram";
    const value: FieldPathValue<ProfileSettingsFormValues, "contact.telegram"> = "@dev_alimov";

    setValue(path, value, { shouldDirty: true, shouldValidate: true });
  };

  const onSubmit: SubmitHandler<ProfileSettingsFormValues> = async (data) => {
    await new Promise((resolve) => setTimeout(resolve, 300));
    console.log("Saqlangan sozlamalar:", data);
    alert(`Sozlamalar saqlandi! Foydalanuvchi: ${data.username}`);
    reset();
  };

  return (
    <form onSubmit={handleSubmit(onSubmit)} noValidate style={{ maxWidth: "480px" }}>
      <h3 style={{ marginBottom: "16px" }}>Profil sozlamalari</h3>

      {/* 1. Oddiy birinchi darajali maydon */}
      <TypedTextInput
        label="Foydalanuvchi nomi *"
        name="username"
        register={register}
        errors={errors}
        rules={{ required: "Foydalanuvchi nomi kiritilishi shart" }}
        placeholder="muhammadjon"
      />

      {/* 2. Ichma-ich obyekt maydoni: contact.email */}
      <TypedTextInput
        label="Elektron pochta *"
        name="contact.email"
        register={register}
        errors={errors}
        rules={{ required: "Email manzili majburiy" }}
        placeholder="[email protected]"
      />

      {/* 3. Ichma-ich obyekt maydoni: contact.telegram */}
      <div style={{ marginBottom: "14px" }}>
        <TypedTextInput
          label="Telegram profili"
          name="contact.telegram"
          register={register}
          errors={errors}
          placeholder="@username"
        />
        <button
          type="button"
          onClick={fillDefaultTelegram}
          style={{
            padding: "4px 8px",
            background: "#e0f2fe",
            color: "#0369a1",
            border: "none",
            borderRadius: "4px",
            cursor: "pointer",
            fontSize: "12px",
            fontWeight: 500,
          }}
        >
          Standart Telegram qo'yish
        </button>
      </div>

      {/* 4. Massiv maydoni: links.0.label va links.0.url */}
      <TypedTextInput
        label="1-havola nomi *"
        name="links.0.label"
        register={register}
        errors={errors}
        rules={{ required: "Havola nomi kiritilishi shart" }}
        placeholder="Portfolio sayt"
      />

      <TypedTextInput
        label="1-havola manzili *"
        name="links.0.url"
        register={register}
        errors={errors}
        rules={{ required: "Havola URL manzili majburiy" }}
        placeholder="https://..."
      />

      <button
        type="submit"
        disabled={isSubmitting}
        style={{
          padding: "10px 20px",
          background: "#2563eb",
          color: "#fff",
          border: "none",
          borderRadius: "6px",
          cursor: isSubmitting ? "not-allowed" : "pointer",
          fontWeight: 600,
          marginTop: "10px",
        }}
      >
        {isSubmitting ? "Saqlanmoqda..." : "Sozlamalarni saqlash"}
      </button>
    </form>
  );
}

4. Muhim amaliy jihatlar

  1. Path<T> vs FieldPath<T>: React Hook Form'da Path<T> va FieldPath<T> amalda mutlaqo bir xil vazifani bajaradi. Path<T> shunchaki qisqartirilgan alias bo'lib, ikkalasidan birini tanlash loyiha kelishuviga bog'liq.
  2. Kompilyatsiya chegaralari (Recursive Types): Agar forma obyektida o'ziga o'zi havola qiluvchi (circular / recursive) tuzilmalar bo'lsa, TypeScript chuqurlik chegarasiga (Type instantiation is excessively deep and possibly infinite) yetishi mumkin. Bunday hollarda formaning interfeysini tekis (flat) yoki cheklangan chuqurlikda e'lon qilish lozim.
  3. useController bilan integratsiya: Maxsus UI vidjetlari yaratayotganingizda useController({ name, control }) ham name propida aynan FieldPath<T> ni talab qiladi.