> ## Documentation Index
> Fetch the complete documentation index at: https://www.mellowtel.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# एक अतिरिक्त सुविधा सक्षम करके अधिक कमाएं: Meucci

<Warning>
  इस सुविधा के लिए Mellowtel संस्करण 1.6.2 या उच्चतर की आवश्यकता है। यह पिछले संस्करणों की तुलना में एक ब्रेकिंग परिवर्तन है।
</Warning>

Mellowtel एक वैकल्पिक सुविधा प्रदान करता है जो आपको अधिक अनुरोधों को संभालने और इसलिए अधिक कमाई करने की अनुमति देता है। इस सुविधा को "Meucci" कहा जाता है।

## स्थापना

पहले, अपने पसंदीदा पैकेज प्रबंधक का उपयोग करके आवश्यक npm पैकेज इंस्टॉल करें:

### npm का उपयोग करते हुए

```bash theme={null}
npm install @mellowtel/module-meucci
```

### yarn का उपयोग करते हुए

```bash theme={null}
yarn add @mellowtel/module-meucci
```

### pnpm का उपयोग करते हुए

```bash theme={null}
pnpm add @mellowtel/module-meucci
```

नीचे आपके ब्राउज़र प्लगइन में Meucci सुविधा को सक्षम करने के निर्देश दिए गए हैं, जिसमें मानक और Plasmo फ्रेमवर्क कार्यान्वयन दोनों के विकल्प हैं।

## मानक कार्यान्वयन

### 1. `meucci.js` नामक एक जावास्क्रिप्ट फ़ाइल बनाएँ

src निर्देशिका में, या जहाँ भी आपके js फ़ाइलें हैं, `meucci.js` नामक एक फ़ाइल बनाएँ और निम्नलिखित कोड जोड़ें। सुनिश्चित करें कि यह फ़ाइल आपके अंतिम बिल्ड (/dist) निर्देशिका में शामिल हो।

यदि आपने प्रारंभिक [webpack कॉन्फ़िग सेटअप](/browser-plugins/static-to-webpack) का पालन किया है, तो आप बस इस फ़ाइल को अपने webpack कॉन्फ़िग में `entry` ऑब्जेक्ट में जोड़ सकते हैं।

```javascript theme={null}
import ModuleMeucci from "@mellowtel/module-meucci";

let moduleMeucci;

(async () => {
    moduleMeucci = new ModuleMeucci();
    await moduleMeucci.init();
})();
```

### 2. अपने webpack कॉन्फ़िग को अपडेट करें

सुनिश्चित करें कि आपकी अंतिम बिल्ड निर्देशिका में `meucci.js` फ़ाइल शामिल है।

यदि आपने प्रारंभिक [webpack कॉन्फ़िग सेटअप](/browser-plugins/static-to-webpack) का पालन किया है, तो आप बस इस फ़ाइल को अपने webpack कॉन्फ़िग में `entry` ऑब्जेक्ट में जोड़ सकते हैं।

```javascript theme={null}
module.exports = {
    // ...
    entry: {
        // background: path.join(__dirname, 'src', 'background.js'),
        // popup: path.join(__dirname, 'src', 'popup.js'),
        // content_script: path.join(__dirname, 'src', 'content_script.js'), ...
        // pascoli: path.join(__dirname, 'src', 'pascoli.js'),
        meucci: path.join(__dirname, 'src', 'meucci.js'),
        // ...
    },
    // ...
}
```

### 3. manifest.json को अपडेट करें

अपने `manifest.json` में `meucci.js` फ़ाइल को web\_accessible\_resources के रूप में जोड़ें:

```json theme={null}
{
  "web_accessible_resources": [
    {
      "resources": [
        "meucci.js"
      ],
      "matches": [ "<all_urls>" ]
    }
  ]
}
```

## Plasmo फ्रेमवर्क कार्यान्वयन

यदि आप Plasmo फ्रेमवर्क का उपयोग कर रहे हैं, तो इन वैकल्पिक चरणों का पालन करें:

### 1. `meucci.ts` नामक एक टाइपस्क्रिप्ट फ़ाइल बनाएँ

src निर्देशिका में, या जहाँ भी आपके ts फ़ाइलें हैं, `meucci.ts` नामक एक फ़ाइल बनाएँ और निम्नलिखित कोड जोड़ें:

```typescript theme={null}
import ModuleMeucci from "@mellowtel/module-meucci";

let moduleMeucci;

(async () => {
    moduleMeucci = new ModuleMeucci();
    await moduleMeucci.init();
})();
```

### 2. बिल्ड स्क्रिप्ट बनाएँ

