Rollup-plugin-typescript2: 'इनपुट' रोलअप के रूप में ऑब्जेक्ट के भीतर गलत फ़ोल्डर में उत्पन्न टाइपिंग फ़ाइल

useTsconfigDeclarationDir प्लगइन विकल्प अभी के लिए एक वैकल्पिक हल है।

यह #142 द्वारा तय किया जा सकता है, 0.20.0 . में जारी किया गया

हाय @ezolenkom और @jakearchibald , वास्तव में कोई भाग्य नहीं।

मेरे रोलअप प्लगइन में useTsconfigDeclarationDir विकल्प जोड़ते समय घोषणा फ़ाइलें अब बिल्कुल नहीं बनाई जाती हैं। और 0.20.1 पर अपडेट करने से दुर्भाग्य से कोई फर्क नहीं पड़ा।

@benkeen useTsconfigDeclarationDir: true प्लगइन विकल्प का उपयोग करते समय आपको declarationDir मूल्य tsconfig.json

इसी तरह की परेशानी है, मेरा प्रोजेक्ट लेआउट इस तरह है:

export default [ 
  {
    input: 'src/subFolder1/one.ts,
    output: [
                    {
                      file: 'dist/one.js'
                      .....                      
                     }
    ],
    plugins: [
           typescript({
                typescript: require('typescript'),
            }),
    ]
  },
      input: 'src/subFolder2/two.ts,
      output: [
                    {
                      file: 'dist/two.js'
                      .....                      
                     }
    ],
     ...
  },
]

एक आउटपुट के रूप में मेरे पास है:

  |---subFolder1
  |          |--------one.d.ts
  |
  |---subFolder2
  |          |---------two.d.ts
  |-----one.js
  |-----two.js

मेरे लिए 0.20.1 पर काम करता है useTsconfigDeclarationDir: false -- d.ts फ़ाइलें output.[].dir में निर्दिष्ट फ़ोल्डर में जाती हैं। @बेनकेन क्या आप फिर से कोशिश कर सकते हैं?

@AntonPilyak जो डिज़ाइन द्वारा है - यदि d.ts उप पथ के बिना एक फ़ोल्डर में जा रहे थे, तो यदि आपके पास subFolder1/one.ts और subFolder2/one.ts , तो उनमें से एक दूसरे को ओवरराइट कर रहा होगा।

@ezolenko : मुझे लगता है कि यह सुविधा, अधिक असुविधाएं पैदा करती है बल्कि वास्तविक समस्या हल करती है (क्योंकि उन सभी निर्देशिका संरचना को बनाए रखना मुश्किल है)। मुझे एक स्क्रिप्ट बनानी है जो इन सभी प्रकार की घोषणाओं को बंडल की जड़ में कॉपी करती है, और एक बंडल बनाने के लिए निर्देशिकाओं को .npmignore में जोड़ती है जिसमें शामिल करना आसान है। मेरा सुझाव है कि आप इन अतिरिक्त निर्देशिकाओं को केवल उन्हीं नामों वाली फाइलों के लिए बनाएं। और बाकी के लिए रोलअप.कॉन्फिग.जेसन के 'आउटपुट' खंड में परिभाषित निर्देशिका का उपयोग करें।

@AntonPilyak आप उपयोग करने में सक्षम हो सकता है useTsconfigDeclarationDir: true विकल्प, सेटअप declarationDir tsconfig में, इस जाने टाइपप्रति ही typings उत्पादन रास्तों संभाल चाहिए।

यह तय करना कि क्या पथों की विशिष्टता के आधार पर उपनिर्देशिकाओं का उपयोग किया जाना चाहिए, एक विकसित परियोजना में एक दुःस्वप्न होगा, अचानक आपकी टाइपिंग केवल सबफ़ोल्डर में चली जाएगी क्योंकि आपने एक ही नाम के साथ एक अलग फ़ोल्डर में एक नई फ़ाइल जोड़ दी है।

