jiek 2.0.2-alpha.2 → 2.0.2-alpha.4

package/src/utils/filterSupport.ts

@@ -1,91 +0,0 @@
-import fs from 'node:fs'
-import { createRequire } from 'node:module'
-import path from 'node:path'
-
-import { filterPackagesFromDir } from '@pnpm/filter-workspace-packages'
-import { program } from 'commander'
-import { load } from 'js-yaml'
-
-import { getRoot } from '#~/utils/getRoot.ts'
-import { getWD } from '#~/utils/getWD.ts'
-
-export let type = ''
-
-try {
-  const require = createRequire(import.meta.url)
-  require.resolve('@pnpm/filter-workspace-packages')
-  type = 'pnpm'
-} catch { /* empty */ }
-
-export interface ProjectsGraph {
-  wd: string
-  root: string
-  value?: Record<string, {
-    name?: string
-    type?: string
-    exports?: string | string[] | Record<string, unknown>
-  }>
-}
-
-export function filterPackagesGraph(filters: string[]): Promise<ProjectsGraph[]> {
-  return Promise.all(filters.map(async filter => getSelectedProjectsGraph(filter)))
-}
-
-export async function getSelectedProjectsGraph(
-  filter = program.getOptionValue('filter')
-): Promise<ProjectsGraph> {
-  let root = getRoot()
-  const { wd, notWorkspace } = getWD()
-  if (notWorkspace) {
-    return {
-      wd,
-      root,
-      value: {
-        [wd]: JSON.parse(fs.readFileSync(path.resolve(wd, 'package.json'), 'utf-8'))
-      }
-    }
-  }
-  if (type === 'pnpm') {
-    const pnpmWorkspaceFilePath = path.resolve(wd, 'pnpm-workspace.yaml')
-    const pnpmWorkspaceFileContent = fs.readFileSync(pnpmWorkspaceFilePath, 'utf-8')
-    const pnpmWorkspace = load(pnpmWorkspaceFileContent) as {
-      packages: string[]
-    }
-    if (root === wd && !filter) {
-      throw new Error('root path is workspace root, please provide a filter')
-      // TODO inquirer prompt support user select packages
-    }
-    if (root === undefined) {
-      root = process.cwd()
-    }
-    if (root !== wd && !filter) {
-      const packageJSONIsExist = fs.existsSync(path.resolve(root, 'package.json'))
-      if (!packageJSONIsExist) {
-        throw new Error('root path is not workspace root, please provide a filter')
-      }
-      const packageJSON = JSON.parse(fs.readFileSync(path.resolve(root, 'package.json'), 'utf-8'))
-      if (!packageJSON.name) {
-        throw new Error('root path is not workspace root, please provide a filter')
-      }
-      filter = packageJSON.name
-    }
-    const { selectedProjectsGraph } = await filterPackagesFromDir(wd, [{
-      filter: filter ?? '',
-      followProdDepsOnly: true
-    }], {
-      prefix: root,
-      workspaceDir: wd,
-      patterns: pnpmWorkspace.packages
-    })
-    return {
-      wd,
-      root,
-      value: Object.entries(selectedProjectsGraph)
-        .reduce((acc, [key, value]) => {
-          acc[key] = value.package.manifest
-          return acc
-        }, {} as NonNullable<ProjectsGraph['value']>)
-    }
-  }
-  throw new Error(`not supported package manager ${type}`)
-}

package/src/utils/getExports.ts

