tshy 1.0.0-0

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "tshy",
+  "version": "1.0.0-0",
+  "description": "TypeScript HYbridizer - Hybrid (CommonJS/ESM) TypeScript node package builder",
+  "author": "Isaac Z. Schlueter <i@izs.me> (https://izs.me)",
+  "license": "BlueOak-1.0.0",
+  "type": "module",
+  "bin": "./dist/esm/index.js",
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "foreground-child": "^3.1.1",
+    "mkdirp": "^3.0.1",
+    "rimraf": "^5.0.1",
+    "sync-content": "^1.0.2",
+    "typescript": "5.2"
+  },
+  "scripts": {
+    "postversion": "npm publish",
+    "prepublishOnly": "git push origin --follow-tags",
+    "prepare": "tsc -p tsconfig/esm.json && bash scripts/fixup.sh",
+    "pretest": "npm run prepare",
+    "presnap": "npm run prepare",
+    "format": "prettier --write . --loglevel warn --ignore-path ../../.prettierignore --cache",
+    "typedoc": "typedoc"
+  },
+  "engines": {
+    "node": "16 >=16.17 || 18 >=18.16.0 || >=20.6.1"
+  },
+  "repository": "https://github.com/isaacs/tshy",
+  "keywords": [
+    "typescript",
+    "tsc",
+    "hybrid",
+    "esm",
+    "commonjs",
+    "build"
+  ],
+  "devDependencies": {
+    "@types/node": "^20.6.0",
+    "typedoc": "^0.25.1"
+  },
+  "prettier": {
+    "semi": false,
+    "printWidth": 70,
+    "tabWidth": 2,
+    "useTabs": false,
+    "singleQuote": true,
+    "jsxSingleQuote": false,
+    "bracketSameLine": true,
+    "arrowParens": "avoid",
+    "endOfLine": "lf"
+  },
+  "tshy": {
+    "dialects": [
+      "esm"
+    ],
+    "exports": {
+      "./package.json": "./package.json",
+      ".": "./src/index.ts"
+    }
+  },
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "import": {
+        "types": "./dist/esm/index.d.ts",
+        "default": "./dist/esm/index.js"
+      }
+    }
+  }
+}

package/scripts/fixup.sh

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+
+chmod 0755 .tshy-build-tmp/esm/index.js
+sync-content .tshy-build-tmp dist
+rm -rf .tshy-build-tmp

package/src/bins.ts

@@ -0,0 +1,15 @@
+// chmod bins after build
+import { chmodSync } from 'fs'
+import { resolve } from 'path'
+import pkg from './package.js'
+export default () => {
+  const { bin } = pkg
+  if (!bin) return
+  if (typeof bin === 'string') {
+    chmodSync(resolve(bin), 0o755)
+  } else {
+    for (const v of Object.values(bin)) {
+      chmodSync(resolve(v), 0o755)
+    }
+  }
+}

package/src/build.ts

