itty-packager 1.0.0

package/bin/itty.js

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+
+import { parseArgs } from 'node:util'
+
+const subcommands = {
+  build: () => import('../lib/commands/build.js').then(m => m.buildCommand),
+  // Future subcommands can be added here:
+  // release: () => import('../lib/commands/release.js').then(m => m.releaseCommand),
+  // deploy: () => import('../lib/commands/deploy.js').then(m => m.deployCommand),
+}
+
+const { positionals, values: globalArgs } = parseArgs({
+  args: process.argv.slice(2),
+  options: {
+    help: {
+      type: 'boolean',
+      short: 'h',
+      description: 'Show help'
+    },
+    version: {
+      type: 'boolean',
+      short: 'v',
+      description: 'Show version'
+    }
+  },
+  allowPositionals: true,
+  strict: false
+})
+
+async function main() {
+  const subcommand = positionals[0]
+
+  if (globalArgs.version) {
+    const pkg = await import('../package.json', { with: { type: 'json' } })
+    console.log(pkg.default.version)
+    process.exit(0)
+  }
+
+  if (!subcommand) {
+    showHelp()
+    process.exit(0)
+  }
+
+  // If global help is requested but there's a subcommand, let the subcommand handle it
+  if (globalArgs.help && !subcommands[subcommand]) {
+    showHelp()
+    process.exit(0)
+  }
+
+  if (!subcommands[subcommand]) {
+    console.error(`❌ Unknown subcommand: ${subcommand}`)
+    console.error(`Available subcommands: ${Object.keys(subcommands).join(', ')}`)
+    process.exit(1)
+  }
+
+  try {
+    const commandModule = await subcommands[subcommand]()
+    const remainingArgs = process.argv.slice(3) // Remove 'node', 'itty.js', and subcommand
+    await commandModule(remainingArgs)
+  } catch (error) {
+    console.error('❌ Command failed:', error.message)
+    process.exit(1)
+  }
+}
+
+function showHelp() {
+  console.log(`
+itty - Universal toolkit for itty libraries
+
+Usage: itty <subcommand> [options]
+
+Subcommands:
+  build     Build your library with rollup and typescript
+
+Global Options:
+  -h, --help      Show help
+  -v, --version   Show version
+
+Examples:
+  itty build --snippet=connect --hybrid    # Build with snippet and CJS support
+  itty build --sourcemap --no-minify      # Build with sourcemaps, no minification
+  itty build --help                       # Show build-specific help
+
+Run 'itty <subcommand> --help' for subcommand-specific options.
+`)
+}
+
+main().catch(error => {
+  console.error('❌ Unexpected error:', error.message)
+  process.exit(1)
+})

package/lib/builder.js

