jiek 2.3.3 → 2.3.4

package/src/utils/loadConfig.ts

@@ -1,108 +0,0 @@
-import fs from 'node:fs'
-import path from 'node:path'
-
-import { program } from 'commander'
-import type { Config } from 'jiek'
-import { load } from 'js-yaml'
-
-import { getWD } from './getWD'
-import { tsRegisterName } from './tsRegister'
-
-let configName = 'jiek.config'
-
-function getConfigPath(root: string, dir?: string) {
-  const isSupportTsLoader = !!tsRegisterName
-  function configWithExtIsExist(ext: string) {
-    const filenames = [
-      path.resolve(process.cwd(), `${configName}.${ext}`),
-      path.resolve(process.cwd(), `.${configName}.${ext}`),
-      path.resolve(root, `${configName}.${ext}`),
-      path.resolve(root, `.${configName}.${ext}`)
-    ]
-    if (dir) {
-      filenames.unshift(...[
-        path.resolve(dir, `${configName}.${ext}`),
-        path.resolve(dir, `.${configName}.${ext}`)
-      ])
-    }
-    for (const filename of filenames) {
-      if (
-        fs.existsSync(filename)
-        && fs.lstatSync(filename)
-          .isFile()
-      ) {
-        return filename
-      }
-    }
-    return
-  }
-  configName = configWithExtIsExist('js') ?? configName
-  configName = configWithExtIsExist('json') ?? configName
-  configName = configWithExtIsExist('yaml') ?? configName
-  if (isSupportTsLoader) {
-    configName = configWithExtIsExist('ts') ?? configName
-  }
-  return path.resolve(root, configName)
-}
-
-interface LoadConfigOptions {
-  dir?: string
-  root?: string
-}
-
-export function loadConfig(options?: LoadConfigOptions): Config
-export function loadConfig(dir?: string): Config
-export function loadConfig(dirOrOptions?: string | LoadConfigOptions): Config {
-  let dir: string | undefined
-  let root: string
-  if (typeof dirOrOptions === 'object') {
-    dir = dirOrOptions.dir
-    root = dirOrOptions.root ?? getWD().wd
-  } else {
-    dir = dirOrOptions
-    root = getWD().wd
-  }
-
-  let configPath = program.getOptionValue('configPath')
-
-  if (!configPath) {
-    configPath = getConfigPath(root, dir)
-  } else {
-    if (!fs.existsSync(configPath)) {
-      throw new Error(`config file not found: ${configPath}`)
-    }
-    if (!path.isAbsolute(configPath)) {
-      configPath = path.resolve(root, configPath)
-    }
-  }
-  const ext = path.extname(configPath)
-
-  let module: any
-  switch (ext) {
-    case '.js':
-      module = require(configPath)
-      break
-    case '.json':
-      return require(configPath)
-    case '.yaml':
-      return load(fs.readFileSync(configPath, 'utf-8')) as Config
-    case '.ts':
-      if (tsRegisterName) {
-        require(tsRegisterName)
-        module = require(configPath)
-        break
-      }
-      throw new Error(
-        'ts config file is not supported without ts register, '
-          + 'please install esbuild-register or set JIEK_TS_REGISTER env for custom ts register'
-      )
-    case '.config':
-      module = {}
-      break
-    default:
-      throw new Error(`unsupported config file type: ${ext}`)
-  }
-  if (!module) throw new Error('config file is empty')
-
-  return module.default ?? module
-}

package/src/utils/recursiveListFiles.ts

@@ -1,13 +0,0 @@
-import fs from 'node:fs'
-import { resolve } from 'node:path'
-
-export const recursiveListFiles = (dir: string): string[] =>
-  fs.readdirSync(dir).reduce((acc, file) => {
-    const filePath = resolve(dir, file)
-    if (fs.statSync(filePath).isDirectory()) {
-      if (filePath.endsWith('/node_modules')) return acc
-
-      return [...acc, ...recursiveListFiles(filePath)]
-    }
-    return [...acc, filePath]
-  }, [] as string[])

package/src/utils/resolveExports.ts

