build-strap 4.0.0 → 4.1.0-dev.60

package/dist/src/git.js

@@ -1,24 +0,0 @@
-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/npm.js

@@ -1,104 +0,0 @@
-import fs from 'fs-extra';
-import { platform } from 'os';
-import path from 'path';
-import { exec, spawn } from './cp.js';
-import { getCfg, getPkgName } from './pkg.js';
-import { buildLog } from './run.js';
-import { getDevBranch, getVersion } from './version.js';
-export function getNpmConfig() {
-    return getCfg().npm || {};
-}
-const envNpmCreds = (process.env.NPM_CREDS && JSON.parse(process.env.NPM_CREDS)) || null;
-const npmExe = (npmPath) => npmPath || (platform() === 'win32' ? 'npm.cmd' : 'npm');
-export async function npmExec(args, npmPath) {
-    return (await exec(`${npmExe(npmPath)} ${args.join(' ')}`)).stdout.toString();
-}
-export async function npmGetVersions(packageName, npmPath) {
-    try {
-        return JSON.parse(await npmExec(['show', packageName, 'versions'], npmPath));
-    }
-    catch (err) {
-        buildLog(`warning: failed to find existing package for ${packageName} in npm registry: ${err.message}`);
-        return [];
-    }
-}
-export async function npmPublish({ npmAuthToken, npmConfig, npmCreds, npmPath, publishPath = '.', skipExisting = false, tag, workDir: passedWorkDir, writeNpmrc = false, } = {}) {
-    const creds = npmCreds || envNpmCreds;
-    const authToken = npmAuthToken || process.env.NPM_TOKEN;
-    const name = getPkgName();
-    const { access, dryRun, publish, registry } = npmConfig || getNpmConfig();
-    if (!publish) {
-        buildLog('npm publish info missing from package.json, skipping npm publish');
-        return false;
-    }
-    const resolvedPath = path.resolve(publishPath);
-    const workDir = passedWorkDir ||
-        ((await fs.stat(resolvedPath)).isDirectory()
-            ? resolvedPath
-            : path.dirname(resolvedPath));
-    if (!(await fs.pathExists(path.join(workDir, 'package.json')))) {
-        buildLog(`warning: no package.json found in ${workDir}, skipping npm publish`);
-        return false;
-    }
-    if (writeNpmrc && (creds || registry || authToken)) {
-        // Write out .npmrc with credentials
-        const theRegistry = registry || 'https://registry.npmjs.org/';
-        const [, host] = /^(?:http(?:s)?:\/\/)?(.+)$/.exec(theRegistry) || [];
-        await fs.mkdirp(workDir);
-        await fs.writeFile(path.join(workDir, '.npmrc'), `registry=${theRegistry}
-${authToken ? `//${host}:_authToken=${authToken}` : ''}
-${creds
-            ? `_auth=${Buffer.from(`${creds.username}:${creds.password}`).toString('base64')}
-always-auth=true
-email=${creds.email}`
-            : ''}`);
-    }
-    const existing = await npmGetVersions(name, npmPath);
-    const { branch, isRelease, npm: npmVersion } = await getVersion();
-    if (existing.includes(npmVersion)) {
-        if (skipExisting) {
-            buildLog('npm package with this same version already exists. Skipping publish...');
-            return false;
-        }
-        throw new Error('Failed to publish npm package, this version already exists!');
-    }
-    await spawn(npmExe(npmPath), [
-        'publish',
-        resolvedPath,
-        '--tag',
-        tag ||
-            (isRelease
-                ? 'latest'
-                : branch === (await getDevBranch())
-                    ? 'next'
-                    : 'branch'),
-        ...(access ? ['--access', access] : []),
-        ...(dryRun ? ['--dry-run'] : []),
-        '--color=always',
-    ], {
-        cwd: workDir,
-        env: {
-            ...process.env,
-            NPM_TOKEN: authToken,
-        },
-        stdio: 'inherit',
-    });
-    return true;
-}
-export async function npmPack({ destination, npmConfig, npmPath, workDir = '.', }) {
-    const { dryRun } = npmConfig || getNpmConfig();
-    if (destination) {
-        await fs.ensureDir(destination);
-    }
-    const { stdout } = await spawn(npmExe(npmPath), [
-        'pack',
-        ...(dryRun ? ['--dry-run'] : []),
-        ...(destination ? ['--pack-destination', destination] : []),
-        '--color=always',
-    ], {
-        captureOutput: true,
-        cwd: workDir,
-        pipeOutput: true,
-    });
-    return path.resolve(destination || '.', stdout.trim());
-}

package/dist/src/yarn.js

@@ -1,75 +0,0 @@
-import fs from 'fs-extra';
-import path from 'path';
-import { spawn } from './cp.js';
-import { readDir } from './fs.js';
-import { getPkg } from './pkg.js';
-import { buildLog } from './run.js';
-import { generateFileHash } from './tgz.js';
-export async function yarn({ args = [], spawnOptions, } = {}) {
-    const localYarn = path.join(path.dirname(process.execPath), '/node_modules/yarn/bin/yarn.js');
-    const spawnOpts = {
-        env: process.env,
-        shell: true,
-        stdio: 'inherit',
-        ...spawnOptions,
-    };
-    return (await fs.pathExists(localYarn))
-        ? // prefer to use local copy of yarn
-            spawn(process.execPath, [localYarn, ...args], spawnOpts)
-        : // fall back to globally installed yarn
-            spawn('yarn', args, spawnOpts);
-}
-export const yarnFiles = ['./package.json', './yarn.lock'];
-// Smart yarn invocation, only if package changed
-export async function yarnInstall({ force = false, hashFilePath = './download/buildHash_yarn.md5', nodeModulesPath = './node_modules', } = {}) {
-    await fs.ensureDir(nodeModulesPath);
-    const currentHash = (await Promise.all(yarnFiles.map(async (f) => generateFileHash(f, 'md5')))).join('|');
-    await fs.ensureFile(hashFilePath);
-    const prevHash = await fs.readFile(hashFilePath, 'utf8');
-    if (currentHash !== prevHash) {
-        buildLog('node package definition changed since last build, invoking yarn.');
-    }
-    else if (!(await readDir(`${nodeModulesPath}/**/*.js`)).length) {
-        buildLog('node packages missing, invoking yarn.');
-    }
-    else if (force) {
-        buildLog('node packages unchanged, but yarn forced on command line...');
-    }
-    else {
-        buildLog('node packages unchanged since last build, skipping yarn.');
-        return;
-    }
-    await yarn();
-    await fs.writeFile(hashFilePath, currentHash);
-}
-export async function yarnUpgrade({ all = false, outdated = false, } = {}) {
-    if (outdated) {
-        const { code, stdout } = await yarn({
-            args: ['outdated'],
-            spawnOptions: {
-                captureOutput: true,
-                rejectOnErrorCode: false,
-                stdio: 'pipe',
-            },
-        });
-        if (code === 0) {
-            buildLog('No outdated packages.');
-        }
-        else {
-            const { dependencies = {}, devDependencies = {} } = getPkg();
-            const packages = stdout
-                .split('\n')
-                .slice(5, -1)
-                .map((l) => l.split(/\s+/)[0])
-                .filter((p) => all || !/^\d/.test(dependencies[p] || devDependencies[p] || ''));
-            if (packages.length) {
-                await yarn({ args: ['add', ...packages] });
-                buildLog(`Upgraded: ${packages.join(', ')}`);
-            }
-            else {
-                buildLog('No eligible outdated packages');
-            }
-        }
-    }
-    await yarn({ args: ['upgrade'] });
-}