@xylabs/ts-scripts-yarn3 6.0.9 → 6.1.1

package/src/actions/package/compile/XyConfig.ts

@@ -1,60 +0,0 @@
-import type { Options } from 'tsup'
-
-export type EntryMode = 'all' | 'single' | 'auto' | 'platform'
-
-/**
- * Configuration for specifying which paths are targeted.
- */
-export interface PathConfig {
-  /**
-   * Glob patterns to exclude (takes precedence over include).
-   */
-  exclude?: string[]
-  /**
-   * Glob patterns to include.
-   */
-  include?: string[]
-}
-
-/**
- * Configuration for Dynamic Share.
- */
-
-export interface DynamicShareConfig extends PathConfig {}
-
-/**
- * Configuration for Live Share.
- */
-
-export interface LiveShareConfig extends PathConfig {}
-
-export interface CompileConfig {
-  depth?: number
-  /** @param entryMode all, single, platform, or auto */
-  entryMode?: EntryMode
-  /** @param files Manually specify the files to be compiled */
-  files?: string[]
-}
-
-export type PackageCompileTsupConfig = CompileConfig & {
-  browser?: Record<string, Options | boolean>
-  neutral?: Record<string, Options | boolean>
-  node?: Record<string, Options | boolean>
-  tsup?: { options?: Options }
-}
-
-export type PackageCompileTscConfig = CompileConfig & { mode: 'tsc' }
-
-export interface XyConfigBase {
-  compile?: CompileConfig
-  dynamicShare?: DynamicShareConfig
-  liveShare?: LiveShareConfig
-  publint?: boolean
-  verbose?: boolean
-}
-
-export interface XyTsupConfig extends XyConfigBase { compile?: PackageCompileTsupConfig }
-
-export interface XyTscConfig extends XyConfigBase { compile?: PackageCompileTscConfig }
-
-export type XyConfig = XyTsupConfig | XyTscConfig

package/src/actions/package/compile/buildEntries.ts

@@ -1,22 +0,0 @@
-import { getAllInputs } from './inputs.ts'
-import type { EntryMode } from './XyConfig.ts'
-
-export const buildEntries = (folder: string, entryMode: EntryMode = 'single', verbose = false) => {
-  let entries: string[] = []
-  switch (entryMode) {
-    case 'platform': {
-      entries = [`${folder}/index-node.ts`, `${folder}/index-browser.ts`]
-      break
-    }
-    case 'all': {
-      entries = getAllInputs(folder).filter(entry => !entry.includes('.spec.') && !entry.includes('.story.'))
-      break
-    }
-    default: {
-      entries = [`${folder}/index.ts`]
-      break
-    }
-  }
-  if (verbose) console.log(`buildEntries [${entryMode}] ${entries.length}`)
-  return entries
-}

package/src/actions/package/compile/compile.ts

@@ -1,21 +0,0 @@
-import chalk from 'chalk'
-
-import { loadConfig } from '../../../lib/index.ts'
-import { packagePublint } from '../publint.ts'
-import { packageCompileTsup } from './packageCompileTsup.ts'
-import type { XyConfig } from './XyConfig.ts'
-
-export const packageCompile = async (inConfig: XyConfig = {}): Promise<number> => {
-  const pkg = process.env.INIT_CWD
-  console.log(chalk.green(`Compiling ${pkg}`))
-  const config = await loadConfig(inConfig)
-  const publint = config.publint
-
-  const tsupResults = await packageCompileTsup(config)
-
-  if (tsupResults > 0) {
-    return tsupResults
-  }
-
-  return (publint ? await packagePublint(config) : 0)
-}

package/src/actions/package/compile/compileTypes.ts

@@ -1,13 +0,0 @@
-import chalk from 'chalk'
-
-import { loadConfig } from '../../../lib/index.ts'
-import { packageCompileTscTypes } from './packageCompileTscTypes.ts'
-import type { XyConfig, XyTscConfig } from './XyConfig.ts'
-
-export const packageCompileTypes = async (inConfig: XyConfig = {}): Promise<number> => {
-  const pkg = process.env.INIT_CWD
-  console.log(chalk.green(`Compiling Types ${pkg}`))
-  const config = await loadConfig(inConfig)
-
-  return packageCompileTscTypes(undefined, config as XyTscConfig)
-}

package/src/actions/package/compile/copyTypeFiles.ts

