[ טוען... ]

הקומפיילר הנייטיב של TypeScript 7: מה משתנה ב-Next.js ואיך עוברים

תאריך: 31.10.2026
זמן קריאה: 20 דקות
לידור כהן
מייסד, לידור דיגיטל

שיתוף:

הירשמו לניוזלטר - תובנות על אוטומציה ו-AI, בלי ספאם

שני מסועים מקבילים של בלוקי קוד, אחד איטי ואחד מהיר, הממחישים את הקומפיילר הנייטיב של TypeScript 7 ומדידת ביצועים

מי שמחפש מידע על TypeScript 7 קומפיילר נייטיב ימצא בעיקר כותרות על "פי 10". מאחורי הכותרות עומד שינוי תשתיתי אמיתי בכלי העבודה של כל צוות שכותב TypeScript: גרסה 7.0 הגיעה ל-GA ב-8 ביולי 2026, אחרי RC שיצא ב-18 ביוני. מדובר בפורט של הקומפיילר ושל ה-Language Service לשפת Go, תחת שם הקוד Project Corsa, וההבטחה המרכזית היא בדיקת טיפוסים מהירה בסדרי גודל, גם בעורך וגם ב-CI.

לצוותים שמתחזקים פרויקטי Next.js גדולים, מונוריפו עם כמה אפליקציות או מערכות Payload CMS, השאלה אינה אם הקומפיילר החדש מהיר יותר. השאלה היא כמה הוא מהיר יותר בפרויקט הספציפי שלהם, מה נשבר בדרך, והאם החיסכון בזמני CI מצדיק את המאמץ כבר עכשיו. כאן נכנסים פרטים שהכותרות לא תמיד מדגישות: גרסה 7.0 לא כוללת את ה-API התכנותי של הקומפיילר, חלק מאפשרויות ה-tsconfig הוסרו, ונתוני הביצועים הרשמיים נמדדו על פרויקטים עצומים.

המדריך הזה מסביר מה בדיוק השתנה, איך לקרוא נכון את הבנצ'מרקים, מה המשמעות עבור next build, אילו כלים צפויים להישבר, ואיך לבנות תהליך בדיקה מבוקר שמאפשר להחליט על סמך נתונים ולא על סמך הייפ.

TypeScript 7 קומפיילר נייטיב: פורט ל-Go, לא שפה חדשה

הנקודה הראשונה שחשוב להבין: TypeScript 7 אינו שפה חדשה ואינו מערכת טיפוסים חדשה. זהו פורט נאמן של הקומפיילר הקיים מ-TypeScript/Node.js לשפת Go. התחביר זהה, הסמנטיקה כמעט זהה, והקוד שכותבים לא אמור להשתנות.

למה דווקא Go

לפי ההכרזה של Microsoft והרקע שמתואר במקורות, הבחירה ב-Go נבעה משני שיקולים עיקריים: סגנון הכתיבה בשפה דומה לבסיס הקוד הקיים של הקומפיילר, ומנגנון איסוף הזבל (Garbage Collector) שלה מתאים למבני הגרף המעגליים שהקומפיילר מחזיק בזיכרון. המשמעות המעשית היא שניתן היה להעביר את הלוגיקה בצורה שיטתית, במקום לתכנן קומפיילר חדש מאפס.

עד כמה הפורט נאמן למקור

לפי הניתוח של Dennis Morello, לוגיקת בדיקת הטיפוסים מתוארת כזהה מבנית ל-TypeScript 6.0. מתוך כ-20,000 מקרי בדיקה, כ-6,000 מייצרים שגיאה תחת TS6, ומכולם רק 74 לא מייצרים שגיאה גם תחת TS7. זהו שיעור התאמה גבוה מאוד, אבל לא מושלם, ולכן בדיקה על בסיס הקוד בפועל עדיין נדרשת.

מה נתמך בגרסה היציבה

לפי ARG Software, הגרסה היציבה תומכת ביכולות הליבה שרוב הצוותים צריכים:

  • בנייה אינקרמנטלית (Incremental builds)
  • Project references
  • מצב בנייה (--build)
  • מצב מעקב (Watch mode)
  • הפקת JavaScript (JS emit)
  • הפקת קבצי הצהרה (.d.ts)

כלומר, מבחינת שימוש בשורת הפקודה, רוב התרחישים הסטנדרטיים מכוסים. הפער העיקרי נמצא במקום אחר: בכלים שמייבאים את TypeScript כספרייה.

שינוי מכוון אחד בסמנטיקה

יש שינוי מתועד ומכוון אחד שכדאי להכיר: הסקת טיפוסים ב-Template literal types צורכת כעת Code point מלא של Unicode, במקום חצי מזוג Surrogate של UTF-16.

