TypeScript Dekoratorlari: Mustahkam Ilovalar Uchun Metadata Dasturlash Namunalarini Mukammal O'zlashtirish

            @MyDecorator
class MyClass {
  @AnotherDecorator
  myMethod() {
    // ...
  }
}
            

              
                Copy
              
            
          

            // tsconfig.json
{
  "compilerOptions": {
    "target": "ES2017",
    "module": "commonjs",
    "experimentalDecorators": true,
    "emitDecoratorMetadata": true,
    "outDir": "./dist",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true
  }
}
            

              
                Copy
              
            
          

            npm install reflect-metadata --save
# yoki
yarn add reflect-metadata
            

              
                Copy
              
            
          

            import "reflect-metadata";
// Ilovangiz kodi davom etadi
            

              
                Copy
              
            
          

            function Logger(prefix: string) {
  return function (target: Function) {
    console.log(`[${prefix}] ${target.name} sinfi aniqlandi.`);
  };
}

@Logger("APP_INIT")
class ApplicationBootstrap {
  constructor() {
    console.log("Ilova ishga tushmoqda...");
  }
}

const app = new ApplicationBootstrap();
// Chiqish:
// [APP_INIT] ApplicationBootstrap sinfi aniqlandi.
// Ilova ishga tushmoqda...
            

              
                Copy
              
            
          

            function ClassDecorator(target: Function) { ... }
            

              
                Copy
              
            
          

            const InjectableServiceRegistry = new Map<string, Function>();

function Injectable(name?: string) {
  return function<T extends { new(...args: any[]): {} }>(constructor: T) {
    const serviceName = name || constructor.name;
    InjectableServiceRegistry.set(serviceName, constructor);
    console.log(`Ro'yxatdan o'tgan xizmat: ${serviceName}`);

    // Ixtiyoriy ravishda, xatti-harakatni kengaytirish uchun bu yerda yangi sinf qaytarishingiz mumkin
    return class extends constructor {
      createdAt = new Date();
      // Barcha kiritilgan xizmatlar uchun qo'shimcha xususiyatlar yoki metodlar
    };
  };
}

@Injectable("UserService")
class UserDataService {
  getUsers() {
    return [{ id: 1, name: "Alice" }, { id: 2, name: "Bob" }];
  }
}

@Injectable()
class ProductDataService {
  getProducts() {
    return [{ id: 101, name: "Laptop" }, { id: 102, name: "Mouse" }];
  }
}

console.log("--- Xizmatlar Ro'yxatdan O'tkazildi ---");
console.log(Array.from(InjectableServiceRegistry.keys()));

const userServiceConstructor = InjectableServiceRegistry.get("UserService");
if (userServiceConstructor) {
  const userServiceInstance = new userServiceConstructor();
  console.log("Foydalanuvchilar:", userServiceInstance.getUsers());
  // console.log("Foydalanuvchi Xizmati Yaratilgan Vaqt:", userServiceInstance.createdAt); // Agar qaytarilgan sinf ishlatilsa
}
            

              
                Copy
              
            
          

            function MethodDecorator(target: Object, propertyKey: string | symbol, descriptor: PropertyDescriptor) { ... }
            

              
                Copy
              
            
          

            function MeasurePerformance(target: Object, propertyKey: string, descriptor: PropertyDescriptor) {
  const originalMethod = descriptor.value;

  descriptor.value = function(...args: any[]) {
    const start = process.hrtime.bigint();
    const result = originalMethod.apply(this, args);
    const end = process.hrtime.bigint();
    const duration = Number(end - start) / 1_000_000;
    console.log(`"${propertyKey}" metodi ${duration.toFixed(2)} ms ichida bajarildi`);
    return result;
  };

  return descriptor;
}

class DataProcessor {
  @MeasurePerformance
  processData(data: number[]): number[] {
    // Murakkab, vaqt talab qiladigan operatsiyani simulyatsiya qilish
    for (let i = 0; i < 1_000_000; i++) {
      Math.sin(i);
    }
    return data.map(n => n * 2);
  }

