using typescript itselft to write tsconfig for more reliability

package.json

@@ -1,7 +1,7 @@
 {
   "name": "npmize",
   "description": "Let's create an npm package without worrying about anything.",
-  "version": "1.0.10",
+  "version": "1.0.11",
   "bin": "./dist/index.js",
   "scripts": {
     "dev": "tsc -w",
@@ -13,13 +13,13 @@
     "@babel/parser": "^7.20.7",
     "ansi-colors": "^4.1.3",
     "lskit": "^1.0.0",
-    "noarg": "^3.0.17",
-    "shelljs": "^0.8.5"
+    "noarg": "^3.0.18",
+    "shelljs": "^0.8.5",
+    "typescript": "^5.3.3"
   },
   "devDependencies": {
     "@types/node": "^18.11.9",
-    "@types/shelljs": "^0.8.15",
-    "typescript": "^5.3.3"
+    "@types/shelljs": "^0.8.15"
   },
   "keywords": [
     "npm",

src/__lab.ts

@@ -2,7 +2,6 @@ console.clear()
 
 import app from './main'
 
-app.start(['dev', '-h', '--noEmit'])
-// app.start(['init', '../npmize-test'])
-// app.start(['dev', '../npmize-test', '--node'])
+app.start(['init', '../npmize-test'])
+// app.start(['dev', '../npmize-test'])
 // app.start(['build', '../npmize-test'])

src/main.ts

@@ -4,9 +4,9 @@ import dev from './program/dev'
 import NoArg from 'noarg'
 import init from './program/init'
 import build from './program/build'
-import tsconfigJSON from './scripts/tsconfigJSON'
 import { getVersion } from './utils'
 import ansiColors from 'ansi-colors'
+import { readTSConfig } from './scripts/tsconfig'
 
 const app = NoArg.create(config.name, {
   description: config.description,
@@ -57,6 +57,7 @@ app
   })
   .on(([nameArg = '.'], flags) => {
     const root = path.resolve(nameArg)
+
     init(root, {
       writeSample: flags.demo,
       writePackageJSON: flags.pkg,
@@ -111,17 +112,16 @@ app
     ...devAndBuild,
   })
   .on(([rootArg = '.', railingArgs], options) => {
-    const rootPath = path.resolve(rootArg as string)
+    const rootPath = path.resolve(rootArg)
+    const tsConfig = readTSConfig(rootPath)
+
     dev(rootPath, {
       ...options,
-      tsc: railingArgs as string[],
-      outDir: options.outDir
-        ? path.join(rootPath, options.outDir as string)
-        : path.join(
-            rootPath,
-            tsconfigJSON.read(rootPath)?.compilerOptions?.outDir ??
-              config.defaultOutDir
-          ),
+      tsc: railingArgs,
+      outDir: path.join(
+        rootPath,
+        options.outDir ?? tsConfig?.outDir ?? config.defaultOutDir
+      ),
     })
   })
 
@@ -131,17 +131,16 @@ app
     ...devAndBuild,
   })
   .on(([rootArg = '.', railingArgs], options) => {
-    const rootPath = path.resolve(rootArg as string)
+    const rootPath = path.resolve(rootArg)
+    const tsConfig = readTSConfig(rootPath)
+
     build(rootPath, {
       ...options,
-      tsc: railingArgs as string[],
-      outDir: options.outDir
-        ? path.join(rootPath, options.outDir)
-        : path.join(
-            rootPath,
-            tsconfigJSON.read(rootPath)?.compilerOptions?.outDir ??
-              config.defaultOutDir
-          ),
+      tsc: railingArgs,
+      outDir: path.join(
+        rootPath,
+        options.outDir ?? tsConfig?.outDir ?? config.defaultOutDir
+      ),
     })
   })
 

src/program/init.ts

@@ -5,8 +5,8 @@ import config from '../config'
 import ansiColors from 'ansi-colors'
 import packageJSON from '../scripts/packageJSON'
 import { writeFileSync } from '../utils'
-import tsconfigJSON from '../scripts/tsconfigJSON'
 import ghWorkflows from '../scripts/ghWorkflows'
+import { updateTSConfig } from '../scripts/tsconfig'
 
 export default function (basePath: string, options: InitOptions) {
   console.log(`\x1b[1m\x1b[35m▓▒░ NPMIZE ░▒▓\x1b[0m\n`)
@@ -46,37 +46,26 @@ export default function (basePath: string, options: InitOptions) {
   }
 
   if (options.writeTSConfig) {
-    const oldTSConfig = tsconfigJSON.read(basePath)
-    const newTSConfig = {
-      compilerOptions: {
-        target: 'es6',
-        skipLibCheck: true,
-
-        declaration: true,
-        inlineSourceMap: false,
-
-        strict: true,
-        pretty: true,
-        removeComments: true,
-      },
-      include: ['./src'],
-    }
+    updateTSConfig(
+      path.join(basePath, './tsconfig.json'),
+      {
+        compilerOptions: {
+          baseUrl: '.',
 
-    const mixedTsconfig = {
-      ...oldTSConfig,
-      ...newTSConfig,
-      compilerOptions: {
-        ...oldTSConfig.compilerOptions,
-        ...newTSConfig.compilerOptions,
-      },
-      include: Array.from(
-        new Set([...(oldTSConfig.include ?? []), ...newTSConfig.include])
-      ),
-    }
+          target: 'ES6' as any,
+          skipLibCheck: true,
 
-    writeFileSync(
-      path.join(basePath, './tsconfig.json'),
-      JSON.stringify(mixedTsconfig, null, 2)
+          declaration: true,
+          inlineSourceMap: false,
+
+          strict: true,
+          pretty: true,
+          removeComments: true,
+        },
+
+        include: ['./src'],
+      },
+      true
     )
   }
 

src/scripts/tsconfig.ts

@@ -0,0 +1,93 @@
+import * as fs from 'fs'
+import * as path from 'path'
+import ts from 'typescript'
+
+export function findTSConfigPath(targetPath: string) {
+  return ts.findConfigFile(targetPath, ts.sys.fileExists, 'tsconfig.json')
+}
+
+export function readTSConfig(targetPath: string) {
+  const configFilePath = findTSConfigPath(targetPath)
+  if (!configFilePath) return null
+
+  const configJsonString = ts.readConfigFile(configFilePath, ts.sys.readFile)
+  if (configJsonString.error) {
+    throw new Error(
+      ts.formatDiagnostic(configJsonString.error, ts.createCompilerHost({}))
+    )
+  }
+
+  const configObj = ts.parseJsonConfigFileContent(
+    configJsonString.config,
+    ts.sys,
+    path.dirname(configFilePath)
+  )
+
+  return {
+    ...configObj.options,
+    configDirPath: path.dirname(configFilePath),
+    configFilePath,
+  }
+}
+
+export function updateTSConfig(
+  configFilePath: string,
+  newConfig: {
+    compilerOptions?: ts.CompilerOptions
+    include?: string[]
+  } = {},
+
+  force?: true
+) {
+  if (force && !fs.existsSync(configFilePath)) {
+    fs.writeFileSync(configFilePath, '{}', 'utf-8')
+  }
+
+  const configFileContent = fs.readFileSync(configFilePath, 'utf-8')
+  const configObj = ts.parseConfigFileTextToJson(
+    configFilePath,
+    configFileContent
+  )
+
+  if (configObj.error) {
+    throw new Error(
+      ts.formatDiagnostic(configObj.error, ts.createCompilerHost({}))
+    )
+  }
+
+  const updatedConfig = {
+    ...configObj.config,
+
+    compilerOptions: {
+      ...configObj.config.compilerOptions,
+      ...newConfig.compilerOptions,
+    },
+
+    include: [
+      ...(configObj.config.include ?? []),
+      ...(newConfig.include ?? []),
+    ],
+  }
+
+  if (updatedConfig.include?.length) {
+    const basePath = path.resolve(
+      path.dirname(configFilePath),
+      updatedConfig.compilerOptions.baseUrl ?? ''
+    )
+
+    const fullIncludePaths = updatedConfig.include.map((includePath: string) =>
+      path.resolve(basePath, includePath)
+    )
+
+    updatedConfig.include = [...new Set<string>(fullIncludePaths)]
+      .map((includePath) => path.relative(basePath, includePath))
+      .filter(Boolean)
+  }
+
+  if (updatedConfig.include?.length === 0) {
+    delete updatedConfig.include
+  }
+
+  const updatedConfigString = JSON.stringify(updatedConfig, null, 2)
+  fs.writeFileSync(configFilePath, updatedConfigString, 'utf-8')
+}