מה זה אומר לגבי עברית? כאן מדובר בהסקה טכנית ולא בעובדה מהמקורות: אותיות עבריות נמצאות ב-Basic Multilingual Plane ואינן מיוצגות כזוגות Surrogate, ולכן קוד שמפרק מחרוזות עבריות ברמת הטיפוסים ככל הנראה לא יושפע. ההשפעה צפויה להיות רלוונטית בעיקר לאמוג'י ולתווים נדירים. אתרים שמשתמשים ב-Template literal types מתקדמים על מחרוזות עם תווים כאלה, למשל במפתחות תרגום או בטיפוסי i18n, כדאי שיריצו בדיקה ממוקדת.

הבנצ'מרקים הרשמיים

המספרים מרשימים. לפי הנתונים שפורסמו, בנייה מלאה בחמישה פרויקטים מראה האצה של פי 7.7 עד פי 11.9:

פרויקט

TypeScript 6

TypeScript 7

האצה

VS Code

125.7 שניות

10.6 שניות

פי 11.9

Sentry

139.8 שניות

15.7 שניות

פי 8.9

tldraw

11.2 שניות

1.46 שניות

פי 7.7 בקירוב

למה המספרים האלה הם תרחיש מיטבי

כל הפרויקטים בטבלה הם בסיסי קוד גדולים מאוד. כמה מקורות מדגישים שההאצה אינה מובטחת: מבנה הפרויקט, החומרה, מספר ה-checkers שרצים במקביל וכמות הזיכרון הזמינה משפיעים כולם על התוצאה. ההמלצה החוזרת היא למדוד על הריפו של הצוות עצמו.

טבלת השוואה של צד שלישי מ-DevEncyclopedia מראה תמונה צנועה יותר עבור פרויקטים קטנים:

  • אפליקציה של כ-20,000 שורות: מ-3.2 שניות ל-1.1 שניות (פי 2.9 בערך)
  • צד שרת של כ-100,000 שורות: מ-12 שניות ל-2.1 שניות (פי 5.7 בערך)

יש לציין שבטבלה הזו יש חוסר עקביות מול הנתונים הרשמיים (למשל זמני VS Code שונים), וככל הנראה חלקה נמדד בתקופת הבטא. ובכל זאת, המגמה הגיונית: ככל שהפרויקט קטן יותר, תקורות קבועות כמו טעינה וקריאת קבצים תופסות חלק גדול יותר מהזמן הכולל, וההאצה היחסית קטנה.

ומה עם זיכרון

כאן המקורות סותרים זה את זה. לפי Developers Digest, Microsoft דיווחה על צריכת זיכרון נמוכה ב-6% עד 26% בבסיסי הקוד שנבדקו. מקורות אחרים טוענים לחיסכון גדול בהרבה, וטענות על צריכת זיכרון גבוהה יותר לא נמצאו מגובות במקורות שנבדקו. מה שכן ברור: כמות הזיכרון הזמינה משפיעה על הביצועים, ולכן בשרתי ה-CI (Runners), ובמיוחד בקטנים שבהם, חובה למדוד את שיא צריכת הזיכרון ולא להניח.

העורך: השיפור המורגש ביותר ביומיום

מעבר ל-CI, שיפור משמעותי מגיע ב-Language Service. לפי אותו מקור, זמן פתיחת קובץ עם שגיאה ב-VS Code ירד מ-17.5 שניות לפחות מ-1.3 שניות. עבור מפתחים שעובדים על מונוריפו כבד, זה ההבדל בין עורך שמגיב מיד לבין המתנה מתסכלת להשלמה אוטומטית.

חשוב לזכור: ההאצה רלוונטית לפיתוח ול-CI בלבד, לא לביצועי האפליקציה בזמן ריצה. הקומפיילר החדש מקצר את זמן ההמתנה של המפתחים, אבל לא את זמן הטעינה של הגולשים. מי שמטרתו לשפר את מהירות הטעינה של האתר עצמו ואת חוויית המשתמש צריך לעבוד על גורמים אחרים לגמרי, כמו שמתואר במאמר למה מהירות האתר קריטית להצלחה.

מה משתנה ב-Next.js: next build, SWC ובדיקת טיפוסים

כדי להבין מה המעבר משנה בפרויקט Next.js, צריך קודם להבין איפה TypeScript בכלל רץ בתהליך.

מצב פיתוח: SWC מסיר את הטיפוסים

לפי דיון בקהילת Next.js ב-GitHub, סביבת הפיתוח ככל הנראה משתמשת ב-SWC כדי להסיר את הטיפוסים מהקוד, בלי לבצע בדיקת טיפוסים. המשמעות: next dev לא צפוי להשתנות מהותית בעקבות המעבר. שגיאות טיפוסים בזמן פיתוח מגיעות בעיקר מהעורך, ושם ה-Language Service החדש כן ירגיש מהיר יותר.

