esm.dev 1.7.3 → 1.8.0

package/dist/lib/watch.js

@@ -5,6 +5,7 @@ import { readFile, writeFile } from 'node:fs/promises';
 import { createHash } from 'node:crypto';
 import { glob } from 'glob';
 import { queue, queuedDebounce } from './queue.js';
+import { getWatchIgnorer } from './watchIgnoreList.js';
 export async function watch(packagePath, opts) {
     const { name, packageRoot, private: prvte, } = await getPackageMeta(packagePath);
     if (prvte) {
@@ -29,7 +30,9 @@ export async function watch(packagePath, opts) {
         };
     }
     else {
-        const watcher = fsWatch(packageRoot, { recursive: true }, (_, filename) => debounceRepublish(filename ?? ''));
+        const ignorer = await getWatchIgnorer(packagePath);
+        const watcher = fsWatch(packageRoot, { recursive: true }, (_, filename) => (filename && ignorer.ignores(filename)) ||
+            debounceRepublish(filename ?? ''));
         return () => {
             console.info('stop watching');
             watcher.close();
@@ -38,7 +41,8 @@ export async function watch(packagePath, opts) {
     }
 }
 async function legacyWatch(dirname, cb) {
-    const filename = await hashDirectory(dirname);
+    const ignorer = await getWatchIgnorer(dirname);
+    const filename = await hashDirectory(dirname, ignorer);
     const watcher = watchFile(filename, cb);
     let timer;
     beginTimer();
@@ -47,12 +51,14 @@ async function legacyWatch(dirname, cb) {
         clearTimeout(timer);
     };
     function beginTimer() {
-        timer = setTimeout(() => hashDirectory(dirname).catch(console.error).finally(beginTimer), 1_000);
+        timer = setTimeout(() => hashDirectory(dirname, ignorer)
+            .catch(console.error)
+            .finally(beginTimer), 1_000);
     }
 }
-async function hashDirectory(dirname) {
+async function hashDirectory(dirname, ignorer) {
     const filename = `/tmp/${dirname.replace(/\//g, '-')}.hash.txt`;
-    const files = await glob(`${dirname}/**/*`, { nodir: true });
+    const files = ignorer.filter(await glob(`${dirname}/**/*`, { nodir: true }));
     const hashes = await Promise.all(files.map(async (file) => {
         const contents = await readFile(file, 'utf-8');
         return createHash('sha256').update(contents).digest('hex');

package/dist/lib/watchIgnoreList.js

@@ -0,0 +1,50 @@
+import gitignore from 'ignore';
+import { Minimatch } from 'minimatch';
+import { createReadStream } from 'node:fs';
+import { access, constants } from 'node:fs/promises';
+import * as path from 'node:path';
+import { createInterface as createReadlineInterface } from 'node:readline/promises';
+export async function getWatchIgnorer(dirname) {
+    const ignoreList = await getIgnoreList(dirname);
+    return ignoreList?.basename === '.gitignore'
+        ? createGitIgnore(ignoreList.ignoreList)
+        : ignoreList?.basename === '.npmignore'
+            ? createNPMIgnore(ignoreList.ignoreList)
+            : createNullIgnore();
+}
+function createNullIgnore() {
+    return { ignores: () => false, filter: (filenames) => filenames };
+}
+function createNPMIgnore(list) {
+    const mms = list.map((pattern) => new Minimatch(pattern));
+    const ignores = (filename) => mms.some((mm) => mm.match(filename));
+    return {
+        ignores,
+        filter: (filenames) => filenames.filter((filename) => !ignores(filename)),
+    };
+}
+function createGitIgnore(list) {
+    return gitignore().add(list);
+}
+async function getIgnoreList(dirname) {
+    for (const basename of ['.npmignore', '.gitignore']) {
+        const filename = path.join(dirname, basename);
+        try {
+            await access(filename, constants.F_OK);
+        }
+        catch (error) {
+            continue;
+        }
+        const rl = createReadlineInterface({
+            input: createReadStream(filename),
+        });
+        const ignoreList = [];
+        for await (const line of rl)
+            if (line)
+                ignoreList.push(line.trim());
+        return {
+            basename,
+            ignoreList,
+        };
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "esm.dev",
-  "version": "1.7.3",
+  "version": "1.8.0",
   "description": "TypeScript library template",
   "type": "module",
   "sideEffects": false,
@@ -16,7 +16,8 @@
     "esm.dev": "bun ./src/cli.ts",
     "prepare": "husky",
     "start": "docker compose up --detach --remove-orphans",
-    "stop": "docker compose down"
+    "stop": "docker compose down",
+    "test": "find . -name \"*.test.ts\" -exec sh -c 'bun test \"$1\" || kill \"$PPID\"' sh {} \\;"
   },
   "repository": {
     "type": "git",
@@ -52,18 +53,20 @@
   },
   "dependencies": {
     "clipanion": "^4.0.0-rc.4",
-    "clipanion-generator-command": "^1.3.0",
+    "clipanion-generator-command": "^1.3.1",
     "escape-string-regexp": "^5.0.0",
     "glob": "^11.0.2",
     "http-proxy": "^1.18.1",
+    "ignore": "^7.0.4",
     "lodash.debounce": "^4.0.8",
+    "minimatch": "^10.0.1",
     "mustache": "^4.2.0",
-    "npm": "^11.4.0",
+    "npm": "^11.4.1",
     "ramda": "^0.30.1",
     "throat": "^6.0.2",
     "tslib": "^2.8.1",
     "typanion": "^3.14.0",
-    "zod": "^3.25.13",
+    "zod": "^3.25.23",
     "zx": "^8.5.4"
   }
 }

package/.prettierignore

@@ -1,4 +0,0 @@
-dist
-*.log
-.pnp.cjs
-.yarn/*

package/commitlint.config.cjs

@@ -1,8 +0,0 @@
-// @ts-check
-
-/**
- * @type {import('@commitlint/types').UserConfig}
- */
-module.exports = {
-  extends: ['@commitlint/config-conventional'],
-}

package/docker-bake.hcl

@@ -1,24 +0,0 @@
-group "default" {
-  targets = ["app"]
-}
-
-variable "TAG" {
-  validation {
-    condition = TAG == regex("^(?:\\d+\\.\\d+\\.\\d+)?$", TAG)
-    error_message = "The variable 'TAG' has to be in the 'x.x.x' format."
-  }
-}
-
-variable "IMAGE" {
-  default = "ghcr.io/johngeorgewright/esm.dev"
-}
-
-target "app" {
-  context = "."
-  dockerfile = "Dockerfile"
-  platforms = ["linux/amd64", "linux/arm64"]
-  tags = [
-    "${IMAGE}:latest",
-    notequal("", TAG) ? "${IMAGE}:${TAG}" : ""
-  ]
-}

package/src/cli.ts

@@ -1,21 +0,0 @@
-#!/usr/bin/env node
-import { runExit } from 'clipanion'
-import { WatchCommand } from './commands/WatchCommand.js'
-import { RepublishCommand } from './commands/RepublishCommand.js'
-import { LoginCommand } from './commands/LoginCommand.js'
-import { TokenCommand } from './commands/TokenCommand.js'
-import { WaitForRegistryCommand } from './commands/WaitForRegistryCommand.js'
-import { StartCommand } from './commands/StartCommand.js'
-import { InitCommand } from './commands/InitCommand.js'
-import { VersionCommand } from './commands/VersionCommand.js'
-
-runExit([
-  InitCommand,
-  LoginCommand,
-  TokenCommand,
-  RepublishCommand,
-  StartCommand,
-  VersionCommand,
-  WaitForRegistryCommand,
-  WatchCommand,
-])

package/src/commands/ESMDevCommand.ts

@@ -1,8 +0,0 @@
-import { Command } from 'clipanion'
-import { RegistrySpecific } from './mixins/RegistrySpecific.js'
-import { ESMStorageSpecific } from './mixins/ESMStorageSpecific.js'
-import { PackagePathSpecific } from './mixins/PackagePathSpecific.js'
-
-export abstract class ESMDevCommand extends ESMStorageSpecific(
-  RegistrySpecific(PackagePathSpecific(Command)),
-) {}

package/src/commands/InitCommand.ts

@@ -1,72 +0,0 @@
-import { ESMDevCommand } from './ESMDevCommand.js'
-import { PackagePathSpecific } from './mixins/PackagePathSpecific.js'
-import { MustacheGeneratorCommand } from './MustacheGeneratorCommand.js'
-import { Option } from 'clipanion'
-import { isNumber } from 'typanion'
-
-export class InitCommand extends PackagePathSpecific(MustacheGeneratorCommand) {
-  static override paths = [['init']]
-
-  static override usage = ESMDevCommand.Usage({
-    description: 'Initialises your repo ready to work with ESM.sh locally',
-    examples: [
-      ['Create a minimal template', 'esm.dev init'],
-      ["Specify the packages you're developing", 'esm.dev init packages/*'],
-      [
-        'Specify different ports',
-        'esm.dev init --port 3001 --esm-port 8081 --registry-port 4444',
-      ],
-    ],
-  })
-
-  readonly esmPort = Option.String('-e,--esm-port', '8080', {
-    description: 'The port of the ESM Server',
-    validator: isNumber(),
-  })
-
-  readonly esmStoragePath = Option.String(
-    '-s,--esm-storage-path',
-    './docker-storage/esm/esmd',
-    {
-      description: "Path to ESM.sh's storage",
-    },
-  )
-
-  readonly port = Option.String('-p,--port', '3000', {
-    description: "The server's port",
-  })
-
-  readonly outputDirectory = Option.String('-o,--output-dir', '.', {
-    description: 'The output directory',
-  })
-
-  readonly registryPort = Option.String('-r,--registry-port', '4873', {
-    description: 'The port of your local registry',
-    validator: isNumber(),
-  })
-
-  esmURL!: URL
-  npmRegistryURL!: URL
-  packages!: { path: string; basename: string }[]
-
-  override async execute() {
-    const path = await import('node:path')
-    this.templateDir = path.resolve(
-      import.meta.dirname,
-      '..',
-      '..',
-      'templates',
-      'init',
-    )
-    this.destinationDir = this.outputDirectory
-    this.packages = this.packagePaths.map((packagePath) => ({
-      path: packagePath,
-      basename: path.basename(packagePath),
-    }))
-    await this.removeDestinationFile(
-      'docker-compose.yaml',
-      'docker-compose.yml.mustache',
-    )
-    await super.execute()
-  }
-}

package/src/commands/LoginCommand.ts

@@ -1,15 +0,0 @@
-import { Command } from 'clipanion'
-import { RegistrySpecific } from './mixins/RegistrySpecific.js'
-
-export class LoginCommand extends RegistrySpecific(Command) {
-  static override paths = [['login']]
-
-  static override usage = Command.Usage({
-    description: 'Login in to the NPM registry',
-  })
-
-  override async execute() {
-    const { login } = await import('../lib/login.js')
-    return login(this.registry)
-  }
-}

package/src/commands/MustacheGeneratorCommand.ts

@@ -1,10 +0,0 @@
-import { GeneratorCommand } from 'clipanion-generator-command'
-import { MustacheGenerator } from '../lib/MustacheGenerator.js'
-
-export abstract class MustacheGeneratorCommand extends GeneratorCommand {
-  override get generator() {
-    return new MustacheGenerator(this.templateDir, this.destinationDir, [
-      '.mustache',
-    ])
-  }
-}

package/src/commands/RepublishCommand.ts

@@ -1,15 +0,0 @@
-import { ESMDevCommand } from './ESMDevCommand.js'
-
-export class RepublishCommand extends ESMDevCommand {
-  static override paths = [['republish']]
-
-  static override usage = ESMDevCommand.Usage({
-    description:
-      'Removes the references, of given packages, from the ESM server and registry and republishes.',
-  })
-
-  override async execute() {
-    const { republish } = await import('../lib/republish.js')
-    await this.eachPackagePath((packagePath) => republish(packagePath, this))
-  }
-}

package/src/commands/StartCommand.ts

@@ -1,21 +0,0 @@
-import { ESMDevCommand } from './ESMDevCommand.js'
-import { Servable } from './mixins/Servable.js'
-import { Watchable } from './mixins/Watchable.js'
-import { ESMServed } from './mixins/ESMServed.js'
-
-export class StartCommand extends Servable(
-  Watchable(ESMServed(ESMDevCommand)),
-) {
-  static override paths = [['start']]
-
-  static override usage = ESMDevCommand.Usage({
-    description: 'Runs a server and concurrently watches a file system',
-  })
-
-  override async execute() {
-    const { watch } = await import('../lib/watch.js')
-    const { serve } = await import('../lib/server.js')
-    serve(this.port, this.esmOrigin)
-    await this.eachPackagePath((packagePath) => watch(packagePath, this))
-  }
-}

package/src/commands/TokenCommand.ts

@@ -1,26 +0,0 @@
-import { Command } from 'clipanion'
-import { RegistrySpecific } from './mixins/RegistrySpecific.js'
-
-export class TokenCommand extends RegistrySpecific(Command) {
-  static override paths = [['token']]
-
-  static override usage = Command.Usage({
-    description: 'Get the NPM token',
-  })
-
-  override async execute() {
-    const { default: escapeStringRegexp } = await import('escape-string-regexp')
-    const npmrc = await Bun.file(`~/.npmrc`).text()
-    const url = new URL(this.registry)
-    const regex = new RegExp(
-      `^//${escapeStringRegexp(url.hostname)}/:_authToken=(.*)$`,
-      'm',
-    )
-    const match = regex.exec(npmrc)
-    if (!match) {
-      this.context.stderr.write(`Token has not been created yet\n`)
-      return 1
-    }
-    this.context.stdout.write(match[1] + '\n')
-  }
-}

package/src/commands/VersionCommand.ts

@@ -1,21 +0,0 @@
-import { Command } from 'clipanion'
-import { readFile } from 'node:fs/promises'
-
-export class VersionCommand extends Command {
-  static override paths = [['version']]
-
-  static override usage = Command.Usage({
-    description: 'Display the version of esm.dev',
-  })
-
-  override async execute(): Promise<number | void> {
-    const path = await import('node:path')
-    const pckg = JSON.parse(
-      await readFile(
-        path.resolve(import.meta.dirname, '..', '..', 'package.json'),
-        'utf-8',
-      ),
-    )
-    this.context.stdout.write(`${pckg.version}\n`)
-  }
-}

package/src/commands/WaitForRegistryCommand.ts

@@ -1,17 +0,0 @@
-import { Command } from 'clipanion'
-import { RegistrySpecific } from './mixins/RegistrySpecific.js'
-import { Retryable } from './mixins/Retryable.js'
-
-export class WaitForRegistryCommand extends Retryable(
-  RegistrySpecific(Command),
-) {
-  static override paths = [['wait-for-registry'], ['wfr']]
-
-  static override usage = Command.Usage({
-    description: 'wait for the registry to be online',
-  })
-
-  override async execute() {
-    return this.retry(this.registry)
-  }
-}

package/src/commands/WatchCommand.ts

@@ -1,15 +0,0 @@
-import { ESMDevCommand } from './ESMDevCommand.js'
-import { Watchable } from './mixins/Watchable.js'
-
-export class WatchCommand extends Watchable(ESMDevCommand) {
-  static override paths = [['watch']]
-
-  static override usage = ESMDevCommand.Usage({
-    description: 'Watches directories and republishes on changes',
-  })
-
-  override async execute() {
-    const { watch } = await import('../lib/watch.js')
-    await this.eachPackagePath((packagePath) => watch(packagePath, this))
-  }
-}

package/src/commands/mixins/CommandClass.ts

@@ -1,3 +0,0 @@
-import type { Command } from 'clipanion'
-
-export type CommandClass = abstract new (...args: any[]) => Command

package/src/commands/mixins/ESMServed.ts

@@ -1,12 +0,0 @@
-import { EnvOption } from '../../options/EnvOption.js'
-import type { CommandClass } from './CommandClass.js'
-
-export function ESMServed<T extends CommandClass>(Base: T) {
-  abstract class ESMServed extends Base {
-    readonly esmOrigin = EnvOption('ESM_ORIGIN', '-e,--esm-origin', {
-      description: 'The base URL of the ESM Server',
-    })
-  }
-
-  return ESMServed
-}

package/src/commands/mixins/ESMStorageSpecific.ts

@@ -1,16 +0,0 @@
-import type { CommandClass } from './CommandClass.js'
-import { EnvOption } from '../../options/EnvOption.js'
-
-export function ESMStorageSpecific<T extends CommandClass>(Base: T) {
-  abstract class ESMStorageSpecific extends Base {
-    readonly esmStoragePath = EnvOption(
-      'ESM_STORAGE_PATH',
-      '-s,--esm-storage-path',
-      {
-        description: "Path to ESM.sh's storage",
-      },
-    )
-  }
-
-  return ESMStorageSpecific
-}

package/src/commands/mixins/PackagePathSpecific.ts

@@ -1,22 +0,0 @@
-import { Option } from 'clipanion'
-import type { CommandClass } from './CommandClass.js'
-
-export function PackagePathSpecific<T extends CommandClass>(Base: T) {
-  abstract class PackagePathSpecific extends Base {
-    readonly packagePaths = Option.Rest({
-      name: 'packages',
-    })
-
-    protected async eachPackagePath(cb: (packagePath: string) => Promise<any>) {
-      const { glob } = await import('glob')
-      const packagePaths = (
-        await Promise.all(
-          this.packagePaths.map((packagePath) => glob(packagePath)),
-        )
-      ).flat()
-      await Promise.all(packagePaths.map(cb))
-    }
-  }
-
-  return PackagePathSpecific
-}

package/src/commands/mixins/RegistrySpecific.ts

@@ -1,12 +0,0 @@
-import type { CommandClass } from './CommandClass.js'
-import { EnvOption } from '../../options/EnvOption.js'
-
-export function RegistrySpecific<TBase extends CommandClass>(Base: TBase) {
-  abstract class RegistrySpecific extends Base {
-    readonly registry = EnvOption('NPM_REGISTRY', '-r,--registry', {
-      description: 'The URL of your local registry',
-    })
-  }
-
-  return RegistrySpecific
-}

package/src/commands/mixins/Retryable.ts

@@ -1,35 +0,0 @@
-import { Option } from 'clipanion'
-import { isNumber } from 'typanion'
-import type { CommandClass } from './CommandClass.js'
-
-export function Retryable<T extends CommandClass>(Base: T) {
-  abstract class Retryable extends Base {
-    readonly timeout = Option.String('-t,--timeout', '10000', {
-      description: 'The amount of total ms to keep trying for',
-      validator: isNumber(),
-    })
-
-    readonly interval = Option.String('-i,--interval', '300', {
-      description: 'The amount of ms inbetween each attempt',
-      validator: isNumber(),
-    })
-
-    protected async retry(endpoint: string) {
-      const { until } = await import('../../lib/until.js')
-      if (
-        !(await until({
-          ...this,
-          try: async (signal) => {
-            const response = await fetch(endpoint, { signal })
-            return response.ok
-          },
-        }))
-      ) {
-        this.context.stderr.write(`${endpoint} is not available\n`)
-        return 1
-      }
-    }
-  }
-
-  return Retryable
-}

package/src/commands/mixins/Servable.ts

@@ -1,14 +0,0 @@
-import { isNumber } from 'typanion'
-import { EnvOption } from '../../options/EnvOption.js'
-import type { CommandClass } from './CommandClass.js'
-
-export function Servable<T extends CommandClass>(Base: T) {
-  abstract class Servable extends Base {
-    readonly port = EnvOption('PORT', '-p,--port', {
-      description: 'The port to run the server on',
-      validator: isNumber(),
-    })
-  }
-
-  return Servable
-}

package/src/commands/mixins/Watchable.ts

@@ -1,13 +0,0 @@
-import { Option } from 'clipanion'
-import type { CommandClass } from './CommandClass.js'
-
-export function Watchable<T extends CommandClass>(Base: T) {
-  abstract class Watchable extends Base {
-    readonly legacyMethod = Option.Boolean('-l,--legacy-method', false, {
-      description:
-        'Use a less performant, legacy, watch method. Sometimes needed in docker or vagrant environments.',
-    })
-  }
-
-  return Watchable
-}

package/src/lib/MustacheGenerator.ts

@@ -1,10 +0,0 @@
-import Mustache from 'mustache'
-import { Generator } from 'clipanion-generator-command/Generator'
-
-export class MustacheGenerator extends Generator {
-  override renderTemplate(templateContext: any, template: string) {
-    return Mustache.render(template, templateContext, undefined, {
-      escape: (x) => x,
-    })
-  }
-}

package/src/lib/getPackageMeta.ts

@@ -1,15 +0,0 @@
-import { readFile, stat as getStat } from 'node:fs/promises'
-import * as path from 'node:path'
-
-export async function getPackageMeta(
-  packagePath: string,
-): Promise<{ name: string; packageRoot: string; private?: boolean }> {
-  const stat = await getStat(packagePath)
-  const packageRoot = stat.isDirectory()
-    ? packagePath
-    : path.dirname(packagePath)
-  const pckg = JSON.parse(
-    await readFile(path.join(packageRoot, 'package.json'), 'utf-8'),
-  )
-  return { name: pckg.name, packageRoot, private: pckg.private }
-}

package/src/lib/login.ts

@@ -1,35 +0,0 @@
-import { spawn } from 'node:child_process'
-
-export function login(registry: string) {
-  return new Promise<number>((resolve) => {
-    const child = spawn('bunx', [
-      'npm',
-      'login',
-      '--registry',
-      registry,
-      '--quiet',
-    ])
-
-    child.stderr.on('data', (d) => console.error(d.toString()))
-
-    child.stdout.on('data', (d) => {
-      const data = d.toString()
-      switch (true) {
-        case /username/i.test(data):
-          child.stdin.write('esm.dev\n')
-          break
-        case /password/i.test(data):
-          child.stdin.write('esm.dev\n')
-          break
-        case /email/i.test(data):
-          child.stdin.write('esm.dev@esm.dev.com')
-          break
-        case /logged in as/i.test(data):
-          child.stdin.end()
-          break
-      }
-    })
-
-    child.on('exit', resolve)
-  })
-}

package/src/lib/publish.ts

@@ -1,14 +0,0 @@
-import { $ } from 'zx'
-import * as path from 'node:path'
-
-export async function publish({
-  packageRoot,
-  registry,
-}: {
-  packageRoot: string
-  registry: string
-}) {
-  await $({
-    cwd: path.resolve(packageRoot),
-  })`bunx npm publish --registry ${registry}`
-}

package/src/lib/queue.ts

@@ -1,55 +0,0 @@
-import debounce from 'lodash.debounce'
-import throat from 'throat'
-
-export async function queue<TResult, TArgs extends any[] = []>(
-  signal: AbortSignal,
-  fn: (...args: TArgs) => Promise<TResult>,
-): Promise<TResult> {
-  return _queue((...args) => {
-    signal.throwIfAborted()
-    return fn(...(args as any))
-  })
-}
-
-const _queue = throat.default(1)
-
-/**
- * Just like debounce, but the first call will add a promise to the queue
- * and that promise won't resolve until the debounced function is finally called.
- */
-export function queuedDebounce<Args extends unknown[], R>(
-  fn: (...args: Args) => R,
-  delay: number,
-  signal: AbortSignal,
-): (...args: Args) => Promise<R> {
-  let promiseWithResolvers: PromiseWithResolvers<R> | undefined
-
-  signal.addEventListener('abort', (reason) =>
-    promiseWithResolvers?.reject(reason),
-  )
-
-  const debounced = debounce(async (...args: Args) => {
-    try {
-      const result = await fn(...args)
-      promiseWithResolvers?.resolve(result)
-    } catch (error: any) {
-      promiseWithResolvers?.reject(error)
-    } finally {
-      promiseWithResolvers = undefined
-    }
-  }, delay)
-
-  return (...args: Args) => {
-    const { promise } = start()
-    debounced(...args)
-    return promise
-  }
-
-  function start() {
-    if (!promiseWithResolvers) {
-      promiseWithResolvers = Promise.withResolvers<R>()
-      queue(signal, async () => promiseWithResolvers?.promise)
-    }
-    return promiseWithResolvers
-  }
-}

package/src/lib/republish.ts

@@ -1,16 +0,0 @@
-import { getPackageMeta } from './getPackageMeta.js'
-import { publish } from './publish.js'
-import { unpublish } from './unpublish.js'
-
-export async function republish(
-  packagePath: string,
-  opts: {
-    registry: string
-    esmStoragePath: string
-  },
-) {
-  console.info(`Republishing ${packagePath}`)
-  const { name, packageRoot } = await getPackageMeta(packagePath)
-  await unpublish({ ...opts, name })
-  await publish({ ...opts, packageRoot })
-}

package/src/lib/server.ts

@@ -1,40 +0,0 @@
-import { queue } from './queue.js'
-import { createServer } from 'node:http'
-import httpProxy from 'http-proxy'
-import { addAbortSignal } from 'node:stream'
-
-export function serve(port: number, esmOrigin: string) {
-  const proxy = httpProxy.createProxyServer()
-  const abortController = new AbortController()
-  const signal = abortController.signal
-
-  const server = createServer((req, res) => {
-    queue(
-      signal,
-      () =>
-        new Promise<void>((resolve, reject) => {
-          console.info('Proxying', req.url)
-          addAbortSignal(signal, req)
-          addAbortSignal(signal, res)
-          req.on('error', reject)
-          res.on('error', reject)
-          res.on('close', resolve)
-          proxy.web(req, res, { target: esmOrigin })
-        }),
-    ).catch((error) => {
-      res.statusCode = 500
-      res.setHeader('Content-Type', 'application/json; charset=utf-8')
-      res.write(JSON.stringify(error))
-      res.end()
-    })
-  }).listen(port, () => {
-    console.info('ESM proxy server listining on', server.address())
-  })
-
-  return () => {
-    console.info('closing the server')
-    abortController.abort()
-    server.closeAllConnections()
-    server.close()
-  }
-}

package/src/lib/unpublish.ts

@@ -1,41 +0,0 @@
-import { $, ProcessOutput } from 'zx'
-import { glob } from 'glob'
-import { rm } from 'node:fs/promises'
-
-export async function unpublish({
-  registry,
-  esmStoragePath,
-  name,
-}: {
-  registry: string
-  esmStoragePath: string
-  name: string
-}) {
-  await Promise.all([
-    unpublishPackage(registry, name),
-    deleteESMCache(esmStoragePath, name),
-  ])
-}
-
-async function unpublishPackage(registry: string, name: string) {
-  try {
-    await $`bunx npm unpublish --registry ${registry} --force ${name}`
-  } catch (error) {
-    if (
-      error instanceof ProcessOutput &&
-      !error.stderr.includes('npm error code E404')
-    )
-      throw error
-  }
-}
-
-async function deleteESMCache(esmStoragePath: string, name: string) {
-  await glob(`${esmStoragePath}/**/${name}@*`).then((paths) =>
-    Promise.all(
-      paths.map((path) => {
-        console.info('Deleting', path)
-        return rm(path, { recursive: true })
-      }),
-    ),
-  )
-}

package/src/lib/until.ts

@@ -1,22 +0,0 @@
-import { setTimeout } from 'node:timers/promises'
-
-export async function until({
-  interval,
-  timeout,
-  try: Try,
-}: {
-  interval: number
-  timeout: number
-  try(signal: AbortSignal): Promise<boolean>
-}) {
-  const signal = AbortSignal.timeout(timeout)
-  while (!signal.aborted) {
-    try {
-      if (await Try(signal)) return true
-    } catch (error) {}
-    try {
-      await setTimeout(interval, { signal })
-    } catch (error) {}
-  }
-  return false
-}

package/src/lib/watch.ts

@@ -1,100 +0,0 @@
-import { watch as fsWatch, watchFile, type StatsListener } from 'node:fs'
-import { republish } from './republish.js'
-import { getPackageMeta } from './getPackageMeta.js'
-import { readFile, writeFile } from 'node:fs/promises'
-import { createHash } from 'node:crypto'
-import { glob } from 'glob'
-import { queue, queuedDebounce } from './queue.js'
-
-export async function watch(
-  packagePath: string,
-  opts: { registry: string; esmStoragePath: string; legacyMethod?: boolean },
-): Promise<() => void> {
-  const {
-    name,
-    packageRoot,
-    private: prvte,
-  } = await getPackageMeta(packagePath)
-
-  if (prvte) {
-    console.info(`${name} is a private package... ignoring`)
-    return () => {}
-  }
-
-  console.info('Watching', packagePath)
-
-  const abortController = new AbortController()
-  const signal = abortController.signal
-
-  const republishPackage = () =>
-    republish(packagePath, opts).catch(console.error)
-
-  const debounceRepublish = queuedDebounce(
-    (filename: string = '') => {
-      console.info(`Change detected at ${packagePath}/${filename}`)
-      return republishPackage()
-    },
-    1_000,
-    signal,
-  )
-
-  await queue(signal, republishPackage)
-
-  if (opts.legacyMethod) {
-    const close = await legacyWatch(packagePath, () => debounceRepublish())
-    return () => {
-      console.info('stop watching')
-      close()
-      abortController.abort()
-    }
-  } else {
-    const watcher = fsWatch(packageRoot, { recursive: true }, (_, filename) =>
-      debounceRepublish(filename ?? ''),
-    )
-    return () => {
-      console.info('stop watching')
-      watcher.close()
-      abortController.abort()
-    }
-  }
-}
-
-async function legacyWatch(dirname: string, cb: StatsListener) {
-  const filename = await hashDirectory(dirname)
-  const watcher = watchFile(filename, cb)
-  let timer: NodeJS.Timeout | undefined
-  beginTimer()
-  return () => {
-    watcher.unref()
-    clearTimeout(timer)
-  }
-  function beginTimer() {
-    timer = setTimeout(
-      () => hashDirectory(dirname).catch(console.error).finally(beginTimer),
-      1_000,
-    )
-  }
-}
-
-async function hashDirectory(dirname: string) {
-  const filename = `/tmp/${dirname.replace(/\//g, '-')}.hash.txt`
-  const files = await glob(`${dirname}/**/*`, { nodir: true })
-  const hashes = await Promise.all(
-    files.map(async (file) => {
-      const contents = await readFile(file, 'utf-8')
-      return createHash('sha256').update(contents).digest('hex')
-    }),
-  )
-  const newHash = hashes.join('')
-
-  let previousHash = ''
-
-  try {
-    previousHash = await readFile(filename, 'utf-8')
-  } catch (error: any) {
-    if (error.code !== 'ENOENT') throw error
-  }
-
-  if (newHash !== previousHash) await writeFile(filename, newHash)
-  return filename
-}

package/src/options/EnvOption.ts

@@ -1,27 +0,0 @@
-import { Option } from 'clipanion'
-import type { StrictValidator } from 'typanion'
-
-/**
- * @see https://github.com/arcanis/clipanion/issues/174
- */
-export function EnvOption<T extends {}>(
-  envName: string,
-  descriptor: string,
-  opts: { description?: string; validator: StrictValidator<unknown, T> },
-): T
-
-export function EnvOption(
-  envName: string,
-  descriptor: string,
-  opts?: { description?: string },
-): string
-
-export function EnvOption<T extends {}>(
-  envName: string,
-  descriptor: string,
-  opts: { description?: string; validator?: StrictValidator<unknown, T> } = {},
-) {
-  return process.env[envName]
-    ? Option.String(descriptor, process.env[envName], opts)
-    : Option.String(descriptor, { ...opts, required: true })
-}