Практичне програмування на рівні типів

function getProperty<T, K extends keyof T>(object: T, key: K): T[K] {
  return object[key];
}

const user = {
  id: 10,
  name: "Iryna",
  active: true,
};

const name = getProperty(user, "name");
// string

const active = getProperty(user, "active");
// boolean

type ReadonlyObject<T> = {
  readonly [K in keyof T]: T[K];
};

type ReadonlyUser = ReadonlyObject<{
  id: number;
  name: string;
}>;

type ReadonlyUser = {
  readonly id: number;
  readonly name: string;
};

type Result<T> = {
  [K in keyof T]: /* тип властивості */;
};

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

type RequiredObject<T> = {
  [K in keyof T]-?: T[K];
};

type OptionalObject<T> = {
  [K in keyof T]?: T[K];
};

type Getters<T> = {
  [K in keyof T as `get${Capitalize<string & K>}`]: () => T[K];
};

type UserGetters = Getters<{
  id: number;
  name: string;
}>;

type UserGetters = {
  getId: () => number;
  getName: () => string;
};

type StringKeys<T> = {
  [K in keyof T]: T[K] extends string ? K : never;
}[keyof T];

type User = {
  id: number;
  name: string;
  email: string;
};

type UserStringKeys = StringKeys<User>;
// "name" | "email"

type Intermediate = {
  id: never;
  name: "name";
  email: "email";
};

type Result<T> = T extends SomeType
  ? TypeIfTrue
  : TypeIfFalse;

type IsString<T> = T extends string ? true : false;

type A = IsString<string>;
// true

type B = IsString<number>;
// false

type PickByValue<T, ValueType> = {
  [K in keyof T as T[K] extends ValueType ? K : never]: T[K];
};

type Product = {
  id: number;
  title: string;
  price: number;
  inStock: boolean;
};

type NumericProductFields = PickByValue<Product, number>;

type NumericProductFields = {
  id: number;
  price: number;
};

type SortableFields<T> = keyof PickByValue<T, string | number>;

type ProductSortableField = SortableFields<Product>;
// "id" | "title" | "price"

type ReturnTypeOf<T> = T extends (...args: never[]) => infer Result
  ? Result
  : never;

type User = ReturnTypeOf<() => { id: number; name: string }>;
// { id: number; name: string }

type ElementType<T> = T extends readonly (infer Element)[]
  ? Element
  : never;

type NumberElement = ElementType<readonly number[]>;
// number

type StringElement = ElementType<string[]>;
// string

type EndpointResponse<T> = T extends { response: infer Response }
  ? Response
  : never;

type Endpoint = {
  method: "GET";
  response: {
    id: number;
    name: string;
  };
};

type Response = EndpointResponse<Endpoint>;
// { id: number; name: string }

type User = {
  id: number;
  name: string;
  email: string;
};

type Product = {
  id: number;
  title: string;
  price: number;
};

type ApiContract = {
  "/users/:id": {
    method: "GET";
    response: User;
  };

  "/products": {
    method: "GET";
    response: Product[];
  };

  "/users": {
    method: "POST";
    response: User;
  };
};

type EndpointResponse<T> =
  T extends { response: infer Response }
    ? Response
    : never;

type ApiResponses<Contract> = {
  [Path in keyof Contract]: EndpointResponse<Contract[Path]>;
};

type Responses = ApiResponses<ApiContract>;

type Responses = {
  "/users/:id": User;
  "/products": Product[];
  "/users": User;
};

type ApiClient<Contract> = {
  [Path in keyof Contract]:
    Contract[Path] extends { response: infer Response }
      ? (body?: unknown) => Promise<Response>
      : never;
};

type Client = ApiClient<ApiContract>;

type Client = {
  "/users/:id": (body?: unknown) => Promise<User>;
  "/products": (body?: unknown) => Promise<Product[]>;
  "/users": (body?: unknown) => Promise<User>;
};

interface Validator<T> {
  parse(input: unknown): T;
}

type Infer<T> = T extends Validator<infer Result>
  ? Result
  : never;

type StringValidator = Validator<string>;

type ParsedString = Infer<StringValidator>;
// string

type Schema = Record<string, Validator<any>>;

type InferObject<S extends Schema> = {
  [K in keyof S]: Infer<S[K]>;
};

type UserSchema = {
  id: Validator<number>;
  name: Validator<string>;
};

type ParsedUser = InferObject<UserSchema>;
// {
//   id: number;
//   name: string;
// }

interface Validator<T> {
  parse(input: unknown): T;
}

type AnyValidator = Validator<any>;
type Schema = Record<string, AnyValidator>;

type Infer<T> = T extends Validator<infer Result>
  ? Result
  : never;

type InferObject<S extends Schema> = {
  [K in keyof S]: Infer<S[K]>;
};

const v = {
  string(): Validator<string> {
    return {
      parse(input: unknown): string {
        if (typeof input !== "string") {
          throw new Error("Очікувалося рядкове значення");
        }

        return input;
      },
    };
  },

  number(): Validator<number> {
    return {
      parse(input: unknown): number {
        if (typeof input !== "number" || Number.isNaN(input)) {
          throw new Error("Очікувалося числове значення");
        }

        return input;
      },
    };
  },

  boolean(): Validator<boolean> {
    return {
      parse(input: unknown): boolean {
        if (typeof input !== "boolean") {
          throw new Error("Очікувалося логічне значення");
        }

        return input;
      },
    };
  },

  array<T>(itemValidator: Validator<T>): Validator<T[]> {
    return {
      parse(input: unknown): T[] {
        if (!Array.isArray(input)) {
          throw new Error("Очікувався масив");
        }

        return input.map((item) => itemValidator.parse(item));
      },
    };
  },

  object<S extends Schema>(shape: S): Validator<InferObject<S>> {
    return {
      parse(input: unknown): InferObject<S> {
        if (typeof input !== "object" || input === null || Array.isArray(input)) {
          throw new Error("Очікувався об'єкт");
        }

        const source = input as Record<string, unknown>;
        const result: Record<string, unknown> = {};

        for (const key of Object.keys(shape)) {
          result[key] = shape[key].parse(source[key]);
        }

        return result as InferObject<S>;
      },
    };
  },
};

