TypeScript projects grow. Files multiply. Dependencies tangle. And eventually, your build hits a wall that has nothing t

TypeScript ਪ੍ਰੋਜੈਕਟ ਵਧਦੇ ਹਨ। ਫਾਈਲਾਂ ਵਧਦੀਆਂ ਜਾਂਦੀਆਂ ਹਨ। ਡਿਪੈਂਡੈਂਸੀਆਂ (Dependencies) ਉਲਝ ਜਾਂਦੀਆਂ ਹਨ। ਅਤੇ ਅੰਤ ਵਿੱਚ, ਤੁਹਾਡਾ ਬਿਲਡ (build) ਇੱਕ ਅਜਿਹੀ ਕੰਧ ਨਾਲ ਟਕਰਾਉਂਦਾ ਹੈ ਜਿਸਦਾ ਤੁਹਾਡੇ ਲੌਜਿਕ ਦੀ ਗੁੰਝਲਤਾ ਨਾਲ ਕੋਈ ਲੈਣਾ-ਦੇਣਾ ਨਹੀਂ ਹੁੰਦਾ, ਸਗੋਂ ਇਸ ਗੱਲ ਨਾਲ ਹੁੰਦਾ ਹੈ ਕਿ ਕੰਪਾਈਲਰ ਨੂੰ ਇੱਕ ਸਿੰਗਲ ਡਿਕਲੇਰੇਸ਼ਨ ਫਾਈਲ (declaration file) ਲਿਖਣ ਤੋਂ ਪਹਿਲਾਂ ਪੂਰੀ ਦੁਨੀਆ ਨੂੰ ਪੜ੍ਹਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ।

TypeScript 6.0 ਇਸ ਸਮੱਸਿਆ ਦਾ ਹੱਲ isolatedDeclarations ਨਾਲ ਕਰਦਾ ਹੈ। ਇਹ ਫੀਚਰ .d.ts ਫਾਈਲਾਂ ਦੇ ਬਣਨ ਦੇ ਤਰੀਕੇ ਨੂੰ ਮੁੜ ਸੋਚਦਾ ਹੈ। ਡਿਕਲੇਰੇਸ਼ਨ ਐਮੀਸ਼ਨ (declaration emission) ਨੂੰ ਪੂਰੇ ਟਾਈਪ-ਚੈਕਿੰਗ ਪਾਈਪਲਾਈਨ ਨਾਲ ਜੋੜਨ ਦੀ ਬਜਾਏ, ਇਹ ਕੰਪਾਈਲਰ ਨੂੰ ਹਰੇਕ ਸੋਰਸ ਫਾਈਲ ਨੂੰ ਵੱਖਰੇ ਤੌਰ 'ਤੇ ਦੇਖ ਕੇ ਉਹਨਾਂ ਫਾਈਲਾਂ ਨੂੰ ਐਮਿਟ (emit) ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ। ਨਤੀਜੇ ਵਜੋਂ ਇੱਕ ਅਜਿਹੀ ਬਿਲਡ ਪ੍ਰਕਿਰਿਆ ਮਿਲਦੀ ਹੈ ਜੋ ਤੁਹਾਡੇ ਡਿਪੈਂਡੈਂਸੀ ਗ੍ਰਾਫ (dependency graph) ਵਿੱਚ ਇੱਕ-ਇੱਕ ਲਿੰਕ ਕਰਕੇ ਚੱਲਣ ਦੀ ਬਜਾਏ ਹਜ਼ਾਰਾਂ ਫਾਈਲਾਂ ਵਿੱਚ ਸਮਾਂਤਰ (parallel) ਰੂਪ ਵਿੱਚ ਚੱਲ ਸਕਦੀ ਹੈ।

ਅਸਲ ਰੁਕਾਵਟ (The Real Bottleneck)

