esm.dev 2.0.4 → 2.0.6

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.trim())
+                ignoreList.push(line.trim());
+        return {
+            basename,
+            ignoreList,
+        };
+    }
+}

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "esm.dev",
-  "version": "2.0.4",
+  "version": "2.0.6",
   "description": "TypeScript library template",
   "type": "module",
   "sideEffects": false,
   "exports": {
-    ".": "./src/cli.ts"
+    ".": "./dist/lib/index.js"
   },
   "bin": {
-    "esm.dev": "./src/cli.ts"
+    "esm.dev": "./dist/cli.js"
   },
   "scripts": {
     "build": "npm run clean && tsc",

package/src/cli.ts

@@ -1,21 +0,0 @@
-#!/usr/bin/env node
-import { runExit } from 'clipanion'
-import { WatchCommand } from './commands/WatchCommand.ts'
-import { RepublishCommand } from './commands/RepublishCommand.ts'
-import { LoginCommand } from './commands/LoginCommand.ts'
-import { TokenCommand } from './commands/TokenCommand.ts'
-import { WaitForRegistryCommand } from './commands/WaitForRegistryCommand.ts'
-import { StartCommand } from './commands/StartCommand.ts'
-import { InitCommand } from './commands/InitCommand.ts'
-import { VersionCommand } from './commands/VersionCommand.ts'
-
-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.ts'
-import { ESMStorageSpecific } from './mixins/ESMStorageSpecific.ts'
-import { PackagePathSpecific } from './mixins/PackagePathSpecific.ts'
-
-export abstract class ESMDevCommand extends ESMStorageSpecific(
-  RegistrySpecific(PackagePathSpecific(Command)),
-) {}

package/src/commands/InitCommand.ts

@@ -1,71 +0,0 @@
-import { PackagePathSpecific } from './mixins/PackagePathSpecific.ts'
-import { MustacheGeneratorCommand } from './MustacheGeneratorCommand.ts'
-import { Option } from 'clipanion'
-import { isNumber } from 'typanion'
-
-export class InitCommand extends PackagePathSpecific(MustacheGeneratorCommand) {
-  static override paths = [['init']]
-
-  static override usage = this.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',
-    {
-      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.ts'
-
-export class LoginCommand extends RegistrySpecific(Command) {
-  static override paths = [['login']]
-
-  static override usage = this.Usage({
-    description: 'Login in to the NPM registry',
-  })
-
-  override async execute() {
-    const { login } = await import('../lib/login.ts')
-    return login(this.registry)
-  }
-}

package/src/commands/MustacheGeneratorCommand.ts

@@ -1,10 +0,0 @@
-import { GeneratorCommand } from 'clipanion-generator-command'
-import { MustacheGenerator } from '../lib/MustacheGenerator.ts'
-
-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.ts'
-
-export class RepublishCommand extends ESMDevCommand {
-  static override paths = [['republish']]
-
-  static override usage = this.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.ts')
-    await this.eachPackagePath((packagePath) => republish(packagePath, this))
-  }
-}

package/src/commands/StartCommand.ts

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

package/src/commands/TokenCommand.ts

@@ -1,29 +0,0 @@
-import { Command } from 'clipanion'
-import { RegistrySpecific } from './mixins/RegistrySpecific.ts'
-
-export class TokenCommand extends RegistrySpecific(Command) {
-  static override paths = [['token']]
-
-  static override usage = this.Usage({
-    description: 'Get the NPM token',
-  })
-
-  override async execute() {
-    const [{ default: escapeStringRegexp }, { readFile }] = await Promise.all([
-      import('escape-string-regexp'),
-      import('node:fs/promises'),
-    ])
-    const npmrc = await readFile('~/.npmrc', 'utf-8')
-    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,23 +0,0 @@
-import { Command } from 'clipanion'
-
-export class VersionCommand extends Command {
-  static override paths = [['version']]
-
-  static override usage = this.Usage({
-    description: 'Display the version of esm.dev',
-  })
-
-  override async execute(): Promise<number | void> {
-    const [path, { readFile }] = await Promise.all([
-      import('node:path'),
-      import('node:fs/promises'),
-    ])
-    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.ts'
-import { Retryable } from './mixins/Retryable.ts'
-
-export class WaitForRegistryCommand extends Retryable(
-  RegistrySpecific(Command),
-) {
-  static override paths = [['wait-for-registry'], ['wfr']]
-
-  static override usage = this.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.ts'
-import { Watchable } from './mixins/Watchable.ts'
-
-export class WatchCommand extends Watchable(ESMDevCommand) {
-  static override paths = [['watch']]
-
-  static override usage = this.Usage({
-    description: 'Watches directories and republishes on changes',
-  })
-
-  override async execute() {
-    const { watch } = await import('../lib/watch.ts')
-    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.ts'
-import type { CommandClass } from './CommandClass.ts'
-
-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.ts'
-import { EnvOption } from '../options/EnvOption.ts'
-
-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,18 +0,0 @@
-import { Option } from 'clipanion'
-import type { CommandClass } from './CommandClass.ts'
-
-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 glob(this.packagePaths)
-      await Promise.all(packagePaths.map(cb))
-    }
-  }
-
-  return PackagePathSpecific
-}

package/src/commands/mixins/RegistrySpecific.ts

@@ -1,12 +0,0 @@
-import type { CommandClass } from './CommandClass.ts'
-import { EnvOption } from '../options/EnvOption.ts'
-
-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,33 +0,0 @@
-import { Option } from 'clipanion'
-import { isNumber } from 'typanion'
-import type { CommandClass } from './CommandClass.ts'
-
-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 { EndpointUnavailableError, waitForEndpoint } = await import(
-        '../../lib/until.ts'
-      )
-      try {
-        await waitForEndpoint({ ...this, endpoint })
-      } catch (error) {
-        if (error instanceof EndpointUnavailableError) {
-          this.context.stderr.write(`${endpoint} is not available\n`)
-          return 1
-        } else throw error
-      }
-    }
-  }
-
-  return Retryable
-}

package/src/commands/mixins/Servable.ts

@@ -1,14 +0,0 @@
-import { isNumber } from 'typanion'
-import { EnvOption } from '../options/EnvOption.ts'
-import type { CommandClass } from './CommandClass.ts'
-
-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.ts'
-
-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/commands/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 })
-}

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): 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,29 +0,0 @@
-import { spawn } from 'node:child_process'
-
-export function login(registry: string): Promise<number> {
-  return new Promise((resolve) => {
-    const child = spawn('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
-}): Promise<void> {
-  await $({
-    cwd: path.resolve(packageRoot),
-  })`npm publish --registry ${registry}`
-}

package/src/lib/queue.ts

@@ -1,65 +0,0 @@
-import { debounce, Mutex } from 'es-toolkit'
-
-const mutex = new Mutex()
-
-export async function queue<TResult>(
-  fn: () => Promise<TResult>,
-  signal?: AbortSignal,
-): Promise<TResult> {
-  await mutex.acquire()
-  try {
-    signal?.throwIfAborted()
-    return await fn()
-  } finally {
-    mutex.release()
-  }
-}
-
-/**
- * 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<Awaited<R>> {
-  let promiseWithResolvers: PromiseWithResolvers<R> | undefined
-  let queuedPromise: Promise<Awaited<R>> | undefined
-
-  signal?.addEventListener('abort', (reason) => {
-    debounced.cancel()
-    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,
-    { signal },
-  )
-
-  return (...args: Args) => {
-    const promise = start()
-    debounced(...args)
-    return promise as Promise<Awaited<R>>
-  }
-
-  function start() {
-    if (!queuedPromise) {
-      promiseWithResolvers = Promise.withResolvers<R>()
-      queuedPromise = queue(
-        async () => promiseWithResolvers?.promise,
-      ) as Promise<Awaited<R>>
-    }
-    return queuedPromise
-  }
-}

package/src/lib/republish.ts

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