@@ -0,0 +1,217 @@
+import terser from '@rollup/plugin-terser'
+import typescript from '@rollup/plugin-typescript'
+import fs from 'fs-extra'
+import { globby } from 'globby'
+import { rollup } from 'rollup'
+import bundleSize from 'rollup-plugin-bundle-size'
+import copy from 'rollup-plugin-copy'
+import { rimraf } from 'rimraf'
+import path from 'path'
+
+const DEFAULT_IGNORE_PATTERNS = ['**/*.spec.ts', '**/types.ts', '**/*.ignore.*.ts']
+
+export async function build(options = {}) {
+  const {
+    from = 'src',
+    out = 'dist',
+    copy: copyFiles = 'LICENSE',
+    snippet,
+    sourcemap = false,
+    hybrid = false,
+    minify = true
+  } = options
+
+  console.log(`📦 Building from ${from}/ to ${out}/`)
+  
+  // Clean output directory
+  await rimraf(out)
+  await fs.ensureDir(out)
+
+  // Scan files to build
+  const pattern = `./${from}/*.ts`
+  const files = (await globby(pattern, {
+    ignore: DEFAULT_IGNORE_PATTERNS,
+  })).map(filePath => ({
+    path: filePath,
+    name: path.basename(filePath, '.ts'),
+    shortPath: filePath.replace(new RegExp(`(/${from})|(\.ts)`, 'g'), '').replace('./index', '.'),
+    esm: path.join(out, path.basename(filePath, '.ts') + '.mjs'),
+    cjs: path.join(out, path.basename(filePath, '.ts') + '.cjs'),
+    types: path.join(out, path.basename(filePath, '.ts') + '.d.ts'),
+  })).sort((a, b) => a.shortPath.toLowerCase() < b.shortPath.toLowerCase() ? -1 : 1)
+
+  if (files.length === 0) {
+    throw new Error(`No TypeScript files found in ${from}/`)
+  }
+
+  console.log(`📄 Found ${files.length} file(s):`, files.map(f => f.name).join(', '))
+
+  // Determine export strategy
+  const isSingleFile = files.length === 1
+  const pkg = await fs.readJSON('./package.json')
+
+  // Update package.json exports
+  if (isSingleFile) {
+    // Single file maps to root export
+    const file = files[0]
+    const exportObj = {
+      import: `./${out}/${path.basename(file.esm)}`,
+      types: `./${out}/${path.basename(file.types)}`,
+    }
+    
+    // Add CJS export only if hybrid mode is enabled
+    if (hybrid) {
+      exportObj.require = `./${out}/${path.basename(file.cjs)}`
+    }
+    
+    pkg.exports = {
+      '.': exportObj
+    }
+  } else {
+    // Multiple files get individual exports
+    pkg.exports = files.reduce((acc, file) => {
+      const exportObj = {
+        import: `./${out}/${path.basename(file.esm)}`,
+        types: `./${out}/${path.basename(file.types)}`,
+      }
+      
+      // Add CJS export only if hybrid mode is enabled
+      if (hybrid) {
+        exportObj.require = `./${out}/${path.basename(file.cjs)}`
+      }
+      
+      acc[file.shortPath] = exportObj
+      return acc
+    }, {})
+  }
+
+  // Write updated package.json
+  await fs.writeJSON('./package.json', pkg, { spaces: 2 })
+
+  // Build files with rollup
+  const builds = []
+  
+  for (const file of files) {
+    // Determine outputs based on hybrid mode
+    const outputs = [
+      {
+        format: 'esm',
+        file: file.esm,
+        sourcemap,
+      }
+    ]
+    
+    // Add CJS output only if hybrid mode is enabled
+    if (hybrid) {
+      outputs.push({
+        format: 'cjs',
+        file: file.cjs,
+        sourcemap,
+      })
+    }
+    
+    // Build plugins array
+    const plugins = [
+      typescript({ sourceMap: sourcemap }),
+      bundleSize(),
+    ]
+    
+    // Add terser only if minify is enabled
+    if (minify) {
+      plugins.splice(1, 0, terser()) // Insert terser before bundleSize
+    }
+    
+    const config = {
+      input: file.path,
+      output: outputs,
+      plugins,
+    }
+
+    // Add copy plugin only to the first build to avoid conflicts
+    if (file === files[0] && copyFiles) {
+      const copyTargets = copyFiles.split(',').map(f => f.trim()).map(src => ({ src, dest: out }))
+      config.plugins.push(copy({ targets: copyTargets }))
+    }
+
+    builds.push(config)
+  }
+
+  // Add snippet build if requested
+  if (snippet) {
+    const snippetFile = files.find(f => f.name === snippet)
+    if (!snippetFile) {
+      throw new Error(`Snippet file "${snippet}" not found. Available files: ${files.map(f => f.name).join(', ')}`)
+    }
+
+    const snippetPlugins = [typescript()]
+    
+    // Add terser to snippet only if minify is enabled
+    if (minify) {
+      snippetPlugins.push(terser())
+    }
+    
+    builds.push({
+      input: snippetFile.path,
+      output: {
+        file: path.join(out, `${snippet}.snippet.js`),
+        format: 'esm',
+        name: snippet,
+      },
+      plugins: snippetPlugins,
+    })
+  }
+
+  // Execute all builds
+  for (const config of builds) {
+    const bundle = await rollup(config)
+    
+    if (Array.isArray(config.output)) {
+      for (const output of config.output) {
+        await bundle.write(output)
+      }
+    } else {
+      await bundle.write(config.output)
+    }
+    
+    await bundle.close()
+  }
+
+  // Handle README snippet injection if requested
+  if (snippet) {
+    await injectSnippet(snippet, out)
+  }
+
+  console.log(`✨ Build completed: ${files.length} file(s) built to ${out}/`)
+}
+
+async function injectSnippet(snippetName, outDir) {
+  const snippetPath = path.join(outDir, `${snippetName}.snippet.js`)
+  
+  if (!await fs.pathExists(snippetPath)) {
+    console.warn(`⚠️  Snippet file not found: ${snippetPath}`)
+    return
+  }
+
+  const transformCode = code => code
+    .replace(/^let\s+(\w+)\s*=/, `let ${snippetName}=`)
+    .replace(/;export\s*{[^}]+};?\s*$/, ';')
+
+  const snippet = await fs.readFile(snippetPath, 'utf-8')
+  const transformed = transformCode(snippet).trim()
+
+  // Remove snippet file
+  await fs.unlink(snippetPath)
+
+  // Update README if it exists
+  const readmePath = './README.md'
+  if (await fs.pathExists(readmePath)) {
+    const readme = await fs.readFile(readmePath, 'utf-8')
+    const newReadme = readme.replace(
+      /(<!-- BEGIN SNIPPET -->[\r\n]+```(?:js|ts)[\r\n]).*?([\r\n]```[\r\n]+<!-- END SNIPPET -->)/s,
+      `$1${transformed}$2`
+    )
+    
+    await fs.writeFile(readmePath, newReadme)
+    console.log(`📝 README.md updated with ${snippetName} snippet`)
+  }
+}

