TypeScript Advanced Utility Types: Membangun Tipe Dinamis dan Kompleks

interface UserSettings {
    theme?: string;
    notificationsEnabled?: boolean;
    language?: string;
}

// Semua properti di CompleteUserSettings menjadi wajib
type CompleteUserSettings = Required<UserSettings>;

// --- Penggunaan yang Benar ---
const myFullSettings: CompleteUserSettings = {
    theme: "dark",
    notificationsEnabled: true,
    language: "en"
};

// --- Kesalahan Umum / Batasan ---
// const incompleteSettings: CompleteUserSettings = {
//     theme: "light" // Error: Property 'notificationsEnabled' is missing in type '{ theme: string; }' but required in type 'CompleteUserSettings'.
// };
// Keterangan: Setelah menggunakan `Required`, semua properti (bahkan yang sebelumnya opsional) harus disediakan.

console.log("Full Settings:", myFullSettings);

type MyValue = string | number | null | undefined;

// Tipe NonNullableValue hanya akan menjadi 'string | number'
type NonNullableValue = NonNullable<MyValue>;

// --- Penggunaan yang Benar ---
const validString: NonNullableValue = "hello";
const validNumber: NonNullableValue = 123;

function processValue(value: NonNullableValue) {
    console.log("Processing:", value);
}

processValue(validString); // Valid
processValue(validNumber); // Valid

// --- Kesalahan Umum / Batasan ---
// const invalidNull: NonNullableValue = null; // Error: Type 'null' is not assignable to type 'string | number'.
// const invalidUndefined: NonNullableValue = undefined; // Error: Type 'undefined' is not assignable to type 'string | number'.

// Contoh penggunaan di fungsi:
function getUserName(user: { name: string | null }): NonNullable<string> {
    // Dengan NonNullable, kita jamin hasilnya bukan null.
    // TypeScript akan meminta kita untuk menangani kasus null.
    return user.name!; // Menggunakan non-null assertion operator (hati-hati penggunaannya)
    // Atau lebih baik:
    // if (user.name === null) {
    //    throw new Error("User name is null");
    // }
    // return user.name;
}

const user = { name: "Alice" };
console.log("User Name:", getUserName(user));

function getUserData(id: number, name: string) {
    return { id, name, createdAt: new Date() };
}

async function fetchPost(postId: number) {
    const response = await fetch(`https://api.example.com/posts/${postId}`);
    return (await response.json()) as { id: number; title: string; body: string };
}

// Mendapatkan tipe kembalian dari fungsi getUserData
type UserData = ReturnType<typeof getUserData>;

// Mendapatkan tipe kembalian dari fungsi fetchPost (setelah Promise diselesaikan)
type PostData = Awaited<ReturnType<typeof fetchPost>>; // Menggunakan Awaited (akan dibahas selanjutnya)

// --- Penggunaan yang Benar ---
const userData: UserData = {
    id: 1,
    name: "Alice",
    createdAt: new Date()
};

const postData: PostData = {
    id: 101,
    title: "My First Post",
    body: "Lorem ipsum..."
};

// --- Kesalahan Umum / Batasan ---
// type InvalidReturnType = ReturnType<string>; // Error: Type 'string' does not satisfy the constraint '(...args: any) => any'.
// Keterangan: ReturnType hanya bisa digunakan pada tipe yang merupakan fungsi.

console.log("User Data Type Example:", userData);
console.log("Post Data Type Example:", postData);

function registerUser(username: string, email: string, isActive: boolean) {
    console.log(`Registering ${username} with email ${email}. Active: ${isActive}`);
}

// Mendapatkan tipe parameter dari fungsi registerUser
type RegisterUserParams = Parameters<typeof registerUser>;

// --- Penggunaan yang Benar ---
const paramsForUser1: RegisterUserParams = ["john_doe", "john@example.com", true];

function logAndCall(func: (...args: RegisterUserParams) => void, ...args: RegisterUserParams) {
    console.log("Calling function with params:", args);
    func(...args);
}

logAndCall(registerUser, "jane_doe", "jane@example.com", false);

// --- Kesalahan Umum / Batasan ---
// const invalidParams: RegisterUserParams = ["alice"]; // Error: Type '[string]' is not assignable to type '[username: string, email: string, isActive: boolean]'. Source has 1 element(s) but target requires 3.
// Keterangan: Jumlah dan tipe parameter harus sesuai dengan tuple yang dihasilkan.

// type InvalidParamsType = Parameters<number>; // Error: Type 'number' does not satisfy the constraint '(...args: any) => any'.
// Keterangan: Parameters hanya bisa digunakan pada tipe fungsi.

console.log("Parameters for User 1:", paramsForUser1);

class ProductService {
    constructor(private apiUrl: string, private apiKey: string) {
        // ...
    }

    fetchProducts() {
        // ...
    }
}

// Mendapatkan tipe parameter dari constructor ProductService
type ProductServiceCtorParams = ConstructorParameters<typeof ProductService>;

// --- Penggunaan yang Benar ---
const serviceArgs: ProductServiceCtorParams = ["https://api.products.com", "mysecretkey123"];

const myProductService = new ProductService(...serviceArgs);

// --- Kesalahan Umum / Batasan ---
// const invalidCtorArgs: ProductServiceCtorParams = ["only_one_arg"]; // Error: Type '[string]' is not assignable to type '[apiUrl: string, apiKey: string]'.
// Keterangan: Jumlah dan tipe parameter harus sesuai dengan constructor kelas.

// type InvalidCtorType = ConstructorParameters<Function>; // Error: Type 'Function' does not satisfy the constraint 'new (...args: any) => any'.
// Keterangan: ConstructorParameters hanya bisa digunakan pada tipe *constructor* (kelas).

console.log("Product Service Arguments:", serviceArgs);

type MyPromiseString = Promise<string>;
type MyNestedPromiseNumber = Promise<Promise<number>>;
type MyDirectValue = boolean;

// Awaited akan "membuka" Promise
type ResolvedString = Awaited<MyPromiseString>;         // Hasil: string
type ResolvedNumber = Awaited<MyNestedPromiseNumber>;   // Hasil: number
type ResolvedBoolean = Awaited<MyDirectValue>;          // Hasil: boolean

// --- Penggunaan yang Benar ---
async function fetchData(): Promise<{ data: string }> {
    return Promise.resolve({ data: "Some data" });
}

type DataResult = Awaited<ReturnType<typeof fetchData>>; // Menggabungkan ReturnType dan Awaited

const processedData: DataResult = { data: "Processed data" }; // Sesuai dengan { data: string }

// --- Kesalahan Umum / Batasan ---
// const invalidAwaited: Awaited<string>; // Ini tidak akan menghasilkan error tipe, karena Awaited dirancang untuk mengembalikan tipe aslinya jika bukan Promise.
// Keterangan: Awaited akan bekerja pada tipe non-Promise juga, mengembalikan tipe aslinya. Batasannya adalah jika Kamu mengharapkan Promise tetapi nilai aslinya bukan Promise, mungkin ada kesalahan logika.

console.log("Resolved String Type:", "Hello World" as ResolvedString);
console.log("Resolved Number Type:", 123 as ResolvedNumber);
console.log("Data Result Type:", processedData);