आम तौर पर यदि आप सुंदर टाइपिंग चाहते हैं तो आप उन्हें वैसे भी एक फ़ाइल में मर्ज करना चाहेंगे (एक npm मॉड्यूल था जिसके लिए मैं उसका नाम भूलता रहता हूं)

मैं संस्करण 0.22.0 का उपयोग कर रहा हूं और मुझे @ AntonPilyak . जैसी ही समस्या है

{
    ...
    input: {
        foo: 'src/lorem/foo.ts',
        bar: 'src/ipsum/bar.ts'
    },
    output: {
        dir: 'dist',
        format: 'cjs',
        sourcemap: true,
    }
}

और मैं इसे बाहर निकालता हूं:

dist/
    lorem/
        foo.d.ts
    ipsum/
        bar.d.ts
    foo.js
    foo.js.map
    bar.js
    bar.js.map

जाहिर है, मैं चाहता हूं कि *.d.ts फाइलें *.js और *.js.map फाइलों के साथ बैठें।

मैंने useTsconfigDeclarationDir और declarationDir के साथ कोई फायदा नहीं हुआ।

परिभाषा फ़ाइलें हमेशा क्रमशः lorem और ipsum उप-फ़ोल्डर के अंदर समाप्त होती हैं, और कभी भी एक सपाट सूची में नहीं होती हैं।

इसके अलावा ऐसा लगता है कि यह प्रत्येक .ts फ़ाइल के लिए घोषणा फ़ाइलें बनाता है, न कि केवल प्रवेश बिंदु।

dist/
    lorem/
        foo.d.ts
    ipsum/
        utils/
            bar-helper.d.ts
        bar.d.ts
     some_other_ts_file/
         not_imported_by/
             neither_foo_nor_bar/
                  wat.d.ts
    foo.js
    foo.js.map
    bar.js
    bar.js.map

मैंने केवल प्रवेश बिंदुओं पर options.tsconfigOverride.input को स्कोप करने का प्रयास किया है, लेकिन ऐसा लगता है कि इसका कोई प्रभाव नहीं पड़ता है। असल में मुझे यह भी यकीन नहीं है कि tsconfigOverride.input बिल्कुल काम करता है या नहीं।

यह सब थोड़ा भ्रमित करने वाला है।

...

मेरा मतलब है, यह काफी उचित है अगर इसे utils/bar-helper.ts लिए एक घोषणा फ़ाइल बनाने की आवश्यकता है लेकिन कम से कम wat.ts को पूरी चीज से छोड़ दिया जाना चाहिए।

हाँ, यह tsconfig द्वारा प्राप्त सभी फ़ाइलों के लिए घोषणाएँ उत्पन्न करता है, यदि आप विशेष फ़ाइल को स्पर्श नहीं करना चाहते हैं, तो सुनिश्चित करें कि इसे बाहर रखा गया है या tsconfig में शामिल नहीं किया गया है। टाइपस्क्रिप्ट द्वारा मिली फाइलों की सूची देखने के लिए, वर्बोसिटी 3 के साथ प्लगइन चलाएं और "पार्स किए गए tsconfig" प्रविष्टि की तलाश करें।

परिभाषा पथ के लिए, आपके उदाहरण में आप 'src/ipsum/foo.ts' परिभाषा कहाँ चाहेंगे?

चूंकि यह dist/foo.js लिए एक परिभाषा है, मैंने मान लिया था कि यह इसके बगल में समाप्त होगा - स्रोत मानचित्र फ़ाइल की तरह - यानी dist/foo.d.ts ।

क्या टाइपस्क्रिप्ट dist/foo.js और dist/lorem/foo.d.ts को जोड़ना जानता है?

पूरा परिदृश्य जहां यह टूट जाता है:
src/dir1/foo.ts
src/dir2/foo.ts