package/lib/commands/build.js

@@ -0,0 +1,96 @@
+import { parseArgs } from 'node:util'
+import { build } from '../builder.js'
+
+export async function buildCommand(args) {
+  const { values: buildArgs } = parseArgs({
+    args,
+    options: {
+      snippet: {
+        type: 'string',
+        short: 's',
+        description: 'Generate snippet file for README injection'
+      },
+      from: {
+        type: 'string',
+        short: 'f',
+        default: 'src',
+        description: 'Source directory (default: src)'
+      },
+      out: {
+        type: 'string',
+        short: 'o',
+        default: 'dist',
+        description: 'Output directory (default: dist)'
+      },
+      copy: {
+        type: 'string',
+        short: 'c',
+        default: 'LICENSE',
+        description: 'Files to copy to output (default: LICENSE)'
+      },
+      sourcemap: {
+        type: 'boolean',
+        description: 'Generate source maps (default: false)'
+      },
+      hybrid: {
+        type: 'boolean',
+        description: 'Build both ESM and CJS (default: ESM only)'
+      },
+      minify: {
+        type: 'boolean',
+        description: 'Minify output with terser (default: true)'
+      },
+      'no-minify': {
+        type: 'boolean',
+        description: 'Skip minification'
+      },
+      help: {
+        type: 'boolean',
+        short: 'h',
+        description: 'Show help'
+      }
+    },
+    allowPositionals: false
+  })
+
+  if (buildArgs.help) {
+    console.log(`
+itty build - Build your library with rollup and typescript
+
+Usage: itty build [options]
+
+Options:
+  -s, --snippet <name>    Generate snippet file for README injection
+  -f, --from <dir>        Source directory (default: src)
+  -o, --out <dir>         Output directory (default: dist)
+  -c, --copy <files>      Files to copy to output (default: LICENSE)
+      --sourcemap         Generate source maps (default: false)
+      --hybrid            Build both ESM and CJS (default: ESM only)
+      --minify            Minify output with terser (default: true)
+      --no-minify         Skip minification
+  -h, --help              Show help
+
+Examples:
+  itty build                              # Build ESM only, minified, no sourcemaps
+  itty build --snippet=connect           # Build with connect snippet generation
+  itty build --hybrid --sourcemap        # Build both ESM/CJS with sourcemaps
+  itty build --no-minify                 # Build without minification
+  itty build --from=lib --out=build      # Build from lib/ to build/
+`)
+    return
+  }
+
+  // Handle minify logic (default true, but --no-minify overrides)
+  if (buildArgs['no-minify']) {
+    buildArgs.minify = false
+  } else if (buildArgs.minify === undefined) {
+    buildArgs.minify = true
+  }
+
+  try {
+    await build(buildArgs)
+    console.log('✅ Build completed successfully')
+  } catch (error) {
+    throw new Error(`Build failed: ${error.message}`)
+  }
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "itty-packager",
+  "version": "1.0.0",
+  "description": "Universal build tool for itty libraries",
+  "type": "module",
+  "bin": {
+    "itty": "./bin/itty.js"
+  },
+  "scripts": {
+    "dev": "node bin/itty-packager.js",
+    "test": "echo 'No tests yet'"
+  },
+  "keywords": [
+    "build",
+    "rollup",
+    "typescript",
+    "itty"
+  ],
+  "author": "Kevin R. Whitley <krwhitley@gmail.com>",
+  "license": "MIT",
+  "dependencies": {
+    "@rollup/plugin-terser": "^0.4.4",
+    "@rollup/plugin-typescript": "^11.1.6",
+    "fs-extra": "^11.2.0",
+    "globby": "^14.1.0",
+    "rimraf": "^6.0.1",
+    "rollup": "^4.28.1",
+    "rollup-plugin-bundle-size": "^1.0.3",
+    "rollup-plugin-copy": "^3.5.0",
+    "tslib": "^2.8.1",
+    "typescript": "^5.7.2"
+  }
+}