Modulni kengaytirish: Uchinchi tomon kutubxonasi turlarini muammosiz kengaytirish

            
// Misol uchun, agar siz 'lodash' modulini kengaytirishni istasangiz
import 'lodash';

declare module 'lodash' {
  interface LoDashStatic {
    // Yangi usullar yoki xususiyatlarni shu yerga qo'shing
    myCustomUtility(input: string): string;
  }
}

            

              
                Copy
              
            
          

            
import _ from 'lodash';

const result = _.myCustomUtility('hello from the world!');
console.log(result); // Natija: 'hello from the world!' (agar sizning ta'minotingiz kirishni qaytarsa)

            

              
                Copy
              
            
          

            
// src/types/date-fns.d.ts

// Kengaytirishni belgilash uchun modulni import qiling.
// Ushbu qator hech qanday runtime kodni qo'shmaydi.
import 'date-fns';

declare module 'date-fns' {
  // Biz asosiy eksportni kengaytiramiz, bu ko'pincha neymspeys yoki ob'ekt bo'ladi.
  // date-fns uchun, ko'pincha funksiyalar bilan to'g'ridan-to'g'ri ishlashadi, shuning uchun biz
  // maxsus funksiyani yoki modulning eksport ob'ektini kengaytirishimiz kerak bo'lishi mumkin.
  // Kengaytirish uchun to'g'ri joyni topishimiz kerak.

  // date-fns uchun, aniqroq yondashuv bu modulning eksportlariga yangi funksiya imzosini qo'shishdir.
  // Agar biz asosiy kutubxona turlarini o'zgartirmoqchi bo'lsak.

  // Kengaytirishni modulga yangi funksiya bilan ko'rsatishni ko'rsatamiz.

  // Ushbu soddalashtirilgan misol, agar biz `formatEuropeanDate` nomli funksiya qo'shmoqchi bo'lsak.
  // Haqiqatda, date-fns funksiyalarni to'g'ridan-to'g'ri eksport qiladi. Bizning funksiyamizni modul eksportlariga qo'shishimiz mumkin.

  // Modulni yangi funksiya bilan kengaytirish uchun biz modul eksporti uchun yangi tur e'lon qilishimiz mumkin.
  // Agar kutubxona `import * as dateFns from 'date-fns';` kabi import qilinsa,
  // biz DateFns neymspeysini kengaytiramiz. Agar `import dateFns from 'date-fns';` kabi import qilinsa,
  // biz standart eksport turini kengaytiramiz.

  // date-fns uchun, funksiyalarni to'g'ridan-to'g'ri eksport qiladi, siz odatda o'zingizni yozasiz
  // funksiya, u ichida date-fns'dan foydalanadi. Biroq, kutubxona strukturasi bunga imkon bersa
  // (masalan, u foydali usullarning ob'ektini eksport qilsa), siz ushbu ob'ektni kengaytira olgan bo'lardingiz.

  // Kengaytirishni modulga yangi funksiya qo'shish orqali ko'rsatamiz.
  // Bu modulning eksportlariga yangi nomlangan eksportni qo'shishni o'z ichiga oladi.

  // Birinchi navbatda, modulning o'zini kengaytirishga harakat qilamiz.
  // Agar date-fns kabi tuzilgan bo'lsa: `export const format = ...; export const parse = ...;`
  // Biz ularga to'g'ridan-to'g'ri qo'sha olmaymiz. Modul kengaytirish deklaratsiyalarni birlashtirish orqali ishlaydi.

  // date-fns uchun eng keng tarqalgan va to'g'ri yo'l - bu modulni yangi funksiya imzosi bilan kengaytirishdir.
  // Bu, kutubxona eksportlari moslashuvchanligini taxmin qiladi.

  // Agar biz `formatEuropeanDate` funksiyasini qo'shmoqchi bo'lsak:
  // Buning eng yaxshi usuli - bu o'zingizning funksiyangizni aniqlash va uni ichida date-fnsni import qilish.
  // Biroq, modulni kengaytirish masalasini ko'rsatish uchun:

  // Biz 'date-fns' modulini yangi funksiya imzosi bilan kengaytiramiz.
  // Ushbu yondashuv modul eksportlari moslashuvchanligini taxmin qiladi.
  // Haqiqiyroq stsenariy - bu funksiya tomonidan qaytarilgan turini kengaytirish.

  // Kengaytirilgan `format` funksiyasi uchun yangi format belgisini kiritish orqali.
  // Bu `format` funksiyasining ichki tuzilishini va qabul qilinadigan format belgilari.

  // Keng tarqalgan usul - bu modulni nomlangan eksport bilan kengaytirish, agar kutubxona uni qo'llab-quvvatlasa.

  // Bu soddalashtirilgan misol, biz `formatEuropeanDate` nomli funksiya qo'shmoqchi bo'lsak.
  // Haqiqatda, date-fns funksiyalarni to'g'ridan-to'g'ri eksport qiladi. Bizning funksiyamizni modul eksportlariga qo'shishimiz mumkin.

  // Modulni yangi funksiya bilan kengaytirish uchun biz modul eksporti uchun yangi tur e'lon qilishimiz mumkin.
  // Agar kutubxona `import * as dateFns from 'date-fns';` kabi import qilinsa,
  // biz DateFns neymspeysini kengaytiramiz. Agar `import dateFns from 'date-fns';` kabi import qilinsa,
  // biz standart eksport turini kengaytiramiz.

  // date-fns uchun, funksiyalarni to'g'ridan-to'g'ri eksport qiladi, siz odatda o'zingizni yozasiz
  // funksiya, u ichida date-fns'dan foydalanadi. Biroq, kutubxona strukturasi bunga imkon bersa
  // (masalan, u foydali usullarning ob'ektini eksport qilsa), siz ushbu ob'ektni kengaytira olgan bo'lardingiz.

  // Kengaytirilgan `format` funksiyasi uchun yangi format belgisini kiritish orqali.
  // Bu `format` funksiyasining ichki tuzilishini va qabul qilinadigan format belgilari.

  // Keng tarqalgan usul - bu modulni nomlangan eksport bilan kengaytirish, agar kutubxona uni qo'llab-quvvatlasa.

  // Bu soddalashtirilgan misol, biz `formatEuropeanDate` nomli funksiya qo'shmoqchi bo'lsak.
  // Haqiqatda, date-fns funksiyalarni to'g'ridan-to'g'ri eksport qiladi. Bizning funksiyamizni modul eksportlariga qo'shishimiz mumkin.

  // Modulni yangi funksiya bilan kengaytirish uchun biz modul eksporti uchun yangi tur e'lon qilishimiz mumkin.
  // Agar kutubxona `import * as dateFns from 'date-fns';` kabi import qilinsa,
  // biz DateFns neymspeysini kengaytiramiz. Agar `import dateFns from 'date-fns';` kabi import qilinsa,
  // biz standart eksport turini kengaytiramiz.

  // date-fns uchun, funksiyalarni to'g'ridan-to'g'ri eksport qiladi, siz odatda o'zingizni yozasiz
  // funksiya, u ichida date-fns'dan foydalanadi. Biroq, kutubxona strukturasi bunga imkon bersa
  // (masalan, u foydali usullarning ob'ektini eksport qilsa), siz ushbu ob'ektni kengaytira olgan bo'lardingiz.

  // Agar biz `formatEuropeanDate` funksiyasini qo'shmoqchi bo'lsak:
  // Buning eng yaxshi usuli - bu o'zingizning funksiyangizni aniqlash va uni ichida date-fnsni import qilish.
  // Biroq, modulni kengaytirish masalasini ko'rsatish uchun:

  // Biz 'date-fns' modulini yangi funksiya imzosi bilan kengaytiramiz.
  // Ushbu yondashuv modul eksportlari moslashuvchanligini taxmin qiladi.
  // Haqiqiyroq stsenariy - bu funksiya tomonidan qaytarilgan turini kengaytirish.

