Migrate 10 JavaScript files to TypeScript (#57971)

Author: heiskr

src/content-linter/lib/linting-rules/frontmatter-validation.js renamed to src/content-linter/lib/linting-rules/frontmatter-validation.ts

@@ -1,9 +1,27 @@
+// @ts-ignore - no types available for markdownlint-rule-helpers
 import { addError } from 'markdownlint-rule-helpers'
 import { getFrontmatter } from '@/content-linter/lib/helpers/utils'
 
+import type { RuleParams, RuleErrorCallback } from '@/content-linter/types'
+
+interface PropertyLimits {
+  max: number
+  recommended: number
+  required?: boolean
+}
+
+interface ContentRules {
+  title: PropertyLimits
+  shortTitle: PropertyLimits
+  intro: PropertyLimits
+  requiredProperties: string[]
+}
+
+type ContentType = 'category' | 'mapTopic' | 'article' | null
+
 // Strip liquid tags from text for character counting purposes
-function stripLiquidTags(text) {
-  if (typeof text !== 'string') return text
+function stripLiquidTags(text: unknown): string {
+  if (typeof text !== 'string') return text as string
   // Remove both {% %} and {{ }} liquid tags
   return text.replace(/\{%.*?%\}/g, '').replace(/\{\{.*?\}\}/g, '')
 }
@@ -13,15 +31,15 @@ export const frontmatterValidation = {
   description:
     'Frontmatter properties must meet character limits and required property requirements',
   tags: ['frontmatter', 'character-limits', 'required-properties'],
-  function: (params, onError) => {
-    const fm = getFrontmatter(params.lines)
+  function: (params: RuleParams, onError: RuleErrorCallback) => {
+    const fm = getFrontmatter(params.lines as string[])
     if (!fm) return
 
     // Detect content type based on frontmatter properties and file path
     const contentType = detectContentType(fm, params.name)
 
     // Define character limits and requirements for different content types
-    const contentRules = {
+    const contentRules: Record<string, ContentRules> = {
       category: {
         title: { max: 70, recommended: 67 },
         shortTitle: { max: 30, recommended: 27 },
@@ -42,7 +60,7 @@ export const frontmatterValidation = {
       },
     }
 
-    const rules = contentRules[contentType]
+    const rules = contentType ? contentRules[contentType] : null
     if (!rules) return
 
     // Check required properties
@@ -61,14 +79,21 @@ export const frontmatterValidation = {
 
     // Check title length
     if (fm.title) {
-      validatePropertyLength(onError, params.lines, 'title', fm.title, rules.title, 'Title')
+      validatePropertyLength(
+        onError,
+        params.lines as string[],
+        'title',
+        fm.title,
+        rules.title,
+        'Title',
+      )
     }
 
     // Check shortTitle length
     if (fm.shortTitle) {
       validatePropertyLength(
         onError,
-        params.lines,
+        params.lines as string[],
         'shortTitle',
         fm.shortTitle,
         rules.shortTitle,
@@ -78,17 +103,24 @@ export const frontmatterValidation = {
 
     // Check intro length if it exists
     if (fm.intro && rules.intro) {
-      validatePropertyLength(onError, params.lines, 'intro', fm.intro, rules.intro, 'Intro')
+      validatePropertyLength(
+        onError,
+        params.lines as string[],
+        'intro',
+        fm.intro,
+        rules.intro,
+        'Intro',
+      )
     }
 
     // Cross-property validation: if title is longer than shortTitle limit, shortTitle must exist
     const strippedTitle = stripLiquidTags(fm.title)
-    if (fm.title && strippedTitle.length > rules.shortTitle.max && !fm.shortTitle) {
-      const titleLine = findPropertyLine(params.lines, 'title')
+    if (fm.title && (strippedTitle as string).length > rules.shortTitle.max && !fm.shortTitle) {
+      const titleLine = findPropertyLine(params.lines as string[], 'title')
       addError(
         onError,
         titleLine,
-        `Title is ${strippedTitle.length} characters, which exceeds the shortTitle limit of ${rules.shortTitle.max} characters. A shortTitle must be provided.`,
+        `Title is ${(strippedTitle as string).length} characters, which exceeds the shortTitle limit of ${rules.shortTitle.max} characters. A shortTitle must be provided.`,
         fm.title,
         null,
         null,
@@ -98,10 +130,10 @@ export const frontmatterValidation = {
     // Special validation for articles: should have at least one topic
     if (contentType === 'article' && fm.topics) {
       if (!Array.isArray(fm.topics)) {
-        const topicsLine = findPropertyLine(params.lines, 'topics')
+        const topicsLine = findPropertyLine(params.lines as string[], 'topics')
         addError(onError, topicsLine, 'Topics must be an array', String(fm.topics), null, null)
       } else if (fm.topics.length === 0) {
-        const topicsLine = findPropertyLine(params.lines, 'topics')
+        const topicsLine = findPropertyLine(params.lines as string[], 'topics')
         addError(
           onError,
           topicsLine,
@@ -115,9 +147,16 @@ export const frontmatterValidation = {
   },
 }
 
-function validatePropertyLength(onError, lines, propertyName, propertyValue, limits, displayName) {
+function validatePropertyLength(
+  onError: RuleErrorCallback,
+  lines: string[],
+  propertyName: string,
+  propertyValue: string,
+  limits: PropertyLimits,
+  displayName: string,
+): void {
   const strippedValue = stripLiquidTags(propertyValue)
-  const propertyLength = strippedValue.length
+  const propertyLength = (strippedValue as string).length
   const propertyLine = findPropertyLine(lines, propertyName)
 
   // Only report the most severe error - maximum takes precedence over recommended
@@ -142,7 +181,8 @@ function validatePropertyLength(onError, lines, propertyName, propertyValue, lim
   }
 }
 
-function detectContentType(frontmatter, filePath) {
+// frontmatter object structure varies based on YAML content, using any for flexibility
+function detectContentType(frontmatter: any, filePath: string): ContentType {
   // Only apply validation to markdown files
   if (!filePath || !filePath.endsWith('.md')) {
     return null
@@ -168,7 +208,7 @@ function detectContentType(frontmatter, filePath) {
   return 'article'
 }
 
-function findPropertyLine(lines, property) {
+function findPropertyLine(lines: string[], property: string): number {
   const line = lines.find((line) => line.trim().startsWith(`${property}:`))
   return line ? lines.indexOf(line) + 1 : 1
 }

src/content-linter/scripts/pretty-print-results.js renamed to src/content-linter/scripts/pretty-print-results.ts

@@ -1,19 +1,36 @@
 import chalk from 'chalk'
 
-function isNumber(value) {
+interface LintResult {
+  ruleDescription: string
+  ruleNames: string[]
+  lineNumber: number
+  columnNumber?: number
+  severity: string
+  errorDetail?: string
+  errorContext?: string
+  context?: string
+  fixable?: boolean
+}
+
+type LintResults = Record<string, LintResult[]>
+
+function isNumber(value: unknown): value is number {
   return typeof value === 'number' && !isNaN(value)
 }
 
-function shorten(text, length = 70) {
+function shorten(text: string, length = 70): string {
   if (text.length <= length) return text
   return `${text.slice(0, length - 3)}…`
 }
 
-export function prettyPrintResults(results, { fixed = false } = {}) {
+export function prettyPrintResults(
+  results: LintResults,
+  { fixed = false }: { fixed?: boolean } = {},
+): void {
   const PREFIX_PADDING = ' '.repeat(4)
   const columnPadding = 'Description'.length // The longest column header word
 
-  function label(text, padding = columnPadding) {
+  function label(text: string, padding = columnPadding): string {
     if (padding < text.length) throw new Error('Padding must be greater than text length')
     return `${PREFIX_PADDING}${chalk.dim(text.padEnd(padding))}`
   }
@@ -114,7 +131,8 @@ export function prettyPrintResults(results, { fixed = false } = {}) {
   }
 }
 
-function chalkFunColors(text) {
+function chalkFunColors(text: string): string {
+  // Valid chalk color method names for terminal output
   const colors = [
     'red',
     'yellow',
@@ -126,19 +144,21 @@ function chalkFunColors(text) {
     'greenBright',
     'magentaBright',
     'cyanBright',
-  ].sort(() => Math.random() - 0.5)
+  ] as const
+  const shuffledColors = [...colors].sort(() => Math.random() - 0.5)
   let colorIndex = 0
   return text
     .split('')
     .map((char) => {
-      const color = colors[colorIndex]
-      colorIndex = (colorIndex + 1) % colors.length
-      return chalk[color](char)
+      const color = shuffledColors[colorIndex]
+      colorIndex = (colorIndex + 1) % shuffledColors.length
+      // Chalk's TypeScript types don't support dynamic property access, but these are valid color methods
+      return (chalk as any)[color](char)
     })
     .join('')
 }
 
-function indentWrappedString(str, startingIndent) {
+function indentWrappedString(str: string, startingIndent: number): string {
   const NEW_LINE_PADDING = ' '.repeat(16)
   const width = process.stdout.columns || 80 // Use terminal width, default to 80 if not available
   let indentedString = ''

src/content-render/tests/annotate.js renamed to src/content-render/tests/annotate.ts

@@ -2,6 +2,7 @@ import { describe, expect, test } from 'vitest'
 import cheerio from 'cheerio'
 
 import { renderContent } from '@/content-render/index'
+import type { Context } from '@/types'
 
 const example = `
 \`\`\`yaml annotate
@@ -131,7 +132,7 @@ on: [push]
 `
 
     // Create a mock context with pages for AUTOTITLE resolution
-    const mockPages = {
+    const mockPages: Record<string, { href: string; rawTitle: string }> = {
       '/get-started/start-your-journey/hello-world': {
         href: '/get-started/start-your-journey/hello-world',
         rawTitle: 'Hello World',
@@ -147,7 +148,8 @@ on: [push]
       currentVersion: 'free-pro-team@latest',
       pages: mockPages,
       redirects: {},
-    }
+      // Mock test object doesn't need all Context properties, using 'as unknown as' to bypass strict type checking
+    } as unknown as Context
 
     const res = await renderContent(example, mockContext)
     const $ = cheerio.load(res)