  @MeasurePerformance
  fetchRemoteData(id: string): Promise<string> {
    return new Promise(resolve => {
      setTimeout(() => {
        resolve(`ID uchun ma'lumotlar: ${id}`);
      }, 500);
    });
  }
}

const processor = new DataProcessor();
processor.processData([1, 2, 3]);
processor.fetchRemoteData("abc").then(result => console.log(result));
            

              
                Copy
              
            
          

            function AccessorDecorator(target: Object, propertyKey: string | symbol, descriptor: PropertyDescriptor) { ... }
            

              
                Copy
              
            
          

            function CachedGetter(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
  const originalGetter = descriptor.get;
  const cacheKey = `_cached_${String(propertyKey)}`;

  if (originalGetter) {
    descriptor.get = function() {
      if (this[cacheKey] === undefined) {
        console.log(`[Kesh Topilmadi] ${String(propertyKey)} uchun qiymat hisoblanmoqda`);
        this[cacheKey] = originalGetter.apply(this);
      } else {
        console.log(`[Kesh Topildi] ${String(propertyKey)} uchun keshlangan qiymat ishlatilmoqda`);
      }
      return this[cacheKey];
    };
  }
  return descriptor;
}

class ReportGenerator {
  private data: number[];

  constructor(data: number[]) {
    this.data = data;
  }

  // Qimmat hisob-kitobni simulyatsiya qiladi
  @CachedGetter
  get expensiveSummary(): number {
    console.log("Qimmat xulosa hisob-kitobi bajarilmoqda...");
    return this.data.reduce((sum, current) => sum + current, 0) / this.data.length;
  }
}

const generator = new ReportGenerator([10, 20, 30, 40, 50]);

console.log("Birinchi kirish:", generator.expensiveSummary);
console.log("Ikkinchi kirish:", generator.expensiveSummary);
console.log("Uchinchi kirish:", generator.expensiveSummary);
            

              
                Copy
              
            
          

            function PropertyDecorator(target: Object, propertyKey: string | symbol) { ... }
            

              
                Copy
              
            
          

            interface ValidationRule {
  property: string | symbol;
  validate: (value: any) => boolean;
  message: string;
}

const validationRules: Map<Function, ValidationRule[]> = new Map();

function Required(target: Object, propertyKey: string | symbol) {
  const rules = validationRules.get(target.constructor) || [];
  rules.push({
    property: propertyKey,
    validate: (value: any) => value !== null && value !== undefined && value !== "",
    message: `${String(propertyKey)} majburiy.`
  });
  validationRules.set(target.constructor, rules);
}

function validate(instance: any): string[] {
  const classRules = validationRules.get(instance.constructor) || [];
  const errors: string[] = [];

  for (const rule of classRules) {
    if (!rule.validate(instance[rule.property])) {
      errors.push(rule.message);
    }
  }
  return errors;
}

class UserProfile {
  @Required
  firstName: string;

  @Required
  lastName: string;

  age?: number;

  constructor(firstName: string, lastName: string, age?: number) {
    this.firstName = firstName;
    this.lastName = lastName;
    this.age = age;
  }
}

const user1 = new UserProfile("John", "Doe", 30);
console.log("User 1 tekshiruv xatolari:", validate(user1)); // []

const user2 = new UserProfile("", "Smith");
console.log("User 2 tekshiruv xatolari:", validate(user2)); // ["firstName majburiy."]

const user3 = new UserProfile("Alice", "");
console.log("User 3 tekshiruv xatolari:", validate(user3)); // ["lastName majburiy."]
            

              
                Copy
              
            
          

            function ParameterDecorator(target: Object, propertyKey: string | symbol | undefined, parameterIndex: number) { ... }
            

              
                Copy
              
            
          

            interface ParameterMetadata {
  index: number;
  key: string | symbol;
  resolver: (request: any) => any;
}