@@ -1,165 +0,0 @@
-import { isAbsolute, relative, resolve } from 'node:path'
-import process from 'node:process'
-
-import {
-  type Entrypoints2ExportsOptions,
-  type RecursiveRecord,
-  entrypoints2Exports,
-  filterLeafs,
-  getDefaultSkipValues,
-  resolveEntrypoints
-} from '@jiek/pkger/entrypoints'
-import type { Config } from 'jiek'
-import { isMatch } from 'micromatch'
-
-import { intersection } from '#~/utils/intersection'
-
-const {
-  JIEK_OUT_DIR,
-  JIEK_CROSS_MODULE_CONVERTOR
-} = process.env
-
-const OUTDIR = JIEK_OUT_DIR ?? 'dist'
-const crossModuleConvertorDefault = JIEK_CROSS_MODULE_CONVERTOR === undefined
-  ? true
-  : JIEK_CROSS_MODULE_CONVERTOR === 'true'
-
-export function getOutDirs({
-  cwd = process.cwd(),
-  defaultOutdir = OUTDIR,
-  config,
-  pkgName
-}: {
-  cwd?: string
-  defaultOutdir?: string
-  config?: Config
-  pkgName?: string
-}) {
-  const { build = {} } = config ?? {}
-  const outdir = build?.output?.dir
-  function resolveOutdir(type: 'js' | 'dts') {
-    const dir = (typeof outdir === 'object'
-      ? outdir[type] ?? outdir[
-        ({
-          js: 'dts',
-          dts: 'js'
-        } as const)[type]
-      ]
-      : outdir) ?? defaultOutdir
-    return (
-      isAbsolute(dir)
-        ? dir
-        : `./${relative(cwd, resolve(cwd, dir))}`
-    ).replace('{{PKG_NAME}}', pkgName!)
-  }
-  return {
-    js: resolveOutdir('js'),
-    dts: resolveOutdir('dts')
-  }
-}
-
-export interface ResolveExportsOptions {
-  entrypoints: string | string[] | Record<string, unknown>
-  pkgName: string
-  pkgIsModule: boolean
-  entries?: string[]
-  config?: Config
-  dir?: string
-  outdir?: string
-  defaultOutdir?: string
-  noFilter?: boolean
-  isPublish?: boolean
-  skipJS?: boolean
-}
-
-export function resolveExports({
-  entrypoints,
-  pkgName,
-  pkgIsModule,
-  entries,
-  config,
-  dir,
-  defaultOutdir = OUTDIR,
-  // FIXME dts support
-  outdir = getOutDirs({ pkgName, defaultOutdir, config, cwd: dir }).js,
-  noFilter,
-  isPublish,
-  skipJS
-}: ResolveExportsOptions) {
-  const {
-    build = {},
-    publish: {
-      withSuffix = false,
-      withSource = true
-    } = {}
-  } = config ?? {}
-  const {
-    crossModuleConvertor = crossModuleConvertorDefault
-  } = build
-  const [, resolvedEntrypoints] = resolveEntrypoints(entrypoints, {
-    allowJS: !skipJS
-  })
-  if (entries) {
-    Object
-      .entries(resolvedEntrypoints)
-      .forEach(([key]) => {
-        if (!entries.some(e => isMatch(key, e, { matchBase: true }))) {
-          delete resolvedEntrypoints[key]
-        }
-      })
-  }
-  const filteredResolvedEntrypoints = noFilter ? resolvedEntrypoints : filterLeafs(
-    resolvedEntrypoints as RecursiveRecord<string>,
-    {
-      skipValue: [
-        // ignore values that filename starts with `.jk-noentry`
-        /(^|\/)\.jk-noentry/,
-        ...getDefaultSkipValues({
-          allowJS: !skipJS
-        })
-      ]
-    }
-  )
-  const crossModuleWithConditional: Entrypoints2ExportsOptions['withConditional'] = crossModuleConvertor
-    ? {
-      import: opts => {
-        if (pkgIsModule) return false
-        if (opts.src.endsWith('.cts')) return false
-        if (
-          intersection(
-            new Set(opts.conditionals),
-            new Set(['import', 'module'])
-          ).size !== 0
-        ) return false
-
-        return opts.dist.replace(/\.js$/, '.mjs')
-      },
-      require: opts => {
-        if (!pkgIsModule) return false
-        if (opts.src.endsWith('.mts')) return false
-        if (
-          intersection(
-            new Set(opts.conditionals),
-            new Set(['require', 'node'])
-          ).size !== 0
-        ) return false
-
-        return opts.dist.replace(/\.js$/, '.cjs')
-      }
-    }
-    : {}
-  return [
-    filteredResolvedEntrypoints,
-    entrypoints2Exports(filteredResolvedEntrypoints, {
-      outdir,
-      sourceTag: pkgName,
-      withSuffix: isPublish ? withSuffix : undefined,
-      withSource: isPublish ? withSource : undefined,
-      withConditional: {
-        ...crossModuleWithConditional
-      },
-      allowJS: !skipJS
-    }),
-    outdir
-  ] as const
-}

package/src/utils/ts.ts

