{
    "compilerOptions": {
        /* Basic Options */
        "target": "ES2022", // Яку версію JS генерувати
        "module": "NodeNext", // Яку саме систему модулів використовувати (CommonJS vs ESM)
        "lib": ["DOM", "ESNext"], // Які глобальні типи доступні (window, document, Array.flat)

        /* Strictness */
        "strict": true, // Вмикає купу перевірок
        "noImplicitReturns": true, // Заставляє повертати значення з усіх гілок функції
        "noUncheckedIndexedAccess": true, // Робить доступ по індексу (arr[0]) -> T | undefined

        /* Emit */
        "outDir": "./dist", // Куди класти .js файли
        "rootDir": "./src", // Де лежать .ts файли
        "declaration": true, // Генерувати .d.ts файли (для бібліотек)
        "sourceMap": true, // Для дебаггингу
        "removeComments": true // Видаляти коментарі з JS
    },
    "include": ["src/**/*"], // Що компілювати
    "exclude": ["node_modules", "**/*.test.ts"] // Що ігнорувати
}

// Без нього
const users: User[] = []
const user = users[0] // Тип: User. Реальність: undefined.
// user.name -> CRASH

// З ним (true)
const user = users[0] // Тип: User | undefined.
// user.name -> Error: Object is possibly 'undefined'.

/repo
  /packages
    /core
      tsconfig.json
    /ui
      tsconfig.json (depends on core)
  tsconfig.json (root)

{
    "compilerOptions": {
        "composite": true, // Дозволяє іншим проектам посилатися на цей
        "declaration": true
    }
}

{
    "references": [{ "path": "../core" }]
}

{
    "files": [],
    "references": [{ "path": "./packages/core" }, { "path": "./packages/ui" }]
}

namespace Validation {
    export const emailRegex = /.../
}

// Validation.emailRegex

// globals.d.ts
declare const SuperLib: {
    init(config: any): void
    version: string
}

// express.d.ts
import { User } from './user'

declare module 'express-serve-static-core' {
    interface Request {
        user?: User // Ми додали це поле!
    }
}

/// <reference path="..." />
/// <reference types="node" />

export {} // Робимо файл модулем

declare global {
    interface Window {
        __REDUX_DEVTOOLS_EXTENSION__: any
    }
}

// Тепер це працює всюди
// window.__REDUX_DEVTOOLS_EXTENSION__

try {
    // ...
} catch (e: unknown) {
    // Тепер ми повинні перевірити тип
    if (e instanceof Error) {
        console.error(e.message)
    } else {
        console.error('Unknown error', e)
    }
}

class HttpError extends Error {
    constructor(
        public status: number,
        message: string,
    ) {
        super(message)
        this.name = 'HttpError' // Важливо для логування
    }
}

function fetchUser() {
    throw new HttpError(404, 'User not found')
}

type Result<T, E = Error> = { ok: true; value: T } | { ok: false; error: E }

function divide(a: number, b: number): Result<number, string> {
    if (b === 0) return { ok: false, error: 'Division by zero' }
    return { ok: true, value: a / b }
}

const res = divide(10, 0)
if (res.ok) {
    console.log(res.value)
} else {
    console.log(res.error)
}

import { z } from 'zod'

// 1. Створюємо схему
const UserSchema = z.object({
    id: z.number(),
    email: z.string().email(),
    website: z.string().url().optional(),
})

// 2. Отримуємо TS тип автоматично!
type User = z.infer<typeof UserSchema>

// 3. Валідуємо дані (з API)
function saveUser(input: unknown) {
    const result = UserSchema.safeParse(input)

    if (!result.success) {
        console.error('Validation failed:', result.error)
        return
    }

    // Тут input вже типізований як User
    const user = result.data
    console.log(user.email)
}

// Backend
const appRouter = router({
    getUser: publicProcedure.input(z.string()).query((req) => {
        return { id: req.input, name: 'Alice' }
    }),
})

export type AppRouter = typeof appRouter

// Frontend
const user = await trpc.getUser.query('123')
// user.name -> Автодоповнення працює!
// Якщо змінити ім'я на бекенді, фронтенд впаде при компіляції.

interface MyStorage {
    theme: 'dark' | 'light'
    volume: number
}

const store = new TypedStorage<MyStorage>()

store.setItem('theme', 'dark') // ✅
store.setItem('volume', 50) // ✅
// store.setItem("theme", 123); // 🛑 Error

const t = store.getItem('theme') // Type: "dark" | "light" | null

{
    "compilerOptions": {
        "baseUrl": "./src",
        "paths": {
            "@/*": ["*"],
            "@components/*": ["components/*"]
        }
    }
}

{
    "compilerOptions": {
        "esModuleInterop": true,
        "allowSyntheticDefaultImports": true
    }
}

const enum Direction {
    Up,
    Down,
}
const d = Direction.Up

// JS output:
// const d = 0; // Нуль оверхеду!

import { type User, createUser } from './user'

// User використовується тільки як тип, тому цей імпорт повністю зникне з JS бандлу,
// якщо createUser не використовується.

// api.ts
async function request<T>(url: string, schema: z.ZodType<T>): Promise<T> {
    const response = await fetch(url)
    const data = await response.json()

    // Parse кине помилку, якщо дані не валідні!
    return schema.parse(data)
}

// user-service.ts
const UserResponseSchema = z.object({
    id: z.number(),
    name: z.string(),
    company: z.object({
        name: z.string(),
    }),
})

// Автоматичний вивід типу відповіді
async function getUser(id: number) {
    // result має тип { id: number; name: string; ... }
    const result = await request(`/users/${id}`, UserResponseSchema)
    console.log(result.company.name)
}

// env.d.ts
namespace NodeJS {
    interface ProcessEnv {
        DATABASE_URL: string
        PORT: string
        NODE_ENV: 'development' | 'production'
    }
}

process.env.DATABASE_URL // string
process.env.PORT // string
// process.env.UNKNOWN // 🛑 Error

type Action<T = any> = { type: T }
type Reducer<S, A extends Action> = (state: S, action: A) => S
type Listener = () => void

class Store<S, A extends Action> {
    private state: S
    private listeners: Listener[] = []

    constructor(
        private reducer: Reducer<S, A>,
        initialState: S,
    ) {
        this.state = initialState
    }

    getState(): S {
        return this.state
    }

    dispatch(action: A): void {
        this.state = this.reducer(this.state, action)
        this.listeners.forEach((l) => l())
    }

    subscribe(listener: Listener): () => void {
        this.listeners.push(listener)
        return () => {
            this.listeners = this.listeners.filter((l) => l !== listener)
        }
    }
}