// Variables
let x = 5;
const y = "Hello";

// Data Types
let num = 10; // Number
let str = "Hello"; // String
let bool = true; // Boolean
let arr = [1, 2, 3]; // Array
let obj = { name: "sadanandgadwal", age: 23 }; // Object

// Functions
function greet(name) {
  return "Hello, " + name + "!";
}
console.log(greet("sadanandgadwal")); // Output: Hello, sadanandgadwal!

// Objects
let person = {
  name: "sadanandgadwal",
  age: 23,
  greet: function() {
    return "Hello, " + this.name + "!";
  }
};
console.log(person.greet()); // Output: Hello, sadanandgadwal!

// Define a function named greet that takes a parameter 'name' of type string and returns a string.
function greet(name: string): string {
  return "Hello, " + name + "!";
}

// Call the greet function with the argument "sadanandgadwal" and log the returned value to the console.
console.log(greet("sadanandgadwal")); // Output: Hello, sadanandgadwal!

// Define an interface named Person which specifies that any object implementing it must have a 'name' property of type string and an 'age' property of type number.
interface Person {
  name: string;
  age: number;
}

// Define a function named greetPerson that takes a parameter 'person' of type Person interface and returns a string.
function greetPerson(person: Person): string {
  return "Hello, " + person.name + "!";
}

// Call the greetPerson function with an object that satisfies the Person interface, and log the returned value to the console.
console.log(greetPerson({ name: "sadanandgadwal", age: 23 })); // Output: Hello, sadanandgadwal!

# Install Node.js and npm
# Download and install from https://nodejs.org/

# Install TypeScript globally
npm install -g typescript

# Create a TypeScript file (example.ts)
# Run the TypeScript compiler to generate JavaScript
tsc example.ts

// Variable Declaration
let x: number = 5; // Declare a variable 'x' of type number and assign it the value 5.
const y: string = "Hello"; // Declare a constant 'y' of type string and assign it the value "Hello".

// Type Inference
let num = 10; // TypeScript infers the type of 'num' as 'number' based on its initial value.
let str = "Hello"; // TypeScript infers the type of 'str' as 'string' based on its initial value.

// Basic Type Annotations and Assertions
let z: boolean; // Declare a variable 'z' of type boolean.
z = true; // Assign the value true to the variable 'z'.

// Type Assertion
let someValue: any = "this is a string"; // Declare a variable 'someValue' of type 'any' and assign it a string value.
let strLength: number = (someValue as string).length; // Assert that 'someValue' is of type string and then access its length property.
// Alternatively, you could use angle bracket syntax: let strLength: number = (<string>someValue).length;

console.log(x); // Output: 5
console.log(y); // Output: Hello
console.log(num); // Output: 10
console.log(str); // Output: Hello
console.log(z); // Output: true
console.log(strLength); // Output: 16

// Function Types
// Define a type alias named GreetFunction representing a function that takes a 'name' parameter of type 'string' and returns a 'string'.
type GreetFunction = (name: string) => string;

// Declare a variable 'greet' of type 'GreetFunction' and assign it a function expression that matches the defined function type.
let greet: GreetFunction = function(name: string) {
  return "Hello, " + name + "!";
};

// Call the 'greet' function with the argument "sadanandgadwal" and log the returned value to the console.
console.log(greet("sadanandgadwal")); // Output: Hello, sadanandgadwal!

// Interface
// Define an interface named 'Person' with properties 'name' of type 'string' and 'age' of type 'number'.
interface Person {
  name: string;
  age: number;
}

// Define a function named 'greetPerson' that takes a parameter 'person' of type 'Person' interface and returns a 'string'.
function greetPerson(person: Person): string {
  return "Hello, " + person.name + "!";
}

// Call the 'greetPerson' function with an object that satisfies the 'Person' interface, and log the returned value to the console.
console.log(greetPerson({ name: "sadanandgadwal", age: 23 })); // Output: Hello, sadanandgadwal!

// Class
class Person {
  // Define properties 'name' and 'age'.
  name: string;
  age: number;

  // Define a constructor function that initializes 'name' and 'age' properties when a new object is created.
  constructor(name: string, age: number) {
    this.name = name;
    this.age = age;
  }

  // Define a method named 'greet' that returns a greeting message using the 'name' property.
  greet(): string {
    return "Hello, " + this.name + "!";
  }
}

// Create a new instance of the 'Person' class with name "sadanandgadwal" and age 23.
let person = new Person("sadanandgadwal", 23);

// Call the 'greet' method of the 'person' object and log the returned value to the console.
console.log(person.greet()); // Output: Hello, sadanandgadwal!

// Union Types
// Declare a variable 'val' that can hold values of type 'number' or 'string'.
let val: number | string;
val = 10; // Assign a number to 'val' (valid).
val = "Hello"; // Assign a string to 'val' (valid).
// val = true; // Error: Type 'boolean' is not assignable to type 'number | string'

// Intersection Types
// Define two interfaces 'A' and 'B' with different properties.
interface A {
  propA: number;
}
interface B {
  propB: string;
}
// Create a new type 'C' which is an intersection of types 'A' and 'B'.
type C = A & B;
// Declare a variable 'obj' of type 'C' and assign an object with properties from both interfaces.
let obj: C = { propA: 10, propB: "Hello" };

// Conditional Types
// Define a conditional type 'TypeName<T>' which returns different strings based on the type of 'T'.
type TypeName<T> = T extends string ? "string" :
                   T extends number ? "number" :
                   T extends boolean ? "boolean" :
                   "unknown";