next build: בדיקת הטיפוסים היא רק חלק מהזמן

בזמן next build, בדיקת הטיפוסים היא שלב נוסף לצד הקומפילציה, האריזה (Bundling), ייצור עמודים סטטיים ואופטימיזציות. לכן גם אם בדיקת הטיפוסים עצמה מאיצה פי 5, זמן הבנייה הכולל ישתפר הרבה פחות. לדוגמה, בפרויקט שבו בדיקת הטיפוסים לוקחת 30 שניות מתוך בנייה של 4 דקות, החיסכון המקסימלי הוא בסביבות 25 שניות.

מה המשמעות לפי גודל הפרויקט

החישוב משתנה מאוד לפי גודל בסיס הקוד. אם מדובר, למשל, באתר תדמית, בדף נחיתה או בחנות בהיקף של עשרות אלפי שורות, סביר לצפות להאצה נמוכה מהכותרות, ברוח המדידות של צד שלישי שהוזכרו קודם. חיסכון של שתי שניות בבדיקת הטיפוסים נחמד, אבל לא משנה את סדר היום של צוות. לעומת זאת, מונוריפו עם כמה אפליקציות, ספריית קומפוננטות משותפת ו-Payload CMS הוא כבר סיפור אחר, ושם הפוטנציאל גדול יותר.

אין אינטגרציה רשמית, יש מעקף מהקהילה

במקורות שנבדקו לא נמצאה תמיכה רשמית של Next.js בהרצת הקומפיילר החדש כחלק מהבנייה. בדיון הקהילתי הוצע מעקף: לכבות את בדיקת הטיפוסים המובנית ולהריץ את הבדיקה בנפרד. חשוב להדגיש שזו הצעה של הקהילה ולא הנחיה רשמית:

// next.config.ts
import type { NextConfig } from 'next';

const nextConfig: NextConfig = {
  typescript: {
    // בדיקת הטיפוסים מתבצעת בשלב נפרד ב-CI
    ignoreBuildErrors: true,
  },
};

export default nextConfig;

ולצד זה, ב-CI מריצים בדיקה עצמאית לפני הבנייה:

# בדיקת טיפוסים עם הקומפיילר החדש, ללא פלט קבצים
npx tsgo --noEmit
# או, בהתאם לשם הבינארי בגרסה המותקנת:
npx tsc --noEmit

npx next build

הסיכון כאן ברור: אם שלב בדיקת הטיפוסים הנפרד מוסר בטעות מתהליך ה-CI, שגיאות טיפוסים יגיעו לפרודקשן בלי שאיש ישים לב. מי שבוחר במעקף הזה צריך להגדיר את שלב הבדיקה כבדיקת חובה (Required check) בענף הראשי, כך שאי אפשר למזג קוד בלי שהיא עברה.

הערה על שמות הבינארי

המקורות אינם מסכימים בנקודה הזו. לפי אחד המקורות, בגרסה היציבה tsc הוא הבינארי של Go, ו-tsgo קיים רק בגרסאות ה-Nightly של ה-native preview. לפי מקור אחר, tsgo הוא הבינארי החדש ו-tsc משמש כשכבת מעבר (Shim). לפני שמעדכנים סקריפטים, כדאי לבדוק מה בדיוק מותקן ב-node_modules/.bin ולהריץ --version על כל אחד מהבינאריים.

ה-API החסר: typescript-eslint, ts-jest, ts-morph ו-ts-node

זו הנקודה שבה רוב הצוותים ייתקלו בבעיות. TypeScript 7.0 לא כולל את ה-API התכנותי שהיה זמין ב-6.0. כל כלי שמבצע import ts from 'typescript' ומשתמש בפונקציות של הקומפיילר עלול להפסיק לעבוד.

אילו כלים מושפעים

לפי מקור שבחן את הנושא, בלי ה-API הכלים הבאים לא עובדים עד שה-API יחזור בגרסה 7.1:

  • typescript-eslint: כללי Lint שמבוססים על מידע טיפוסים
  • ts-jest: הרצת בדיקות Jest על קבצי TypeScript
  • ts-morph: מניפולציה על עץ התחביר (AST), נפוץ בכלי ייצור קוד

ומה עם ts-node

ts-node לא מוזכר במפורש באף אחד מהמקורות. עם זאת, ts-node מייבא את חבילת typescript ומשתמש בקומפיילר שלה כדי להריץ קבצי TS ישירות, ולכן סביר שהוא ייפגע באותה דרך. זו הסקה ולא עובדה מאומתת, והדרך היחידה לדעת היא לבדוק. בפועל, הפתרון הפשוט הוא להשאיר את ts-node עובד מול TS6, בשיטה שמתוארת בפרק הבא.

איך לזהות תלות ב-API בפרויקט

