build-strap 4.0.0-dev.46 → 4.0.0

package/dist/src/dockerCompose.js

@@ -0,0 +1,439 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _DockerComposeService_name, _DockerComposeService_svcDef, _DockerComposeService_dockerCompose, _DockerComposeService_tracker, _DockerComposeService_parsedPorts, _DockerComposeService_parsedNetworks, _DockerComposeService_parsedVolumes, _DockerComposeService_baseRunArgs;
+import fs from 'fs-extra';
+import getPort from 'get-port';
+import yaml from 'js-yaml';
+import path from 'path';
+import { dockerContainerFind, dockerContainerRunDaemon, } from './docker.container.js';
+import { dockerPull } from './docker.js';
+import { dockerNetworkCreate, dockerNetworkDelete, } from './docker.network.js';
+import { dockerVolumeCreate, dockerVolumeRm, } from './docker.volume.js';
+import { mapValuesAsync } from './maps.js';
+import { buildLog } from './run.js';
+export const dockerComposeCreateResourceTracker = () => ({
+    cleaning: null,
+    containers: new Map(),
+    networks: new Map(),
+    services: new Map(),
+    volumes: new Map(),
+});
+const defaultTracker = dockerComposeCreateResourceTracker();
+/**
+ * Parse a docker-compose.yml file into a pojo representation
+ * @param {string} filePath Path to the docker-compose.yml file
+ */
+export const dockerComposeParse = async (filePath = './docker-compose.yml') => yaml.load(await fs.readFile(filePath, 'utf8'));
+let dc = null;
+/**
+ * Get the main docker-compose.yml from the root of the repo
+ * @param {boolean} force Force reload from file
+ */
+export const dockerComposeGetMain = async (force = false) => {
+    if (force || !dc) {
+        dc = await dockerComposeParse();
+    }
+    return dc;
+};
+// Function that handles passed dockerCompose as either a file path or `DockerCompose` object.
+// If not passed, defaults to the main docker-compose.yml from the root of the repo
+const dockerComposeResolve = async (dockerCompose, force) => typeof dockerCompose === 'string'
+    ? dockerComposeParse(dockerCompose)
+    : dockerCompose || dockerComposeGetMain(force);
+// Determines an unnamed resource's name from the dirname combined with the key
+const prefixName = (name) => `${path.basename(__dirname)}_${name}`;
+const getServiceDef = async (name, force, dockerCompose) => (await dockerComposeResolve(dockerCompose, force)).services?.[name] || null;
+const parsePorts = async (portsCfg = [], avoidConflicts = true, mapLocal = true, host = '0.0.0.0') => {
+    const ports = [];
+    const runArgs = await portsCfg.reduce(async (args, portStr) => {
+        const [lp, dp] = portStr.split(':');
+        const localDefault = parseInt(lp, 10);
+        const docker = parseInt(dp, 10);
+        const local = mapLocal
+            ? avoidConflicts
+                ? await getPort({ host, port: localDefault })
+                : localDefault
+            : null;
+        ports.push({ docker, local, localDefault });
+        return local ? [...(await args), '-p', `${local}:${docker}`] : args;
+    }, Promise.resolve([]));
+    return { ports, runArgs };
+};
+const parseEnv = (env = []) => Array.isArray(env)
+    ? env.flatMap((e) => ['-e', e])
+    : Object.entries(env).flatMap(([k, v]) => ['-e', `${k}=${v}`]);
+const parseULimits = (ul = {}) => Object.entries(ul).flatMap(([k, v]) => [
+    '--ulimit',
+    `${k}=${typeof v === 'number' ? v : `${v.soft}${v.hard ? `:${v.hard}` : ''}`}`,
+]);
+const parseVolumes = async (volCfg = [], nameSuffix = '', dockerCompose = null) => {
+    const { volumes: volMap } = await dockerComposeResolve(dockerCompose);
+    const volumes = [];
+    const runArgs = volCfg
+        .map((v) => {
+        const [src, ...rest] = v.split(':');
+        const name = volMap?.[src]
+            ? `${volMap[src].name || prefixName(src)}${nameSuffix}`
+            : null;
+        if (name) {
+            volumes.push(name);
+        }
+        const realSrc = name || path.resolve(src);
+        return [realSrc, ...rest].join(':');
+    })
+        .flatMap((v) => ['-v', v]);
+    return { runArgs, volumes };
+};
+const parseNetworks = async (netCfg = [], dockerCompose = null) => {
+    const { networks: netMap } = await dockerComposeResolve(dockerCompose);
+    const networks = netCfg.map((n) => netMap?.[n].name || prefixName(n));
+    return {
+        networks,
+        runArgs: networks.flatMap((n) => ['--network', n]),
+    };
+};
+export const dockerComposeCreateNetworks = async (names, dockerCompose, tracker = defaultTracker) => {
+    const { networks = {} } = await dockerComposeResolve(dockerCompose);
+    await Promise.all(Object.entries(networks).map(async ([key, val]) => {
+        const name = val?.name || prefixName(key);
+        if (names?.includes(name)) {
+            const network = await dockerNetworkCreate(name, val);
+            if (network) {
+                tracker.networks.set(name, network);
+            }
+        }
+    }));
+};
+export const dockerComposeCreateVolumes = async (names, dockerCompose, tracker = defaultTracker) => {
+    const { volumes = {} } = await dockerComposeResolve(dockerCompose);
+    await Promise.all(Object.entries(volumes).map(async ([key, val]) => {
+        const name = val?.name || prefixName(key);
+        if (!names || names.includes(name)) {
+            const volume = await dockerVolumeCreate(name, val);
+            if (volume) {
+                tracker.volumes.set(name, volume);
+            }
+        }
+    }));
+};
+export class DockerComposeService {
+    constructor(name, serviceDef, dockerCompose) {
+        _DockerComposeService_name.set(this, void 0);
+        _DockerComposeService_svcDef.set(this, void 0);
+        _DockerComposeService_dockerCompose.set(this, void 0);
+        _DockerComposeService_tracker.set(this, dockerComposeCreateResourceTracker());
+        // lazily computed
+        _DockerComposeService_parsedPorts.set(this, null);
+        _DockerComposeService_parsedNetworks.set(this, null);
+        _DockerComposeService_parsedVolumes.set(this, null);
+        _DockerComposeService_baseRunArgs.set(this, null);
+        __classPrivateFieldSet(this, _DockerComposeService_name, name, "f");
+        __classPrivateFieldSet(this, _DockerComposeService_svcDef, serviceDef, "f");
+        __classPrivateFieldSet(this, _DockerComposeService_dockerCompose, dockerCompose || null, "f");
+    }
+    get name() {
+        return __classPrivateFieldGet(this, _DockerComposeService_name, "f");
+    }
+    get serviceDef() {
+        return __classPrivateFieldGet(this, _DockerComposeService_svcDef, "f");
+    }
+    get image() {
+        return __classPrivateFieldGet(this, _DockerComposeService_svcDef, "f").image || null;
+    }
+    get defaultContainerName() {
+        return __classPrivateFieldGet(this, _DockerComposeService_svcDef, "f").container_name || __classPrivateFieldGet(this, _DockerComposeService_name, "f");
+    }
+    get cmd() {
+        return __classPrivateFieldGet(this, _DockerComposeService_svcDef, "f").command || [];
+    }
+    get envArgs() {
+        return parseEnv(__classPrivateFieldGet(this, _DockerComposeService_svcDef, "f").environment);
+    }
+    /**
+     * Find (available) container name and alias(es)
+     * @param {boolean} avoidConflicts if `true`, find a container name that is unused
+     * @param {number} max maximum number of names to try
+     */
+    async getNames(avoidConflicts = false, max = 100) {
+        /* eslint-disable no-await-in-loop */
+        for (let i = 0; i < max; i += 1) {
+            const suffix = i ? `-${i}` : '';
+            const testName = `${this.defaultContainerName}${suffix}`;
+            const container = await dockerContainerFind(testName, { all: true });
+            if (!avoidConflicts || !container) {
+                return {
+                    aliases: [`${this.name}${suffix}`],
+                    name: testName,
+                    suffix,
+                };
+            }
+        }
+        /* eslint-enable no-await-in-loop */
+        throw new Error(`Failed to find available container name for ${this.defaultContainerName}`);
+    }
+    // Get (available) port mappings
+    async getPorts(avoidConflicts = false, mapLocal = true) {
+        return parsePorts(__classPrivateFieldGet(this, _DockerComposeService_svcDef, "f").ports, avoidConflicts, mapLocal);
+    }
+    async getDefaultPortInfo() {
+        if (!__classPrivateFieldGet(this, _DockerComposeService_parsedPorts, "f")) {
+            __classPrivateFieldSet(this, _DockerComposeService_parsedPorts, await this.getPorts(), "f");
+        }
+        return __classPrivateFieldGet(this, _DockerComposeService_parsedPorts, "f");
+    }
+    async getDefaultPorts() {
+        const { ports } = await this.getDefaultPortInfo();
+        return ports;
+    }
+    async getDefaultPortArgs() {
+        const { runArgs } = await this.getDefaultPortInfo();
+        return runArgs;
+    }
+    async getDefaultUrls() {
+        return DockerComposeService.getUrls(await this.getDefaultPorts(), this.defaultContainerName);
+    }
+    async getDefaultNetworkInfo() {
+        if (!__classPrivateFieldGet(this, _DockerComposeService_parsedNetworks, "f")) {
+            __classPrivateFieldSet(this, _DockerComposeService_parsedNetworks, await parseNetworks(__classPrivateFieldGet(this, _DockerComposeService_svcDef, "f").networks), "f");
+        }
+        return __classPrivateFieldGet(this, _DockerComposeService_parsedNetworks, "f");
+    }
+    async getDefaultNetworks() {
+        const { networks } = await this.getDefaultNetworkInfo();
+        return networks;
+    }
+    async getDefaultNetworkArgs() {
+        const { runArgs } = await this.getDefaultNetworkInfo();
+        return runArgs;
+    }
+    async getDefaultVolumeInfo() {
+        if (!__classPrivateFieldGet(this, _DockerComposeService_parsedVolumes, "f")) {
+            __classPrivateFieldSet(this, _DockerComposeService_parsedVolumes, await parseVolumes(__classPrivateFieldGet(this, _DockerComposeService_svcDef, "f").networks), "f");
+        }
+        return __classPrivateFieldGet(this, _DockerComposeService_parsedVolumes, "f");
+    }
+    async getDefaultVolumes() {
+        const { volumes } = await this.getDefaultVolumeInfo();
+        return volumes;
+    }
+    async getDefaultVolumeArgs() {
+        const { runArgs } = await this.getDefaultVolumeInfo();
+        return runArgs;
+    }
+    async pull() {
+        if (!this.image) {
+            throw new Error(`Cannot pull '${this.name}', no image configured.`);
+        }
+        await dockerPull({ image: this.image });
+    }
+    async getBaseRunArgs() {
+        if (!__classPrivateFieldGet(this, _DockerComposeService_baseRunArgs, "f")) {
+            const envArgs = parseEnv(__classPrivateFieldGet(this, _DockerComposeService_svcDef, "f").environment);
+            const ulArgs = parseULimits(__classPrivateFieldGet(this, _DockerComposeService_svcDef, "f").ulimits);
+            const netArgs = await this.getDefaultNetworkArgs();
+            __classPrivateFieldSet(this, _DockerComposeService_baseRunArgs, ['--rm', ...envArgs, ...netArgs, ...ulArgs], "f");
+        }
+        return __classPrivateFieldGet(this, _DockerComposeService_baseRunArgs, "f");
+    }
+    async assembleRunArgs(containerName = this.defaultContainerName, aliases = [this.name], additionalArgs = null) {
+        const additional = additionalArgs || [
+            ...(await this.getDefaultPortArgs()),
+            ...(await this.getDefaultVolumeArgs()),
+        ];
+        return [
+            ...(await this.getBaseRunArgs()),
+            ...(containerName ? ['--name', containerName] : []),
+            ...aliases.flatMap((a) => (a ? ['--network-alias', a] : [])),
+            ...additional,
+        ];
+    }
+    async getRunArgs(avoidConflicts = false, mapLocalPorts = true) {
+        const { aliases, name: cName, suffix, } = await this.getNames(avoidConflicts);
+        const { runArgs: pArgs } = await this.getPorts(avoidConflicts, mapLocalPorts);
+        const { runArgs: vArgs } = await parseVolumes(__classPrivateFieldGet(this, _DockerComposeService_svcDef, "f").volumes, suffix);
+        return this.assembleRunArgs(cName, aliases, [...pArgs, ...vArgs]);
+    }
+    async up({ healthCheck, avoidConflicts = false, mapVolumes = true, mapPorts = true, cmd = this.cmd, tracker = defaultTracker, } = {}) {
+        const { image } = this;
+        if (!image) {
+            throw new Error(`Cannot bring up service '${this.name}', no image defined.`);
+        }
+        if (__classPrivateFieldGet(this, _DockerComposeService_tracker, "f").containers.size) {
+            buildLog(`Warning: up called on service '${this.name}' with already running container`);
+        }
+        const { aliases, name: containerName, suffix, } = await this.getNames(avoidConflicts);
+        const { ports, runArgs: pArgs } = await this.getPorts(avoidConflicts, mapPorts);
+        const { runArgs: vArgs, volumes } = mapVolumes
+            ? await parseVolumes(__classPrivateFieldGet(this, _DockerComposeService_svcDef, "f").volumes, suffix)
+            : { runArgs: [], volumes: [] };
+        let container = await dockerContainerFind(containerName, { all: true });
+        if (container && !(await container.isRunning())) {
+            await container.start();
+        }
+        if (!container) {
+            await this.pull();
+            await dockerComposeCreateNetworks(await this.getDefaultNetworks(), __classPrivateFieldGet(this, _DockerComposeService_dockerCompose, "f"), __classPrivateFieldGet(this, _DockerComposeService_tracker, "f"));
+            await dockerComposeCreateVolumes(volumes, __classPrivateFieldGet(this, _DockerComposeService_dockerCompose, "f"), __classPrivateFieldGet(this, _DockerComposeService_tracker, "f"));
+            const runArgs = await this.assembleRunArgs(containerName, aliases, [
+                ...pArgs,
+                ...vArgs,
+            ]);
+            container = await dockerContainerRunDaemon({
+                cmd,
+                image,
+                runArgs,
+            });
+        }
+        else {
+            buildLog(`Reusing existing container for '${this.name}' service.`);
+        }
+        // This service tracks the things it created
+        __classPrivateFieldGet(this, _DockerComposeService_tracker, "f").containers.set(containerName, container);
+        // The passed tracker needs to track this service
+        tracker.services.set(this.name, this);
+        const idAlias = container.id.slice(0, 12);
+        aliases.push(idAlias);
+        const urls = DockerComposeService.getUrls(ports, idAlias);
+        const info = {
+            aliases,
+            container,
+            containerName,
+            ports,
+            service: this,
+            urls,
+            volumes,
+        };
+        await healthCheck?.(info);
+        return info;
+    }
+    async down({ includeDefaults = false, includeNetworks = false, includeVolumes = false, } = {}) {
+        buildLog(`Bringing down <${this.name}> service...`);
+        await dockerComposeTeardown({
+            includeNetworks,
+            includeVolumes,
+            tracker: __classPrivateFieldGet(this, _DockerComposeService_tracker, "f"),
+        });
+        if (includeDefaults) {
+            const container = await dockerContainerFind(this.defaultContainerName);
+            if (container) {
+                await container.teardown(true);
+            }
+        }
+    }
+    static async parse(name, force = true, dockerCompose = null) {
+        const svcDef = await getServiceDef(name, force, dockerCompose);
+        return svcDef ? new this(name, svcDef, dockerCompose) : null;
+    }
+    static getUrls(ports, alias) {
+        return ports.map(({ docker, local }) => ({
+            docker: docker ? `http://${alias}:${docker}` : null,
+            local: local ? `http://localhost:${local}` : null,
+        }));
+    }
+}
+_DockerComposeService_name = new WeakMap(), _DockerComposeService_svcDef = new WeakMap(), _DockerComposeService_dockerCompose = new WeakMap(), _DockerComposeService_tracker = new WeakMap(), _DockerComposeService_parsedPorts = new WeakMap(), _DockerComposeService_parsedNetworks = new WeakMap(), _DockerComposeService_parsedVolumes = new WeakMap(), _DockerComposeService_baseRunArgs = new WeakMap();
+export async function dockerComposeGetAllServices(dockerCompose) {
+    const { services } = await dockerComposeResolve(dockerCompose);
+    return mapValuesAsync(services, (s, name) => DockerComposeService.parse(name));
+}
+export async function dockerComposeTeardown({ includeDefaults = false, includeVolumes = false, includeNetworks = false, dockerCompose, tracker = defaultTracker, } = {}) {
+    if (!tracker.cleaning) {
+        // eslint-disable-next-line no-param-reassign
+        tracker.cleaning = (async () => {
+            if (tracker.services.size) {
+                buildLog('Bringing down started docker services...');
+                const promises = Promise.all(Array.from(tracker.services.values()).map(async (s) => s.down({ includeNetworks, includeVolumes })));
+                tracker.services.clear();
+                await promises;
+            }
+            if (includeDefaults) {
+                const { services } = await dockerComposeResolve(dockerCompose);
+                const svcNames = Object.keys(services ?? {});
+                if (svcNames.length) {
+                    buildLog('Bringing down default docker services...');
+                    await Promise.all(svcNames.map(async (s) => (await DockerComposeService.parse(s))?.down({
+                        includeDefaults,
+                        includeNetworks,
+                        includeVolumes,
+                    })));
+                }
+            }
+            if (tracker.containers.size) {
+                buildLog('Stopping created docker containers...');
+                const promises = Promise.all(Array.from(tracker.containers.values()).map(async (c) => c.teardown(true)));
+                tracker.containers.clear();
+                await promises;
+            }
+            if (includeVolumes) {
+                if (tracker.volumes.size) {
+                    buildLog('Removing created docker volumes...');
+                    const promises = Promise.all(Array.from(tracker.volumes.values()).map(async (v) => v.rm()));
+                    tracker.volumes.clear();
+                    await promises;
+                }
+                if (includeDefaults) {
+                    buildLog('Removing default docker volumes...');
+                    const { volumes } = await dockerComposeResolve(dockerCompose);
+                    await Promise.all(Object.entries(volumes ?? {}).map(async ([key, val]) => {
+                        const name = val?.name || prefixName(key);
+                        await dockerVolumeRm(name, true);
+                    }));
+                }
+            }
+            if (includeNetworks) {
+                if (tracker.networks.size) {
+                    buildLog('Removing created docker networks...');
+                    const promises = Promise.all(Array.from(tracker.networks.values()).map(async (n) => n.rm()));
+                    tracker.networks.clear();
+                    await promises;
+                }
+                if (includeDefaults) {
+                    buildLog('Removing default docker networks...');
+                    const { networks } = await dockerComposeResolve(dockerCompose);
+                    await Promise.all(Object.entries(networks ?? {}).map(async ([key, val]) => {
+                        const name = val?.name || prefixName(key);
+                        try {
+                            await dockerNetworkDelete(name);
+                        }
+                        catch (err) {
+                            buildLog(`Error deleting network '${name}': ${err.message}`);
+                        }
+                    }));
+                }
+            }
+            // eslint-disable-next-line no-param-reassign
+            tracker.cleaning = null;
+        })();
+    }
+    return tracker.cleaning;
+}
+export async function dockerComposeRunService(key, upOptions = {}, dockerCompose = null) {
+    const service = await DockerComposeService.parse(key, false, dockerCompose);
+    if (!service) {
+        throw new Error(`Failed to find service '${key}'`);
+    }
+    buildLog(`Starting <${service.name}> service...`);
+    const upResult = await service.up(upOptions);
+    const { container, urls, urls: [{ docker: dockerUrl, local: url }], ports: [{ docker: dockerPort, local: port }], } = upResult;
+    const { id, image, name } = container;
+    urls.forEach(({ local }) => local && buildLog(`<${service.name}> accessible at ${local}`));
+    return {
+        ...upResult,
+        dockerPort,
+        dockerUrl,
+        id,
+        image,
+        name,
+        port,
+        url,
+    };
+}