const parameterResolvers: Map<Function, Map<string | symbol, ParameterMetadata[]>> = new Map();

function RequestParam(paramName: string) {
  return function (target: Object, propertyKey: string | symbol | undefined, parameterIndex: number) {
    const targetKey = propertyKey || "constructor";
    let methodResolvers = parameterResolvers.get(target.constructor);
    if (!methodResolvers) {
      methodResolvers = new Map();
      parameterResolvers.set(target.constructor, methodResolvers);
    }
    const paramMetadata = methodResolvers.get(targetKey) || [];
    paramMetadata.push({
      index: parameterIndex,
      key: targetKey,
      resolver: (request: any) => request[paramName]
    });
    methodResolvers.set(targetKey, paramMetadata);
  };
}

// Metodni hal qilingan parametrlar bilan chaqirish uchun gipotetik freymvork funksiyasi
function executeWithParams(instance: any, methodName: string, request: any) {
  const classResolvers = parameterResolvers.get(instance.constructor);
  if (!classResolvers) {
    return (instance[methodName] as Function).apply(instance, []);
  }
  const methodParamMetadata = classResolvers.get(methodName);
  if (!methodParamMetadata) {
    return (instance[methodName] as Function).apply(instance, []);
  }

  const args: any[] = Array(methodParamMetadata.length);
  for (const meta of methodParamMetadata) {
    args[meta.index] = meta.resolver(request);
  }
  return (instance[methodName] as Function).apply(instance, args);
}

class UserController {
  getUser(@RequestParam("id") userId: string, @RequestParam("token") authToken?: string) {
    console.log(`Foydalanuvchini ID bilan qidirish: ${userId}, Token: ${authToken || "N/A"}`);
    return { id: userId, name: "Jane Doe" };
  }

  deleteUser(@RequestParam("id") userId: string) {
    console.log(`Foydalanuvchini ID bilan o'chirish: ${userId}`);
    return { status: "deleted", id: userId };
  }
}

const userController = new UserController();

// Kiruvchi so'rovni simulyatsiya qilish
const mockRequest = {
  id: "user123",
  token: "abc-123",
  someOtherProp: "xyz"
};

console.log("\n--- getUser bajarilmoqda ---");
executeWithParams(userController, "getUser", mockRequest);

console.log("\n--- deleteUser bajarilmoqda ---");
executeWithParams(userController, "deleteUser", { id: "user456" });
            

              
                Copy
              
            
          

            @DecoratorA
@DecoratorB
class MyClass {
  // ...
}

            

              
                Copy
              
            
          

            function LogCall(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
  const originalMethod = descriptor.value;
  descriptor.value = function (...args: any[]) {
    console.log(`[LOG] ${String(propertyKey)} chaqirilmoqda, argumentlar:`, args);
    const result = originalMethod.apply(this, args);
    console.log(`[LOG] ${String(propertyKey)} metodi qaytardi:`, result);
    return result;
  };
  return descriptor;
}

function Authorization(roles: string[]) {
  return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
    const originalMethod = descriptor.value;
    descriptor.value = function (...args: any[]) {
      const currentUserRoles = ["admin"]; // Joriy foydalanuvchi rollarini olishni simulyatsiya qilish
      const authorized = roles.some(role => currentUserRoles.includes(role));
      if (!authorized) {
        console.warn(`[AUTH] ${String(propertyKey)} uchun kirish rad etildi. Talab qilinadigan rollar: ${roles.join(", ")}`);
        throw new Error("Ruxsatsiz kirish");
      }
      console.log(`[AUTH] ${String(propertyKey)} uchun kirishga ruxsat berildi`);
      return originalMethod.apply(this, args);
    };
    return descriptor;
  };
}

class SecureService {
  @LogCall
  @Authorization(["admin"])
  deleteSensitiveData(id: string) {
    console.log(`Maxfiy ma'lumotlar o'chirilmoqda, ID: ${id}`);
    return `Ma'lumot ID ${id} o'chirildi.`;
  }