לפני המעבר כדאי למפות אילו חבילות בפרויקט תלויות ב-typescript:

# אילו חבילות מצהירות על תלות ב-typescript
npm ls typescript --all

# האם קוד הפרויקט עצמו מייבא את הקומפיילר
grep -rn "from 'typescript'" --include=*.ts --include=*.js --exclude-dir=node_modules .

כל תוצאה ברשימה הזו היא מועמדת לבדיקה. חבילות שמופיעות רק כ-peerDependency לא בהכרח משתמשות ב-API, אבל רוב כלי ה-Lint, הבדיקות וייצור הקוד כן.

המיפוי הזה הוא גם הזדמנות טובה לבחון את שרשרת התלויות כולה: אילו חבילות כבר לא בשימוש, אילו לא עודכנו זמן רב ומי מושך גרסאות ישנות. הצ'קליסט במדריך אבטחת שרשרת אספקה לצוותים קטנים משתלב היטב בתהליך כזה.

Custom transformers וייצור קוד

לפי ITPath Solutions, צוותים שמשתמשים ב-API של הקומפיילר, ב-Custom transformers או ב-ts-morph לא צריכים להחליף את TS6 ישירות בשלב זה. לעומתם, פרויקטי React, Node או NestJS שמשתמשים ב-tsc רגיל יכולים להתחיל מעבר מבוקר.

מעבר ל-TypeScript 7: ביקורת tsconfig והרצה במקביל ל-TS6

גם אם כל הכלים עובדים, ה-tsconfig עלול לשבור את הבנייה. TS7 ממשיך את ברירות המחדל של TS6 ומסיר אפשרויות ישנות. לכן התהליך הבטוח מורכב משני חלקים: ביקורת קונפיגורציה, ואחריה הרצה של שתי הגרסאות זו לצד זו.

ברירות מחדל חדשות

לפי ARG Software, ברירות המחדל הן:

אפשרות

ברירת מחדל ב-TS7

מה זה אומר בפועל

strict

מופעל

פרויקטים שלא הגדירו strict במפורש עלולים לקבל שגיאות חדשות

types

רשימה ריקה

טיפוסים גלובליים כמו @types/node לא ייטענו אוטומטית

rootDir

תיקיית הקונפיגורציה

עלול לשנות את מבנה הפלט בפרויקטים שמפיקים קבצים

module

esnext

מתאים ל-Next.js, אבל לא לכל סקריפט Node

target

גרסת ECMAScript היציבה האחרונה

קוד הפלט עשוי להשתמש בתחביר חדש יותר

השינוי ב-types הוא כנראה המפתיע ביותר. פרויקט שהסתמך על כך ש-@types/node או @types/jest נטענים אוטומטית יקבל שגיאות כמו Cannot find name 'process'. הפתרון הוא להצהיר במפורש:

{
  "compilerOptions": {
    "types": ["node"]
  }
}

אפשרויות שהוסרו

TS7 מסיר את moduleResolution מסוג node/node10 ו-classic, וגם את baseUrl. במקומם יש להשתמש ב-nodenext או ב-bundler, עם paths מפורשים ויחסיים לפרויקט. לפי מקור נוסף, הוסרו גם יעדים ומערכות מודולים כמו es5, amd, umd ו-systemjs.

לפני ואחרי: tsconfig של Next.js

פרויקטי Next.js ותיקים מכילים לעיתים קונפיגורציה כזו:

{
  "compilerOptions": {
    "target": "es5",
    "moduleResolution": "node",
    "baseUrl": ".",
    "paths": {
      "@/*": ["src/*"]
    }
  }
}

גרסה שתואמת ל-TS7 נראית בערך כך:

{
  "compilerOptions": {
    "target": "es2022",
    "module": "esnext",
    "moduleResolution": "bundler",
    "strict": true,
    "types": ["node"],
    "paths": {
      "@/*": ["./src/*"]
    }
  }
}

שני פרטים חשובים: הנתיב ב-paths מתחיל ב-./ כי אין יותר baseUrl, ו-moduleResolution: bundler מתאים לפרויקט שבו Next.js (ולא Node ישירות) אחראי על האריזה. סקריפטים שרצים ישירות ב-Node, כמו Migrations, עשויים לדרוש tsconfig נפרד עם nodenext.

מאחר ש-TS7 ממשיך את ברירות המחדל של TS6, הצהרה מפורשת על אפשרויות כמו strict ו-types אמורה להתנהג באותו אופן בשתי הגרסאות. המקורות לא מפרטים איך TS6 מגיב לקונפיגורציה החדשה ללא baseUrl, ולכן כדאי לבצע את השינויים בענף נפרד ולהריץ עליהם את tsc6 לפני המעבר. כך מפצלים את הסיכון: קודם מיישרים את הקונפיגורציה ומוודאים שהיא עובדת, ורק אחר כך מחליפים קומפיילר.