ਇਸ ਸਮੇਂ, ਡਿਕਲੇਰੇਸ਼ਨ ਫਾਈਲਾਂ ਬਣਾਉਣਾ ਇੱਕ ਸੀਰੀਅਲ (serial) ਕਾਰਜ ਹੈ। ਜਦੋਂ ਤੁਸੀਂ --declaration ਨੂੰ ਇਨੇਬਲ ਕਰਦੇ ਹੋ ਅਤੇ ਕੰਪਾਈਲਰ ਚਲਾਉਂਦੇ ਹੋ, ਤਾਂ TypeScript ਕਿਸੇ ਦਿੱਤੇ ਗਏ ਮੋਡਿਊਲ ਲਈ .d.ts ਫਾਈਲ ਉਦੋਂ ਤੱਕ ਐਮਿਟ ਨਹੀਂ ਕਰ ਸਕਦਾ ਜਦੋਂ ਤੱਕ ਉਹ ਉਸ ਮੋਡਿਊਲ ਨਾਲ ਜੁੜੇ ਹਰ ਇੱਕ ਟਾਈਪ ਨੂੰ ਪੂਰੀ ਤਰ੍ਹਾਂ ਨਹੀਂ ਸਮਝ ਲੈਂਦਾ। ਜੇਕਰ utils.ts, types.ts ਤੋਂ ਟਾਈਪਸ ਇੰਪੋਰਟ ਕਰਦਾ ਹੈ, ਅਤੇ types.ts, api.ts ਤੋਂ ਕੁਝ ਲੈਂਦਾ ਹੈ, ਤਾਂ ਕੰਪਾਈਲਰ ਨੂੰ utils.ts ਕੀ ਐਕਸਪੋਰਟ ਕਰਦਾ ਹੈ, ਇਸ ਦਾ ਵਰਣਨ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਉਸ ਚੇਨ ਨੂੰ ਹੱਲ ਕਰਨਾ ਪੈਂਦਾ ਹੈ।

ਇੱਕ ਵੱਡੇ ਮੋਨੋਰੇਪੋ (monorepo) ਵਿੱਚ, ਇਹ ਕ੍ਰਮਵਾਰ ਪ੍ਰਭਾਵ ਬਹੁਤ ਭਾਰੀ ਹੁੰਦਾ ਹੈ। ਤੁਹਾਡੇ ਇੰਪੋਰਟ ਗ੍ਰਾਫ ਦੇ ਰੂਟ ਦੇ ਨੇੜੇ ਇੱਕ ਸਿੰਗਲ ਫਾਈਲ ਸੈਂਕੜੇ ਡਾਊਨਸਟ੍ਰੀਮ ਫਾਈਲਾਂ ਲਈ ਡਿਕਲੇਰੇਸ਼ਨ ਐਮੀਸ਼ਨ ਨੂੰ ਰੋਕ ਸਕਦੀ ਹੈ। ਤੁਹਾਡੇ CPU ਵਿੱਚ ਅੱਠ ਕੋਰ (cores) ਹਨ, ਪਰ ਸੱਤ ਕੋਰ ਉਦੋਂ ਤੱਕ ਵਿਹਲੇ ਬੈਠੇ ਰਹਿੰਦੇ ਹਨ ਜਦੋਂ TypeScript ਪੈਕੇਜ ਦੀਆਂ ਸੀਮਾਵਾਂ ਦੇ ਆਰ-ਪਾਰ ਹਰ ਇੰਟਰਫੇਸ ਦੇ ਰੂਪ ਨੂੰ ਬੜੀ ਮੁਸ਼ਕਲ ਨਾਲ ਮੁੜ ਸਿਰਜਦਾ ਹੈ। ਕੰਪਾਈਲਰ ਜ਼ਰੂਰੀ ਕੰਮ ਕਰ ਰਿਹਾ ਹੈ, ਪਰ ਟਾਈਪ ਚੈਕਿੰਗ ਅਤੇ ਡਿਕਲੇਰੇਸ਼ਨ ਐਮੀਸ਼ਨ ਵਿਚਕਾਰਲੇ ਜੁੜੇ ਹੋਣ ਦਾ ਮਤਲਬ ਹੈ ਕਿ ਤੁਹਾਨੂੰ ਕਰਾਸ-ਫਾਈਲ ਵਿਸ਼ਲੇਸ਼ਣ ਦੀ ਪੂਰੀ ਕੀਮਤ ਚੁਕਾਉਣੀ ਪੈਂਦੀ ਹੈ, ਭਾਵੇਂ ਤੁਸੀਂ ਸਿਰਫ਼ ਪਬਲਿਕ ਸਰਫੇਸ ਟਾਈਪਸ ਨੂੰ ਡਿਸਕ 'ਤੇ ਲਿਖਣਾ ਚਾਹੁੰਦੇ ਹੋ।

