જો તમે ક્યારેય TypeScript મોનોરેપોમાં બે લાઇનનું બગફિક્સ પુશ કર્યું હોય અને તમારી બિલ્ડ પાઇપલાઇનને દસ મિનિટ સુધી ટાઇપ ચેકિંગ કરવામાં ખર્ચતા જોઈ હોય, તો તમે સમસ્યાને સમજી ગયા છો. વિલંબ બંડલિંગને કારણે નથી. તે મિનિફિકેશનને કારણે પણ નથી. તે એ ક્ષણ છે જ્યારે TypeScript તમારી ડિક્લેરેશન ફાઇલ્સ લખવાનો પ્રયાસ કરે છે. તે એક પણ .d.ts ફાઇલ એમિટ કરી શકે તે પહેલાં, કમ્પાઇલરે સંપૂર્ણ ટાઇપ ગ્રાફ (type graph) ઉકેલવો પડે છે. તે ઇમ્પોર્ટ્સને તપાસે છે, જનરિક્સનું મૂલ્યાંકન કરે છે, અને એવા રિટર્ન ટાઇપ્સનું અનુમાન (infer) કરે છે જે કદાચ ત્રણ ડિપેન્ડન્સી લેયર્સ ઊંડે હોઈ શકે છે. તમે બદલેલી એક ફાઇલ બીજી ફાઇલને સ્પર્શે છે, જે ત્રીજીને સ્પર્શે છે, અને અચાનક કમ્પાઇલર ફક્ત તમારું ફંક્શન શું રિટર્ન કરે છે તેનું વર્ણન કરવા માટે આખા રિપોઝિટરીમાં ડિટેક્ટિવ વર્ક કરી રહ્યું હોય છે.

TypeScript 6.0 આ આદત તોડવા માટે isolatedDeclarations રજૂ કરે છે.

અસલી અવરોધ

ડિક્લેરેશન ફાઇલ્સ તમારા કોડનો પબ્લિક કોન્ટ્રાક્ટ છે. જ્યારે અન્ય ડેવલપર તમારું પેકેજ ઇમ્પોર્ટ કરે છે, ત્યારે TypeScript સોર્સને બદલે .d.ts ફાઇલો વાંચે છે. તે ફાઇલોને યોગ્ય રીતે જનરેટ કરવાનો અર્થ એ છે કે કમ્પાઇલર ટાઇપ ચેકરને સ્કીપ કરી શકતું નથી. આઉટપુટની એક લાઇન લખતા પહેલા તેણે દરેક શેપ (shape), દરેક યુનિયન (union), અને દરેક ઇન્ફર્ડ રિટર્ન ટાઇપ વિશે જાણવું આવશ્યક છે.

પચાસ ફાઇલો ધરાવતા નાના પ્રોજેક્ટમાં, આ પ્રક્રિયા ત્વરિત છે. હજારો મોડ્યુલ્સ ધરાવતા મોટા મોનોરેપોમાં, તે એક ક્રમિક кошાળ (serialized nightmare) સમાન છે. કોર પેકેજમાં યુટિલિટી ટાઇપ બદલો, અને કમ્પાઇલર એ ચકાસવા માટે દરેક કન્ઝ્યુમર પાસે ફરીથી જાય છે કે ઇન્ફર્ડ ટાઇપ્સ હજુ પણ સાચા છે કે નહીં. બિલ્ડ સમય માત્ર ફાઇલની સંખ્યા સાથે નહીં, પણ ડિપેન્ડન્સીની ઊંડાઈ સાથે વધે છે. એક સામાન્ય રિફેક્ટર પણ આખા ગ્રાફનું ફરીથી ગણતરી (recomputation) શરૂ કરી શકે છે. ટીમો ઘણીવાર આને અનિવાર્ય માની લે છે. પણ તે નથી.

isolatedDeclarations કેવી રીતે કામ કરે છે

