@wular/pnext 0.0.4 → 0.0.6

package/src/compat/tsconfig-defaults.ts

@@ -12,53 +12,53 @@
 //
 // When no tsconfig.json exists but the project contains TypeScript sources, one is created from scratch.
 
-import { existsSync, readdirSync } from 'node:fs';
-import { readFile } from 'node:fs/promises';
-import { writeFileAtomic } from '../utils/fs';
-import { createRequire } from 'node:module';
-import path from 'node:path';
-import type { ResolvedConfig } from '../config';
-import { getNextConfig } from './next/config-loader';
+import { existsSync, readdirSync } from 'node:fs'
+import { readFile } from 'node:fs/promises'
+import { writeFileAtomic } from '../utils/fs'
+import { createRequire } from 'node:module'
+import path from 'node:path'
+import type { ResolvedConfig } from '../config'
+import { getNextConfig } from './next/config-loader'
 
 interface SuggestedOption {
-  suggested: unknown;
-  reason?: string;
+  suggested: unknown
+  reason?: string
 }
 interface RequiredOption {
-  parsedValue?: unknown;
-  parsedValues?: unknown[];
-  value: unknown;
-  reason: string;
+  parsedValue?: unknown
+  parsedValues?: unknown[]
+  value: unknown
+  reason: string
 }
-type DesiredOption = SuggestedOption | RequiredOption;
+type DesiredOption = SuggestedOption | RequiredOption
 
 interface TsconfigShape {
-  compilerOptions?: Record<string, unknown>;
-  include?: unknown;
-  exclude?: unknown;
-  [key: string]: unknown;
+  compilerOptions?: Record<string, unknown>
+  include?: unknown
+  exclude?: unknown
+  [key: string]: unknown
 }
 
 // Whether the project carries any .ts/.tsx source (bounded walk skipping
 // node_modules/dot-dirs) — Next's TS-detection gate for first-time setup.
 function hasTypescriptSources(root: string, depth = 0): boolean {
-  if (depth > 6) return false;
-  let entries: import('node:fs').Dirent[];
+  if (depth > 6) return false
+  let entries: import('node:fs').Dirent[]
   try {
-    entries = readdirSync(root, { withFileTypes: true });
+    entries = readdirSync(root, { withFileTypes: true })
   } catch {
-    return false;
+    return false
   }
   for (const entry of entries) {
-    if (entry.name.startsWith('.') || entry.name === 'node_modules') continue;
+    if (entry.name.startsWith('.') || entry.name === 'node_modules') continue
     if (entry.isFile() && /\.(ts|tsx|mts|cts)$/.test(entry.name) && !entry.name.endsWith('.d.ts')) {
-      return true;
+      return true
     }
     if (entry.isDirectory() && hasTypescriptSources(path.join(root, entry.name), depth + 1)) {
-      return true;
+      return true
     }
   }
-  return false;
+  return false
 }
 
 // The app's typescript version, else pnext's own. Read from package.json rather