@@ -0,0 +1,64 @@
+import chalk from 'chalk'
+import { spawnSync, SpawnSyncReturns } from 'node:child_process'
+import { renameSync } from 'node:fs'
+import { relative, resolve } from 'node:path/posix'
+import { rimrafSync } from 'rimraf'
+import { syncContentSync } from 'sync-content'
+import bins from './bins.js'
+import dialects from './dialects.js'
+import { fail } from './fail.js'
+import polyfills from './polyfills.js'
+import setFolderDialect from './set-folder-dialect.js'
+import './tsconfig.js'
+import writePackage from './write-package.js'
+
+const buildFail = (res: SpawnSyncReturns<Buffer>) => {
+  setFolderDialect('src')
+  fail('build failed')
+  console.error(res)
+  process.exit(1)
+}
+
+rimrafSync('.tshy-build-tmp')
+
+if (dialects.includes('esm')) {
+  setFolderDialect('src', 'esm')
+  const res = spawnSync('tsc -p .tshy/esm.json', {
+    shell: true,
+    stdio: 'inherit',
+  })
+  setFolderDialect('src')
+  if (res.status || res.signal) buildFail(res)
+  setFolderDialect('.tshy-build-tmp/esm', 'esm')
+  console.error(chalk.cyan.bold('built esm'))
+}
+
+if (dialects.includes('commonjs')) {
+  setFolderDialect('src', 'commonjs')
+  const res = spawnSync('tsc -p .tshy/commonjs.json', {
+    shell: true,
+    stdio: 'inherit',
+  })
+  setFolderDialect('src')
+  if (res.status || res.signal) buildFail(res)
+  setFolderDialect('.tshy-build-tmp/commonjs', 'commonjs')
+  console.error(chalk.cyan.bold('built commonjs'), res)
+  // apply polyfills
+  for (const [f, t] of polyfills.entries()) {
+    const stemFrom = resolve(
+      '.tshy-build-tmp/commonjs',
+      relative(resolve('src'), resolve(f))
+    ).replace(/\.cts$/, '')
+    const stemTo = resolve(
+      '.tshy-build-tmp/commonjs',
+      relative(resolve('src'), resolve(t))
+    ).replace(/\.ts$/, '')
+    renameSync(`${stemFrom}.cjs`, `${stemTo}.js`)
+    renameSync(`${stemFrom}.d.cts`, `${stemTo}.d.ts`)
+  }
+}
+
+syncContentSync('.tshy-build-tmp', 'dist')
+rimrafSync('.tshy-build-tmp')
+bins()
+writePackage()

package/src/config.ts

@@ -0,0 +1,117 @@
+// get the config and package and stuff
+
+import { fail } from './fail.js'
+import { Dialect, Package, TshyConfig, TshyExport } from './types.js'
+
+const validConfig = (e: any): e is TshyConfig =>
+  !!e &&
+  typeof e === 'object' &&
+  (e.exports === undefined || validExports(e['exports'])) &&
+  (e.dialects === undefined || validDialects(e['dialects']))
+
+const isDialect = (d: any): d is Dialect =>
+  d === 'commonjs' || d === 'esm'
+
+const validDialects = (
+  d: any
+): d is Exclude<TshyConfig['dialects'], undefined> =>
+  !!d && Array.isArray(d) && !d.some(d => !isDialect(d))
+
+const validExports = (
+  e: any
+): e is Exclude<TshyConfig['exports'], undefined> => {
+  if (!e) return false
+  if (typeof e !== 'object') return false
+  for (const [sub, exp] of Object.entries(e)) {
+    if (sub !== '.' && !sub.startsWith('./')) {
+      fail(
+        `tshy.exports key must be "." or start with "./", got: ${sub}`
+      )
+      process.exit(1)
+    }
+    if (typeof exp === 'string') {
+      e[sub] = addDot(exp)
+      continue
+    }
+    if (typeof exp !== 'object' || !exp || Array.isArray(exp)) {
+      fail(
+        `tshy.exports ${sub} value must be string or import/require object, ` +
+          `got: ${JSON.stringify(exp)}`
+      )
+      process.exit(1)
+    }
+    const { import: i, require: r } = exp as Exclude<
+      TshyExport,
+      string
+    >
+    if (!i && !e) {
+      fail(
+        `tshy.exports ${sub} needs require or import, ` +
+          `got: ${JSON.stringify(exp)}`
+      )
+      process.exit(1)
+    }
+    if (
+      (i !== undefined && typeof i !== 'string') ||
+      (r !== undefined && typeof r !== 'string')
+    ) {
+      fail(
+        `tshy.exports ${sub} import/require must be strings, ` +
+          `got: ${JSON.stringify(exp)}`
+      )
+      process.exit(1)
+    }
+    if (
+      (i !== undefined && join(i).startsWith('src/')) ||
+      (r !== undefined && join(r).startsWith('src/'))
+    ) {
+      fail(
+        `tshy.exports ${sub} in src/ must be string paths, ` +
+          `got: ${JSON.stringify(exp)}`
+      )
+      process.exit(1)
+    }
+    e[sub] = {}
+    if (e[sub].types) e[sub].types = addDot(e[sub].types)
+    if (e[sub].import) e[sub].types = addDot(e[sub].import)
+    if (e[sub].require) e[sub].types = addDot(e[sub].require)
+  }
+  if (e.dialects) {
+    if (!validDialects(e.dialects)) {
+      fail(
+        `tshy.dialects must be array containing 'esm' and/or 'commonjs', ` +
+          `got: ${JSON.stringify(e.dialects)}`
+      )
+    }
+  }
+  return true
+}
+
+const addDot = (s: string) => `./${join(s)}`
+
+const getConfig = (
+  pkg: Package,
+  sources: Set<string>
+): TshyConfig => {
+  const tshy: TshyConfig = validConfig(pkg.tshy) ? pkg.tshy : {}
+  if (tshy.exports) return tshy
+  const e: Exclude<TshyConfig['exports'], undefined> = {
+    './package.json': './package.json',
+  }
+  for (const i of sources) {
+    if (/^\.\/src\/index\.[^\.]+$/.test(i)) {
+      e['.'] = i
+      break
+    }
+  }
+  pkg.tshy = tshy
+  tshy.exports = e
+  return tshy
+}
+
+import { join } from 'path/posix'
+import pkg from './package.js'
+import sources from './sources.js'
+
+const config: TshyConfig = getConfig(pkg, sources)
+export default config

