esm.dev 1.5.0

package/src/lib/unpublish.ts

@@ -0,0 +1,43 @@
+import { $ } from 'bun'
+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 $.ShellError &&
+        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

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1,84 @@
+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 republishPackage = () =>
+    republish(packagePath, opts).catch(console.error)
+
+  const debounceRepublish = queuedDebounce((filename: string = '') => {
+    console.info(`Change detected at ${packagePath}/${filename}`)
+    return republishPackage()
+  }, 1_000)
+
+  await queue(republishPackage)
+
+  if (opts.legacyMethod) {
+    return await legacyWatch(packagePath, () => debounceRepublish())
+  } else {
+    const watcher = fsWatch(packageRoot, { recursive: true }, (_, filename) =>
+      debounceRepublish(filename ?? ''),
+    )
+    return () => watcher.close()
+  }
+}
+
+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

@@ -0,0 +1,27 @@
+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 })
+}