isolatedDeclarations ਨਿਯਮਾਂ ਨੂੰ ਕਿਵੇਂ ਬਦਲਦਾ ਹੈ

isolatedDeclarations ਉਸ ਜੁੜੇ ਹੋਣ (coupling) ਨੂੰ ਤੋੜਦਾ ਹੈ। ਜਦੋਂ ਇਹ ਫਲੈਗ ਇਨੇਬਲ ਹੁੰਦਾ ਹੈ, ਤਾਂ ਕੰਪਾਈਲਰ ਕਿਸੇ ਹੋਰ ਫਾਈਲ ਨੂੰ ਇਹ ਪੁੱਛੇ ਬਿਨਾਂ ਕਿ ਕੋਈ ਚੀਜ਼ ਕੀ ਮਤਲਬ ਰੱਖਦੀ ਹੈ, ਇੱਕ ਸੋਰਸ ਫਾਈਲ ਲਈ .d.ts ਫਾਈਲ ਐਮਿਟ ਕਰਨ ਲਈ ਸਹਿਮਤ ਹੋ ਜਾਂਦਾ ਹੈ। ਇਹ ਇੱਕ ਸਧਾਰਨ ਇਕਰਾਰਨਾਮੇ ਦੀ ਮੰਗ ਕਰਕੇ ਇਹ ਕਰਦਾ ਹੈ: ਹਰ ਐਕਸਪੋਰਟ ਕੀਤੇ ਗਏ ਸਿੰਬਲ (symbol) ਵਿੱਚ ਉਸ ਜਗ੍ਹਾ 'ਤੇ ਇੱਕ ਸਪਸ਼ਟ, ਦਿਖਾਈ ਦੇਣ ਵਾਲਾ ਟਾਈਪ ਐਨੋਟੇਸ਼ਨ (type annotation) ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ ਜਿੱਥੇ ਇਸ ਨੂੰ ਡਿਕਲੇਅਰ ਕੀਤਾ ਗਿਆ ਹੈ।

ਜੇਕਰ ਕੰਪਾਈਲਰ ਸੋਰਸ ਵਿੱਚ ਹੀ ਲਿਖਿਆ ਹੋਇਆ ਪੂਰਾ ਟਾਈਪ ਦੇਖ ਸਕਦਾ ਹੈ, ਤਾਂ ਇਸਨੂੰ ਇਨਫਰੈਂਸ (inference) ਕਰਨ ਦੀ ਲੋੜ ਨਹੀਂ ਹੁੰਦੀ। ਇਸਨੂੰ ਇੰਪੋਰਟਸ ਦੇ ਪਿੱਛੇ ਭੱਜਣ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ। ਇਸਨੂੰ ਇਹ ਜਾਣਨ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ ਕਿ ਦੂਜੀ ਫਾਈਲ ਵਿੱਚ User ਆਈਡੈਂਟੀਫਾਇਰ ਇੱਕ ਇੰਟਰਫੇਸ ਹੈ, ਇੱਕ ਟਾਈਪ ਐਲੀਅਸ (type alias) ਹੈ, ਜਾਂ ਇੱਕ ਕਲਾਸ ਹੈ। ਇਹ ਸਿਰਫ਼ ਉਹੀ ਐਮਿਟ ਕਰਦਾ ਹੈ ਜੋ ਤੁਸੀਂ ਲਿਖਿਆ ਹੈ।

ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਫਾਈਲ A ਅਤੇ ਫਾਈਲ B ਆਪਣੀਆਂ ਡਿਕਲੇਰੇਸ਼ਨਾਂ ਨੂੰ ਇੱਕੋ ਸਮੇਂ ਤਿਆਰ ਕਰ ਸਕਦੀਆਂ ਹਨ। ਇੱਕ ਬਿਲਡ ਆਰਕੈਸਟਰੇਟਰ (build orchestrator) ਹਰੇਕ ਫਾਈਲ ਨੂੰ ਇੱਕ ਵੱਖਰੇ ਥ੍ਰੈਡ (thread) ਨੂੰ ਸੌਂਪ ਸਕਦਾ ਹੈ। ਤੇਜ਼ ਟ੍ਰਾਂਸਪਾਈਲਰ (transpilers) ਜੋ ਪਹਿਲਾਂ ਪੂਰੇ ਟਾਈਪ ਚੈਕਰ ਦੀ ਘਾਟ ਕਾਰਨ .d.ts ਜਨਰੇਸ਼ਨ ਨੂੰ ਛੱਡ ਦਿੰਦੇ ਸਨ

