esm.dev 2.0.4 → 2.0.6

package/src/lib/server.ts

@@ -1,43 +0,0 @@
-import { queue } from './queue.ts'
-import { createServer } from 'node:http'
-import httpProxy from 'http-proxy'
-
-export async function serve(
-  port: number,
-  esmOrigin: string,
-): Promise<() => Promise<void>> {
-  const proxy = httpProxy.createProxyServer()
-  const { promise, resolve } = Promise.withResolvers<void>()
-
-  const server = createServer((req, res) => {
-    queue(
-      () =>
-        new Promise<void>((resolve, reject) => {
-          console.info('Proxying', req.url)
-          req.on('error', reject)
-          res.on('error', reject)
-          res.on('close', resolve)
-          proxy.web(req, res, { followRedirects: true, 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())
-    resolve()
-  })
-
-  await promise
-
-  return () =>
-    new Promise<void>((resolve, reject) => {
-      console.info('closing the server')
-      server.close((error) => {
-        if (error) reject(error)
-        else resolve()
-      })
-    })
-}

package/src/lib/unpublish.ts

@@ -1,40 +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
-}): Promise<void> {
-  await Promise.all([
-    unpublishPackage(registry, name),
-    deleteESMCache(esmStoragePath, name),
-  ])
-}
-
-async function unpublishPackage(registry: string, name: string) {
-  try {
-    await $`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) {
-  const paths = await glob(`${esmStoragePath}/**/${name}@*`)
-  await Promise.all(
-    paths.map((path) => {
-      console.info('Deleting', path)
-      return rm(path, { recursive: true })
-    }),
-  )
-}

package/src/lib/until.ts

@@ -1,50 +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>
-}): Promise<boolean> {
-  const signal = AbortSignal.timeout(timeout)
-  while (!signal.aborted) {
-    try {
-      if (await Try(signal)) return true
-    } catch (error) {}
-    try {
-      await setTimeout(interval, null, { signal })
-    } catch (error) {}
-  }
-  return false
-}
-
-export async function waitForEndpoint({
-  interval = 300,
-  timeout = 10_000,
-  endpoint,
-}: {
-  interval?: number
-  timeout?: number
-  endpoint: string
-}): Promise<void> {
-  if (
-    !(await until({
-      interval,
-      timeout,
-      async try(signal) {
-        const response = await fetch(endpoint, { signal })
-        return response.ok
-      },
-    }))
-  )
-    throw new EndpointUnavailableError()
-}
-
-export class EndpointUnavailableError extends Error {
-  constructor() {
-    super('Endpoint not available')
-  }
-}

package/src/lib/watch.ts

@@ -1,138 +0,0 @@
-import { watch as fsWatch } from 'node:fs'
-import { republish } from './republish.ts'
-import { getPackageMeta } from './getPackageMeta.ts'
-import { readFile, writeFile } from 'node:fs/promises'
-import { createHash } from 'node:crypto'
-import { glob } from 'glob'
-import { queue, queuedDebounce } from './queue.ts'
-import { getWatchIgnorer, type Ignorer } from './watchIgnoreList.ts'
-import { tempfile } from 'zx'
-
-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', packageRoot)
-
-  const abortController = new AbortController()
-  const { signal } = abortController
-
-  const republishPackage = (filename: string = '') => {
-    console.info(`Change detected at ${packageRoot}/${filename}`)
-    return republish(packageRoot, opts).catch(console.error)
-  }
-
-  try {
-    await queue(republishPackage, signal)
-  } catch (error: any) {
-    if (error.name === 'AbortError') return () => {}
-    else throw error
-  }
-
-  return opts.legacyMethod
-    ? legacyWatch(abortController, packageRoot, republishPackage)
-    : modernWatch(
-        abortController,
-        packageRoot,
-        queuedDebounce(republishPackage, 1_000, signal),
-      )
-}
-
-async function modernWatch(
-  abortController: AbortController,
-  dirname: string,
-  republish: (filename?: string | undefined) => Promise<void>,
-) {
-  abortController.signal.addEventListener('abort', () => {
-    console.info('Stop watching', dirname)
-    watcher.close()
-  })
-
-  const ignorer = await getWatchIgnorer(dirname)
-  const watcher = fsWatch(
-    dirname,
-    { recursive: true, signal: abortController.signal },
-    (_, filename) =>
-      (filename && ignorer.ignores(filename)) ||
-      republish(filename ?? '').catch((error) => {
-        if (
-          !(error instanceof Event && error.target instanceof AbortSignal) &&
-          error.name !== 'AbortError'
-        )
-          throw error
-      }),
-  )
-
-  return () => abortController.abort()
-}
-
-async function legacyWatch(
-  abortController: AbortController,
-  dirname: string,
-  republish: (filename?: string) => Promise<void>,
-) {
-  const ignorer = await getWatchIgnorer(dirname)
-  const filename = tempfile()
-  await hashDirectory(dirname, ignorer, filename, () => {})
-
-  abortController.signal.addEventListener('abort', () => {
-    console.info('Stop (legacy) watching', dirname)
-    clearTimeout(timer)
-  })
-
-  let timer: NodeJS.Timeout | undefined
-  beginTimer()
-  return () => abortController.abort()
-
-  function beginTimer() {
-    timer = setTimeout(
-      () =>
-        hashDirectory(dirname, ignorer, filename, republish)
-          .catch(console.error)
-          .finally(beginTimer),
-      1_000,
-    )
-  }
-}
-
-async function hashDirectory(
-  dirname: string,
-  ignorer: Ignorer,
-  filename: string,
-  onChange: () => any,
-) {
-  const files = await glob(`${dirname}/**/*`, {
-    nodir: true,
-    ignore: { ignored: (path) => ignorer.ignores(path.fullpath()) },
-  })
-  const hashes = await Promise.all(
-    files.map(async (file) => {
-      const contents = await readFile(file)
-      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 Promise.all([writeFile(filename, newHash), onChange()])
-  }
-}

package/src/lib/watchIgnoreList.ts

@@ -1,61 +0,0 @@
-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: string): Promise<Ignorer> {
-  const ignoreList = await getIgnoreList(dirname)
-  return ignoreList?.basename === '.gitignore'
-    ? createGitIgnore(ignoreList.ignoreList)
-    : ignoreList?.basename === '.npmignore'
-      ? createNPMIgnore(ignoreList.ignoreList)
-      : createNullIgnore()
-}
-
-export interface Ignorer {
-  ignores(filename: string): boolean
-  filter(filenames: string[]): string[]
-}
-
-function createNullIgnore(): Ignorer {
-  return { ignores: () => false, filter: (filenames) => filenames }
-}
-
-function createNPMIgnore(list: string[]): Ignorer {
-  const mms = list.map((pattern) => new Minimatch(pattern))
-  const ignores = (filename: string) => mms.some((mm) => mm.match(filename))
-  return {
-    ignores,
-    filter: (filenames) => filenames.filter((filename) => !ignores(filename)),
-  }
-}
-
-function createGitIgnore(list: string[]): Ignorer {
-  return gitignore().add(list)
-}
-
-async function getIgnoreList(dirname: string) {
-  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: string[] = []
-    for await (const line of rl) if (line.trim()) ignoreList.push(line.trim())
-
-    return {
-      basename,
-      ignoreList,
-    }
-  }
-}