jiek 1.0.0 → 1.0.1

package/src/utils/getExports.ts

@@ -0,0 +1,104 @@
+import { 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)))
+
+export function getExports({
+  entrypoints,
+  pkgIsModule,
+  entries,
+  config,
+  dir,
+  noFilter,
+  isPublish
+}: {
+  entrypoints: string | string[] | Record<string, unknown>
+  pkgIsModule: boolean
+  entries?: string[]
+  config?: Config
+  dir?: string
+  noFilter?: boolean
+  isPublish?: boolean
+}) {
+  const dirResolve = (...paths: string[]) => resolve(dir ?? process.cwd(), ...paths)
+  const dirRelative = (path: string) => relative(dir ?? process.cwd(), path)
+  const {
+    build = {},
+    publish: {
+      withSuffix = false,
+      withSource = true
+    } = {}
+  } = config ?? {}
+  const {
+    crossModuleConvertor = true
+  } = build
+  const jsOutdir = `./${
+    dirRelative(dirResolve(
+      (
+        typeof build?.output?.dir === 'object'
+          // the outdir only affect js output in this function
+          ? build.output.dir.js
+          : build?.output?.dir
+      ) ?? 'dist'
+    ))
+  }`
+  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: jsOutdir,
+      withSuffix: isPublish ? withSuffix : undefined,
+      withSource: isPublish ? withSource : undefined,
+      withConditional: {
+        ...crossModuleWithConditional
+      }
+    })
+  ] 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,93 @@
+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)
+}
+
+export function loadConfig(dir?: string): Config {
+  const { wd: root } = getWD()
+
+  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/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
+  }
+}

package/index.js

@@ -1 +0,0 @@
-module.exports = () => console.log('hello')