package/dist/src/fs.d.ts

@@ -0,0 +1,5 @@
+import glob from 'glob';
+export declare const readDir: (pattern: string, options?: glob.IOptions | undefined) => Promise<string[]>;
+export declare const moveDir: (source: string, target: string) => Promise<void>;
+export declare const copyDir: (source: string, target: string, fileGlob?: string, globOptions?: null | glob.IOptions, renameFn?: (name: string) => string) => Promise<void>;
+export declare const cleanDir: (pattern: string, globOptions?: false | glob.IOptions | undefined) => Promise<void>;

package/dist/src/fs.js

@@ -0,0 +1,38 @@
+import fs from 'fs-extra';
+import glob from 'glob';
+import path from 'path';
+import rimraf from 'rimraf';
+export const readDir = async (pattern, options) => new Promise((resolve, reject) => {
+    glob(pattern, options || {}, (err, result) => err ? reject(err) : resolve(result));
+});
+export const moveDir = async (source, target) => {
+    const dirs = await readDir('**/*.*', {
+        cwd: source,
+        dot: true,
+        nosort: true,
+    });
+    await Promise.all(dirs.map(async (dir) => {
+        const from = path.resolve(source, dir);
+        const to = path.resolve(target, dir);
+        await fs.ensureDir(path.dirname(to));
+        await fs.rename(from, to);
+    }));
+};
+export const copyDir = async (source, target, fileGlob = '**/*.*', globOptions = null, renameFn = (n) => n) => {
+    const paths = await readDir(fileGlob, {
+        cwd: source,
+        dot: true,
+        nodir: true,
+        nosort: true,
+        ...globOptions,
+    });
+    await Promise.all(paths.map(async (p) => {
+        const from = path.resolve(source, p);
+        const to = path.resolve(target, renameFn(p));
+        await fs.ensureDir(path.dirname(to));
+        await fs.copyFile(from, to);
+    }));
+};
+export const cleanDir = async (pattern, globOptions) => new Promise((resolve, reject) => {
+    rimraf(pattern, { glob: globOptions }, (err) => err ? reject(err) : resolve());
+});