התקנה במקביל: tsc6 לצד TS7

הגישה הבטוחה ביותר היא לא להחליף, אלא להוסיף. חבילת @typescript/typescript6 מספקת בינארי בשם tsc6 שמאפשר להריץ את 6.0 לצד 7.0:

npm install -D typescript@latest @typescript/typescript6

בתקופת ה-RC ההתקנה התבצעה עם typescript@rc. אחרי ההתקנה כדאי לבדוק אילו בינאריים זמינים ומה הגרסה של כל אחד:

npx tsc --version
npx tsc6 --version
ls node_modules/.bin | grep -i ts

הפער בתצורה ההיברידית: מי מקבל את חבילת typescript

כאן מסתתרת מלכודת. tsc6 פותר את הרצת הבדיקה של TS6 משורת הפקודה, אבל כלים כמו typescript-eslint ו-ts-jest לא מריצים בינארי. הם מבצעים import 'typescript', ומקבלים את מה שמותקן תחת השם typescript. אם typescript@latest הוא 7.0, הם יקבלו את 7.0, שאין בה API, וייכשלו.

אחת הדרכים להתמודד עם זה היא להפוך את הסדר: להשאיר את שם החבילה typescript נעוץ על גרסה 6, ולהתקין את TS7 תחת שם חלופי באמצעות npm alias. כך כל כלי שמייבא typescript ממשיך לקבל את TS6 עם ה-API, ו-TS7 משמש רק לבדיקת הטיפוסים:

# typescript נשאר על 6, כך שכלים שמייבאים אותו מקבלים את ה-API
npm install -D typescript@^6 typescript7@npm:typescript@^7

# בדיקה איזה בינארי מוצהר בחבילת ה-alias
node -p "require('./node_modules/typescript7/package.json').bin"

# בדיקה איזו גרסה מקבל כל מי שמייבא את 'typescript'
node -p "require('typescript').version"

כמה הסתייגויות חשובות, כי המקורות לא מתעדים את התצורה הזו:

  • ייתכן ששתי החבילות מצהירות על אותו שם בינארי (tsc), ואז לא מובטח מי מהן תופיע ב-node_modules/.bin. לכן עדיף להריץ את TS7 דרך נתיב מפורש לקובץ שמופיע בשדה bin, ולא דרך npx tsc.
  • אם השדה bin מצביע על קובץ JavaScript, מריצים אותו עם node. אם הוא מצביע על קובץ הרצה, מריצים אותו ישירות.
  • מנהלי חבילות שונים (npm, pnpm, Yarn) מטפלים ב-alias ובתלויות peer באופן שונה, ולכן התוצאה צריכה להיבדק בפועל בכל פרויקט.
  • הבדיקה המובנית של next build תשתמש ככל הנראה בחבילת typescript, כלומר ב-TS6 בתצורה הזו. זה לא שובר דבר, אבל גם לא מאיץ את הבנייה, וזו סיבה נוספת לשקול את מעקף ignoreBuildErrors.

בכל מקרה, צריך לוודא כלי אחר כלי איזו גרסה הוא טוען בפועל: להריץ את ESLint ואת חבילת הבדיקות, ולבדוק שאין שגיאות על API חסר. התיעוד של כל כלי הוא נקודת התחלה, אבל ההוכחה היחידה היא הרצה מוצלחת ב-CI.

סקריפטים נפרדים והשוואת תוצאות

בתצורת ה-alias, הסקריפטים יכולים להיראות כך (את הנתיב המדויק יש להעתיק מהשדה bin שנבדק קודם):

{
  "scripts": {
    "typecheck:ts6": "tsc --noEmit",
    "typecheck:ts7": "node ./node_modules/typescript7/<נתיב-מהשדה-bin> --noEmit",
    "lint": "eslint .",
    "build": "next build"
  }
}

בתצורה שבה typescript הוא 7 ו-@typescript/typescript6 מותקן לצידו, הסקריפטים יהיו tsc --noEmit ו-tsc6 --noEmit בהתאמה. בשלב הראשון מריצים את שתי הבדיקות ב-CI ומשווים תוצאות. אם TS7 מדווח על שגיאות ש-TS6 לא מדווח, או להפך, זה בדיוק המידע שצריך לפני החלטה. 74 המקרים שבהם התוצאות שונות נדירים, אבל ייתכן שהקוד נופל על אחד מהם.

מדידה אמיתית: זמן, זיכרון, בנייה קרה וחמה

במקום להסתמך על תחושה, כדאי למדוד כמה הרצות של כל גרסה. הכלי hyperfine נוח לזה:

hyperfine --warmup 1 --runs 5 'npm run typecheck:ts6' 'npm run typecheck:ts7'

ולמדידת שיא זיכרון על Linux:

/usr/bin/time -v npm run typecheck:ts6 2>&1 | grep 'Maximum resident'
/usr/bin/time -v npm run typecheck:ts7 2>&1 | grep 'Maximum resident'

כדי שההשוואה תהיה הוגנת, יש לנקות את המטמון (Cache) של הבנייה האינקרמנטלית בין ההרצות. כדאי למדוד גם בנייה קרה וגם בנייה חמה, כי ב-CI עם מטמון מוגדר היטב הבנייה החמה היא המצב הנפוץ.

נקודה נוספת שהמקורות לא מכסים: התאימות של קבצי .tsbuildinfo בין TS6 ל-TS7. אין מידע אם קובץ שנוצר בגרסה אחת קריא לגרסה השנייה, ולכן כדאי להפריד ביניהם (למשל באמצעות tsBuildInfoFile שונה לכל גרסה, או מפתח מטמון נפרד ב-CI) ולבדוק בפועל שהבנייה החמה מתנהגת כמצופה.

בזמן המדידה כדאי לשים לב גם לחבילות שמבצעות הסקת טיפוסים כבדה. ספריות ולידציה, למשל, נשענות על הסקה מורכבת, והן עשויות להיות חלק משמעותי מזמן הבדיקה. ההשוואה בין Zod, Valibot ו-ArkType מסבירה את ההבדלים בגישה של כל אחת מהן לטיפוסים.

צ'קליסט CI

לפני שמעבירים את תהליך ה-CI לקומפיילר החדש, כדאי לעבור על הרשימה הבאה:

  1. זמן: למדוד את שלב בדיקת הטיפוסים לבד, לא רק את זמן ה-Job הכולל. זה המקום היחיד שבו ההאצה מתבטאת.
  2. זיכרון: לבדוק שיא צריכת זיכרון על שרת ה-CI האמיתי. שרתים קטנים עלולים להיתקע אם הזיכרון לא מספיק, וכאמור הזיכרון הזמין משפיע על הביצועים.
  3. מקביליות: מספר ה-checkers שרצים במקביל משפיע על התוצאה. על שרת עם מעט ליבות ההאצה עשויה להיות קטנה יותר מאשר על מחשב פיתוח חזק.
  4. מטמון: לוודא שקבצי ה-.tsbuildinfo נשמרים בין הרצות, ושהמטמון של TS6 ושל TS7 מופרד עד שהתאימות ביניהם נבדקה.
  5. בדיקת חובה: אם עוברים למעקף של ignoreBuildErrors, שלב בדיקת הטיפוסים חייב להיות חוסם.
  6. Lint: לוודא ש-typescript-eslint טוען בפועל את TS6 עד שה-API יחזור.
  7. בדיקות: להריץ את כל חבילת הבדיקות, כולל אלו שרצות דרך ts-jest.
  8. חזרה לאחור: להשאיר דרך פשוטה לחזור, למשל משתנה סביבה שבוחר איזה סקריפט בדיקה מריצים.

דוגמה ל-Job ב-GitHub Actions שמריץ את שתי הגרסאות במקביל בתקופת המעבר:

jobs:
  typecheck:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        script: [typecheck:ts6, typecheck:ts7]
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: 22
          cache: npm
      - run: npm ci
      - name: Type check (${{ matrix.script }})
        run: /usr/bin/time -v npm run ${{ matrix.script }}

אחרי כמה שבועות של נתונים, ניתן להחליט אם להסיר את TS6 משלב הבדיקה או להמשיך בתצורה ההיברידית.

זווית תקציבית

השאלה התקציבית תלויה במבנה התשתית של כל צוות. צוות שמשלם על שרתי CI לפי דקה, או שמריץ שרתים עצמאיים (Self-hosted runners) עם משאבים מוגבלים, יכול לחשב את התועלת באופן ישיר. בפרויקט קטן החיסכון בדקות CI עשוי להיות זניח. במונוריפו שמריץ בדיקת טיפוסים על כל Pull request בכמה חבילות, החיסכון מצטבר. הנוסחה פשוטה: זמן בדיקת הטיפוסים הנוכחי, כפול מספר ההרצות בחודש, כפול ההאצה שנמדדה בפועל.

פרויקטי Payload CMS: מה לבדוק לפני המעבר

אף אחד מהמקורות לא מתייחס ספציפית ל-Payload CMS, ולכן כל מה שבפרק הזה הוא רשימת בדיקה ולא קביעה. Payload בגרסאותיו האחרונות רץ בתוך אפליקציית Next.js ומייצר טיפוסים מהגדרות ה-Collections, כך שהוא נוגע כמעט בכל נקודת סיכון שתוארה עד כה. למי שעדיין בוחן ארכיטקטורה כזו, המאמר מה זה Headless CMS מסביר את ההקשר הרחב.

ייצור הטיפוסים