package/src/dialects.ts

@@ -0,0 +1,2 @@
+import config from './config.js'
+export default config.dialects || ['esm', 'commonjs']

package/src/exports.ts

@@ -0,0 +1,105 @@
+import { relative, resolve } from 'node:path/posix'
+import config from './config.js'
+import dialects from './dialects.js'
+import polyfills from './polyfills.js'
+import { Export, TshyConfig, TshyExport } from './types.js'
+
+const getImpTarget = (
+  s: string | TshyExport | undefined
+): string | undefined => {
+  if (s === undefined) return undefined
+  if (typeof s === 'string') {
+    const imp = s.endsWith('.cts') ? undefined : s
+    return !imp || !imp.startsWith('./src/')
+      ? imp
+      : dialects.includes('esm')
+      ? `./dist/esm/${relative(
+          resolve('./src'),
+          resolve(imp)
+        ).replace(/\.(m?)tsx?$/, '.$1js')}`
+      : undefined
+  }
+  if (s && typeof s === 'object') {
+    return getImpTarget(s.import)
+  }
+}
+
+const getReqTarget = (
+  s: string | TshyExport | undefined,
+  polyfills: Map<string, string>
+): string | undefined => {
+  if (s === undefined) return undefined
+  if (typeof s === 'string') {
+    const req = s.endsWith('.mts') ? undefined : s
+    return !req || !req.startsWith('./src/')
+      ? req
+      : dialects.includes('commonjs')
+      ? `./dist/commonjs/${relative(
+          resolve('./src'),
+          resolve(polyfills.get(req) || req)
+        ).replace(/\.(m?)tsx?$/, '.$1js')}`
+      : undefined
+  }
+  if (s && typeof s === 'object') {
+    return getReqTarget(s.require, polyfills)
+  }
+}
+
+const getExports = (
+  c: TshyConfig,
+  polyfills: Map<string, string>
+): Record<string, Export> => {
+  if (!c.exports) {
+    fail('no exports on tshy config (is there code in ./src?)')
+    process.exit(1)
+  }
+  const e: Record<string, Export> = {}
+  for (const [sub, s] of Object.entries(c.exports)) {
+    const impTarget = getImpTarget(s)
+    const reqTarget = getReqTarget(s, polyfills)
+
+    // only possible for exports outside of ./src
+    const types = typeof s !== 'string' && s.types
+
+    if (typeof s !== 'string' || !s.startsWith('./src/')) {
+      if (impTarget === reqTarget) {
+        if (impTarget === undefined) continue
+        if (types) {
+          e[sub] = {
+            import: impTarget,
+            require: reqTarget,
+            types,
+          }
+        } else if (impTarget !== undefined) e[sub] = impTarget
+        continue
+      }
+      if (types) {
+        e[sub] = {
+          types,
+          import: impTarget,
+          require: reqTarget,
+        }
+        continue
+      }
+    }
+
+    const exp: Export = (e[sub] = {})
+    if (impTarget) {
+      exp.import = {
+        types: impTarget.replace(/\.(m?)js$/, '.d.$1ts'),
+        default: impTarget,
+      }
+    }
+    if (reqTarget) {
+      exp.require = {
+        types: reqTarget.replace(/\.(c?)js$/, '.d.$1ts'),
+        default: reqTarget,
+      }
+    }
+  }
+  return e
+}
+
+import { fail } from './fail.js'
+import pkg from './package.js'
+export default pkg.exports = getExports(config, polyfills)