  // Kengaytirilgan `format` funksiyasi uchun yangi format belgisini kiritish orqali.
  // Bu `format` funksiyasining ichki tuzilishini va qabul qilinadigan format belgilari.

  // Keng tarqalgan usul - bu modulni nomlangan eksport bilan kengaytirish, agar kutubxona uni qo'llab-quvvatlasa.

  // Bu soddalashtirilgan misol, biz `formatEuropeanDate` nomli funksiya qo'shmoqchi bo'lsak.
  // Haqiqatda, date-fns funksiyalarni to'g'ridan-to'g'ri eksport qiladi. Bizning funksiyamizni modul eksportlariga qo'shishimiz mumkin.

  // Modulni yangi funksiya bilan kengaytirish uchun biz modul eksporti uchun yangi tur e'lon qilishimiz mumkin.
  // Agar kutubxona `import * as dateFns from 'date-fns';` kabi import qilinsa,
  // biz DateFns neymspeysini kengaytiramiz. Agar `import dateFns from 'date-fns';` kabi import qilinsa,
  // biz standart eksport turini kengaytiramiz.

  // date-fns uchun, funksiyalarni to'g'ridan-to'g'ri eksport qiladi, siz odatda o'zingizni yozasiz
  // funksiya, u ichida date-fns'dan foydalanadi. Biroq, kutubxona strukturasi bunga imkon bersa
  // (masalan, u foydali usullarning ob'ektini eksport qilsa), siz ushbu ob'ektni kengaytira olgan bo'lardingiz.

  // Agar biz `formatEuropeanDate` funksiyasini qo'shmoqchi bo'lsak:
  // Buning eng yaxshi usuli - bu o'zingizning funksiyangizni aniqlash va uni ichida date-fnsni import qilish.
  // Biroq, modulni kengaytirish masalasini ko'rsatish uchun:

  // Biz 'date-fns' modulini yangi funksiya imzosi bilan kengaytiramiz.
  // Ushbu yondashuv modul eksportlari moslashuvchanligini taxmin qiladi.
  // Haqiqiyroq stsenariy - bu funksiya tomonidan qaytarilgan turini kengaytirish.

  // Kengaytirilgan `format` funksiyasi uchun yangi format belgisini kiritish orqali.
  // Bu `format` funksiyasining ichki tuzilishini va qabul qilinadigan format belgilari.

  // Keng tarqalgan usul - bu modulni nomlangan eksport bilan kengaytirish, agar kutubxona uni qo'llab-quvvatlasa.

  // Bu soddalashtirilgan misol, biz `formatEuropeanDate` nomli funksiya qo'shmoqchi bo'lsak.
  // Haqiqatda, date-fns funksiyalarni to'g'ridan-to'g'ri eksport qiladi. Bizning funksiyamizni modul eksportlariga qo'shishimiz mumkin.

  // Modulni yangi funksiya bilan kengaytirish uchun biz modul eksporti uchun yangi tur e'lon qilishimiz mumkin.
  // Agar kutubxona `import * as dateFns from 'date-fns';` kabi import qilinsa,
  // biz DateFns neymspeysini kengaytiramiz. Agar `import dateFns from 'date-fns';` kabi import qilinsa,
  // biz standart eksport turini kengaytiramiz.

  // date-fns uchun, funksiyalarni to'g'ridan-to'g'ri eksport qiladi, siz odatda o'zingizni yozasiz
  // funksiya, u ichida date-fns'dan foydalanadi. Biroq, kutubxona strukturasi bunga imkon bersa
  // (masalan, u foydali usullarning ob'ektini eksport qilsa), siz ushbu ob'ektni kengaytira olgan bo'lardingiz.
}

            

              
                Copy
              
            
          

            
// Kutubxona ichida qanday tuzilgan bo'lishi mumkin
export interface AppConfig {
  apiUrl: string;
  timeout: number;
}

export const config: AppConfig = { ... };

            

              
                Copy
              
            
          

            
// src/types/config.d.ts