package/dist/src/git.d.ts

@@ -0,0 +1,9 @@
+export declare function git(args: string[]): Promise<string>;
+export declare function gitBranch(): Promise<string>;
+export declare function gitRevId(): Promise<string>;
+declare type GitInfo = {
+    branch: string;
+    revision: string;
+};
+export declare function gitInfo(noCache?: boolean): Promise<GitInfo>;
+export {};

package/dist/src/git.js

@@ -0,0 +1,24 @@
+import { exec } from './cp.js';
+export async function git(args) {
+    return (await exec(`git ${args.join(' ')}`)).stdout.toString();
+}
+export async function gitBranch() {
+    return (await git(['symbolic-ref', '--short', 'HEAD']))
+        .replace(/[_+/]/g, '-')
+        .trim();
+}
+export async function gitRevId() {
+    return (await git(['rev-parse', '--short=12', 'HEAD']))
+        .replace(/[+]/g, '')
+        .trim();
+}
+let info = null;
+export async function gitInfo(noCache = false) {
+    if (!info || noCache) {
+        info = {
+            branch: await gitBranch(),
+            revision: await gitRevId(),
+        };
+    }
+    return info;
+}

package/dist/src/index.d.ts

@@ -0,0 +1,20 @@
+export * from './ant.js';
+export * from './cert.js';
+export * from './clean.js';
+export * from './copy.js';
+export * from './cp.js';
+export * from './docker.js';
+export * from './docker.container.js';
+export * from './docker.network.js';
+export * from './docker.volume.js';
+export * from './dockerCleanup.js';
+export * from './dockerCompose.js';
+export * from './fs.js';
+export * from './git.js';
+export * from './npm.js';
+export * from './pkg.js';
+export * from './publish.js';
+export * from './run.js';
+export * from './tgz.js';
+export * from './version.js';
+export * from './yarn.js';