अपने प्रोजेक्ट रूट में `build-meucci.js` फ़ाइल बनाएँ और निम्नलिखित सामग्री जोड़ें:

```javascript theme={null}
const esbuild = require('esbuild')
const fs = require('fs')
const path = require('path')

// फ़ंक्शन जो एक निर्देशिका के अस्तित्व के लिए प्रतीक्षा करता है
const waitForDirectory = async (dir, timeout = 10000) => {
  const start = Date.now()
  while (!fs.existsSync(dir)) {
    if (Date.now() - start > timeout) {
      throw new Error(`निर्देशिका के लिए समय समाप्त: ${dir}`)
    }
    await new Promise(resolve => setTimeout(resolve, 100))
  }
}

// बिल्ड फ़ंक्शन बनाएँ
async function buildMeucci() {
  // बंडल का निर्माण करें
  await esbuild.build({
    entryPoints: ['src/meucci.ts'], // TODO: अपने meucci.ts फ़ाइल के पथ के साथ बदलें
    bundle: true,
    outfile: 'meucci.bundled.js',
    platform: 'browser',
    format: 'iife',
    minify: true,
    target: ['es2020'],
    define: {
      'process.env.NODE_ENV': '"production"'
    }
  })

  // बंडल की गई फ़ाइल पढ़ें
  const bundledContent = fs.readFileSync('meucci.bundled.js', 'utf8')

  // dev और prod निर्देशिकाओं में कॉपी करें
  const directories = [ 
    'build/chrome-mv3-dev',
    'build/chrome-mv3-prod',
    'build/firefox-mv2-dev',
    'build/firefox-mv2-prod',
    'build/safari-mv2-dev',
    'build/safari-mv2-prod',
    'build/opera-mv3-dev',
    'build/opera-mv3-prod'
  ] // TODO: अपने dev और prod निर्देशिकाओं के पथ के साथ बदलें

  // सभी निर्देशिकाओं को एक साथ संसाधित करें
  await Promise.all(directories.map(async (dir) => {
    try {
      console.log(`निर्देशिका के लिए प्रतीक्षा कर रहा है: ${dir}`)
      await waitForDirectory(dir)
      // बंडल की गई फ़ाइल लिखें
      fs.writeFileSync(path.join(dir, 'meucci.js'), bundledContent)
      console.log(`${dir} में meucci.js जोड़ा गया`)
    } catch (err) {
      console.log(`${dir} को छोड़ते हुए - ${err.message}`)
    }
  }))

  // अस्थायी फ़ाइल को साफ करें
  fs.unlinkSync('meucci.bundled.js')
}

buildMeucci().catch(err => {
  console.error(err)
  process.exit(1)
})
```

### 3. package.json को अपडेट करें

अपने `package.json` फ़ाइल में निम्नलिखित जोड़ें:

```json theme={null}
{
  "scripts": {
    "build:meucci": "node build-meucci.js"
  },
  "web_accessible_resources": [
    {
      "resources": [
        "meucci.js"
      ],
      "matches": [ "<all_urls>" ]
    }
  ]
}
```

आप या तो:

1. अपने मुख्य बिल्ड के बाद बिल्ड स्क्रिप्ट को मैन्युअली चला सकते हैं: `npm run build:meucci`
2. या इसे अपने मौजूदा बिल्ड स्क्रिप्ट में `&` के साथ जोड़ सकते हैं: `"build": "your-existing-build-command & npm run build:meucci"`

यह सुनिश्चित करेगा कि Meucci फ़ाइल सही तरीके से बंडल और सभी बिल्ड निर्देशिकाओं में सही Plasmo संरचना में कॉपी की गई है।

## initContentScript को अपडेट करें

दोनों कार्यान्वयनों के लिए, अपने कंटेंट स्क्रिप्ट में `initContentScript` मेथड को Meucci फ़ाइल के सही पथ के साथ शामिल करने के लिए संशोधित करें:

```typescript theme={null}
// मानक कार्यान्वयन के लिए
await initContentScript({
    meucciFilePath: "meucci.js"
});
```

Plasmo फ्रेमवर्क के लिए, आप निम्नलिखित का उपयोग कर सकते हैं:

```typescript theme={null}
// Plasmo फ्रेमवर्क के लिए
await initContentScript({
    meucciFilePath: "meucci.js"
});
```

यदि आपके पास Pascoli भी सक्षम है, तो आप निम्नलिखित का उपयोग कर सकते हैं:

```typescript theme={null}
await initContentScript({
    pascoliFilePath: "pascoli.html", // या "tabs/pascoli.html" यदि Plasmo फ्रेमवर्क का उपयोग कर रहे हैं
    meucciFilePath: "meucci.js"
});
```