@@ -1,140 +0,0 @@
-import { isAbsolute, relative, resolve } from 'node:path'
-
-import {
-  DEFAULT_SKIP_VALUES,
-  entrypoints2Exports,
-  type Entrypoints2ExportsOptions,
-  filterLeafs,
-  type RecursiveRecord,
-  resolveEntrypoints
-} from '@jiek/pkger/entrypoints'
-import type { Config } from 'jiek'
-import { isMatch } from 'micromatch'
-
-const intersection = <T>(a: Set<T>, b: Set<T>) => new Set([...a].filter(i => b.has(i)))
-
-const {
-  JIEK_OUT_DIR
-} = process.env
-
-const OUTDIR = JIEK_OUT_DIR ?? 'dist'
-
-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 function getExports({
-  entrypoints,
-  pkgName,
-  pkgIsModule,
-  entries,
-  config,
-  dir,
-  defaultOutdir = OUTDIR,
-  // FIXME dts support
-  outdir = getOutDirs({ pkgName, defaultOutdir, config, cwd: dir }).js,
-  noFilter,
-  isPublish
-}: {
-  entrypoints: string | string[] | Record<string, unknown>
-  pkgName: string
-  pkgIsModule: boolean
-  entries?: string[]
-  config?: Config
-  dir?: string
-  outdir?: string
-  defaultOutdir?: string
-  noFilter?: boolean
-  isPublish?: boolean
-}) {
-  const {
-    build = {},
-    publish: {
-      withSuffix = false,
-      withSource = true
-    } = {}
-  } = config ?? {}
-  const {
-    crossModuleConvertor = true
-  } = build
-  const [, resolvedEntrypoints] = resolveEntrypoints(entrypoints)
-  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/,
-        ...DEFAULT_SKIP_VALUES
-      ]
-    }
-  )
-  const crossModuleWithConditional: Entrypoints2ExportsOptions['withConditional'] = crossModuleConvertor
-    ? {
-      import: opts =>
-        !pkgIsModule && intersection(
-              new Set(opts.conditionals),
-              new Set(['import', 'module'])
-            ).size === 0
-          ? opts.dist.replace(/\.js$/, '.mjs')
-          : false,
-      require: opts =>
-        pkgIsModule && intersection(
-              new Set(opts.conditionals),
-              new Set(['require', 'node'])
-            ).size === 0
-          ? opts.dist.replace(/\.js$/, '.cjs')
-          : false
-    }
-    : {}
-  return [
-    filteredResolvedEntrypoints,
-    entrypoints2Exports(filteredResolvedEntrypoints, {
-      outdir,
-      withSuffix: isPublish ? withSuffix : undefined,
-      withSource: isPublish ? withSource : undefined,
-      withConditional: {
-        ...crossModuleWithConditional
-      }
-    }),
-    outdir
-  ] as const
-}

package/src/utils/getRoot.ts

@@ -1,16 +0,0 @@
-import path from 'node:path'
-
-import { program } from 'commander'
-
-let root: string
-export function getRoot() {
-  if (root) return root
-
-  const rootOption = program.getOptionValue('root')
-  root = rootOption
-    ? path.isAbsolute(rootOption)
-      ? rootOption
-      : path.resolve(process.cwd(), rootOption)
-    : undefined
-  return root
-}

package/src/utils/getWD.ts

@@ -1,31 +0,0 @@
-import { getWorkspaceDir, isWorkspaceDir } from '@jiek/utils/getWorkspaceDir'
-
-import { type } from './filterSupport'
-import { getRoot } from './getRoot'
-
-let wd: string
-let notWorkspace = false
-
-export function getWD() {
-  if (wd) return { wd, notWorkspace }
-
-  const root = getRoot()
-  if (root !== undefined) {
-    const isWorkspace = isWorkspaceDir(root, type)
-    notWorkspace = !isWorkspace
-    wd = root
-    return { wd, notWorkspace }
-  }
-  try {
-    wd = getWorkspaceDir(type)
-  } catch (e) {
-    // @ts-ignore
-    if ('message' in e && e.message === 'workspace root not found') {
-      wd = root
-      notWorkspace = true
-    } else {
-      throw e
-    }
-  }
-  return { wd, notWorkspace }
-}

package/src/utils/loadConfig.ts

@@ -1,111 +0,0 @@
-import fs from 'node:fs'
-import { createRequire } from 'node:module'
-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'
-
-const require = createRequire(import.meta.url)
-
-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/recusiveListFiles.ts

@@ -1,13 +0,0 @@
-import fs from 'node:fs'
-import { resolve } from 'node:path'
-
-export const recusiveListFiles = (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, ...recusiveListFiles(filePath)]
-    }
-    return [...acc, filePath]
-  }, [] as string[])

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'
-
-type 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 })
-
-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 ? 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,26 +0,0 @@
-import { createRequire } from 'node:module'
-
-const require = createRequire(import.meta.url)
-
-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
-  }
-}