@@ -1,38 +0,0 @@
-import { copyFile, readdir } from 'node:fs/promises'
-
-import { Mutex } from 'async-mutex'
-import type { TsConfigCompilerOptions } from 'tsc-prog'
-
-const copyFileMutex = new Mutex()
-
-const getDistTypeFiles = async (compilerOptions: TsConfigCompilerOptions) => {
-  const outDir = compilerOptions.outDir ?? 'dist'
-  return (await readdir(outDir, { recursive: true })).filter(file => file.endsWith('d.ts')).map(file => `${outDir}/${file}`)
-}
-
-const getDistTypeMapFiles = async (compilerOptions: TsConfigCompilerOptions) => {
-  const outDir = compilerOptions.outDir ?? 'dist'
-  return (await readdir(outDir, { recursive: true })).filter(file => file.endsWith('d.ts.map')).map(file => `${outDir}/${file}`)
-}
-
-export const copyTypeFiles = async (compilerOptions: TsConfigCompilerOptions) => {
-  // using a mutex since sometimes two compiles are running at once and cause a lock on windows
-  await copyFileMutex.runExclusive(async () => {
-    // hybrid packages want two copies of the types
-    const distTypeFiles = await getDistTypeFiles(compilerOptions)
-    await Promise.all(
-      distTypeFiles.map(async (file) => {
-        await copyFile(file, file.replace('d.ts', 'd.mts'))
-        await copyFile(file, file.replace('d.ts', 'd.cts'))
-      }),
-    )
-
-    const distTypeMapFiles = await getDistTypeMapFiles(compilerOptions)
-    await Promise.all(
-      distTypeMapFiles.map(async (file) => {
-        await copyFile(file, file.replace('d.ts.map', 'd.mts.map'))
-        await copyFile(file, file.replace('d.ts.map', 'd.cts.map'))
-      }),
-    )
-  })
-}

package/src/actions/package/compile/deepMerge.ts

@@ -1,33 +0,0 @@
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-type AnyObject = Record<any, any>
-
-function deepMerge<T extends AnyObject>(target: AnyObject, source: AnyObject): T {
-  if (!source || typeof source !== 'object') return target
-
-  for (const key of Object.keys(source)) {
-    if (
-      typeof source[key] === 'object'
-      && source[key] !== null
-      && !Array.isArray(source[key])
-    ) {
-      // Recursively merge nested objects
-      if (!target[key] || typeof target[key] !== 'object') {
-        target[key] = {} as T[typeof key]
-      }
-      deepMerge(target[key], source[key])
-    } else {
-      // Overwrite with non-object values
-      target[key] = source[key]
-    }
-  }
-
-  return target
-}
-
-export function deepMergeObjects<T extends AnyObject>(objects: T[]): T {
-  const result = {} as T
-  for (const obj of objects) {
-    deepMerge(result, obj)
-  }
-  return result
-}

package/src/actions/package/compile/getCompilerOptions.ts

@@ -1,30 +0,0 @@
-import { createRequire } from 'node:module'
-
-import deepmerge from 'deepmerge'
-import type { TsConfig } from 'tsc-prog'
-import type { CompilerOptions } from 'typescript'
-import {
-  findConfigFile, readConfigFile, sys,
-} from 'typescript'
-
-const getNested = (config: TsConfig): CompilerOptions => {
-  if (config.extends) {
-    const require = createRequire(import.meta.url)
-    const opts = require(config.extends)
-    return deepmerge(getNested(opts), config.compilerOptions ?? {}) as CompilerOptions
-  }
-
-  return config.compilerOptions as CompilerOptions
-}
-
-const getCompilerOptionsJSONFollowExtends = (filename: string): CompilerOptions => {
-  const config = readConfigFile(filename, sys.readFile).config
-  return getNested(config)
-}
-
-export const getCompilerOptions = (options: CompilerOptions = {}, tsconfig: string = 'tsconfig.json'): CompilerOptions => {
-  const configFileName = findConfigFile('./', sys.fileExists, tsconfig)
-  const configFileCompilerOptions = (configFileName ? getCompilerOptionsJSONFollowExtends(configFileName) : undefined) ?? {}
-
-  return deepmerge(configFileCompilerOptions, options)
-}

package/src/actions/package/compile/index.ts

@@ -1,6 +0,0 @@
-export * from './compile.ts'
-export * from './compileTypes.ts'
-export * from './packageCompileTsc.ts'
-export * from './packageCompileTscTypes.ts'
-export * from './packageCompileTsup.ts'
-export * from './XyConfig.ts'