આ નવો ફ્લેગ તમારા અને કમ્પાઇલર વચ્ચેના કોન્ટ્રાક્ટને બદલી નાખે છે. તમારા એક્સપોર્ટ્સના ટાઇપ્સ ઇન્ફર કરવા માટે TypeScript ને કહેવાને બદલે, તમે જાતે જ તેને એનોટેટ (annotate) કરો છો. આ એક ફેરફાર ગ્લોબલ નોલેજની જરૂરિયાતને દૂર કરે છે. હવે તમારા મોડ્યુલ માટે ડિક્લેરેશન્સ એમિટ કરવા માટે કમ્પાઇલરે તમારી ડિપેન્ડન્સીઝનું વિશ્લેષણ કરવાની જરૂર નથી. તે ફક્ત તેની સામેના સિન્ટેક્સને જ જુએ છે.

આનો અર્થ એ છે કે દરેક ફાઇલ તેનું .d.ts આઉટપુટ સ્વતંત્ર રીતે, સમાંતર (in parallel) એમિટ કરી શકે છે. ડિક્લેરેશન જનરેશન શરૂ કરતા પહેલા બિલ્ડ ટૂલને સંપૂર્ણ ટાઇપ ગ્રાફ બનાવવાની જરૂર નથી. esbuild અને swc જેવા ટૂલ્સ, જે અગાઉ ટાઇપ ચેકરના અભાવે .d.ts એમિટ કરવાનું ટાળતા હતા, તેઓ હવે ટ્રાન્સપાઇલેશનની ઝડપની નજીક ડિક્લેરેશન્સ જનરેટ કરી શકે છે. તેઓ સીધા સોર્સમાંથી સ્પષ્ટ એનોટેશન્સ વાંચે છે અને કોઈપણ ટાઇપ ઇક્વેશન ઉકેલ્યા વિના સંબંધિત ટાઇપ ડેફિનેશન લખે છે.

અગાઉ, ડિક્લેરેશન એમિટ પર tsc નો એકાધિકાર હતો કારણ કે માત્ર સત્તાવાર કમ્પાઇલર પાસે જ .d.ts ફાઇલો બનાવવા માટે જરૂરી ટાઇપ માહિતી હતી. ફાસ્ટ ટ્રાન્સપાઇલર્સ ટાઇપ્સ દૂર કરી શકતા હતા અથવા સિન્ટેક્સ બદલી શકતા હતા, પરંતુ તેઓ ટાઇપ ડેફિનેશન જનરેટ કરી શકતા નહોતા. isolatedDeclarations સાથે, આખા ઇકોસિસ્ટમ માટે ડિક્લેરેશન વર્કફ્લો હેન્ડલ કરવા માટેના દ્વાર ખુલી જાય છે. પરિવર્તન લોજિકલને બદલે મિકેનિકલ બની જાય છે. આ તફાવત જ દસ મિનિટના ઇન્તજારને સેકન્ડોમાં ફેરવી નાખે છે.

ટ્રેડઓફ: એક્સપ્લિસિટ (Explicit) એ નવું ડિફોલ્ટ છે

ઝડપની સાથે એક સીધી કિંમત આવે છે. દરેક એક્સપોર્ટેડ ફંક્શન, ક્લાસ અને વેરિએબલ પાસે સ્પષ્ટ (explicit) ટાઇપ એનોટેશન હોવું આવશ્યક છે. TypeScript તમારા માટે પબ્લિક API ઇન્ફર કરવાનો ઇનકાર કરશે.

એક સાદી યુટિલિટીનો વિચાર કરો:

export function getUser(id: number) {
  return fetchUser(id);
}

isolatedDeclarations ઇનેબલ હોવા સાથે, આમાં એરર આવશે. કમ્પાઇલર તેની તપાસ કર્યા વિના fetchUser નો રિટર્ન ટાઇપ જાણી શકતું નથી, અને આ ફ્લેગ હેઠળ