ਇਹ ਉਹਨਾਂ ਟੂਲਜ਼ ਨੂੰ ਵੀ ਬਦਲ ਦਿੰਦਾ ਹੈ ਜੋ ਤੁਸੀਂ ਵਰਤ ਸਕਦੇ ਹੋ। esbuild ਅਤੇ swc ਵਰਗੇ transpilers ਪਹਿਲਾਂ ਹੀ TypeScript ਨੂੰ JavaScript ਵਿੱਚ ਬਦਲਣ ਵਿੱਚ ਬਹੁਤ ਤੇਜ਼ ਹਨ, ਪਰ ਬਹੁਤ ਸਾਰੀਆਂ ਟੀਮਾਂ ਅਜੇ ਵੀ ਸਿਰਫ਼ .d.ts ਫਾਈਲਾਂ ਬਣਾਉਣ ਲਈ ਵੱਖਰੇ ਤੌਰ 'ਤੇ tsc ਚਲਾਉਂਦੀਆਂ ਹਨ। isolatedDeclarations ਦੇ ਨਾਲ, ਉਹ ਤੇਜ਼ ਟੂਲ ਦੋਵੇਂ ਕੰਮ ਕਰ ਸਕਦੇ ਹਨ। ਉਹਨਾਂ ਨੂੰ ਡੀਕਲੇਰੇਸ਼ਨਜ਼ (declarations) ਬਣਾਉਣ ਲਈ TypeScript ਦੇ ਪੂਰੇ ਟਾਈਪ ਸਿਸਟਮ ਦੀ ਨਕਲ ਕਰਨ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ; ਉਹਨਾਂ ਨੂੰ ਸਿਰਫ਼ ਸਿੰਟੈਕਸ ਨੂੰ ਪਾਰਸ ਕਰਨ ਅਤੇ ਤੁਹਾਡੇ ਦੁਆਰਾ ਦਿੱਤੇ ਗਏ ਐਕਸਪਲਿਸਿਟ (explicit) ਟਾਈਪਸ ਨੂੰ ਕਾਪੀ ਕਰਨ ਦੀ ਲੋੜ ਹੈ। ਇਹ ਵਿਕਲਪਿਕ ਟੂਲਚੇਨਾਂ (toolchains) ਨਾਲ end-to-end TypeScript ਬਿਲਡਸ ਨੂੰ ਕਿਤੇ ਜ਼ਿਆਦਾ ਵਿਹਾਰਕ ਬਣਾਉਂਦਾ ਹੈ।

ਡਿਸਟ੍ਰੀਬਿਊਟਡ (Distributed) ਅਤੇ ਇੰਕਰੀਮੈਂਟਲ (incremental) ਬਿਲਡਸ ਵੀ ਸੌਖੇ ਹੋ ਜਾਂਦੇ ਹਨ। ਕੰਟੀਨਿਊਅਸ ਇੰਟੀਗ੍ਰੇਸ਼ਨ (continuous integration) ਵਿੱਚ, ਇੱਕ ਰਿਮੋਟ ਕੈਸ਼ (remote cache) ਜਾਂ ਇੱਕ ਸ਼ਾਰਡਡ ਬਿਲਡ (sharded build) ਪੈਕੇਜ ਦੇ ਪੂਰੇ ਟ੍ਰਾਂਜ਼ਿਟਿਵ ਡਿਪੈਂਡੈਂਸੀ ਗ੍ਰਾਫ (transitive dependency graph) ਨੂੰ ਪਹਿਲਾਂ ਡਾਊਨਲੋਡ ਕੀਤੇ ਬਿਨਾਂ ਡੀਕਲੇਰੇਸ਼ਨਜ਼ ਜਾਰੀ ਕਰ ਸਕਦਾ ਹੈ। ਜੇਕਰ ਸੋਰਸ ਵਿੱਚ ਟਾਈਪਸ ਐਕਸਪਲਿਸਟ ਹਨ, ਤਾਂ ਬਿਲਡ ਸ਼ਾਰਡ ਕੋਲ ਉਹ ਸਭ ਕੁਝ ਹੁੰਦਾ ਹੈ ਜਿਸਦੀ ਉਸਨੂੰ ਲੋੜ ਹੈ।