  @Authorization(["user"])
  @LogCall // Tartib bu yerda o'zgartirildi
  fetchPublicData(query: string) {
    console.log(`Ommaviy ma'lumotlar so'rov bilan qidirilmoqda: ${query}`);
    return `So'rov uchun ommaviy ma'lumotlar: ${query}`; 
  }
}

const service = new SecureService();

try {
  console.log("\n--- deleteSensitiveData (Admin Foydalanuvchi) chaqirilmoqda ---");
  service.deleteSensitiveData("record123");
} catch (error: any) {
  console.error(error.message);
}

try {
  console.log("\n--- fetchPublicData (Admin bo'lmagan Foydalanuvchi) chaqirilmoqda ---");
  // 'user' rolini talab qiladigan fetchPublicData ga kirishga urinayotgan admin bo'lmagan foydalanuvchini simulyatsiya qilish
  const mockUserRoles = ["guest"]; // Bu avtorizatsiyadan o'tmaydi
  // Buni dinamik qilish uchun sizga DI tizimi yoki joriy foydalanuvchi rollari uchun statik kontekst kerak bo'ladi.
  // Sodda bo'lishi uchun, Authorization dekoratori joriy foydalanuvchi kontekstiga kirish huquqiga ega deb faraz qilamiz.
  // Birinchi chaqiruv muvaffaqiyatli bo'lishi va ikkinchisi muvaffaqiyatsiz bo'lishi uchun demo maqsadida Authorization dekoratorini har doim 'admin' deb hisoblashga sozlaymiz,
  // shunda turli yo'llar ko'rsatiladi.
  
  // fetchPublicData muvaffaqiyatli bo'lishi uchun foydalanuvchi roli bilan qayta ishga tushiring.
  // Authorization'dagi currentUserRoles: ['user'] bo'ladi deb tasavvur qiling
  // Ushbu misol uchun, buni oddiy saqlaymiz va tartib ta'sirini ko'rsatamiz.
  service.fetchPublicData("search term"); // Bu Auth -> Log ni bajaradi
} catch (error: any) {
  console.error(error.message);
}

/* deleteSensitiveData uchun kutilgan chiqish:
[AUTH] deleteSensitiveData uchun kirishga ruxsat berildi
[LOG] deleteSensitiveData chaqirilmoqda, argumentlar: [ 'record123' ]
Maxfiy ma'lumotlar o'chirilmoqda, ID: record123
[LOG] deleteSensitiveData metodi qaytardi: Ma'lumot ID record123 o'chirildi.
*/

/* fetchPublicData uchun kutilgan chiqish (agar foydalanuvchi 'user' roliga ega bo'lsa):
[LOG] fetchPublicData chaqirilmoqda, argumentlar: [ 'search term' ]
[AUTH] fetchPublicData uchun kirishga ruxsat berildi
Ommaviy ma'lumotlar so'rov bilan qidirilmoqda: search term
[LOG] fetchPublicData metodi qaytardi: So'rov uchun ommaviy ma'lumotlar: search term
*/
            

              
                Copy
              
            
          

            function log(message: string) {
  return function (target: any, propertyKey: string | symbol | undefined, descriptorOrIndex?: PropertyDescriptor | number) {
    if (typeof descriptorOrIndex === 'number') {
      console.log(`Parametr Dekoratori: ${message} ${String(propertyKey || "constructor")} ning #${descriptorOrIndex} parametrida`);
    } else if (typeof propertyKey === 'string' || typeof propertyKey === 'symbol') {
      if (descriptorOrIndex && 'value' in descriptorOrIndex && typeof descriptorOrIndex.value === 'function') {
        console.log(`Metod/Aksessor Dekoratori: ${message} ${String(propertyKey)} da`);
      } else {
        console.log(`Xususiyat Dekoratori: ${message} ${String(propertyKey)} da`);
      }
    } else {
      console.log(`Sinf Dekoratori: ${message} ${target.name} da`);
    }
    return descriptorOrIndex; // Metod/aksessor uchun deskriptorni, boshqalar uchun undefined qaytaradi
  };
}