השאלה הראשונה היא האם הפקודה שמייצרת את קובץ הטיפוסים של Payload מסתמכת על ה-API התכנותי של TypeScript. אם כן, היא תדרוש את TS6, וזו בדיוק הסיבה לשמור את חבילת typescript על גרסה 6 בתצורת ה-alias. הדרך לבדוק: להריץ את פקודת ייצור הטיפוסים אחרי השינוי, ולהשוות את הקובץ שנוצר לגרסה הקודמת באמצעות git diff.

tsconfig ו-Path aliases

שתי נקודות קריטיות בקונפיגורציה:

  • האם מוגדרים baseUrl או moduleResolution: node? שתי האפשרויות הוסרו ב-TS7.
  • ייבוא של קובץ הקונפיגורציה דרך alias כמו @payload-config חייב לעבוד עם paths יחסיים, בלי baseUrl. כדאי לוודא שהנתיב מתחיל ב-./ ושהוא נפתר נכון גם בעורך וגם בבנייה.

סקריפטים ו-Plugins

מעבר לאפליקציה עצמה, בפרויקטי Payload יש בדרך כלל קוד שרץ מחוץ ל-Next.js:

  1. Migrations ו-Seed scripts: סקריפטים שרצים ישירות על קבצי TS דרך Loader כלשהו צריכים בדיקה נפרדת, ובמקרים מסוימים tsconfig נפרד עם nodenext.
  2. תוספים של צד שלישי: תוספים שמבצעים טרנספורמציות קוד עשויים להיות תלויים ב-API של TypeScript.
  3. בדיקות אינטגרציה: אם הן רצות דרך ts-jest, הן נופלות באותה קטגוריה של כלים שזקוקים ל-API.
  4. סקריפטי פריסה: סקריפטים שמריצים tsc לצורך הפקת קבצים, ולא רק בדיקה, מושפעים מברירת המחדל החדשה של rootDir.

סדר בדיקה מומלץ

בפרויקט Payload, סדר עבודה הגיוני הוא: קודם ביקורת tsconfig ובדיקה מול tsc6, אחר כך הרצת ייצור הטיפוסים והשוואת הפלט, אחר כך הוספת TS7 כבדיקה מקבילה ב-CI, ורק בסוף בחינה של המעקף ב-next build. כל שלב הפיך, וכל שלב מספק מידע לפני הבא.

לאמץ עכשיו או לחכות ל-TypeScript 7.1?

אין תשובה אחת לכל הצוותים. ההחלטה תלויה בעיקר בשתי שאלות: עד כמה הפרויקט תלוי בכלים שצריכים את ה-API, וכמה זמן CI באמת מבוזבז על בדיקת טיפוסים.

שלוש אסטרטגיות אפשריות

אסטרטגיה

יתרונות

חסרונות

אימוץ מלא עכשיו (שורת פקודה ו-CI)

חיסכון גדול ב-CI במונוריפו גדולים, סמנטיקה זהה ל-TS6, Language Service מהיר

אין API ב-7.0, דורש ביקורת tsconfig, ההאצה בפועל משתנה, אין אינטגרציה רשמית של Next.js

המתנה ל-7.1

ה-API חוזר עבור typescript-eslint, ts-morph ו-Transformers, פחות מעקפים

דוחה את החיסכון ב-CI, 7.1 היה בבטא בלבד במקורות, עדיין צריך לבדוק כל כלי

היברידי: TS6 לכלים ו-TS7 לבדיקת טיפוסים

ESLint וכלי API ממשיכים לעבוד, רוב החיסכון ב-CI, הפיך

שתי גרסאות לתחזק, בלבול אפשרי לגבי איזה בינארי רץ, הבדיקה המובנית של Next עלולה להשתמש בחבילה המותקנת

הטבלה מבוססת על ניתוחים של ITPath Solutions, של המדריך על השבירה של ESLint ושל הדיון ב-Next.js.

מה ידוע על 7.1

לפי קטע שפורסם, גרסת בטא של 7.1 עם ה-API שהיה חסר ב-7.0 יצאה ב-20 באוקטובר 2026. המידע הזה מגיע ממקור יחיד ולא אומת במלואו, ולכן כדאי לעקוב אחרי ההכרזות הרשמיות ב-בלוג של TypeScript לפני שמתכננים סביבו.

מסגרת החלטה פשוטה

  • פרויקט Next.js קטן, בדיקת טיפוסים מתחת ל-10 שניות: אין דחיפות. כדאי לבצע את ביקורת ה-tsconfig עכשיו ולהמתין ל-7.1.
  • מונוריפו בינוני עד גדול, בלי ייצור קוד מבוסס API: התצורה ההיברידית מתאימה. TS7 לבדיקת טיפוסים, TS6 ל-ESLint ולבדיקות.
  • פרויקט שתלוי ב-ts-morph, Custom transformers או ייצור טיפוסים מבוסס API: לא להחליף את TS6 ישירות. אפשר להוסיף את TS7 כבדיקה מקבילה בלבד.
  • צוות שסובל מעורך איטי: שווה לנסות את ה-Language Service החדש בעורך, גם אם ה-CI נשאר על TS6.