// Declare variables of type 'TypeName' with different type arguments and assign them values.
let a: TypeName<string> = "string"; // Output: "string"
let b: TypeName<number> = "number"; // Output: "number"
let c: TypeName<boolean> = "boolean"; // Output: "boolean"
let d: TypeName<object> = "unknown"; // Output: "unknown"

console.log(val); // Output: Hello
console.log(obj); // Output: { propA: 10, propB: "Hello" }
console.log(a);   // Output: string
console.log(b);   // Output: number
console.log(c);   // Output: boolean
console.log(d);   // Output: unknown

// Generic Function
// Define a generic function 'identity' that takes an argument 'arg' of type 'T' and returns the same type 'T'.
function identity<T>(arg: T): T {
  return arg;
}
// Call the 'identity' function with a number and assign the result to 'num'.
let num: number = identity(10); // Output: 10
// Call the 'identity' function with a string and assign the result to 'str'.
let str: string = identity("Hello"); // Output: "Hello"

// Generic Interface
// Define a generic interface 'Box<T>' with a single property 'value' of type 'T'.
interface Box<T> {
  value: T;
}
// Create a variable 'box' of type 'Box<number>' and assign an object with a 'value' property of type number.
let box: Box<number> = { value: 10 };

// Generic Class
// Define a generic class 'Pair<T, U>' with two properties 'first' of type 'T' and 'second' of type 'U'.
class Pair<T, U> {
  constructor(public first: T, public second: U) {}
}
// Create an instance 'pair' of the 'Pair<number, string>' class with values 10 and "Hello".
let pair: Pair<number, string> = new Pair(10, "Hello");

console.log(num); // Output: 10
console.log(str); // Output: Hello
console.log(box); // Output: { value: 10 }
console.log(pair); // Output: Pair { first: 10, second: "Hello" }

// math.ts
// Define a function 'sum' in the module 'math' that takes two numbers and returns their sum.
export function sum(a: number, b: number): number {
  return a + b;
}

// app.ts
// Import the 'sum' function from the 'math' module.
import { sum } from "./math";
// Call the 'sum' function and log the result to the console.
console.log(sum(2, 3)); // Output: 5

// namespace
// Define a namespace 'Math' containing a function 'sum' that calculates the sum of two numbers.
namespace Math {
  export function sum(a: number, b: number): number {
    return a + b;
  }
}

// app.ts
/// <reference path="math.ts" />
// Use the 'sum' function from the 'Math' namespace and log the result to the console.
console.log(Math.sum(2, 3)); // Output: 5

// Class Decorator
// Define a class decorator 'Logged' that takes a target function.
function Logged(target: Function) {
  // Log a message indicating that the class has been logged.
  console.log("Class logged:", target);
}

// Apply the 'Logged' decorator to the 'MyClass' class.
@Logged
class MyClass {}

// Method Decorator
// Define a method decorator 'Log' that takes target, key, and descriptor arguments.
function Log(target: any, key: string, descriptor: PropertyDescriptor) {
  // Log a message indicating that the method has been logged.
  console.log("Method logged:", key);
}

// Define a class 'MyService'.
class MyService {
  // Apply the 'Log' decorator to the 'getData' method.
  @Log
  getData() {}
}

// Property Decorator
// Define a property decorator factory 'Configurable' that takes a boolean value.
function Configurable(value: boolean) {
  return function(target: any, propertyKey: string) {
    // Define the property with configurable set to the provided value.
    Object.defineProperty(target, propertyKey, {
      configurable: value
    });
  };
}

// Define a class 'MyComponent'.
class MyComponent {
  // Apply the 'Configurable' decorator to the 'apiUrl' property with configurable set to false.
  @Configurable(false)
  apiUrl = "https://example.com";
}

// Console output
console.log(MyClass);
new MyService().getData();
console.log(Object.getOwnPropertyDescriptor(MyComponent.prototype, "apiUrl"));

// Synchronous Error Handling
// Define a function 'divide' that takes two numbers and returns the result of dividing the first number by the second number.
function divide(x: number, y: number): number {
  // Check if the second number is zero.
  if (y === 0) {
    // If it is zero, throw an error with a message.
    throw new Error("Division by zero");
  }
  // If the second number is not zero, perform the division and return the result.
  return x / y;
}

// Use a try-catch block to handle errors that may occur during the execution of the 'divide' function.
try {
  // Call the 'divide' function with arguments 10 and 0.
  console.log(divide(10, 0)); // Output: Error: Division by zero
} catch (error) {
  // If an error occurs, log the error message to the console.
  console.error(error.message);
}

// Asynchronous Error Handling
// Define an asynchronous function 'fetchData' that fetches data from a remote URL.
async function fetchData() {
  try {
    // Attempt to fetch data from the specified URL.
    let response = await fetch("https://example.com/data");
    // Check if the response is OK.
    if (!response.ok) {
      // If the response is not OK, throw an error with a message.
      throw new Error("Failed to fetch data");
    }
    // If the response is OK, parse the JSON data.
    let data = await response.json();
    // Log the parsed data to the console.
    console.log(data);
  } catch (error) {
    // If an error occurs during the fetch operation or parsing, log the error message to the console.
    console.error(error.message);
  }
}

// Call the 'fetchData' function to initiate the asynchronous data fetching process.
fetchData();