@log("Sinf Darajasi D")
@log("Sinf Darajasi C")
class MyDecoratedClass {
  @log("Statik Xususiyat A")
  static staticProp: string = "";

  @log("Instans Xususiyati B")
  instanceProp: number = 0;

  @log("Metod D")
  @log("Metod C")
  myMethod(
    @log("Parametr Z") paramZ: string,
    @log("Parametr Y") paramY: number
  ) {
    console.log("myMethod metodi bajarildi.");
  }

  @log("Getter/Setter F")
  get myAccessor() {
    return "";
  }

  set myAccessor(value: string) {
    //...
  }

  constructor() {
    console.log("Konstruktor bajarildi.");
  }
}

new MyDecoratedClass();
// Metod dekoratorini ishga tushirish uchun metodni chaqirish
new MyDecoratedClass().myMethod("hello", 123);

/* Taxminiy Chiqish Tartibi (muayyan TypeScript versiyasi va kompilyatsiyaga bog'liq):
Parametr Dekoratori: Parametr Y myMethod ning #1 parametrida
Parametr Dekoratori: Parametr Z myMethod ning #0 parametrida
Xususiyat Dekoratori: Statik Xususiyat A staticProp da
Xususiyat Dekoratori: Instans Xususiyati B instanceProp da
Metod/Aksessor Dekoratori: Getter/Setter F myAccessor da
Metod/Aksessor Dekoratori: Metod C myMethod da
Metod/Aksessor Dekoratori: Metod D myMethod da
Sinf Dekoratori: Sinf Darajasi C MyDecoratedClass da
Sinf Dekoratori: Sinf Darajasi D MyDecoratedClass da
Konstruktor bajarildi.
myMethod metodi bajarildi.
*/
            

              
                Copy
              
            
          

            import "reflect-metadata"; // emitDecoratorMetadata uchun muhim

const INJECTABLE_METADATA_KEY = Symbol("injectable");
const INJECT_METADATA_KEY = Symbol("inject");

function Injectable() {
  return function (target: Function) {
    Reflect.defineMetadata(INJECTABLE_METADATA_KEY, true, target);
  };
}

function Inject(token: any) {
  return function (target: Object, propertyKey: string | symbol, parameterIndex: number) {
    const existingInjections: any[] = Reflect.getOwnMetadata(INJECT_METADATA_KEY, target, propertyKey) || [];
    existingInjections[parameterIndex] = token;
    Reflect.defineMetadata(INJECT_METADATA_KEY, existingInjections, target, propertyKey);
  };
}

class Container {
  private static instances = new Map<any, any>();

  static resolve<T>(target: { new (...args: any[]): T }): T {
    if (Container.instances.has(target)) {
      return Container.instances.get(target);
    }

    const isInjectable = Reflect.getMetadata(INJECTABLE_METADATA_KEY, target);
    if (!isInjectable) {
      throw new Error(`${target.name} sinfi @Injectable deb belgilanmagan.`);
    }

    // Konstruktor parametrlarining turlarini olish (emitDecoratorMetadata talab qiladi)
    const paramTypes: any[] = Reflect.getMetadata("design:paramtypes", target) || [];
    const explicitInjections: any[] = Reflect.getMetadata(INJECT_METADATA_KEY, target) || [];

    const dependencies = paramTypes.map((paramType, index) => {
      // Agar taqdim etilgan bo'lsa, aniq @Inject tokenidan foydalaning, aks holda tipni aniqlang
      const token = explicitInjections[index] || paramType;
      if (token === undefined) {
        throw new Error(`${target.name} uchun ${index} indeksidagi parametrni hal qilib bo'lmadi. Bu aylanma bog'liqlik yoki aniq @Inject'siz primitiv tur bo'lishi mumkin.`);
      }
      return Container.resolve(token);
    });

    const instance = new target(...dependencies);
    Container.instances.set(target, instance);
    return instance;
  }
}