package/src/fail.ts

@@ -0,0 +1,5 @@
+import chalk from 'chalk'
+export const fail = (message: string, er?: Error) => {
+  console.error(chalk.red.bold(message))
+  if (er) console.error(er.message)
+}

package/src/index.ts

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+
+import chalk from 'chalk'
+
+import './exports.js'
+import pkg from './package.js'
+
+const { exports: exp, tshy } = pkg
+
+console.error(chalk.yellow.bold('building'))
+console.error(chalk.cyan.dim('tshy config'), tshy)
+console.error(chalk.cyan.dim('exports'), exp)
+
+// have our config, time to build
+await import('./build.js')
+
+console.log(chalk.bold.green('success!'))

package/src/package.ts

@@ -0,0 +1,18 @@
+// get the package.json data for the cwd
+
+import { readFileSync } from 'fs'
+import { fail } from './fail.js'
+import { Package } from './types.js'
+
+const readPkg = (): Package => {
+  try {
+    return JSON.parse(readFileSync('package.json', 'utf8'))
+  } catch (er) {
+    fail('failed to read package.json', er as Error)
+    process.exit(1)
+  }
+}
+
+const pkg = readPkg()
+pkg.type = 'module'
+export default pkg

package/src/polyfills.ts

@@ -0,0 +1,21 @@
+// the modules like -cjs.cts that override a module at .ts
+import sources from './sources.js'
+import chalk from 'chalk'
+
+const getPolyfills = (sources: Set<string>): Map<string, string> =>
+  new Map(
+    [...sources]
+      .filter(
+        f =>
+          f.endsWith('-cjs.cts') &&
+          sources.has(f.replace(/-cjs\.cts$/, '.ts'))
+      )
+      .map(f => [f, f.replace(/-cjs\.cts$/, '.ts')])
+  )
+
+const polyfills = getPolyfills(sources)
+if (polyfills.size) {
+  console.error(chalk.cyan.dim('polyfills detected'), polyfills)
+}
+
+export default getPolyfills(sources)

package/src/set-folder-dialect.ts

@@ -0,0 +1,16 @@
+import { writeFileSync } from 'fs'
+import { rimrafSync } from 'rimraf'
+import { Dialect } from './types.js'
+
+const writeDialectPJ = (f: string, mode?: Dialect) =>
+  mode
+    ? writeFileSync(
+        f,
+        JSON.stringify({
+          type: mode === 'commonjs' ? 'commonjs' : 'module',
+        })
+      )
+    : rimrafSync(f)
+
+export default (where: string, mode?: Dialect) =>
+  writeDialectPJ(`${where}/package.json`, mode)

package/src/sources.ts

@@ -0,0 +1,20 @@
+// get the list of sources in ./src
+
+import { readdirSync } from 'fs'
+import { join } from 'path/posix'
+
+const getSources = (dir = 'src'): string[] => {
+  const sources: string[] = []
+  const entries = readdirSync(dir, { withFileTypes: true })
+  for (const e of entries) {
+    const j = `./${join(dir, e.name)}`
+    if (e.isFile()) sources.push(j)
+    else if (e.isDirectory()) {
+      sources.push(...getSources(j))
+    }
+  }
+  return sources
+}
+
+const sources = new Set(getSources())
+export default sources

package/src/tsconfig.ts

