npm install -D typescript

declare function callIt<T>(obj: {
    produce: (x: number) => T,
    consume: (y: T) => void,
}): void;

// 문제없이 작동합니다.
callIt({
    produce: (x: number) => x * 2,
    consume: y => y.toFixed(),
});

// 속성의 순서가 바뀌어도 문제없이 작동합니다.
callIt({
    consume: y => y.toFixed(),
    produce: (x: number) => x * 2,
});

declare function callIt<T>(obj: {
    produce: (x: number) => T,
    consume: (y: T) => void,
}): void;

// 잘 작동하며, `x`는 number로 추론됩니다.
callIt({
    produce(x: number) { return x * 2; },
    consume(y) { return y.toFixed(); },
});

callIt({
    consume(y) { return y.toFixed(); },
    //                  ~
    // 오류: 'y'의 타입이 'unknown'입니다.

    produce(x: number) { return x * 2; },
});

function callFunc<T>(callback: (x: T) => void, value: T) {
    return callback(value);
}

callFunc(x => x.toFixed(), 42);
//       ^
// 여기서 `x`의 타입을 알아내야 하지만,
// 콜백을 체크하기 위해 `T`의 타입도 알아내야 합니다.

// 화살표 구문 - 오류 없음.
callIt({
    consume: y => y.toFixed(),
    produce: (x: number) => x * 2,
});

// 메서드 구문 - 오류 발생!
callIt({
    consume(y) { return y.toFixed(); },
    //                  ~
    // 오류: 'y'의 타입이 'unknown'입니다.

    produce(x: number) { return x * 2; },
});

{
    "name": "my-package",
    "type": "module",
    "imports": {
        "#root/*": "./dist/*"
    }
}

import * as utils from "../../utils.js";

import * as utils from "#root/utils.js";

{
    "name": "my-package",
    "type": "module",
    "imports": {
        "#/*": "./dist/*"
    }
}

// 입력: some-file.ts
export function foo(condition: boolean) {
    return condition ? 100 : 500;
}

// 출력: some-file.d.ts
export declare function foo(condition: boolean): 100 | 500;
//                                               ^^^^^^^^^
//             유니온의 순서에 주목하세요: 100 다음 500.

// 입력: some-file.ts
const x = 500;
export function foo(condition: boolean) {
    return condition ? 100 : 500;
}

// 출력: some-file.d.ts
export declare function foo(condition: boolean): 500 | 100;
//                                               ^^^^^^^^^
//                           순서가 바뀐 것에 주목하세요.

- someFunctionCall(/*...*/);
+ someFunctionCall<SomeExplicitType>(/*...*/);

- const someVariable = { /*... 복잡한 객체 ...*/ };
+ const someVariable: SomeExplicitType = { /*... 복잡한 객체 ...*/ };

someFunctionCall(someVariable);

let yesterday = Temporal.Now.instant().subtract({
    hours: 24,
});

let tomorrow = Temporal.Now.instant().add({
    hours: 24,
});

console.log(`Yesterday: ${yesterday}`);
console.log(`Tomorrow: ${tomorrow}`);

function processOptions(compilerOptions: Map<string, unknown>) {
    let strictValue: unknown;
    if (compilerOptions.has("strict")) {
        strictValue = compilerOptions.get("strict");
    }
    else {
        strictValue = true;
        compilerOptions.set("strict", strictValue);
    }
    // ...
}

function processOptions(compilerOptions: Map<string, unknown>) {
    let strictValue = compilerOptions.getOrInsert("strict", true);
    // ...
}

someMap.getOrInsertComputed("someKey", () => {
    return computeSomeExpensiveValue(/*...*/);
});

someMap.getOrInsertComputed(someKey, computeSomeExpensiveDefaultValue);

function computeSomeExpensiveValue(key: string) {
    // ...
}

function matchWholeWord(word: string, text: string) {
    const escapedWord = RegExp.escape(word);
    const regex = new RegExp(`\\b${escapedWord}\\b`, "g");
    return text.match(regex);
}

// TypeScript 6.0 이전에는 "lib": ["dom", "dom.iterable"]이 필요했습니다.
// 이제는 "lib": ["dom"]만으로 작동합니다.
for (const element of document.querySelectorAll("div")) {
    console.log(element.textContent);
}

  {
      "compilerOptions": {
          // ...
          "rootDir": "./src"
      },
      "include": ["./src"]
  }

  {
      "compilerOptions": {
          // ...
          "rootDir": "../src"
      },
      "include": ["../src/**/*.tests.ts"]
  }

  {
      "compilerOptions": {
          // 필요한 @types 패키지를 명시적으로 나열하세요.
          "types": ["node", "jest"]
      }
  }

  {
      "compilerOptions": {
          // 모든 타입을 로드합니다 - TypeScript 5.9 이전의 기본값입니다.
          "types": ["*"]
      }
  }

Cannot find module '...' or its corresponding type declarations.
Cannot find name 'fs'. Do you need to install type definitions for node? Try `npm i --save-dev @types/node` and then add 'node' to the types field in your tsconfig.
...

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

import * as someModule from "someModule.js";

  {
    "compilerOptions": {
      // ...
-     "baseUrl": "./src",
      "paths": {
-       "@app/*": ["app/*"],
-       "@lib/*": ["lib/*"]
+       "@app/*": ["./src/app/*"],
+       "@lib/*": ["./src/lib/*"]
      }
    }
  }

{
  "compilerOptions": {
    // ...
    "paths": {
      // baseUrl을 대체하는 새로운 포괄적 매핑:
      "*": ["./src/*"],

      // 이제 다른 모든 경로에 명시적인 공통 접두사가 붙습니다:
      "@app/*": ["./src/app/*"],
      "@lib/*": ["./src/lib/*"],
    }
  }
}

// 이전 (esModuleInterop: false 인 경우)
import * as express from "express";

// 이후 (esModuleInterop이 항상 활성화된 경우)
import express from "express";

// ❌ 지원 중단된 구문 - 이제 오류 발생
module Foo {
    export const bar = 10;
}

// ✅ 올바른 구문
namespace Foo {
    export const bar = 10;
}

// ✅ 여전히 완벽하게 작동합니다.
declare module "some-module" {
    export function doSomething(): void;
}

// ❌ 지원 중단된 구문 - 이제 오류 발생.
import blob from "./blahb.json" asserts { type: "json" }
//                              ~~~~~~~
// 오류: 임포트 단언(Import assertions)은 임포트 속성(Import attributes)으로 대체되었습니다. 'asserts' 대신 'with'를 사용하세요.

// ✅ 새로운 임포트 속성 구문으로 작동합니다.
import blob from "./blahb.json" with { type: "json" }

error TS5112: tsconfig.json is present but will not be loaded if files are specified on commandline. Use '--ignoreConfig' to skip this error.

tsc --ignoreConfig foo.ts