أنماط أنواع الأدوات المساعدة المتقدمة

type DeepPartial<T> = {
  [P in keyof T]?: T[P] extends object
    ? T[P] extends Array<infer U>
      ? Array<DeepPartial<U>>
      : DeepPartial<T[P]>
    : T[P];
};

// مثال الاستخدام
interface User {
  id: number;
  profile: {
    firstName: string;
    lastName: string;
    address: {
      street: string;
      city: string;
      country: string;
    };
  };
  preferences: {
    theme: 'light' | 'dark';
    notifications: {
      email: boolean;
      push: boolean;
    };
  };
}

// جميع الخصائص على جميع المستويات تصبح اختيارية
type PartialUser = DeepPartial<User>;

const updateUser: PartialUser = {
  profile: {
    address: {
      city: 'نيويورك', // يمكن تحديث خاصية متداخلة واحدة فقط
    },
  },
};

type DeepReadonly<T> = {
  readonly [P in keyof T]: T[P] extends object
    ? T[P] extends Array<infer U>
      ? ReadonlyArray<DeepReadonly<U>>
      : DeepReadonly<T[P]>
    : T[P];
};

// مثال الاستخدام
interface Config {
  api: {
    baseURL: string;
    timeout: number;
    headers: {
      authorization: string;
      contentType: string;
    };
  };
  features: {
    darkMode: boolean;
    analytics: boolean;
  };
}

type ImmutableConfig = DeepReadonly<Config>;

const config: ImmutableConfig = {
  api: {
    baseURL: 'https://api.example.com',
    timeout: 5000,
    headers: {
      authorization: 'Bearer token',
      contentType: 'application/json',
    },
  },
  features: {
    darkMode: true,
    analytics: false,
  },
};

// خطأ TypeScript: لا يمكن التعيين إلى 'baseURL' لأنها خاصية للقراءة فقط
// config.api.baseURL = 'https://new-api.com';

// خطأ TypeScript: لا يمكن التعيين إلى 'darkMode' لأنها خاصية للقراءة فقط
// config.features.darkMode = false;

type DeepRequired<T> = {
  [P in keyof T]-?: T[P] extends object
    ? T[P] extends Array<infer U>
      ? Array<DeepRequired<U>>
      : DeepRequired<T[P]>
    : T[P];
};

// مثال مع خصائص متداخلة اختيارية
interface PartialForm {
  username?: string;
  profile?: {
    bio?: string;
    social?: {
      twitter?: string;
      github?: string;
    };
  };
}

type CompleteForm = DeepRequired<PartialForm>;

// خطأ TypeScript: يجب توفير جميع الخصائص
const form: CompleteForm = {
  username: 'john_doe',
  profile: {
    bio: 'مطور',
    social: {
      twitter: '@johndoe',
      github: 'johndoe',
    },
  },
};

type PathKeys<T> = T extends object
  ? {
      [K in keyof T]: K extends string
        ? T[K] extends object
          ? `${K}` | `${K}.${PathKeys<T[K]>}`
          : `${K}`
        : never;
    }[keyof T]
  : never;

// مثال الاستخدام
interface Settings {
  user: {
    name: string;
    email: string;
    preferences: {
      theme: string;
      language: string;
    };
  };
  app: {
    version: string;
    features: {
      darkMode: boolean;
      notifications: boolean;
    };
  };
}

type SettingPath = PathKeys<Settings>;
// نوع النتيجة:
// "user" | "user.name" | "user.email" | "user.preferences" |
// "user.preferences.theme" | "user.preferences.language" |
// "app" | "app.version" | "app.features" |
// "app.features.darkMode" | "app.features.notifications"

// دالة getter آمنة من حيث النوع
function getNestedValue<T, P extends PathKeys<T>>(
  obj: T,
  path: P
): any {
  return path.split('.').reduce((acc: any, key) => acc?.[key], obj);
}

const settings: Settings = {
  user: {
    name: 'أحمد',
    email: 'ahmad@example.com',
    preferences: {
      theme: 'dark',
      language: 'ar',
    },
  },
  app: {
    version: '1.0.0',
    features: {
      darkMode: true,
      notifications: false,
    },
  },
};

const theme = getNestedValue(settings, 'user.preferences.theme'); // صالح
// const invalid = getNestedValue(settings, 'user.invalid.path'); // خطأ TypeScript

type Mutable<T> = {
  -readonly [P in keyof T]: T[P];
};

// نسخة عميقة
type DeepMutable<T> = {
  -readonly [P in keyof T]: T[P] extends object
    ? T[P] extends Array<infer U>
      ? Array<DeepMutable<U>>
      : DeepMutable<T[P]>
    : T[P];
};

// مثال
interface ReadonlyUser {
  readonly id: number;
  readonly name: string;
  readonly profile: {
    readonly bio: string;
  };
}

type WritableUser = DeepMutable<ReadonlyUser>;

const user: WritableUser = {
  id: 1,
  name: 'أحمد',
  profile: { bio: 'مطور' },
};

user.name = 'فاطمة'; // مسموح
user.profile.bio = 'مصممة'; // مسموح

type PickByType<T, U> = {
  [P in keyof T as T[P] extends U ? P : never]: T[P];
};

// العكس: OmitByType
type OmitByType<T, U> = {
  [P in keyof T as T[P] extends U ? never : P]: T[P];
};