package/src/actions/package/compile/inputs.ts

@@ -1,6 +0,0 @@
-import { glob } from 'glob'
-
-export const getAllInputs = (folder: string) => {
-  /* tsup wants posix paths */
-  return glob.sync(`${folder}/**/*.*`, { ignore: ['**/*.spec.*', '**/*.stories.*', '**/spec/**/*'], posix: true })
-}

package/src/actions/package/compile/packageCompileTsc.ts

@@ -1,67 +0,0 @@
-import { cwd } from 'node:process'
-
-import chalk from 'chalk'
-import type { TsConfigCompilerOptions } from 'tsc-prog'
-import { createProgramFromConfig } from 'tsc-prog'
-import type {
-  CompilerOptions,
-  FormatDiagnosticsHost,
-  LineAndCharacter,
-} from 'typescript'
-import {
-  DiagnosticCategory,
-  formatDiagnosticsWithColorAndContext,
-  getLineAndCharacterOfPosition,
-  getPreEmitDiagnostics,
-} from 'typescript'
-
-import { packagePublint } from '../publint.ts'
-import { getCompilerOptions } from './getCompilerOptions.ts'
-import type { XyTscConfig } from './XyConfig.ts'
-
-export const packageCompileTsc = async (noEmit?: boolean, config?: XyTscConfig, compilerOptionsParam?: CompilerOptions): Promise<number> => {
-  const pkg = process.env.INIT_CWD ?? cwd()
-
-  const publint = config?.publint ?? true
-  const verbose = config?.verbose ?? false
-
-  const formatHost: FormatDiagnosticsHost = {
-    getCanonicalFileName: fileName => fileName,
-    getCurrentDirectory: () => pkg,
-    getNewLine: () => '\n',
-  }
-
-  if (verbose) {
-    console.log(`Compiling with NoEmit TSC [${pkg}]`)
-  }
-
-  const compilerOptions = {
-    ...(getCompilerOptions({
-      outDir: 'dist',
-      removeComments: true,
-      rootDir: 'src',
-    })),
-    ...compilerOptionsParam,
-    ...(noEmit === undefined ? {} : { noEmit }),
-  } as TsConfigCompilerOptions
-
-  const program = createProgramFromConfig({
-    basePath: pkg ?? cwd(),
-    compilerOptions,
-    exclude: ['dist', 'docs', '**/*.spec.*', '**/*.stories.*', 'src/**/spec/**/*'],
-    include: ['src'],
-  })
-
-  const results = getPreEmitDiagnostics(program)
-
-  for (const diag of results) {
-    const lineAndChar: LineAndCharacter = diag.file
-      ? getLineAndCharacterOfPosition(diag.file, diag.start ?? 0)
-      : { character: 0, line: 0 }
-    console.log(chalk.cyan(`${diag.file?.fileName}:${lineAndChar.line + 1}:${lineAndChar.character + 1}`))
-    console.log(formatDiagnosticsWithColorAndContext([diag], formatHost))
-  }
-
-  // eslint-disable-next-line unicorn/no-array-reduce
-  return results.reduce((prev, diag) => (prev + diag.category === DiagnosticCategory.Error ? 1 : 0), 0) || (publint ? await packagePublint() : 0)
-}

package/src/actions/package/compile/packageCompileTscTypes.ts