@@ -0,0 +1,65 @@
+import chalk from 'chalk'
+import { existsSync, writeFileSync } from 'fs'
+import { mkdirpSync } from 'mkdirp'
+
+// the commonjs build needs to exclude anything that will be polyfilled
+import polyfills from './polyfills.js'
+
+const recommended: Record<string, any> = {
+  compilerOptions: {
+    jsx: 'react',
+    declaration: true,
+    declarationMap: true,
+    inlineSources: true,
+    esModuleInterop: true,
+    forceConsistentCasingInFileNames: true,
+    moduleResolution: 'nodenext',
+    resolveJsonModule: true,
+    skipLibCheck: true,
+    sourceMap: true,
+    strict: true,
+    target: 'es2022',
+    module: 'nodenext',
+  },
+}
+
+const build: Record<string, any> = {
+  extends: '../tsconfig.json',
+  compilerOptions: {
+    rootDir: '../src',
+    target: 'es2022',
+    module: 'nodenext',
+    moduleResolution: 'nodenext',
+  },
+}
+
+const commonjs: Record<string, any> = {
+  extends: './build.json',
+  include: ['../src/**/*.ts', '../src/**/*.cts', '../src/**/*.tsx'],
+  exclude: [...polyfills.values()].map(f => `.${f}`),
+  compilerOptions: {
+    outDir: '../.tshy-build-tmp/commonjs',
+  },
+}
+
+const esm: Record<string, any> = {
+  extends: './build.json',
+  include: ['../src/**/*.ts', '../src/**/*.cts', '../src/**/*.tsx'],
+  compilerOptions: {
+    outDir: '../.tshy-build-tmp/esm',
+  },
+}
+
+mkdirpSync('.tshy')
+const writeConfig = (name: string, data: Record<string, any>) =>
+  writeFileSync(
+    `.tshy/${name}.json`,
+    JSON.stringify(data, null, 2) + '\n'
+  )
+
+console.error(chalk.cyan.dim('writing tsconfig files...'))
+if (!existsSync('tsconfig.json'))
+  writeConfig('../tsconfig', recommended)
+writeConfig('build', build)
+writeConfig('commonjs', commonjs)
+writeConfig('esm', esm)

package/src/types.ts

@@ -0,0 +1,43 @@
+export type TshyConfig = {
+  exports?: Record<string, TshyExport>
+  dialects?: Dialect[]
+}
+
+export type Dialect = 'commonjs' | 'esm'
+
+export type TshyExport =
+  | string
+  | ({ types?: string; import?: string; require?: string } & (
+      | { import: string }
+      | { require: string }
+    ))
+
+export type Package = {
+  name: string
+  version: string
+  type?: 'module'
+  bin?: string | Record<string, string>
+  exports: Record<string, Export>
+  tshy?: TshyConfig
+  [k: string]: any
+}
+
+// VERY limited subset of the datatypes "exports" can be
+// but we're only writing our flavor, so it's fine.
+export type Export =
+  | string
+  | { import?: string; require?: string; types?: string }
+  | {
+      import?:
+        | string
+        | {
+            types: string
+            default: string
+          }
+      require?:
+        | string
+        | {
+            types: string
+            default: string
+          }
+    }

package/src/write-package.ts

@@ -0,0 +1,6 @@
+import { writeFileSync } from 'fs'
+import pkg from './package.js'
+
+export default () => {
+  writeFileSync('package.json', JSON.stringify(pkg, null, 2) + '\n')
+}

package/tsconfig/esm.json

@@ -0,0 +1,7 @@
+{
+  "extends": "../tsconfig.json",
+  "include": ["../src/**/*.ts"],
+  "compilerOptions": {
+    "outDir": "../.tshy-build-tmp/esm"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "jsx": "react",
+    "declaration": true,
+    "declarationMap": true,
+    "inlineSources": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "moduleResolution": "nodenext",
+    "resolveJsonModule": true,
+    "skipLibCheck": true,
+    "sourceMap": true,
+    "strict": true,
+    "target": "es2022",
+    "module": "nodenext"
+  }
+}

package/typedoc.json

@@ -0,0 +1,7 @@
+{
+  "tsconfig": "./tsconfig/esm.json",
+  "entryPoints": ["./src/**/*.+(ts|tsx|mts|cts)"],
+  "navigationLinks": {
+    "isaacs projects": "https://isaacs.github.io/"
+  }
+}