esm.dev 2.0.3 → 2.0.5

package/dist/cli.js

@@ -0,0 +1,20 @@
+#!/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/dist/commands/ESMDevCommand.js

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

package/dist/commands/InitCommand.js

@@ -0,0 +1,49 @@
+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 paths = [['init']];
+    static 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',
+            ],
+        ],
+    });
+    esmPort = Option.String('-e,--esm-port', '8080', {
+        description: 'The port of the ESM Server',
+        validator: isNumber(),
+    });
+    esmStoragePath = Option.String('-s,--esm-storage-path', './docker-storage/esm', {
+        description: "Path to ESM.sh's storage",
+    });
+    port = Option.String('-p,--port', '3000', {
+        description: "The server's port",
+    });
+    outputDirectory = Option.String('-o,--output-dir', '.', {
+        description: 'The output directory',
+    });
+    registryPort = Option.String('-r,--registry-port', '4873', {
+        description: 'The port of your local registry',
+        validator: isNumber(),
+    });
+    esmURL;
+    npmRegistryURL;
+    packages;
+    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/dist/commands/LoginCommand.js

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

package/dist/commands/MustacheGeneratorCommand.js

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

package/dist/commands/RepublishCommand.js

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

package/dist/commands/StartCommand.js

@@ -0,0 +1,18 @@
+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 paths = [['start']];
+    static usage = this.Usage({
+        description: 'Runs a server and concurrently watches a file system',
+    });
+    async execute() {
+        const [{ watch }, { serve }] = await Promise.all([
+            import('../lib/watch.js'),
+            import('../lib/server.js'),
+        ]);
+        serve(this.port, this.esmOrigin);
+        await this.eachPackagePath((packagePath) => watch(packagePath, this));
+    }
+}

package/dist/commands/TokenCommand.js