@@ -1,68 +0,0 @@
-import { cwd } from 'node:process'
-
-import type { TsConfigCompilerOptions } from 'tsc-prog'
-import { createProgramFromConfig } from 'tsc-prog'
-import type { CompilerOptions } from 'typescript'
-import {
-  DiagnosticCategory, formatDiagnosticsWithColorAndContext, getPreEmitDiagnostics, sys,
-} from 'typescript'
-
-import { buildEntries } from './buildEntries.ts'
-import { getCompilerOptions } from './getCompilerOptions.ts'
-import type { XyConfig } from './XyConfig.ts'
-
-export const packageCompileTscTypes = (
-  folder: string = 'src',
-  config: XyConfig = {},
-  compilerOptionsParam?: CompilerOptions,
-): number => {
-  const pkg = process.env.INIT_CWD ?? cwd()
-  const verbose = config?.verbose ?? false
-
-  if (verbose) {
-    console.log(`Compiling types [${pkg}]`)
-  }
-
-  const compilerOptions = {
-    ...(getCompilerOptions({
-      emitDeclarationOnly: true,
-      outDir: 'dist/types',
-      removeComments: false,
-      skipDefaultLibCheck: true,
-      skipLibCheck: true,
-      sourceMap: false,
-    })),
-    ...compilerOptionsParam,
-    emitDeclarationOnly: true,
-    noEmit: false,
-  } as TsConfigCompilerOptions
-
-  const validTsExt = ['.ts', '.tsx', '.d.ts', '.cts', '.d.cts', '.mts', '.d.mts']
-
-  // calling all here since the types do not get rolled up
-  const files = buildEntries(folder, 'all', verbose).filter(file => validTsExt.find(ext => file.endsWith(ext)))
-
-  const program = createProgramFromConfig({
-    basePath: pkg ?? cwd(),
-    compilerOptions,
-    exclude: ['dist', 'docs', '**/*.spec.*', '**/*.stories.*', 'src/**/spec/**/*'],
-    files,
-  })
-
-  const diagnostics = getPreEmitDiagnostics(program)
-
-  if (diagnostics.length > 0) {
-    const formattedDiagnostics = formatDiagnosticsWithColorAndContext(
-      diagnostics,
-      {
-        getCanonicalFileName: fileName => fileName,
-        getCurrentDirectory: () => folder,
-        getNewLine: () => sys.newLine,
-      },
-    )
-    console.error(formattedDiagnostics)
-  }
-
-  program.emit()
-  return diagnostics.reduce((acc, diag) => acc + (diag.category === DiagnosticCategory.Error ? 1 : 0), 0)
-}

package/src/actions/package/compile/packageCompileTsup.ts

@@ -1,154 +0,0 @@
-import type { Loader } from 'esbuild'
-import type { Options } from 'tsup'
-import { build, defineConfig } from 'tsup'
-
-import { buildEntries } from './buildEntries.ts'
-import { packageCompileTypes } from './compileTypes.ts'
-import { deepMergeObjects } from './deepMerge.ts'
-import type { EntryMode, XyTsupConfig } from './XyConfig.ts'
-
-const compileFolder = async (
-  folder: string,
-  entryMode: EntryMode = 'single',
-  options?: Options,
-  verbose?: boolean,
-): Promise<number> => {
-  const outDir = options?.outDir ?? 'dist'
-
-  if (verbose) {
-    console.log(`compileFolder [${folder}]`)
-  }
-
-  const entry = buildEntries(folder, entryMode)
-  const optionsResult = defineConfig({
-    bundle: true,
-    cjsInterop: true,
-    clean: true,
-    dts: false,
-    entry,
-    format: ['esm'],
-    outDir,
-    silent: true,
-    sourcemap: true,
-    splitting: false,
-    tsconfig: 'tsconfig.json',
-    ...options,
-  })
-  const optionsList = (
-    await Promise.all(
-      (Array.isArray(optionsResult) ? optionsResult : [optionsResult]).flatMap<Promise<Options[]>>(async (options) => {
-        const result = typeof options === 'function' ? await options({}) : [options]
-        return Array.isArray(result) ? result : [result]
-      }),
-    )
-  ).flat()
-
-  if (verbose) {
-    console.log(`TSUP:build:start [${folder}]`)
-  }
-
-  await Promise.all(optionsList.map(options => build(options)))
-
-  if (verbose) {
-    console.log(`TSUP:build:stop [${folder}]`)
-  }
-
-  return 0
-}
-
-export const tsupOptions = (options: Options[] = []): Options => {
-  const standardLoaders: Record<string, Loader> = {
-    '.gif': 'copy', '.html': 'copy', '.jpg': 'copy', '.json': 'json', '.png': 'copy', '.svg': 'copy', '.webp': 'copy',
-  }
-
-  const standardOptions: Options = {
-    bundle: true,
-    format: ['esm'],
-    loader: standardLoaders,
-    outExtension: ({ format }) => (format === 'esm' ? { js: '.mjs' } : { js: '.cjs' }),
-    skipNodeModulesBundle: true,
-    sourcemap: true,
-    target: 'esnext',
-  }
-
-  return deepMergeObjects([standardOptions, ...options])
-}
-
-export const packageCompileTsup = async (config?: XyTsupConfig) => {
-  console.log('packageCompileTsup-types')
-  const compile = config?.compile
-  const verbose = config?.verbose ?? false
-  if (verbose) {
-    console.log(`Compiling with TSUP [Depth: ${compile?.depth}]`)
-  }
-
-  const compileForNode = compile?.node ?? { src: {} }
-  const compileForBrowser = compile?.browser ?? { src: {} }
-  const compileForNeutral = compile?.neutral ?? { src: {} }
-
-  if (verbose) {
-    console.log('Calling packageCompileTscTypes')
-  }
-  const errors = await packageCompileTypes(config)
-  if (errors > 0) {
-    return errors
-  }
-
-  return (
-    (
-      await Promise.all(
-        Object.entries(compileForNode).map(async ([folder, options]) => {
-          const inEsBuildOptions = typeof compile?.node?.esbuildOptions === 'object' ? compile?.node?.esbuildOptions : {}
-          return folder
-            ? await compileFolder(
-              folder,
-              compile?.entryMode,
-              tsupOptions([inEsBuildOptions,
-                compile?.tsup?.options ?? {},
-                (typeof options === 'object' ? options : {}),
-                { platform: 'node', outDir: 'dist/node' }]),
-              verbose,
-            )
-            : 0
-        }),
-      )
-    ).reduce((prev, value) => prev + value, 0)
-    || (
-      await Promise.all(
-        Object.entries(compileForBrowser).map(async ([folder, options]) => {
-          const inEsBuildOptions = typeof compile?.browser?.esbuildOptions === 'object' ? compile?.browser?.esbuildOptions : {}
-          return folder
-            ? await compileFolder(
-              folder,
-              compile?.entryMode,
-              tsupOptions([inEsBuildOptions,
-                compile?.tsup?.options ?? {},
-                (typeof options === 'object' ? options : {}),
-                { platform: 'browser', outDir: 'dist/browser' }]),
-              verbose,
-            )
-            : 0
-        }),
-      )
-    ).reduce((prev, value) => prev + value, 0)
-    || (
-      await Promise.all(
-        Object.entries(compileForNeutral).map(async ([folder, options]) => {
-          const inEsBuildOptions = typeof compile?.neutral?.esbuildOptions === 'object' ? compile?.neutral?.esbuildOptions : {}
-          return folder
-            ? await compileFolder(
-              folder,
-              compile?.entryMode,
-              tsupOptions([inEsBuildOptions,
-                compile?.tsup?.options ?? {},
-                (typeof options === 'object' ? options : {}),
-                { platform: 'neutral', outDir: 'dist/neutral' }]),
-              verbose,
-            )
-            : 0
-        }),
-      )
-    ).reduce((prev, value) => prev + value, 0)
-    || 0
-  )
-}