@@ -67,19 +67,19 @@ function hasTypescriptSources(root: string, depth = 0): boolean {
 function appTypescriptVersion(root: string): string {
   for (const base of [root, import.meta.dirname]) {
     try {
-      const require = createRequire(path.join(base, 'noop.js'));
-      const pkg = require('typescript/package.json') as { version?: string };
-      if (typeof pkg.version === 'string') return pkg.version;
+      const require = createRequire(path.join(base, 'noop.js'))
+      const pkg = require('typescript/package.json') as { version?: string }
+      if (typeof pkg.version === 'string') return pkg.version
     } catch {
       // keep looking
     }
   }
-  return '5.9.0';
+  return '5.9.0'
 }
 
 function versionGte(version: string, major: number, minor: number): boolean {
-  const [maj = 0, min = 0] = version.split('.').map(part => Number.parseInt(part, 10));
-  return maj > major || (maj === major && min >= minor);
+  const [maj = 0, min = 0] = version.split('.').map(part => Number.parseInt(part, 10))
+  return maj > major || (maj === major && min >= minor)
 }
 
 function getDesiredCompilerOptions(
@@ -89,12 +89,12 @@ function getDesiredCompilerOptions(
   const configuredModule =
     typeof userTsConfig.compilerOptions?.module === 'string'
       ? userTsConfig.compilerOptions.module.toLowerCase()
-      : undefined;
+      : undefined
   const preferBundlerResolution =
     versionGte(typescriptVersion, 5, 0) &&
     configuredModule !== 'commonjs' &&
-    configuredModule !== 'amd';
-  const modulePreserve = versionGte(typescriptVersion, 5, 4) && configuredModule === 'preserve';
+    configuredModule !== 'amd'
+  const modulePreserve = versionGte(typescriptVersion, 5, 4) && configuredModule === 'preserve'
 
   return {
     target: {
@@ -148,7 +148,7 @@ function getDesiredCompilerOptions(
       value: 'react-jsx',
       reason: 'next.js uses the React automatic runtime',
     },
-  };
+  }
 }
 
 // `<distDir>/types/**` plus the dev-mode variant, shortest first (Next sorts by
@@ -156,7 +156,7 @@ function getDesiredCompilerOptions(
 function typeDefinitionGlobPatterns(distDir: string): string[] {
   return [`${distDir}/types/**/*.ts`, `${distDir}/dev/types/**/*.ts`].sort(
     (a, b) => a.length - b.length,
-  );
+  )
 }
 
 /**
@@ -166,80 +166,80 @@ function typeDefinitionGlobPatterns(distDir: string): string[] {
  * every requirement.
  */
 export async function writeTsconfigDefaults(config: ResolvedConfig): Promise<void> {
-  const tsConfigPath = path.join(config.root, 'tsconfig.json');
-  let isFirstTimeSetup = false;
+  const tsConfigPath = path.join(config.root, 'tsconfig.json')
+  let isFirstTimeSetup = false
   if (!existsSync(tsConfigPath)) {
-    if (!hasTypescriptSources(config.root)) return;
-    isFirstTimeSetup = true;
+    if (!hasTypescriptSources(config.root)) return
+    isFirstTimeSetup = true
     // Atomic: the client build's tsconfig-paths reader runs in a parallel phase
     // and must never see a truncated file.
-    await writeFileAtomic(tsConfigPath, '{}\n');
+    await writeFileAtomic(tsConfigPath, '{}\n')
   }
 
-  let userTsConfig: TsconfigShape;
+  let userTsConfig: TsconfigShape
   try {
-    userTsConfig = JSON.parse(await readFile(tsConfigPath, 'utf8')) as TsconfigShape;
+    userTsConfig = JSON.parse(await readFile(tsConfigPath, 'utf8')) as TsconfigShape
   } catch {
-    return; // JSONC / invalid — leave the user's file alone
+    return // JSONC / invalid — leave the user's file alone
   }
-  if (userTsConfig === null || typeof userTsConfig !== 'object') return;
+  if (userTsConfig === null || typeof userTsConfig !== 'object') return
   // Automatic setup would clobber inherited options; Next bails here too.
-  if ('extends' in userTsConfig || 'references' in userTsConfig) return;
+  if ('extends' in userTsConfig || 'references' in userTsConfig) return
 
-  if (userTsConfig.compilerOptions == null) userTsConfig.compilerOptions = {};
-  const compilerOptions = userTsConfig.compilerOptions;
+  if (userTsConfig.compilerOptions == null) userTsConfig.compilerOptions = {}
+  const compilerOptions = userTsConfig.compilerOptions
 
-  const desired = getDesiredCompilerOptions(appTypescriptVersion(config.root), userTsConfig);
+  const desired = getDesiredCompilerOptions(appTypescriptVersion(config.root), userTsConfig)
 
-  const suggestedActions: string[] = [];
-  const requiredActions: string[] = [];
+  const suggestedActions: string[] = []
+  const requiredActions: string[] = []
   for (const [optionKey, check] of Object.entries(desired)) {
     if ('suggested' in check) {
       if (!(optionKey in compilerOptions)) {
-        compilerOptions[optionKey] = check.suggested;
+        compilerOptions[optionKey] = check.suggested
         suggestedActions.push(
           `${optionKey} was set to ${JSON.stringify(check.suggested)}` +
             (check.reason ? ` (${check.reason})` : ''),
-        );
+        )
       }
-      continue;
+      continue
     }
-    let existingValue = compilerOptions[optionKey];
-    if (typeof existingValue === 'string') existingValue = existingValue.toLowerCase();
+    let existingValue = compilerOptions[optionKey]
+    if (typeof existingValue === 'string') existingValue = existingValue.toLowerCase()
     const satisfied = check.parsedValues
       ? check.parsedValues.includes(existingValue)
-      : (check.parsedValue ?? check.value) === existingValue;
+      : (check.parsedValue ?? check.value) === existingValue
     if (!satisfied) {
-      compilerOptions[optionKey] = check.value;
-      requiredActions.push(`${optionKey} was set to ${String(check.value)} (${check.reason})`);
+      compilerOptions[optionKey] = check.value
+      requiredActions.push(`${optionKey} was set to ${String(check.value)} (${check.reason})`)
     }
   }
 
   const hasAppDir =
-    existsSync(path.join(config.root, 'app')) || existsSync(path.join(config.root, 'src', 'app'));
+    existsSync(path.join(config.root, 'app')) || existsSync(path.join(config.root, 'src', 'app'))
   const hasPagesDir =
     existsSync(path.join(config.root, 'pages')) ||
-    existsSync(path.join(config.root, 'src', 'pages'));
+    existsSync(path.join(config.root, 'src', 'pages'))
   // eslint-disable-next-line turbo/no-undeclared-env-vars
-  const strictRouteTypes = process.env.__NEXT_EXPERIMENTAL_STRICT_ROUTE_TYPES === 'true';
+  const strictRouteTypes = process.env.__NEXT_EXPERIMENTAL_STRICT_ROUTE_TYPES === 'true'
   const distDir =
-    typeof getNextConfig().distDir === 'string' ? (getNextConfig().distDir as string) : '.next';
-  const nextTypes = typeDefinitionGlobPatterns(distDir);
+    typeof getNextConfig().distDir === 'string' ? (getNextConfig().distDir as string) : '.next'
+  const nextTypes = typeDefinitionGlobPatterns(distDir)
 
   if (!('include' in userTsConfig)) {
     const defaultInclude =
       hasAppDir && !strictRouteTypes
         ? ['next-env.d.ts', ...nextTypes, '**/*.mts', '**/*.ts', '**/*.tsx']
-        : ['next-env.d.ts', '**/*.mts', '**/*.ts', '**/*.tsx'];
-    userTsConfig.include = defaultInclude;
+        : ['next-env.d.ts', '**/*.mts', '**/*.ts', '**/*.tsx']
+    userTsConfig.include = defaultInclude
     suggestedActions.push(
       `include was set to [${defaultInclude.map(type => `'${type}'`).join(', ')}]`,
-    );
+    )
   } else if (hasAppDir && !strictRouteTypes && Array.isArray(userTsConfig.include)) {
     for (const type of nextTypes) {
       if (!userTsConfig.include.includes(type)) {
-        userTsConfig.include.push(type);
-        suggestedActions.push(`include was updated to add '${type}'`);
+        userTsConfig.include.push(type)
+        suggestedActions.push(`include was updated to add '${type}'`)
       }
     }
   }
@@ -248,36 +248,32 @@ export async function writeTsconfigDefaults(config: ResolvedConfig): Promise<voi
     const plugins = [
       ...(Array.isArray(userTsConfig.plugins) ? (userTsConfig.plugins as unknown[]) : []),
       ...(Array.isArray(compilerOptions.plugins) ? (compilerOptions.plugins as unknown[]) : []),
-    ] as { name?: string }[];
+    ] as { name?: string }[]
     if (!plugins.some(plugin => plugin?.name === 'next')) {
-      if (!Array.isArray(compilerOptions.plugins)) compilerOptions.plugins = [];
-      (compilerOptions.plugins as unknown[]).push({ name: 'next' });
-      suggestedActions.push(`plugins was updated to add { name: 'next' }`);
+      if (!Array.isArray(compilerOptions.plugins)) compilerOptions.plugins = []
+      ;(compilerOptions.plugins as unknown[]).push({ name: 'next' })
+      suggestedActions.push(`plugins was updated to add { name: 'next' }`)
     }