package/dist/src/index.js

@@ -0,0 +1,20 @@
+export * from './ant.js';
+export * from './cert.js';
+export * from './clean.js';
+export * from './copy.js';
+export * from './cp.js';
+export * from './docker.js';
+export * from './docker.container.js';
+export * from './docker.network.js';
+export * from './docker.volume.js';
+export * from './dockerCleanup.js';
+export * from './dockerCompose.js';
+export * from './fs.js';
+export * from './git.js';
+export * from './npm.js';
+export * from './pkg.js';
+export * from './publish.js';
+export * from './run.js';
+export * from './tgz.js';
+export * from './version.js';
+export * from './yarn.js';

package/dist/src/maps.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Given a `ObjMap`, iterate over each entry and run it through the given `map` function.
+ * @param {ObjMap} obj the input object
+ * @param {Function} map the mapping operation
+ * @returns {ObjMap} a new object
+ */
+export declare const mapValues: <K extends string, V, R>(obj: Record<K, V> | null | undefined, map: (value: V, key: K, map: Record<K, V>) => R) => Record<K, R>;
+/**
+ * Given a `ObjMap`, iterate over each entry and run it through the given async `map` function.
+ * The promise returned by the `map` is awaited, such that the resulting `ObjMap` values are
+ * the result of the resolved promise.
+ * @param {ObjMap} obj the input object
+ * @param {Function} map the async mapping operation
+ * @returns {Promise} a promise for a new object
+ */
+export declare const mapValuesAsync: <K extends string, V, R>(obj: Record<K, V> | null | undefined, map: (value: V, key: K, objMap: Record<K, V>) => Promise<R>) => Promise<Record<K, R>>;
+/**
+ * Given a `ObjMap`, iterate over each entry and run it through the given `filter` function.
+ * Any entry for which the `filter` returns `false` is removed from the resulting `ObjMap`.
+ * All other entries are left as-is. The resulting output is a subset of the input.
+ * If no `filter` is specified, default to filtering out nullish values.
+ * @param {ObjMap} obj the input object
+ * @param {Function} filter the filter operation
+ * @returns {ObjMap} a new object, a subset of the input
+ */
+export declare const filterKeys: <V, K extends string = string>(obj: Record<K, V> | null | undefined, filter?: (value: V, key: K, objMap: Record<K, V>) => boolean) => Partial<Record<K, V>>;
+/**
+ * Given an object, removes any top level keys with a nullish value.
+ * The type system should preserve the incoming object type, with all such keys typed as `empty`.
+ * @param {Object} obj the input object
+ * @returns {Object} a new object, a subset of the input
+ */
+export declare const filterNullish: <T>(obj: Record<string, T>) => Record<string, Exclude<T, null | undefined>>;