dir1/foo.ts हमें रोलअप इनपुट के रूप में सेट करते हैं और यह dir2/foo.ts आयात करता है। रोलअप dist/foo.js बंडल बनाएगा जिसमें दोनों स्रोत फ़ाइलों के प्रासंगिक भाग होंगे, लेकिन टाइपस्क्रिप्ट को कहीं न कहीं समान नाम से 2 प्रकार की परिभाषा फ़ाइलें बनाने की आवश्यकता है।

आसान समाधान सबफ़ोल्डर्स का उपयोग करना है, स्रोत लेआउट को प्रतिबिंबित करना। मुझे लगता है कि tsc करता है, जब तक कि आप इसे टाइप परिभाषाओं को मर्ज करने के लिए नहीं कहते हैं (आरपीटी 2 परिभाषा विलय का समर्थन नहीं करता है)।

और हाँ, टाइपस्क्रिप्ट को पता चल जाएगा कि टाइप परिभाषाएँ कहाँ मिलेंगी। तो थोड़ा गन्दा होने के अलावा, यह कोई समस्या नहीं होनी चाहिए। यदि आप npm पर प्रकारों के साथ पैकेज परिनियोजित करना चाहते हैं, तो अपने प्रवेश बिंदु के लिए "types" में package.json को d.ts फ़ाइल में सेट करें। टाइपस्क्रिप्ट वहां से चीजें ढूंढेगा।

आह, तो यह प्लगइन वास्तव में घोषणा-निर्माण प्रक्रिया के किसी भी हिस्से का प्रबंधन नहीं करता है। रोलअप की प्रक्रिया से अप्रासंगिक, यह अपना काम करने के लिए सिर्फ tsc को सक्रिय करता है?

फिर भी, अगर मैं केवल कुछ मॉड्यूल को उजागर/प्रकाशित कर रहा हूं, तो मैं टाइपस्क्रिप्ट को प्रत्येक टीएस फ़ाइल के लिए *.d.ts फाइलें क्यों उत्पन्न करना चाहता हूं? क्या इसे केवल प्रवेश बिंदुओं तक सीमित करने का कोई तरीका नहीं है?

बात यह है कि, मैं स्टैंडअलोन मॉड्यूल ( import tool1 from 'myTools/tool1'; आदि ..) का एक सेट निर्यात कर रहा हूं, इसलिए pkg.types में उपयोग करने के लिए कोई एकल प्रविष्टि बिंदु नहीं है। VSCode को लेने के लिए प्रत्येक परिभाषा फ़ाइल को उसके *.js समकक्ष के बगल में रहना चाहिए।

इससे भी बदतर, अगर मेरे पास है

{
    ...
    input: {
        fooscript: 'src/foo/index.ts',
        barscript: 'src/bar/index.ts'
    },
    output: {
        dir: 'dist',
        format: 'cjs',
        sourcemap: true,
    }
}

मुझे समझ आ गया:

dist/
    foo/
        index.d.ts
    bar/
        index.d.ts
    fooscript.js
    fooscript.js.map
    barscript.js
    barscript.js.map

और अब टाइपस्क्रिप्ट के लिए dist/fooscript.js और dist/foo/index.d.ts को जोड़ने का कोई तरीका नहीं है।

...

क्या कोई तरीका नहीं है कि आपका प्लगइन प्रत्येक जावास्क्रिप्ट बंडल फ़ाइल के लिए टाइपस्क्रिप्ट को गंतव्य/आउटपुट पथ खिला सके? ऐसा लगता है कि टीएससी मूल प्रविष्टि फ़ाइल नाम प्राप्त कर रहा है और घोषणाओं को उत्पन्न करते समय इसे कसकर पकड़ रहा है।
...या प्रत्येक इनपुट फ़ाइल के लिए संबंधित *.d.ts फ़ाइल की तलाश करें और इसे इनपुट-फ़ाइल मानचित्र गंतव्य पर ले जाएँ + उसका नाम बदलें। (आप देख सकते हैं कि मैं यहाँ अपनी गांड से बात कर रहा हूँ, इसलिए... ;-)