// Xizmatlarni aniqlash
@Injectable()
class DatabaseService {
  connect() {
    console.log("Ma'lumotlar bazasiga ulanilmoqda...");
    return "DB Ulanishi";
  }
}

@Injectable()
class AuthService {
  private db: DatabaseService;

  constructor(db: DatabaseService) {
    this.db = db;
  }

  login() {
    console.log(`AuthService: ${this.db.connect()} yordamida autentifikatsiya qilinmoqda`);
    return "Foydalanuvchi tizimga kirdi";
  }
}

@Injectable()
class UserService {
  private authService: AuthService;
  private dbService: DatabaseService; // Maxsus dekorator yoki freymvork xususiyati yordamida xususiyat orqali kiritish misoli

  constructor(@Inject(AuthService) authService: AuthService,
              @Inject(DatabaseService) dbService: DatabaseService) {
    this.authService = authService;
    this.dbService = dbService;
  }

  getUserProfile() {
    this.authService.login();
    this.dbService.connect();
    console.log("UserService: Foydalanuvchi profilini qidirilmoqda...");
    return { id: 1, name: "Global User" };
  }
}

// Asosiy xizmatni hal qilish
console.log("--- UserService hal qilinmoqda ---");
const userService = Container.resolve(UserService);
console.log(userService.getUserProfile());

console.log("\n--- AuthService hal qilinmoqda (keshlangan bo'lishi kerak) ---");
const authService = Container.resolve(AuthService);
authService.login();
            

              
                Copy
              
            
          

            function LogMethod(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
  const originalMethod = descriptor.value;
  descriptor.value = function (...args: any[]) {
    console.log(`[LOG AOP] Metodga kirilmoqda: ${String(propertyKey)}, argumentlar:`, args);
    try {
      const result = originalMethod.apply(this, args);
      console.log(`[LOG AOP] Metoddan chiqilmoqda: ${String(propertyKey)}, natija:`, result);
      return result;
    } catch (error: any) {
      console.error(`[LOG AOP] ${String(propertyKey)} metodida xatolik:`, error.message);
      throw error;
    }
  };
  return descriptor;
}

class PaymentProcessor {
  @LogMethod
  processPayment(amount: number, currency: string) {
    if (amount <= 0) {
      throw new Error("To'lov miqdori musbat bo'lishi kerak.");
    }
    console.log(`${amount} ${currency} to'lovi qayta ishlanmoqda...`);
    return `${amount} ${currency} to'lovi muvaffaqiyatli qayta ishlandi.`;
  }

  @LogMethod
  refundPayment(transactionId: string) {
    console.log(`Tranzaksiya ID si uchun to'lov qaytarilmoqda: ${transactionId}...`);
    return `${transactionId} uchun qaytarish boshlandi.`;
  }
}

const processor = new PaymentProcessor();
processor.processPayment(100, "USD");
try {
  processor.processPayment(-50, "EUR");
} catch (error: any) {
  console.error("Ushlangan xato:", error.message);
}
            

              
                Copy
              
            
          

            interface FieldValidationRule {
  property: string | symbol;
  validator: (value: any) => boolean;
  message: string;
}

const fieldValidationRules = new Map<Function, FieldValidationRule[]>();

function addValidationRule(target: Object, propertyKey: string | symbol, validator: (value: any) => boolean, message: string) {
  const rules = fieldValidationRules.get(target.constructor) || [];
  rules.push({ property: propertyKey, validator, message });
  fieldValidationRules.set(target.constructor, rules);
}

function IsPositive(target: Object, propertyKey: string | symbol) {
  addValidationRule(target, propertyKey, (value: number) => value > 0, `${String(propertyKey)} musbat son bo'lishi kerak.`);
}

function MaxLength(maxLength: number) {
  return function (target: Object, propertyKey: string | symbol) {
    addValidationRule(target, propertyKey, (value: string) => value.length <= maxLength, `${String(propertyKey)} ko'pi bilan ${maxLength} belgidan iborat bo'lishi kerak.`);
  };
}