ਕੀ ਉਹੀ ਰਹਿੰਦਾ ਹੈ

ਇਹ ਪਾਬੰਦੀ ਸਿਰਫ਼ exports 'ਤੇ ਲਾਗੂ ਹੁੰਦੀ ਹੈ। ਇੱਕ ਮੋਡਿਊਲ ਦੇ ਅੰਦਰ, ਸਭ ਕੁਝ ਆਮ ਤੌਰ 'ਤੇ ਚਲਦਾ ਰਹਿੰਦਾ ਹੈ। ਲੋਕਲ ਵੇਰੀਏਬਲਜ਼, ਪ੍ਰਾਈਵੇਟ ਕਲਾਸ ਮੈਂਬਰਜ਼, ਅਤੇ ਅਨ-ਐਕਸਪੋਰਟਡ ਹੈਲਪਰ ਫੰਕਸ਼ਨਜ਼ ਅਜੇ ਵੀ ਪੂਰੇ ਟਾਈਪ ਇਨਫਰੈਂਸ (type inference) 'ਤੇ ਨਿਰਭਰ ਕਰ ਸਕਦੇ ਹਨ। TypeScript ਬਿਨਾਂ ਕਿਸੇ ਸ਼ਿਕਾਇਤ ਦੇ ਲੂਪ ਵੇਰੀਏਬਲ ਜਾਂ ਕਲੋਜ਼ਰ ਪੈਰਾਮੀਟਰ ਦੇ ਟਾਈਪ ਦਾ ਅੰਦਾਜ਼ਾ ਲਗਾ ਲਵੇਗਾ।

export function calculateTotal(items: Item[]): number {
  // Local variable: inference is fine
  const taxRate = 0.08;
  
  // Private class member inside a local class: inference is fine
  class Helper {
    private cache = new Map();
  }
  
  return items.reduce((sum, item) => sum + item.price * (1 + taxRate), 0);
}

ਸਿਰਫ਼ ਐਕਸਪੋਰਟ ਕੀਤੇ ਗਏ ਫੰਕਸ਼ਨ ਸਿਗਨੇਚਰ ਨੂੰ ਐਨੋਟੇਸ਼ਨ ਦੀ ਲੋੜ ਸੀ। ਅੰਦਰੂਨੀ ਮਸ਼ੀਨਰੀ ਲਚਕਦਾਰ ਅਤੇ ਪ੍ਰਗਟਾਵੇ ਵਾਲੀ ਰਹਿੰਦੀ ਹੈ। ਇਹ ਲਿਖਣ ਦੇ ਬੋਝ ਨੂੰ ਸਹਿਣਯੋਗ ਰੱਖਦਾ ਹੈ। ਤੁਸੀਂ ਹਰ ਜਗ੍ਹਾ ਪੂਰੀ ਤਰ੍ਹਾਂ ਐਕਸਪਲਿਸਟ ਸਟਾਈਲ 'ਤੇ ਨਹੀਂ ਜਾ ਰਹੇ ਹੋ; ਤੁਸੀਂ ਸਿਰਫ਼ ਹਰੇਕ ਮੋਡਿਊਲ ਦੀ ਸੀਮਾ 'ਤੇ ਇਕਰਾਰਨਾਮੇ (contract) ਨੂੰ ਰਸਮੀ ਬਣਾ ਰਹੇ ਹੋ।

ਕੀ ਇਹ ਤੁਹਾਡੇ ਕੋਡਬੇਸ ਲਈ ਸਹੀ ਹੈ?