रोलअप समाप्त होने के बाद यह कुछ ऐसा है जिसे मैं मैन्युअल रूप से आज़माने के लिए बाध्य हूं - लेकिन यह इतना अच्छा होगा यदि प्लगइन इसे स्वचालित रूप से संभाल लेगा।

नहीं, प्लगइन भाषा सेवाओं का उपयोग करता है (उसी टाइपस्क्रिप्ट एपीआई आईडीई आमतौर पर उपयोग कर रहे हैं), इसलिए मेरा कुछ नियंत्रण है कि क्या लिखना है और कहां लिखना है।

प्रति रोलअप इनपुट एक प्रकार की परिभाषा लिखने के लिए हमें उस इनपुट के लिए सभी आयातों के लिए परिभाषाओं को मर्ज करना होगा। रोलअप एक इनपुट ts फ़ाइल देख रहा हो सकता है, लेकिन यह किसी भी संख्या में स्रोत फ़ाइलों को आयात और बंडल कर सकता है, जब उन्हें निर्माण की आवश्यकता होती है।

वर्तमान में मैं tsconfig फ़ाइल को देखते समय टाइपस्क्रिप्ट खोजने वाली हर चीज़ के लिए परिभाषाएँ उत्पन्न करने के पक्ष में हूँ। अगर मैं केवल ट्रांसपिल्ड मॉड्यूल के लिए प्रकार उत्पन्न करता हूं, तो केवल फाइलों को ही अनदेखा कर दिया जाएगा।

मुझे उस हिस्से पर फिर से जाना पड़ सकता है, उस हिस्से के पूरा होने के बाद से एपीआई काफी बदल गया है ...

मुझे यह देखना होगा कि आपका उदाहरण कैसे काम करता है। एक रोलअप कॉन्फ़िगरेशन में एकाधिक बंडलों के लिए बेहतर समर्थन की आवश्यकता हो सकती है।

हालांकि इसे बनाने के बाद आप उस पैकेज का उपभोग कैसे करते हैं? यह ऐसा कुछ नहीं है जिसे आप एनपीएम पर प्रकाशित कर सकते हैं और पैकेज नाम से आयात कर सकते हैं ...

मैं स्टैंडअलोन उपयोगिताओं का संग्रह बना रहा हूं। प्रकाशित/स्थापित पैकेज के रूट-फ़ोल्डर में एक फ्लैट सूची में सभी निर्मित मॉड्यूल फ़ाइलें शामिल हैं।

(मैं उन्हें एक नेस्टेड फ़ोल्डर-संरचना में TS/ES6 में लिख रहा हूं, जिसमें परीक्षण-फाइलें मिश्रित हैं, और रोलअप पर निर्भर हैं ताकि उन्हें कोड-विभाजन और किसी के लिए इनलाइनिंग के कुशल मिश्रण के साथ CJS फ़ाइलों की एक फ्लैट सूची में परिवर्तित किया जा सके। साझा कोड।)

मैं फिर इन उपकरणों को फ़ाइल-नाम से आयात करके उपभोग करता हूं - जैसे:

import tool1 from 'myTools/tool1';
import tool2 from 'myTools/tool2';

विचार यह है कि पूरे टूलकिट (कोई pkg.main या pkg.module प्रविष्टियों) के लिए एक भी प्रवेश बिंदु नहीं होने से, मैं शायद ही कभी उपयोग किए जाने वाले, और यहां तक ​​​​कि प्रयोगात्मक, उपकरण जोड़ने के लिए लापरवाह हो सकता हूं डाउनस्ट्रीम उपभोक्ताओं के लिए वजन/ब्लोट जोड़े बिना (जिसमें कुशल ट्री-हिलिंग नहीं हो सकती है)।

...मैं अब कमांडलाइन पर tsc साथ खेल रहा हूं, और मुझे लगता है कि अब मैं उन सीमाओं को देखता हूं जिनसे आप निपट रहे हैं।