package/src/actions/package/copy-assets.ts

@@ -1,46 +0,0 @@
-import path from 'node:path/posix'
-
-import chalk from 'chalk'
-import cpy from 'cpy'
-
-export interface PackageCopyAssetsParams { target?: 'esm' | 'cjs' }
-
-const copyTargetAssets = async (target: 'esm' | 'cjs', name: string, location: string) => {
-  try {
-    const values = await cpy(
-      ['**/*.jpg', '**/*.png', '**/*.gif', '**/*.svg', '**/*.webp', '**/*.sass', '**/*.scss', '**/*.gif', '**/*.css'],
-      `../dist/${target}`,
-      {
-        cwd: path.join(location, 'src'),
-        flat: false,
-      },
-    )
-    if (values.length > 0) {
-      console.log(chalk.green(`Copying Assets [${target.toUpperCase()}] - ${name} - ${location}`))
-    }
-    for (const value of values) {
-      console.log(`${value.split('/').pop()} => ./dist/${target}`)
-    }
-    return 0
-  } catch (ex) {
-    const error = ex as Error
-    console.log(`Copy Assets Failed: ${name}: ${error.message}`)
-    return 1
-  }
-}
-
-export const packageCopyAssets = async ({ target }: PackageCopyAssetsParams) => {
-  const pkg = process.env.INIT_CWD ?? './'
-  const pkgName = process.env.npm_package_name ?? 'Unknown'
-  switch (target) {
-    case 'esm': {
-      return await copyTargetAssets('esm', pkgName, pkg)
-    }
-    case 'cjs': {
-      return await copyTargetAssets('cjs', pkgName, pkg)
-    }
-    default: {
-      return (await copyTargetAssets('esm', pkgName, pkg)) || (await copyTargetAssets('cjs', pkgName, pkg))
-    }
-  }
-}