// مثال الاستخدام
interface Product {
  id: number;
  name: string;
  price: number;
  description: string;
  inStock: boolean;
  rating: number;
  category: string;
}

// احصل على خصائص السلسلة فقط
type StringProps = PickByType<Product, string>;
// النتيجة: { name: string; description: string; category: string }

// احصل على خصائص الرقم فقط
type NumberProps = PickByType<Product, number>;
// النتيجة: { id: number; price: number; rating: number }

// احصل على الخصائص غير السلسلة فقط
type NonStringProps = OmitByType<Product, string>;
// النتيجة: { id: number; price: number; inStock: boolean; rating: number }

type RequireAtLeastOne<T, Keys extends keyof T = keyof T> = Pick<
  T,
  Exclude<keyof T, Keys>
> &
  {
    [K in Keys]-?: Required<Pick<T, K>> &
      Partial<Pick<T, Exclude<Keys, K>>>;
  }[Keys];

// مثال الاستخدام
interface ContactInfo {
  name: string;
  email?: string;
  phone?: string;
  address?: string;
}

type ContactRequired = RequireAtLeastOne<
  ContactInfo,
  'email' | 'phone' | 'address'
>;

// صالح: يحتوي على البريد الإلكتروني
const contact1: ContactRequired = {
  name: 'أحمد',
  email: 'ahmad@example.com',
};

// صالح: يحتوي على الهاتف
const contact2: ContactRequired = {
  name: 'فاطمة',
  phone: '555-0123',
};

// صالح: يحتوي على متعددة
const contact3: ContactRequired = {
  name: 'محمد',
  email: 'mohamed@example.com',
  phone: '555-0456',
};

// خطأ TypeScript: يجب أن يحتوي على واحدة على الأقل من email أو phone أو address
// const invalid: ContactRequired = {
//   name: 'غير صالح',
// };

type RequireExactlyOne<T, Keys extends keyof T = keyof T> = Pick<
  T,
  Exclude<keyof T, Keys>
> &
  {
    [K in Keys]-?: Required<Pick<T, K>> &
      Partial<Record<Exclude<Keys, K>, undefined>>;
  }[Keys];

// مثال الاستخدام
interface SearchParams {
  query?: string;
  userId?: number;
  email?: string;
}

type ExactSearch = RequireExactlyOne<
  SearchParams,
  'query' | 'userId' | 'email'
>;

// صالح: خاصية واحدة بالضبط
const search1: ExactSearch = { query: 'typescript' };
const search2: ExactSearch = { userId: 123 };
const search3: ExactSearch = { email: 'user@example.com' };

// خطأ TypeScript: لا يمكن توفير عدة خصائص
// const invalid1: ExactSearch = { query: 'ts', userId: 1 };

// خطأ TypeScript: يجب توفير خاصية واحدة بالضبط
// const invalid2: ExactSearch = {};

type Prettify<T> = {
  [K in keyof T]: T[K];
} & {};

// مثال
type Base = { id: number; name: string };
type Extended = Base & { email: string; age: number };

// بدون Prettify، يعرض IDE: Base & { email: string; age: number }
type Ugly = Extended;

// مع Prettify، يعرض IDE: { id: number; name: string; email: string; age: number }
type Pretty = Prettify<Extended>;

type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;

// مثال
interface User {
  id: number;
  email: string;
  username: string;
  firstName: string;
  lastName: string;
}

// اجعل البريد الإلكتروني واسم المستخدم فقط اختياريًا
type UserUpdate = PartialBy<User, 'email' | 'username'>;

const update: UserUpdate = {
  id: 1,
  firstName: 'أحمد',
  lastName: 'علي',
  // email و username اختياريان
};

// types/utils.ts

export type DeepPartial<T> = {
  [P in keyof T]?: T[P] extends object
    ? T[P] extends Array<infer U>
      ? Array<DeepPartial<U>>
      : DeepPartial<T[P]>
    : T[P];
};

export type DeepReadonly<T> = {
  readonly [P in keyof T]: T[P] extends object
    ? T[P] extends Array<infer U>
      ? ReadonlyArray<DeepReadonly<U>>
      : DeepReadonly<T[P]>
    : T[P];
};

export type DeepRequired<T> = {
  [P in keyof T]-?: T[P] extends object
    ? T[P] extends Array<infer U>
      ? Array<DeepRequired<U>>
      : DeepRequired<T[P]>
    : T[P];
};

export type DeepMutable<T> = {
  -readonly [P in keyof T]: T[P] extends object
    ? T[P] extends Array<infer U>
      ? Array<DeepMutable<U>>
      : DeepMutable<T[P]>
    : T[P];
};

export type PickByType<T, U> = {
  [P in keyof T as T[P] extends U ? P : never]: T[P];
};

export type OmitByType<T, U> = {
  [P in keyof T as T[P] extends U ? never : P]: T[P];
};

export type Prettify<T> = {
  [K in keyof T]: T[K];
} & {};

export type PartialBy<T, K extends keyof T> = Omit<T, K> &
  Partial<Pick<T, K>>;

export type RequiredBy<T, K extends keyof T> = Omit<T, K> &
  Required<Pick<T, K>>;

// الاستخدام عبر تطبيقك
import { DeepPartial, DeepReadonly, Prettify } from './types/utils';