isolatedDeclarations ਨੂੰ ਅਪਣਾਉਣ ਨਾਲ ਤੁਹਾਡਾ ਸਮਾਂ ਖਰਚਣ ਦਾ ਤਰੀਕਾ ਬਦਲ ਜਾਂਦਾ ਹੈ। ਜਦੋਂ ਤੁਸੀਂ ਇੱਕ export ਲਿਖਦੇ ਹੋ ਤਾਂ ਤੁਸੀਂ ਕੁਝ ਵਾਧੂ ਕੀ-ਸਟ੍ਰੋਕਸ ਲਗਾਉਂਦੇ ਹੋ, ਅਤੇ ਬਦਲੇ ਵਿੱਚ ਤੁਸੀਂ ਹਰ ਬਿਲਡ 'ਤੇ ਵਾਧੂ ਸਮਾਂ ਖਰਚ ਕਰਨਾ ਬੰਦ ਕਰ ਦਿੰਦੇ ਹੋ। ਲਾਇਬ੍ਰੇਰੀ ਲੇਖਕਾਂ ਲਈ, ਇਹ ਅਕਸਰ ਇੱਕ ਆਸਾਨ ਫੈਸਲਾ ਹੁੰਦਾ ਹੈ। ਪਬਲਿਕ APIs ਨੂੰ ਫਿਰ ਵੀ ਐਨੋਟੇਟ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। ਇੱਕ ਬੰਦ ਮੋਨੋਰੇਪੋ (monorepo) ਦੇ ਅੰਦਰ ਕੰਮ ਕਰ ਰਹੇ ਐਪਲੀਕੇਸ਼ਨ ਡਿਵੈਲਪਰਾਂ ਲਈ, ਸ਼ੁਰੂਆਤੀ ਲਾਗਤ ਬੇਲੋੜੀ ਲੱਗ ਸਕਦੀ ਹੈ। ਪਰ ਜੇਕਰ ਤੁਹਾਡੀ ਟੀਮ ਬਿਲਡ ਸਮੇਂ ਨੂੰ ਕੌਫੀ ਬ੍ਰੇਕਾਂ ਨਾਲ ਮਾਪਦੀ ਹੈ, ਤਾਂ ਇਹ ਸੌਦਾ ਜਲਦੀ ਹੀ ਆਕਰਸ਼ਕ ਹੋ ਜਾਂਦਾ ਹੈ।

ਤੁਸੀਂ ਇਸਨੂੰ ਹੌਲੀ-ਹੌਲੀ ਅਪਣਾ ਸਕਦੇ ਹੋ। ਫਲੈਗ ਨੂੰ ਇਨੇਬਲ ਕਰੋ, ਕੰਪਾਈਲਰ ਚਲਾਓ, ਅਤੇ ਐਕਸਪੋਰਟ ਕੀਤੇ ਗਏ ਸਿੰਬਲਜ਼ 'ਤੇ ਆਉਣ ਵਾਲੀਆਂ ਗਲਤੀਆਂ ਨੂੰ ਸੁਧਾਰੋ। ਗਲਤੀਆਂ ਦੇ ਸੰਦੇਸ਼ ਤੁਹਾਨੂੰ ਬਿਲਕੁਲ ਦੱਸਦੇ ਹਨ ਕਿ ਕਿਹੜੇ ਪਬਲਿਕ-ਫੇਸਿੰਗ ਟਾਈਪਸ ਇੰਪਲਿਸਿਟ ਹਨ। ਉਹਨਾਂ ਨੂੰ ਸੁਧਾਰੋ, ਅੰਦਰੂਨੀ ਚੀਜ਼ਾਂ ਨੂੰ ਉਵੇਂ ਹੀ ਰਹਿਣ ਦਿਓ, ਅਤੇ ਆਪਣੇ ਡੀਕਲੇਰੇਸ਼ਨ ਸਟੈਪ ਨੂੰ ਤੇਜ਼ ਹੁੰਦੇ ਦੇਖੋ।