@@ -0,0 +1,23 @@
+import { Command } from 'clipanion';
+import { RegistrySpecific } from './mixins/RegistrySpecific.js';
+export class TokenCommand extends RegistrySpecific(Command) {
+    static paths = [['token']];
+    static usage = this.Usage({
+        description: 'Get the NPM token',
+    });
+    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/dist/commands/VersionCommand.js

@@ -0,0 +1,15 @@
+import { Command } from 'clipanion';
+export class VersionCommand extends Command {
+    static paths = [['version']];
+    static usage = this.Usage({
+        description: 'Display the version of esm.dev',
+    });
+    async execute() {
+        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/dist/commands/WaitForRegistryCommand.js

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

package/dist/commands/WatchCommand.js

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

package/dist/commands/mixins/CommandClass.js

@@ -0,0 +1 @@
+export {};

package/dist/commands/mixins/ESMServed.js

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

package/dist/commands/mixins/ESMStorageSpecific.js

@@ -0,0 +1,9 @@
+import { EnvOption } from '../options/EnvOption.js';
+export function ESMStorageSpecific(Base) {
+    class ESMStorageSpecific extends Base {
+        esmStoragePath = EnvOption('ESM_STORAGE_PATH', '-s,--esm-storage-path', {
+            description: "Path to ESM.sh's storage",
+        });
+    }
+    return ESMStorageSpecific;
+}

package/dist/commands/mixins/PackagePathSpecific.js

@@ -0,0 +1,14 @@
+import { Option } from 'clipanion';
+export function PackagePathSpecific(Base) {
+    class PackagePathSpecific extends Base {
+        packagePaths = Option.Rest({
+            name: 'packages',
+        });
+        async eachPackagePath(cb) {
+            const { glob } = await import('glob');
+            const packagePaths = await glob(this.packagePaths);
+            await Promise.all(packagePaths.map(cb));
+        }
+    }
+    return PackagePathSpecific;
+}

package/dist/commands/mixins/RegistrySpecific.js

@@ -0,0 +1,9 @@
+import { EnvOption } from '../options/EnvOption.js';
+export function RegistrySpecific(Base) {
+    class RegistrySpecific extends Base {
+        registry = EnvOption('NPM_REGISTRY', '-r,--registry', {
+            description: 'The URL of your local registry',
+        });
+    }
+    return RegistrySpecific;
+}

package/dist/commands/mixins/Retryable.js

@@ -0,0 +1,29 @@
+import { Option } from 'clipanion';
+import { isNumber } from 'typanion';
+export function Retryable(Base) {
+    class Retryable extends Base {
+        timeout = Option.String('-t,--timeout', '10000', {
+            description: 'The amount of total ms to keep trying for',
+            validator: isNumber(),
+        });
+        interval = Option.String('-i,--interval', '300', {
+            description: 'The amount of ms inbetween each attempt',
+            validator: isNumber(),
+        });
+        async retry(endpoint) {
+            const { EndpointUnavailableError, waitForEndpoint } = await import('../../lib/until.js');
+            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/dist/commands/mixins/Servable.js

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

package/dist/commands/mixins/Watchable.js

@@ -0,0 +1,9 @@
+import { Option } from 'clipanion';
+export function Watchable(Base) {
+    class Watchable extends Base {
+        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/dist/commands/options/EnvOption.js

@@ -0,0 +1,6 @@
+import { Option } from 'clipanion';
+export function EnvOption(envName, descriptor, opts = {}) {
+    return process.env[envName]
+        ? Option.String(descriptor, process.env[envName], opts)
+        : Option.String(descriptor, { ...opts, required: true });
+}

package/dist/lib/MustacheGenerator.js

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

package/dist/lib/getPackageMeta.js

@@ -0,0 +1,10 @@
+import { readFile, stat as getStat } from 'node:fs/promises';
+import * as path from 'node:path';
+export async function getPackageMeta(packagePath) {
+    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/dist/lib/index.js

@@ -0,0 +1,8 @@
+export * from './login.js';
+export * from './publish.js';
+export * from './queue.js';
+export * from './republish.js';
+export * from './unpublish.js';
+export * from './until.js';
+export * from './watch.js';
+export * from './watchIgnoreList.js';

package/dist/lib/login.js

@@ -0,0 +1,25 @@
+import { spawn } from 'node:child_process';
+export function login(registry) {
+    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/dist/lib/publish.js

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

package/dist/lib/queue.js

@@ -0,0 +1,48 @@
+import { debounce, Mutex } from 'es-toolkit';
+const mutex = new Mutex();
+export async function queue(fn, signal) {
+    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(fn, delay, signal) {
+    let promiseWithResolvers;
+    let queuedPromise;
+    signal?.addEventListener('abort', (reason) => {
+        debounced.cancel();
+        promiseWithResolvers?.reject(reason);
+    });
+    const debounced = debounce(async (...args) => {
+        try {
+            const result = await fn(...args);
+            promiseWithResolvers?.resolve(result);
+        }
+        catch (error) {
+            promiseWithResolvers?.reject(error);
+        }
+        finally {
+            promiseWithResolvers = undefined;
+        }
+    }, delay, { signal });
+    return (...args) => {
+        const promise = start();
+        debounced(...args);
+        return promise;
+    };
+    function start() {
+        if (!queuedPromise) {
+            promiseWithResolvers = Promise.withResolvers();
+            queuedPromise = queue(async () => promiseWithResolvers?.promise);
+        }
+        return queuedPromise;
+    }
+}

package/dist/lib/republish.js

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

package/dist/lib/server.js

@@ -0,0 +1,34 @@
+import { queue } from './queue.js';
+import { createServer } from 'node:http';
+import httpProxy from 'http-proxy';
+export async function serve(port, esmOrigin) {
+    const proxy = httpProxy.createProxyServer();
+    const { promise, resolve } = Promise.withResolvers();
+    const server = createServer((req, res) => {
+        queue(() => new Promise((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((resolve, reject) => {
+        console.info('closing the server');
+        server.close((error) => {
+            if (error)
+                reject(error);
+            else
+                resolve();
+        });
+    });
+}

package/dist/lib/unpublish.js

@@ -0,0 +1,26 @@
+import { $, ProcessOutput } from 'zx';
+import { glob } from 'glob';
+import { rm } from 'node:fs/promises';
+export async function unpublish({ registry, esmStoragePath, name, }) {
+    await Promise.all([
+        unpublishPackage(registry, name),
+        deleteESMCache(esmStoragePath, name),
+    ]);
+}
+async function unpublishPackage(registry, name) {
+    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, name) {
+    const paths = await glob(`${esmStoragePath}/**/${name}@*`);
+    await Promise.all(paths.map((path) => {
+        console.info('Deleting', path);
+        return rm(path, { recursive: true });
+    }));
+}

package/dist/lib/until.js

@@ -0,0 +1,32 @@
+import { setTimeout } from 'node:timers/promises';
+export async function until({ interval, timeout, try: Try, }) {
+    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, }) {
+    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/dist/lib/watch.js

@@ -0,0 +1,88 @@
+import { watch as fsWatch } 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';
+import { getWatchIgnorer } from './watchIgnoreList.js';
+import { tempfile } from 'zx';
+export async function watch(packagePath, opts) {
+    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 = '') => {
+        console.info(`Change detected at ${packageRoot}/${filename}`);
+        return republish(packageRoot, opts).catch(console.error);
+    };
+    try {
+        await queue(republishPackage, signal);
+    }
+    catch (error) {
+        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, dirname, republish) {
+    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, dirname, republish) {
+    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;
+    beginTimer();
+    return () => abortController.abort();
+    function beginTimer() {
+        timer = setTimeout(() => hashDirectory(dirname, ignorer, filename, republish)
+            .catch(console.error)
+            .finally(beginTimer), 1_000);
+    }
+}
+async function hashDirectory(dirname, ignorer, filename, onChange) {
+    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) {
+        if (error.code !== 'ENOENT')
+            throw error;
+    }
+    if (newHash !== previousHash) {
+        await Promise.all([writeFile(filename, newHash), onChange()]);
+    }
+}