בכל אחד מהמסלולים, ביקורת ה-tsconfig היא צעד שאין סיבה לדחות. היא נדרשת בכל מקרה, והיא מקטינה את כמות ההפתעות ביום שבו מחליפים קומפיילר.

שאלות נפוצות

האם TypeScript 7 באמת מהיר פי 10?

הבנצ'מרקים של Microsoft מראים פי 7.7 עד פי 11.9 בפרויקטים גדולים, אבל התוצאה תלויה בגודל הפרויקט, בחומרה, במספר ה-checkers ובזיכרון הזמין. בפרויקטים קטנים, מדידות של צד שלישי מראות האצה של פי 3 בערך. הדרך היחידה לדעת היא למדוד על הריפו עצמו.

האם אפליקציית Next.js תרוץ מהר יותר בפרודקשן?

לא. TS7 מאיץ את הפיתוח ואת בדיקת הטיפוסים ב-CI, לא את ביצועי האפליקציה בזמן ריצה. הקוד שמגיע לדפדפן נבנה על ידי Next.js ולא מושפע מהחלפת הקומפיילר.

האם next dev משתמש בקומפיילר של TypeScript?

ככל הנראה לא לצורך בדיקת טיפוסים. לפי דיון בקהילה, סביבת הפיתוח משתמשת ב-SWC כדי להסיר טיפוסים. בזמן next build בדיקת הטיפוסים היא שלב נוסף.

מה נשבר כשאין API לקומפיילר?

כלים שמייבאים את ה-API של TypeScript, כמו typescript-eslint, ts-jest ו-ts-morph, לא עובדים עם 7.0 עד שה-API יחזור ב-7.1. ts-node לא מוזכר במקורות, אבל מאחר שהוא מבוסס על הקומפיילר של TypeScript, יש לבדוק אותו בנפרד.

אפשר להריץ TypeScript 6 ו-7 יחד?

כן. מתקינים את @typescript/typescript6 ומשתמשים בבינארי tsc6 לצד TS7. חשוב לזכור שכלים שמייבאים את חבילת typescript יקבלו את הגרסה שמותקנת תחת השם הזה, ולכן צריך לוודא, כלי אחר כלי, איזו גרסה כל אחד טוען בפועל.

אילו שינויים ב-tsconfig צריך לבדוק?

strict מופעל כברירת מחדל, types ריק, module הוא esnext ו-rootDir הוא תיקיית הקונפיגורציה. רזולוציית node/node10/classic ו-baseUrl הוסרו, ובמקומן יש להשתמש ב-bundler או ב-nodenext עם paths יחסיים.

סיכום

הקומפיילר הנייטיב של TypeScript 7 הוא פורט נאמן ל-Go של הקומפיילר הקיים, לא שפה חדשה. הסמנטיקה כמעט זהה, והיתרון המרכזי הוא מהירות בדיקת הטיפוסים בעורך וב-CI. המספרים הרשמיים של פי 7.7 עד פי 11.9 נמדדו על פרויקטים עצומים, ובפרויקטי Next.js קטנים עד בינוניים סביר לצפות להאצה צנועה יותר. גם נושא הזיכרון שנוי במחלוקת בין המקורות, ולכן כדאי למדוד אותו על שרתי ה-CI בפועל.

הסיכונים העיקריים הם שניים: היעדר ה-API התכנותי ב-7.0, ששובר כלים כמו typescript-eslint, ts-jest ו-ts-morph, וביקורת tsconfig מחייבת בגלל ברירות מחדל חדשות ואפשרויות שהוסרו. ב-Next.js אין אינטגרציה רשמית, והמעקף של ignoreBuildErrors הוא הצעה קהילתית שדורשת משמעת ב-CI. בתצורה ההיברידית, יש לוודא במפורש איזו גרסה כל כלי טוען, למשל באמצעות npm alias שמשאיר את typescript על גרסה 6.

הדרך המומלצת לרוב הצוותים היא הדרגתית: ליישר את ה-tsconfig ולבדוק אותו מול TS6, להתקין את TS7 לצד TS6, להריץ את שתי הבדיקות במקביל, למדוד זמן וזיכרון בבנייה קרה וחמה, ורק אז להחליט. צוותים שתלויים בכלים מבוססי API יכולים להמתין ל-7.1, ואילו צוותים עם מונוריפו גדול ו-CI עמוס יכולים ליהנות כבר עכשיו מהתצורה ההיברידית.

מקורות

וואטסאפ