@@ -1,94 +0,0 @@
-import fs from 'node:fs'
-import { dirname, resolve } from 'node:path'
-
-import { parse } from 'jsonc-parser'
-import { isMatch } from 'micromatch'
-
-interface TSConfig {
-  extends?: string | string[]
-  compilerOptions?: Record<string, unknown>
-  references?: { path: string }[]
-  files?: string[]
-  include?: string[]
-  exclude?: string[]
-}
-
-const getTSConfig = (p: string): TSConfig =>
-  !fs.existsSync(p) || !fs.statSync(p).isFile()
-    ? {}
-    : parse(fs.readFileSync(p, 'utf-8'), [], { allowTrailingComma: true, allowEmptyContent: true }) as TSConfig
-
-const getExtendTSConfig = (tsconfigPath: string): TSConfig => {
-  tsconfigPath = resolve(tsconfigPath)
-  const tsconfigPathDirname = dirname(tsconfigPath)
-  const { extends: exts, ...tsconfig } = getTSConfig(tsconfigPath)
-  const resolvePaths = (paths: string[] | undefined) => paths?.map(p => resolve(tsconfigPathDirname, p)) ?? []
-
-  const extendsPaths = resolvePaths(
-    exts !== undefined ? Array.isArray(exts) ? exts : [exts] : []
-  )
-  if (extendsPaths.length === 0) return tsconfig
-  return extendsPaths
-    .map(getExtendTSConfig)
-    .concat(tsconfig)
-    // https://www.typescriptlang.org/tsconfig/#files:~:text=Currently%2C%20the%20only%20top%2Dlevel%20property%20that%20is%20excluded%20from%20inheritance%20is%20references.
-    // Currently, the only top-level property that is excluded from inheritance is references.
-    .reduce((acc, { compilerOptions = {}, references: _, ...curr }) => ({
-      ...acc,
-      ...curr,
-      compilerOptions: {
-        ...acc.compilerOptions,
-        ...compilerOptions
-      }
-    }), {})
-}
-
-export const getCompilerOptionsByFilePath = (
-  tsconfigPath: string,
-  filePath: string
-): Record<string, unknown> | undefined => {
-  tsconfigPath = resolve(tsconfigPath)
-  filePath = resolve(filePath)
-  const tsconfigPathDirname = dirname(tsconfigPath)
-  // https://www.typescriptlang.org/tsconfig/#files:~:text=It%E2%80%99s%20worth%20noting%20that%20files%2C%20include%2C%20and%20exclude%20from%20the%20inheriting%20config%20file%20overwrite%20those%20from%20the%20base%20config%20file%2C%20and%20that%20circularity%20between%20configuration%20files%20is%20not%20allowed.
-  // It’s worth noting that files, include, and exclude from the inheriting config file overwrite
-  // those from the base config file, and that circularity between configuration files is not allowed.
-  const tsconfig = getExtendTSConfig(tsconfigPath)
-
-  const resolvePaths = (paths: string[] | undefined) => paths?.map(p => resolve(tsconfigPathDirname, p)) ?? []
-
-  const [
-    references,
-    files,
-    include,
-    exclude
-  ] = [
-    tsconfig.references?.map(({ path }) => path),
-    tsconfig.files,
-    tsconfig.include,
-    tsconfig.exclude
-  ].map(resolvePaths)
-  if (exclude.length > 0 && exclude.some(i => isMatch(filePath, i))) return
-
-  // when files or include is not empty, the tsconfig should be ignored
-  if (tsconfig.files?.length === 0 && tsconfig.include?.length === 0) return
-  let isInclude = false
-  isInclude ||= files.length > 0 && files.includes(filePath)
-  isInclude ||= include.length > 0 && include.some(i => isMatch(filePath, i))
-  if (isInclude) {
-    return tsconfig.compilerOptions ?? {}
-  } else {
-    // when files or include is not empty, but the file is not matched, the tsconfig should be ignored
-    if (
-      (tsconfig.files && tsconfig.files.length > 0)
-      || (tsconfig.include && tsconfig.include.length > 0)
-    ) return
-  }
-
-  references.reverse()
-  for (const ref of references) {
-    const compilerOptions = getCompilerOptionsByFilePath(ref, filePath)
-    if (compilerOptions) return compilerOptions
-  }
-  return tsconfig.compilerOptions
-}

package/src/utils/tsRegister.ts

@@ -1,22 +0,0 @@
-function packageIsExist(name: string) {
-  try {
-    require.resolve(name)
-    return true
-  } catch (e) {
-    return false
-  }
-}
-
-export let tsRegisterName: string | undefined
-const registers = [
-  process.env.JIEK_TS_REGISTER,
-  'esbuild-register',
-  '@swc-node/register',
-  'ts-node/register'
-].filter(Boolean) as string[]
-for (const register of registers) {
-  if (packageIsExist(register)) {
-    tsRegisterName = register
-    break
-  }
-}