const userSchema = v.object({
  id: v.number(),
  name: v.string(),
  email: v.string(),
  tags: v.array(v.string()),
  active: v.boolean(),
});

type User = Infer<typeof userSchema>;

const parsedUser = userSchema.parse({
  id: 1,
  name: "Олена",
  email: "olena@example.com",
  tags: ["admin", "editor"],
  active: true,
});

console.log(parsedUser.name.toUpperCase());
console.log(parsedUser.tags.length);

type PickByValue<T, ValueType> = {
  [K in keyof T as T[K] extends ValueType ? K : never]: T[K];
};

type NumericFields<T> = PickByValue<T, number>;

type UserNumericFields = NumericFields<User>;
// {
//   id: number;
// }

type DeepPartial<T> =
  T extends (...args: any[]) => any
    ? T
    : T extends readonly (infer Item)[]
      ? readonly DeepPartial<Item>[]
      : T extends object
        ? {
            [K in keyof T]?: DeepPartial<T[K]>;
          }
        : T;

type DeepReadonly<T> =
  T extends (...args: any[]) => any
    ? T
    : T extends readonly (infer Item)[]
      ? readonly DeepReadonly<Item>[]
      : T extends object
        ? {
            readonly [K in keyof T]: DeepReadonly<T[K]>;
          }
        : T;

type UserPatch = DeepPartial<Omit<User, "id">>;

const patch: UserPatch = {
  name: "Нове ім'я",
  tags: ["reviewed"],
};

type EndpointResponse<T> =
  T extends { response: infer Response }
    ? Response
    : never;

type ApiContract = {
  "/users/:id": {
    method: "GET";
    response: User;
  };

  "/users": {
    method: "POST";
    response: User;
  };
};

type ApiResponses<Contract> = {
  [Path in keyof Contract]: EndpointResponse<Contract[Path]>;
};

type Responses = ApiResponses<ApiContract>;

type ApiClient<Contract> = {
  [Path in keyof Contract]:
    Contract[Path] extends { response: infer Response }
      ? (body?: unknown) => Promise<Response>
      : never;
};

type Client = ApiClient<ApiContract>;

type User = Infer<typeof userSchema>;

const userSchema = v.object({
  id: v.number(),
  name: v.string(),
  email: v.string(),
  tags: v.array(v.string()),
  active: v.boolean(),
});

type User = {
  id: number;
  name: string;
  email: string;
  tags: string[];
  active: boolean;
};

type UserPatch = Partial<User>;

type Profile = {
  user: {
    name: string;
    address: {
      city: string;
    };
  };
};

type DeepPartial<T> =
  T extends (...args: any[]) => any
    ? T
    : T extends readonly (infer Item)[]
      ? readonly DeepPartial<Item>[]
      : T extends object
        ? {
            [K in keyof T]?: DeepPartial<T[K]>;
          }
        : T;

type ProfilePatch = DeepPartial<Profile>;

const profilePatch: ProfilePatch = {
  user: {
    address: {
      city: "Львів",
    },
  },
};

type DeepReadonly<T> =
  T extends (...args: any[]) => any
    ? T
    : T extends readonly (infer Item)[]
      ? readonly DeepReadonly<Item>[]
      : T extends object
        ? {
            readonly [K in keyof T]: DeepReadonly<T[K]>;
          }
        : T;

type ReadonlyProfile = DeepReadonly<Profile>;

declare const profile: ReadonlyProfile;

// profile.user.address.city = "Київ";
// Помилка: властивість доступна лише для читання

type ToArray<T> = T extends unknown ? T[] : never;

type Result = ToArray<string | number>;
// string[] | number[]

type ToArrayAsWhole<T> = [T] extends [unknown] ? T[] : never;

type Result = ToArrayAsWhole<string | number>;
// (string | number)[]

type KeysOfType<T, ValueType> = {
  [K in keyof T as T[K] extends ValueType ? K : never]: T[K];
};

type FormData = {
  username: string;
  age: number;
  subscribed: boolean;
};

type BooleanFields = KeysOfType<FormData, boolean>;
// {
//   subscribed: boolean;
// }

type KeyUnionOfType<T, ValueType> = {
  [K in keyof T]: T[K] extends ValueType ? K : never;
}[keyof T];

type FormBooleanKey = KeyUnionOfType<FormData, boolean>;
// "subscribed"

type User = {
  id: number;
  name: string;
};

type Unsafe = {
  value: any;
};

function printValue(value: unknown): void {
  if (typeof value === "string") {
    console.log(value.toUpperCase());
  }
}

type User = {
  id: number;
  name: string;
};

type Keys = keyof User;
// "id" | "name"

type Values = User[keyof User];
// number | string

type OnlyStrings<T> = {
  [K in keyof T as T[K] extends string ? K : never]: T[K];
};

type IncorrectDeepPartial<T> =
  T extends object
    ? { [K in keyof T]?: IncorrectDeepPartial<T[K]> }
    : T;

type CorrectDeepPartial<T> =
  T extends readonly (infer Item)[]
    ? readonly CorrectDeepPartial<Item>[]
    : T extends object
      ? { [K in keyof T]?: CorrectDeepPartial<T[K]> }
      : T;

: T;