import 'config'; // Bu 'config' moduli uchun kengaytirishni bildiradi.

declare module 'config' {
  // Biz 'config' modulidan mavjud AppConfig interfeysini kengaytiramiz.
  interface AppConfig {
    // Yangi xususiyatimizni qo'shing.
    environment: 'development' | 'staging' | 'production';
    // Boshqa maxsus xususiyatni qo'shing.
    featureFlags: Record;
  }
}

            

              
                Copy
              
            
          

            
// src/config.ts

// Uni kengaytirish uchun original konfiguratsiyani import qilishimiz kerak.
// Agar 'config' `config: AppConfig` ni to'g'ridan-to'g'ri eksport qilsa, biz uni import qilardik.
// Ushbu misol uchun, biz eksport qilingan ob'ektni qayta yozish yoki kengaytirishni ko'rsatamiz.

// MUHIM: Ushbu fayl jismonan mavjud bo'lishi va kompilyatsiya qilinishi kerak.
// Bu faqat tur deklaratsiyalari emas.

// Original konfiguratsiyani import qiling (bu 'config' nimadirni eksport qilishini taxmin qiladi).
// Soddalik uchun, biz uni qayta eksport qilib, xususiyatlarni qo'shishimizni ko'rsatamiz.
// Haqiqiy stsenariyda, siz original config ob'ektini import qilib, uni o'zgartirishingiz mumkin,
// yoki kengaytirilgan turga mos keladigan yangi ob'ektni taqdim etishingiz mumkin.

// Biz 'config' moduli eksport ob'ektini kengaytirishimiz mumkinligini taxmin qilamiz.
// Bu ko'pincha qayta eksport qilish va xususiyatlarni qo'shish orqali amalga oshiriladi.

// Bu original modul kengaytirishga imkon beradigan tarzda tuzilganligini talab qiladi.
// Agar original modul `export const config = { apiUrl: '...', timeout: 5000 };` ni eksport qilsa,
// biz original modulni yoki uning importini o'zgartirmasdan runtime'da unga to'g'ridan-to'g'ri qo'sha olmaymiz.

// Umumiy naqsh - bu inicializatsiya funksiyasi yoki ob'ekt bo'lgan standart eksport.

// Bizning loyihamizdagi 'config' ob'ektini qayta aniqlaymiz, uning kengaytirilgan turlarga ega ekanligiga ishonch hosil qilamiz.
// Bu sizning loyihangizning `config.ts` fayli runtime qiymatlarini taqdim etadi, degan ma'noni anglatadi.

import { AppConfig as OriginalAppConfig } from 'config';

// Kengaytirilgan konfiguratsiya turini aniqlang, bu endi bizning kengaytmalarimizni o'z ichiga oladi.
// Ushbu tur kengaytirilgan `AppConfig` deklaratsiyasidan olingan.
interface ExtendedAppConfig extends OriginalAppConfig {
  environment: 'development' | 'staging' | 'production';
  featureFlags: Record;
}

// Konfiguratsiya uchun haqiqiy amalga oshirishni taqdim eting.
// Ushbu ob'ekt `ExtendedAppConfig` turiga mos kelishi kerak.
export const config: ExtendedAppConfig = {
  apiUrl: 'https://api.example.com',
  timeout: 10000,
  environment: process.env.NODE_ENV as 'development' | 'staging' | 'production' || 'development',
  featureFlags: {
    newUserDashboard: true,
    internationalPricing: false,
  },
};

// Ixtiyoriy ravishda, agar original kutubxona standart eksportni talab qilsa va biz uni saqlamoqchi bo'lsak:
// export default config;

// Agar original kutubxona `config` ni to'g'ridan-to'g'ri eksport qilsa, siz quyidagilarni qilishingiz mumkin:
// export * from 'config'; // Original eksportlarni import qiling
// export const config = { ...originalConfig, environment: '...', featureFlags: {...} }; // Qayta yozish yoki kengaytirish

// Asosiy narsa shundaki, ushbu `config.ts` fayli `environment` va `featureFlags` uchun runtime qiymatlarini taqdim etadi.

            

              
                Copy
              
            
          

            
