Chapter 4: एडवांस्ड फीचर्स (Advanced Features)

// person.ts
export default class Person {
    constructor(public name: string, public age: number) {}
}

// utils.ts
export function add(a: number, b: number): number {
    return a + b;
}

export function subtract(a: number, b: number): number {
    return a - b;
}

// main.ts
import Person from './person';

let person = new Person("Daniel", 30);
console.log(person);

// main.ts
import { add, subtract } from './utils';

console.log(add(10, 5)); // 15
console.log(subtract(10, 5)); // 5

// main.ts
import * as Utils from './utils';

console.log(Utils.add(10, 5)); // 15
console.log(Utils.subtract(10, 5)); // 5

// math.ts
export { add, subtract } from './utils';

{
  "compilerOptions": {
    "experimentalDecorators": true
  }
}

function sealed(constructor: Function) {
    Object.seal(constructor);
    Object.seal(constructor.prototype);
}

@sealed
class Greeter {
    greeting: string;

    constructor(message: string) {
    	this.greeting = message;
    }

    greet() {
    	return `Hello, ${this.greeting}`;
    }
}

function enumerable(value: boolean) {
    return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
    	descriptor.enumerable = value;
    };
}

class Greeter {
    greeting: string;

    constructor(message: string) {
    	this.greeting = message;
    }

    @enumerable(false)
    greet() {
    	return `Hello, ${this.greeting}`;
    }
}

function format(formatString: string) {
    return function (target: any, propertyKey: string) {
    	let value = target[propertyKey];

    	const getter = () => {
        	return formatString.replace('{value}', value);
    	};

    	const setter = (newVal) => {
        	value = newVal;
    	};

    	Object.defineProperty(target, propertyKey, {
        	get: getter,
        	set: setter,
        	enumerable: true,
        	configurable: true,
    	});
    };
}

class Greeter {
    @format('Hello, {value}')
    greeting: string;

    constructor(message: string) {
    	this.greeting = message;
    }
}

let greeter = new Greeter("World");
console.log(greeter.greeting); // Hello, World

function logParameter(target: any, propertyKey: string, parameterIndex: number) {
    const metadataKey = `__log_${propertyKey}_parameters`;

    if (Array.isArray(target[metadataKey])) {
    	target[metadataKey].push(parameterIndex);
    } else {
    	target[metadataKey] = [parameterIndex];
    }
}

class Greeter {
    greeting: string;

    constructor(message: string) {
    	this.greeting = message;
    }

    greet(@logParameter name: string) {
    	return `Hello, ${name}! ${this.greeting}`;
    }
}

let greeter = new Greeter("Welcome to TypeScript");
console.log(greeter.greet("Daniel")); // Hello, Daniel! Welcome to TypeScript

class Person {
    constructor(public name: string) {}
}

function canSayHi<T extends new (...args: any[]) => {}>(Base: T) {
    return class extends Base {
    	sayHi() {
        	console.log(`Hi, my name is ${this.name}`);
    	}
    };
}

const PersonWithSayHi = canSayHi(Person);

const person = new PersonWithSayHi("Daniel");
person.sayHi(); // Hi, my name is Daniel

class Person {
    constructor(public name: string) {}
}

function canSayHi<T extends new (...args: any[]) => {}>(Base: T) {
    return class extends Base {
    	sayHi() {
        	console.log(`Hi, my name is ${this.name}`);
    	}
    };
}

function canDance<T extends new (...args: any[]) => {}>(Base: T) {
    return class extends Base {
    	dance() {
        	console.log(`${this.name} is dancing`);
    	}
    };
}

const PersonWithSkills = canSayHi(canDance(Person));

const skilledPerson = new PersonWithSkills("Daniel");
skilledPerson.sayHi(); // Hi, my name is Daniel
skilledPerson.dance(); // Daniel is dancing

interface CanSayHi {
    sayHi(): void;
}

interface CanDance {
    dance(): void;
}

class Person {
    constructor(public name: string) {}
}

function canSayHi<T extends new (...args: any[]) => {}>(Base: T): T & (new (...args: any[]) => CanSayHi) {
    return class extends Base {
    	sayHi() {
        	console.log(`Hi, my name is ${this.name}`);
    	}
    };
}

function canDance<T extends new (...args: any[]) => {}>(Base: T): T & (new (...args: any[]) => CanDance) {
    return class extends Base {
    	dance() {
        	console.log(`${this.name} is dancing`);
    	}
    };
}

const PersonWithSkills = canSayHi(canDance(Person));

const skilledPerson = new PersonWithSkills("Daniel");
skilledPerson.sayHi(); // Hi, my name is Daniel
skilledPerson.dance(); // Daniel is dancing

type Constructor<T = {}> = new (...args: any[]) => T;

function canEat<TBase extends Constructor>(Base: TBase) {
    return class extends Base {
    	eat() {
        	console.log(`${this.name} is eating`);
    	}
    };
}

function canSleep<TBase extends Constructor>(Base: TBase) {
    return class extends Base {
    	sleep() {
        	console.log(`${this.name} is sleeping`);
    	}
    };
}

class Person {
    constructor(public name: string) {}
}

const PersonWithHabits = canEat(canSleep(Person));

const personWithHabits = new PersonWithHabits("Daniel");
personWithHabits.eat(); // Daniel is eating
personWithHabits.sleep(); // Daniel is sleeping