ਇੱਕ ਗੱਲ ਯਾਦ ਰੱਖਣ ਵਾਲੀ ਹੈ: ਇਹ ਫਲੈਗ TypeScript ਦੇ ਟਾਈਪ ਚੈਕਰ ਨੂੰ ਖੁਦ ਤੇਜ਼ ਨਹੀਂ ਬਣਾਉਂਦਾ। ਜੇਕਰ ਤੁਸੀਂ ਆਪਣੇ ਐਡੀਟਰ ਵਿੱਚ ਤੇਜ਼ ਫੀਡਬੈਕ ਜਾਂ ਤੇਜ਼ tsc --noEmit ਚਲਾਉਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਤੁਹਾਨੂੰ ਅਜੇ ਵੀ ਪ੍ਰੋਜੈਕਟ ਰੈਫਰੈਂਸਿਸ, ਸਖ਼ਤ ਫਾਈਲ ਇਨਕਲੂਜ਼ਨ, ਜਾਂ ਹੋਰ ਆਰਕੀਟੈਕਚਰਲ ਫਿਕਸਾਂ ਦੀ ਲੋੜ ਹੈ। isolatedDeclarations ਖਾਸ ਤੌਰ 'ਤੇ .d.ts ਫਾਈਲਾਂ ਦੇ ਐਮੀਸ਼ਨ ਨੂੰ ਨਿਸ਼ਾਨਾ ਬਣਾਉਂਦਾ ਹੈ। ਇਹ ਇੱਕ ਬਿਲਡ ਆਪਟੀਮਾਈਜ਼ੇਸ਼ਨ ਹੈ, ਟਾਈਪ-ਚੈਕਿੰਗ ਆਪਟੀਮਾਈਜ਼ੇਸ਼ਨ ਨਹੀਂ।

ਅਸਲ ਸਿੱਖਿਆ

isolatedDeclarations ਤੁਹਾਨੂੰ ਆਪਣੇ ਪਬਲਿਕ ਟਾਈਪਸ ਨੂੰ ਫਸਟ-ਕਲਾਸ ਆਰਟੀਫੈਕਟਸ ਵਜੋਂ ਮੰਨਣ ਲਈ ਕਹਿੰਦਾ ਹੈ। ਕੰਪਾਈਲਰ ਨੂੰ ਉਹਨਾਂ ਦਾ ਅੰਦਾਜ਼ਾ ਲਗਾਉਣ ਲਈ ਮਜਬੂਰ ਕਰਨਾ ਬੰਦ ਕਰੋ। ਉਹਨਾਂ ਨੂੰ ਲਿਖੋ। ਇੱਕ ਵਾਰ ਜਦੋਂ ਤੁਸੀਂ ਅਜਿਹਾ ਕਰ ਲੈਂਦੇ ਹੋ, ਤਾਂ ਕੰਪਾਈਲਰ ਹਰ ਵਾਰ ਡੀਕਲੇਰੇਸ਼ਨ ਫਾਈਲ ਬਣਾਉਣ ਦੀ ਲੋੜ ਪੈਣ 'ਤੇ ਤੁਹਾਡੇ ਪੂਰੇ ਡਿਪੈਂਡੈਂਸੀ ਗ੍ਰਾਫ ਵਿੱਚ ਨਹੀਂ ਘੁੰਮਦਾ। ਇਹ ਪੈਰਲਲ ਵਿੱਚ ਐਮਿਟ ਕਰਦਾ ਹੈ, esbuild ਅਤੇ swc ਵਰਗੇ ਟੂਲ ਪੂਰੇ TypeScript ਵਰਕਫਲੋ ਨੂੰ ਸੰਭਾਲਦੇ ਹਨ, ਅਤੇ ਤੁਹਾਡੇ ਮੋਨੋਰੇਪੋ ਬਿਲਡਸ ਲੰਬੇ ਨਹੀਂ ਖਿੱਚਦੇ।

ਲਾਗਤ ਬਿਲਡ ਸਮੇਂ ਤੋਂ ਲਿਖਣ ਦੇ ਸਮੇਂ ਵੱਲ ਤਬਦੀਲ ਹੋ ਜਾਂਦੀ ਹੈ। ਜ਼ਿਆਦਾਤਰ ਵਧ ਰਹੀਆਂ ਟੀਮਾਂ ਲਈ, ਇਹ ਇੱਕ ਲਾਇਕ ਸੌਦਾ ਹੈ।