// src/main.ts

import { config } from './config'; // O'zingizning kengaytirilgan config faylingizdan import qiling

console.log(`API URL: ${config.apiUrl}`);
console.log(`Joriy muhit: ${config.environment}`);
console.log(`Yangi foydalanuvchi Dashboard'i faollashtirilgan: ${config.featureFlags.newUserDashboard}`);

if (config.environment === 'production') {
  console.log('Ishlab chiqarish rejimida ishlayapti.');
}

            

              
                Copy
              
            
          

            
// src/types/express.d.ts

import 'express'; // 'express' moduli uchun kengaytirishni belgilash

declare global {
  // Freymvorklar tomonidan taqdim etilgan global Express neymspeysini kengaytirish ham keng tarqalgan.
  // Yoki, agar siz express moduli uchun modul kengaytirishni afzal ko'rsangiz:
  // declare module 'express' {
  //   interface Request {
  //     user?: { id: string; username: string; roles: string[]; };
  //   }
  // }

  // So'rov/javob ob'ektlari uchun freymvorklar uchun global kengaytirishni ishlatish ko'pincha to'g'ridan-to'g'ri va tozalash.
  namespace Express {
    interface Request {
      // Maxsus foydalanuvchi xususiyati uchun turini aniqlang.
      user?: {
        id: string;
        username: string;
        roles: string[];
        // Boshqa tegishli foydalanuvchi tafsilotlarini qo'shing.
      };
    }
  }
}

            

              
                Copy
              
            
          

            
// src/middleware/auth.ts

import { Request, Response, NextFunction } from 'express';

// Bu vositachi so'rov ob'ektiga foydalanuvchi ma'lumotlarini biriktiradi.
export const authenticateUser = (req: Request, res: Response, next: NextFunction) => {
  // Haqiqiy dasturda, siz buni token, ma'lumotlar bazasi va hokazolardan olardingiz.
  // Namuna uchun, biz uni qattiq kodlaymiz.
  const isAuthenticated = true; // Autentifikatsiyani simulyatsiya qilish

  if (isAuthenticated) {
    // TypeScript endi req.user mavjudligini va to'g'ri turga ega ekanligini biladi
    req.user = {
      id: 'user-123',
      username: 'alice_wonder',
      roles: ['admin', 'editor'],
    };
    console.log(`Foydalanuvchi autentifikatsiya qilindi: ${req.user.username}`);
  } else {
    console.log('Autentifikatsiya muvaffaqiyatsiz tugadi.');
    // Autentifikatsiya qilinmagan kirishni boshqaring (masalan, 401 yuboring)
    return res.status(401).send('Ruxsat etilmagan');
  }

  next(); // Keyingi vositachi yoki marshrut ishlovchisiga boshqaruvni uzating
};

            

              
                Copy
              
            
          

            
// src/app.ts

import express, { Request, Response } from 'express';
import { authenticateUser } from './middleware/auth';

const app = express();
const port = 3000;

// Barcha marshrutlarga yoki maxsus marshrutlarga autentifikatsiya vositachisini qo'llang.
app.use(authenticateUser);

// Kengaytirilgan req.user xususiyatidan foydalanadigan himoyalangan marshrut.
app.get('/profile', (req: Request, res: Response) => {
  // TypeScript req.user mavjudligini va kutilgan xususiyatlarga ega ekanligini to'g'ri aniqlaydi.
  if (req.user) {
    res.send(`Xush kelibsiz, ${req.user.username}! Sizning rollaringiz: ${req.user.roles.join(', ')}.`);
  } else {
    // Bu holat nazariy jihatdan vositachi to'g'ri ishlasa yetib kelmasligi kerak,
    // lekin to'liq tekshiruvlar uchun yaxshi amaliyot.
    res.status(401).send('Autentifikatsiya qilinmagan.');
  }
});

app.listen(port, () => {
  console.log(`Server port ${port} da ishlayapti`);
});

            

              
                Copy