class Product {
  @MaxLength(50)
  name: string;

  @IsPositive
  price: number;

  constructor(name: string, price: number) {
    this.name = name;
    this.price = price;
  }

  static validate(instance: any): string[] {
    const errors: string[] = [];
    const rules = fieldValidationRules.get(instance.constructor) || [];
    for (const rule of rules) {
      if (!rule.validator(instance[rule.property])) {
        errors.push(rule.message);
      }
    }
    return errors;
  }
}

const product1 = new Product("Laptop", 1200);
console.log("Mahsulot 1 xatolari:", Product.validate(product1)); // []

const product2 = new Product("Juda uzun mahsulot nomi, sinov maqsadi uchun ellik belgi chegarasidan oshadi", 50);
console.log("Mahsulot 2 xatolari:", Product.validate(product2)); // ["name ko'pi bilan 50 belgidan iborat bo'lishi kerak."]

const product3 = new Product("Kitob", -10);
console.log("Mahsulot 3 xatolari:", Product.validate(product3)); // ["price musbat son bo'lishi kerak."]
            

              
                Copy
              
            
          

            // Metodning loglanishini va admin rollarini talab qilishini ta'minlaydigan dekorator
function AdminAndLoggedMethod() {
  return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
    // Avval Authorization'ni qo'llang (ichki)
    Authorization(["admin"])(target, propertyKey, descriptor);
    // Keyin LogCall'ni qo'llang (tashqi)
    LogCall(target, propertyKey, descriptor);

    return descriptor; // O'zgartirilgan deskriptorni qaytaring
  };
}

class AdminPanel {
  @AdminAndLoggedMethod()
  deleteUserAccount(userId: string) {
    console.log(`Foydalanuvchi hisobi o'chirilmoqda: ${userId}`);
    return `Foydalanuvchi ${userId} o'chirildi.`;
  }
}

const adminPanel = new AdminPanel();
adminPanel.deleteUserAccount("user007");
/* Kutilgan Chiqish (admin roli mavjud deb taxmin qilinsa):
[AUTH] deleteUserAccount uchun kirishga ruxsat berildi
[LOG] deleteUserAccount chaqirilmoqda, argumentlar: [ 'user007' ]
Foydalanuvchi hisobi o'chirilmoqda: user007
[LOG] deleteUserAccount metodi qaytardi: Foydalanuvchi user007 o'chirildi.
*/
            

              
                Copy
              
            
          

            function ApplyMixins(constructors: Function[]) {
  return function (derivedConstructor: Function) {
    constructors.forEach(baseConstructor => {
      Object.getOwnPropertyNames(baseConstructor.prototype).forEach(name => {
        Object.defineProperty(
          derivedConstructor.prototype,
          name,
          Object.getOwnPropertyDescriptor(baseConstructor.prototype, name) || Object.create(null)
        );
      });
    });
  };
}

class Disposable {
  isDisposed: boolean = false;
  dispose() {
    this.isDisposed = true;
    console.log("Obyekt yo'q qilindi.");
  }
}

class Loggable {
  log(message: string) {
    console.log(`[Loggable] ${message}`);
  }
}

@ApplyMixins([Disposable, Loggable])
class MyResource implements Disposable, Loggable {
  // Bu xususiyatlar/metodlar dekorator tomonidan kiritiladi
  isDisposed!: boolean;
  dispose!: () => void;
  log!: (message: string) => void;

  constructor(public name: string) {
    this.log(`Resurs ${this.name} yaratildi.`);
  }

  cleanUp() {
    this.dispose();
    this.log(`Resurs ${this.name} tozalandi.`);
  }
}

const resource = new MyResource("NetworkConnection");
console.log(`Yo'q qilinganmi: ${resource.isDisposed}`);
resource.cleanUp();
console.log(`Yo'q qilinganmi: ${resource.isDisposed}`);
            

              
                Copy