हालांकि, मैंने देखा कि यदि आप tsc चलाते हैं और मॉड्यूल/आउटपुट प्रारूप को "amd" या "system" , तो यह सभी की एक साफ सूची के साथ एक *.d.ts फ़ाइल उत्पन्न करता है आवश्यक declare module "..." ब्लॉक इनलाइन किए गए हैं।

मुझे आश्चर्य है कि क्या इस व्यवहार का किसी भी तरह से शोषण किया जा सकता है - फ़ाइल का नाम बदलने/स्थानांतरित करने और अंतिम (मुख्य) मॉड्यूल घोषणा को अलिखित/पुनर्लेखन के माध्यम से?

साइड नोट: मैंने यह भी देखा कि tsc उस घोषणा फ़ाइल को ट्री-हिलाने में अधिक प्रयास नहीं करता है। एक मामले में मुझे एक मुख्य (प्रवेश बिंदु) मॉड्यूल दिखाई देता है जो एक एकल, बहुत ही सरल, फ़ंक्शन हस्ताक्षर निर्यात करता है, और फिर भी घोषणा फ़ाइल "पर्दे के पीछे" उपयोग किए जाने वाले सभी निजी मॉड्यूल के लिए घोषणा ब्लॉक का खुलासा करती है। मज़ेदार। :-)

फिर से नमस्कार।
अभी के लिए, मैं सेट कर रहा हूं एक कस्टम declarationDir के लिए tsc सभी डंप करने के लिए *.d.ts में, और उसके बाद एक स्टैंडअलोन स्क्रिप्ट चलाने कि आयात एक ही प्रविष्टि-फ़ाइल-हैं- आउटपुट-फ़ाइल ऑब्जेक्ट के रूप में मैं रोलअप को फ़ीड करता हूं, और यह बंडल-गंतव्य-स्तरीय घोषणा फ़ाइलें उत्पन्न करता है जो केवल वास्तविक घोषणा फ़ाइल export * from है।

अनिवार्य रूप से, मैं dist/fooscript.d.ts उत्पन्न करता हूं जिसमें केवल:

export *  from './__types/foo/index';

यह एक बदसूरत स्टैंडअलोन हैक है, लेकिन यह अनुमानित रूप से सही परिणाम प्रदान करता है।

मुझे आश्चर्य है कि क्या rollup-plugin-typescript2 कुछ ऐसा ही कर सकता है?

वह काम करेगा, हाँ।

मेरे पास कुछ विचार हैं (जब मैं उनके पास जाता हूं), उदाहरण के लिए <bundlename>.d.ts उत्पन्न करना जिसमें प्रत्येक d.ts के लिए /// <reference types=""/> का गुच्छा होता है।

सबसे पहले मुझे कई प्रकार की घोषणाओं को उत्पन्न करने के संबंधित बग को ठीक करना पड़ सकता है और इसे केवल रूट फ़ाइल और वास्तव में आयात की जाने वाली किसी भी चीज़ तक सीमित करना पड़ सकता है।

कुछ विचार:

IMO, मेरे हैक का एकमात्र सही मायने में बदसूरत हिस्सा यह तथ्य है कि यह रोलअप प्रक्रिया से अलग है। मध्यस्थ *.d.ts वास्तव में रोलअप के जेनरेट किए गए बंडलों और tsc की परिभाषाओं के बीच पुल करने का एक बहुत साफ और मूर्खतापूर्ण तरीका है।

चूंकि tsc -जनरेटेड डिक्लेरेशन फाइल एक दूसरे को सापेक्ष पथों के माध्यम से संदर्भित करती है, इसलिए फ़ाइल/फ़ोल्डर संरचना शायद सबसे अच्छी तरह से अकेली रह जाती है - ऐसा न हो कि आप कस्टम भाषा सिंटैक्स के लिए रोलअप की कार्यक्षमता के कुछ हिस्सों को फिर से कार्यान्वित कर सकें।