package/dist/src/maps.js

@@ -0,0 +1,41 @@
+/**
+ * Given a `ObjMap`, iterate over each entry and run it through the given `map` function.
+ * @param {ObjMap} obj the input object
+ * @param {Function} map the mapping operation
+ * @returns {ObjMap} a new object
+ */
+export const mapValues = (obj, map) => Object.entries(obj ?? {}).reduce((acc, [k, v]) => Object.assign(acc, {
+    [k]: map(v, k, (obj ?? {})),
+}), {});
+/**
+ * Given a `ObjMap`, iterate over each entry and run it through the given async `map` function.
+ * The promise returned by the `map` is awaited, such that the resulting `ObjMap` values are
+ * the result of the resolved promise.
+ * @param {ObjMap} obj the input object
+ * @param {Function} map the async mapping operation
+ * @returns {Promise} a promise for a new object
+ */
+export const mapValuesAsync = async (obj, map) => Object.entries(obj ?? {}).reduce(async (acc, [k, v]) => Object.assign(await acc, {
+    [k]: await map(v, k, (obj ?? {})),
+}), Promise.resolve({}));
+/**
+ * Given a `ObjMap`, iterate over each entry and run it through the given `filter` function.
+ * Any entry for which the `filter` returns `false` is removed from the resulting `ObjMap`.
+ * All other entries are left as-is. The resulting output is a subset of the input.
+ * If no `filter` is specified, default to filtering out nullish values.
+ * @param {ObjMap} obj the input object
+ * @param {Function} filter the filter operation
+ * @returns {ObjMap} a new object, a subset of the input
+ */
+export const filterKeys = (obj, filter = (v) => v != null) => Object.entries(obj ?? {}).reduce((acc, [k, v]) => filter(v, k, (obj ?? {}))
+    ? Object.assign(acc, {
+        [k]: v,
+    })
+    : acc, {});
+/**
+ * Given an object, removes any top level keys with a nullish value.
+ * The type system should preserve the incoming object type, with all such keys typed as `empty`.
+ * @param {Object} obj the input object
+ * @returns {Object} a new object, a subset of the input
+ */
+export const filterNullish = (obj) => filterKeys(obj);

