jiek 2.0.2-alpha.12 → 2.0.2-alpha.14

package/src/utils/filterSupport.ts

@@ -0,0 +1,91 @@
+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

@@ -0,0 +1,140 @@
+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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,31 @@
+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

@@ -0,0 +1,111 @@
+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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,94 @@
+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

@@ -0,0 +1,26 @@
+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
+  }
+}