और अगर rollup-plugin-typescript2 output.dir + '__types' को डिफ़ॉल्ट declarationDir output.dir + '__types' रूप में सेट करता है, तो tsc की अति-उत्सुकता के कारण होने वाली कोई भी गड़बड़ी बड़े करीने से बाहर निकल जाती है- स्पष्ट रूप से नामित फ़ोल्डर के अंदर दृष्टि। इस तरह बाहरी परिभाषा फाइलें आईएमओ की बहुत मामूली चिंता बन जाती हैं।

एफडब्ल्यूआईडब्ल्यू, यहां मेरी लिपि का मांस है:

const { makeInputMap, getEntrypoints, distFolder, srcFolder } = require('./buildHelpers');
const { writeFileSync } = require('fs');
const { relative } = require('path');

const srcPrefixRe = new RegExp('^' + srcFolder + '/');
const tsExtRe = /\.tsx?$/;

const declDirRelative = './' + relative(
  distFolder,
  require('../tsconfig.json').compilerOptions.declarationDir
);

const tsEntrypoints = getEntrypoints()
  .filter((fileName) => tsExtRe.test(fileName));

Object.entries(makeInputMap(tsEntrypoints))
  .forEach(([moduleName, sourcePath]) => {
    const tscDeclFile = sourcePath
      .replace(srcPrefixRe, declDirRelative + '/')
      .replace(tsExtRe, '');
    const outFile = distFolder + '/' + moduleName + '.d.ts';
    writeFileSync(
      outFile,
      [
        'export * from "' + tscDeclFile + '";',
        'import x from "' + tscDeclFile + '";',
        'export default x;',
        '',
      ].join('\n')
    );
  });

console.info('Created local declaration files for TypeScripted entrypoints.');

मैंने ऊपर दिए गए उदाहरण को अपडेट किया, क्योंकि ऐसा लगता है कि डिफ़ॉल्ट निर्यात को स्पष्ट रूप से फिर से निर्यात किया जाना है।

प्रारंभिक परीक्षण इंगित करता है कि एक घोषणा फ़ाइल से default आँख बंद करके फिर से निर्यात करना जिसमें कोई default निर्यात नहीं है, हानिरहित है, और चुपचाप अनदेखा किया जाता है। (कम से कम VSCode द्वारा।)

नमस्ते, क्या इस मुद्दे को v0.23.0 में हल किया जाना चाहिए?

(... आश्चर्य है कि क्या मुझे सभी कस्टम फ़फ़िंग को छोड़ने के लिए अपने प्रोजेक्ट को अपडेट करने का प्रयास करना चाहिए)

0.23 सब कुछ के लिए घोषणा उत्पन्न नहीं करेगा, लेकिन यह अभी भी उन घोषणाओं को उत्पन्न करेगा जो आप वास्तव में उनके सापेक्ष सबफ़ोल्डर में आयात करते हैं। आप शायद अपडेट कर सकते हैं और हल्के प्रकार के हो सकते हैं, लेकिन अभी तक रूट प्रकार की घोषणाएं उत्पन्न करने के लिए कुछ भी नहीं है।

मेरी कस्टम वर्कअराउंड बिल्ड स्क्रिप्ट (ऊपर देखें) धीरे-धीरे मेरी अधिक से अधिक परियोजनाओं में रेंग रही है। ओ_ओ

एफवाईआई: आधिकारिक @ रोलअप/प्लगइन-टाइपस्क्रिप्ट पैकेज का विकास फिर से शुरू हो गया है, और अब इसमें टाइप-चेकिंग और डिक्लेरेशन फाइलों को आउटपुट करना शामिल है, इसलिए मैं व्यक्तिगत रूप से इसका उपयोग करने के लिए स्विच कर रहा हूं।
हालाँकि, सीमाएँ बहुत समान हैं।