-    if (
-      hasPagesDir &&
-      !compilerOptions.strict &&
-      !('strictNullChecks' in compilerOptions)
-    ) {
-      compilerOptions.strictNullChecks = true;
-      suggestedActions.push('strictNullChecks was set to true');
+    if (hasPagesDir && !compilerOptions.strict && !('strictNullChecks' in compilerOptions)) {
+      compilerOptions.strictNullChecks = true
+      suggestedActions.push('strictNullChecks was set to true')
     }
   }
 
   if (!('exclude' in userTsConfig)) {
-    userTsConfig.exclude = ['node_modules'];
-    suggestedActions.push(`exclude was set to ['node_modules']`);
+    userTsConfig.exclude = ['node_modules']
+    suggestedActions.push(`exclude was set to ['node_modules']`)
   }
 
-  if (suggestedActions.length === 0 && requiredActions.length === 0) return;
+  if (suggestedActions.length === 0 && requiredActions.length === 0) return
 
-  await writeFileAtomic(tsConfigPath, `${JSON.stringify(userTsConfig, null, 2)}\n`);
+  await writeFileAtomic(tsConfigPath, `${JSON.stringify(userTsConfig, null, 2)}\n`)
 
   if (isFirstTimeSetup) {
     console.log(
       '\nWe detected TypeScript in your project and created a tsconfig.json file for you.',
-    );
-    return;
+    )
+    return
   }
 
   const lines = [
@@ -285,20 +281,20 @@ export async function writeTsconfigDefaults(config: ResolvedConfig): Promise<voi
     `We detected TypeScript in your project and reconfigured your tsconfig.json file for you.${
       compilerOptions.strict ? '' : ' Strict-mode is set to false by default.'
     }`,
-  ];
+  ]
   if (suggestedActions.length > 0) {
     lines.push(
       `The following suggested values were added to your tsconfig.json. These values can be changed to fit your project's needs:\n`,
       ...suggestedActions.map(action => `\t- ${action}`),
       '',
-    );
+    )
   }
   if (requiredActions.length > 0) {
     lines.push(
       `The following mandatory changes were made to your tsconfig.json:\n`,
       ...requiredActions.map(action => `\t- ${action}`),
       '',
-    );
+    )
   }
-  console.log(lines.join('\n'));
+  console.log(lines.join('\n'))
 }