package/dist/src/npm.d.ts

@@ -0,0 +1,35 @@
+export declare type NpmCreds = {
+    email?: string;
+    password?: string;
+    username?: string;
+};
+export declare type NpmConfig = {
+    access?: 'public' | 'restricted';
+    dryRun?: boolean;
+    name?: string;
+    publish?: boolean;
+    registry?: string;
+};
+export declare function getNpmConfig(): NpmConfig;
+export declare function npmExec(args: string[], npmPath?: string): Promise<string>;
+export declare function npmGetVersions(packageName: string, npmPath?: string): Promise<string[]>;
+export interface NpmPublishOptions {
+    npmAuthToken?: string;
+    npmConfig?: NpmConfig;
+    npmCreds?: NpmCreds;
+    npmPath?: string;
+    publishPath?: string;
+    skipExisting?: boolean;
+    tag?: string;
+    workDir?: string;
+    writeNpmrc?: boolean;
+}
+export declare function npmPublish({ npmAuthToken, npmConfig, npmCreds, npmPath, publishPath, skipExisting, tag, workDir: passedWorkDir, writeNpmrc, }?: NpmPublishOptions): Promise<boolean>;
+interface NpmPackOptions {
+    destination?: string;
+    npmConfig?: NpmConfig;
+    npmPath?: string;
+    workDir?: string;
+}
+export declare function npmPack({ destination, npmConfig, npmPath, workDir, }: NpmPackOptions): Promise<string>;
+export {};