@maranomynet क्या आप अभी भी रोलअप के बाद घोषणा फ़ाइलों को स्थानांतरित करने के लिए अपनी स्क्रिप्ट पर भरोसा करते हैं? मुझे खुद को बदलने का ज्यादा सौभाग्य नहीं मिला।

हाँ। यह एकमात्र तरीका प्रतीत होता है जब तक कि आप tsc को बंडलिंग एंड-टू-एंड नहीं करने देते।
ऐसा लगता है कि ये रोलअप प्लगइन्स tsc को दो अलग-अलग कार्य करने के लिए प्रभावी ढंग से कह रहे हैं:

1. "इन सभी अलग-अलग मॉड्यूल को टाइप-चेक करें और जावास्क्रिप्ट में कनवर्ट करें" और मुझे (यानी रोलअप) डिस्क पर बंडलिंग और लिखने दें।
2. "इस TS प्रोजेक्ट फ़ोल्डर के लिए सभी घोषणाएँ करें और उन्हें वहाँ पर डंप करें।"

जब आप "इनपुट मैप" और कोड-विभाजन आदि का उपयोग कर रहे हों, तो 1 और 2 के परिणाम मेल नहीं खा सकते हैं और न ही मेल खा सकते हैं - AFAICT।

... जब तक कि आप रोलअप प्लगइन को टाइप-डिक्लेरेशन जनरेशन प्रक्रिया में पूरी तरह से शामिल नहीं कर लेते।

आह हाँ, यह वही है जो मैंने पाया, धन्यवाद! आपके सहायक उत्तर के लिए आपको दिया गया है, और 👎 इस बारे में है कि मैं इसके बारे में कैसा महसूस करता हूं।

इसके साथ कोई भाग्य?

किसी भी संघर्षरत आत्मा के लिए जिसमें @maranomynet और मेरे समान src फ़ोल्डर संरचना है।

मैं इसके लिए एक त्वरित समाधान में आया, एक और बदसूरत तरीका हो सकता है लेकिन मेरे लिए काम करता है।

मैं रोलअप-प्लगइन/टाइपस्क्रिप्ट 2 का उपयोग कर रहा हूं, इसलिए मैं इस उत्तर में इसकी कॉन्फ़िगरेशन के साथ जाऊंगा:
अपने स्वयं के घोषणापत्र को अपने tsconfig.json में परिभाषित करें ताकि आपका प्रोजेक्ट बंडल किए गए जिले में सभी *.d.ts फ़ाइलों को अपने पथ में डंप कर सके। और रोलअप कॉन्फ़िग फ़ाइल में अपने टाइपस्क्रिप्ट प्लगइन में useTsConfigDeclarationDir को सही पर सेट करना सुनिश्चित करें।
साथ ही, जहां आप अपने रोलअप.config.js (और package.json) में अपने व्यक्तिगत घटक बंडलों के लिए आउटपुट पथ परिभाषित करते हैं, उन पथों को अपने 'declarationDir' + 'आपका src घटक मार्ग कैसा है' के समान होने के लिए बदलें। तो यदि src में आपका घटक इस प्रकार है:

src/होमपेज/foo.tsx

और आपकी घोषणा डीआईआर है:

जिला/माईडिक्लेरेशनडीआईआर

तो आपका आउटपुट पथ इस तरह होना चाहिए:

dist/MyDeclarationDir/homepage/foo.js

इस तरह, रोलअप आपके प्रकार को उसी निर्देशिका में शामिल करेगा जिसमें आपका घटक main.js है और आपका TS उपभोक्ता प्रोजेक्ट टाइपिंग उठाएगा।

तो बंडल कुछ इस तरह दिखेगा:

जिला/

    declarationDirPath/
                  component1/
                        foo.js/
                              foo.js
                              foo.map.js
                        foo.d.ts
                   component2/
                        bar.js/
                               bar.js
                               bar.map.js
                        bar.d.ts