build-strap 4.0.0-dev.46 → 4.0.0-dev.54

package/src/run.js

@@ -1,89 +1,44 @@
-// @flow
-export function format(time?: Date = new Date()): string {
-  return time.toTimeString().replace(/.*(\d{2}:\d{2}:\d{2}).*/, '$1');
+export function format(time = new Date()) {
+    return time.toTimeString().replace(/.*(\d{2}:\d{2}:\d{2}).*/, '$1');
 }
-
 const silenceLogs = process.argv.includes('--silence-buildLog');
-
-export function buildLog(msg: string, time?: Date) {
-  if (silenceLogs) {
-    return;
-  }
-  console.info(`[${format(time || new Date())}] ${msg}`);
+export function buildLog(msg, time) {
+    if (silenceLogs) {
+        return;
+    }
+    console.info(`[${format(time || new Date())}] ${msg}`);
 }
-
-export type RunnableModule<T> =
-  | (() => Promise<T>)
-  | { default: () => Promise<T> };
-
-export async function run<T>(
-  fn: RunnableModule<T>,
-  ...options: any[]
-): Promise<T> {
-  if (fn == null) {
-    throw new Error(`Invalid argument passed to run(${fn})`);
-  }
-  const task = typeof fn === 'function' ? fn : fn.default;
-  if (typeof task !== 'function') {
-    throw new Error(
-      'First argument to run must be a function or module with default function.',
-    );
-  }
-  const start = new Date();
-  buildLog(`Starting '${task.name}'...`, start);
-  const result = await task(...options);
-  const end = new Date();
-  const time = end.getTime() - start.getTime();
-  buildLog(`Finished '${task.name}' after ${time} ms`, end);
-  return result;
+export async function run(fn, ...options) {
+    if (fn == null) {
+        throw new Error(`Invalid argument passed to run(${fn})`);
+    }
+    const task = typeof fn === 'function' ? fn : fn.default;
+    if (typeof task !== 'function') {
+        throw new Error('First argument to run must be a function or module with default function.');
+    }
+    const start = new Date();
+    buildLog(`Starting '${task.name}'...`, start);
+    const result = await task(...options);
+    const end = new Date();
+    const time = end.getTime() - start.getTime();
+    buildLog(`Finished '${task.name}' after ${time} ms`, end);
+    return result;
 }
-
-export type RunCliOptions<T> = {
-  resolveFn?: (path: string) => RunnableModule<T>,
-  defaultAction?: string | RunnableModule<T>,
-  argv?: string[],
-  passthroughArgv?: boolean,
-};
-
-export async function runCli<T>({
-  resolveFn = (path: string) =>
-    // $FlowFixMe
-    require(`./${path}`).default, // eslint-disable-line
-  defaultAction = 'publish',
-  argv = process.argv,
-  passthroughArgv = false,
-}: RunCliOptions<T> = {}): Promise<T> {
-  const module =
-    argv.length > 2
-      ? resolveFn(argv[2])
-      : typeof defaultAction === 'string'
-      ? resolveFn(defaultAction)
-      : defaultAction;
-  const args = Array.isArray(passthroughArgv)
-    ? passthroughArgv.includes(argv[2] || defaultAction)
-      ? argv.slice(3)
-      : []
-    : passthroughArgv
-    ? argv.slice(3)
-    : [];
-  return run(module, ...args).catch((err) => {
-    console.error((err && err.stack) || err);
-    process.exit(1);
-    throw err;
-  });
+export async function runCli({ resolveFn = async (path) => import(`./${path}.js`), defaultAction = 'build', argv = process.argv, passthroughArgv = false, } = {}) {
+    const module = argv.length > 2
+        ? await resolveFn(argv[2])
+        : typeof defaultAction === 'string'
+            ? await resolveFn(defaultAction)
+            : defaultAction;
+    const args = Array.isArray(passthroughArgv)
+        ? passthroughArgv.includes(argv[2] || defaultAction)
+            ? argv.slice(3)
+            : []
+        : passthroughArgv
+            ? argv.slice(3)
+            : [];
+    return run(module, ...args).catch((err) => {
+        console.error((err && err.stack) || err);
+        process.exit(1);
+    });
 }
-
-export function handleEntryPoint<T>(
-  mainModule: typeof module,
-  mainModuleFilename: string,
-  cliOptions?: RunCliOptions<T>,
-) {
-  if (require.main === mainModule) {
-    delete require.cache[mainModuleFilename]; // eslint-disable-line no-underscore-dangle
-    runCli(cliOptions);
-  }
-}
-
-handleEntryPoint(module, __filename);
-
-export default run;

package/src/tgz.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import { Readable } from 'stream';
+import tar from 'tar';
+export declare type ArtifactInfo = {
+    contentType?: string;
+    md5: string;
+    sha1: string;
+    sha512: string;
+    size: number;
+};
+export declare const generateFileHash: (filePath: string, type: 'md5' | 'sha1' | 'sha512') => Promise<string>;
+export declare function getArtifactInfo(artifact: string | Readable): Promise<ArtifactInfo>;
+export declare function tgzDir(srcDir: string, outPath: string, options?: tar.CreateOptions): Promise<ArtifactInfo>;

package/src/tgz.js

@@ -1,101 +1,67 @@
-// @flow
-import path from 'path';
-import tar from 'tar';
-import fs from 'fs';
 import crypto from 'crypto';
+import fs from 'fs-extra';
+import path from 'path';
 import StreamCounter from 'stream-counter';
-import { makeDir } from './fs';
-import { buildLog } from './run';
-
-export type ArtifactInfo = {
-  md5: string,
-  sha1: string,
-  sha512: string,
-  size: number,
-  contentType?: string,
-};
-
-const generateHash = async (
-  stream: stream$Readable,
-  type: 'md5' | 'sha1' | 'sha512',
-): Promise<string> =>
-  new Promise((resolve, reject) => {
+import tar from 'tar';
+import { buildLog } from './run.js';
+const generateHash = async (stream, type) => new Promise((resolve, reject) => {
     stream
-      .pipe(crypto.createHash(type).setEncoding('hex'))
-      .on('finish', function () {
+        .pipe(crypto.createHash(type).setEncoding('hex'))
+        .on('finish', function onFinish() {
         resolve(this.read());
-      })
-      .on('end', function () {
+    })
+        .on('end', function onEnd() {
         resolve(this.read());
-      })
-      .on('error', (err) => reject(err));
-  });
-
-const countBytes = async (stream: stream$Readable): Promise<number> =>
-  new Promise((resolve, reject) => {
+    })
+        .on('error', (err) => reject(err));
+});
+export const generateFileHash = async (filePath, type) => generateHash(fs.createReadStream(filePath), type);
+const countBytes = async (stream) => new Promise((resolve, reject) => {
     const counter = new StreamCounter();
     stream
-      .pipe(counter)
-      .on('finish', () => resolve(counter.bytes))
-      .on('end', () => resolve(counter.bytes))
-      .on('error', (err) => reject(err));
-  });
-
-const writeStreamToFile = async (stream: stream$Readable, filePath: string) =>
-  new Promise((resolve, reject) => {
+        .pipe(counter)
+        .on('finish', () => resolve(counter.bytes))
+        .on('end', () => resolve(counter.bytes))
+        .on('error', (err) => reject(err));
+});
+const writeStreamToFile = async (stream, filePath) => new Promise((resolve, reject) => {
     stream
-      .pipe(fs.createWriteStream(filePath))
-      .on('finish', () => {
+        .pipe(fs.createWriteStream(filePath))
+        .on('finish', () => {
         buildLog(`Successfully wrote file: ${filePath}`);
         resolve();
-      })
-      .on('error', (err) => reject(err));
-  });
-
-// Take the given file (path or stream) and compute the info that artifactory needs.
-// md5 + sha1 hash, and size in bytes
-export async function getArtifactInfo(
-  artifact: string | stream$Readable,
-): Promise<ArtifactInfo> {
-  // make it into a stream
-  const stream: stream$Readable =
-    typeof artifact === 'string' ? fs.createReadStream(artifact) : artifact;
-
-  const [md5, sha1, sha512, size] = await Promise.all([
-    generateHash(stream, 'md5'),
-    generateHash(stream, 'sha1'),
-    generateHash(stream, 'sha512'),
-    countBytes(stream),
-  ]);
-  return { md5, sha1, sha512, size };
+    })
+        .on('error', (err) => reject(err));
+});
+// Take the given file (path or stream) and compute metadata for it.
+// md5 + sha hashes, and size in bytes
+export async function getArtifactInfo(artifact) {
+    // make it into a stream
+    const stream = typeof artifact === 'string' ? fs.createReadStream(artifact) : artifact;
+    const [md5, sha1, sha512, size] = await Promise.all([
+        generateHash(stream, 'md5'),
+        generateHash(stream, 'sha1'),
+        generateHash(stream, 'sha512'),
+        countBytes(stream),
+    ]);
+    return { md5, sha1, sha512, size };
 }
-
 // Creates a gzipped tarball of a directory, returns sha1 + md5 hash and size of resulting file
-export async function tgzDir(
-  srcDir: string,
-  outPath: string,
-  options?: ?{ [string]: any },
-): Promise<ArtifactInfo> {
-  await makeDir(path.dirname(outPath));
-  const tgzStream = tar.c(
-    // $FlowFixMe
-    {
-      gzip: true,
-      cwd: srcDir,
-      portable: true,
-      // $FlowFixMe
-      ...options,
-    },
-    ['.'],
-  );
-
-  // write the file to disk (outPath)
-  const [info] = await Promise.all([
-    getArtifactInfo(tgzStream),
-    writeStreamToFile(tgzStream, `${outPath}`),
-  ]);
-  return {
-    ...info,
-    contentType: 'application/gzip',
-  };
+export async function tgzDir(srcDir, outPath, options) {
+    await fs.ensureDir(path.dirname(outPath));
+    const tgzStream = tar.c({
+        cwd: srcDir,
+        gzip: true,
+        portable: true,
+        ...options,
+    }, ['.']);
+    // write the file to disk (outPath)
+    const [info] = await Promise.all([
+        getArtifactInfo(tgzStream),
+        writeStreamToFile(tgzStream, `${outPath}`),
+    ]);
+    return {
+        ...info,
+        contentType: 'application/gzip',
+    };
 }

package/src/version.d.ts

@@ -0,0 +1,34 @@
+export declare function getBuild(): string;
+export declare function getReleaseBranch(): string;
+declare enum RepoType {
+    git = "git",
+    hg = "hg",
+    unknown = "unknown"
+}
+export declare function getRepoType(): Promise<RepoType>;
+declare type RepoInfo = {
+    branch: string;
+    revision: string;
+};
+export declare function getRepoInfo(): Promise<RepoInfo>;
+export declare function getDevBranch(): Promise<string>;
+export declare function getIsRelease(passedBranch?: null | string, releaseOverride?: null | boolean): Promise<boolean>;
+export declare function useVersionCache(useCache?: boolean): void;
+export interface Version {
+    branch: string;
+    build: string;
+    info: string;
+    isRelease: boolean;
+    major: string;
+    minor: string;
+    name: string;
+    npm: string;
+    patch: string;
+    revision: string;
+    short: string;
+}
+export declare function getVersion(logIt?: boolean, release?: null | boolean): Promise<Version>;
+export declare function getBanner(): Promise<string>;
+export declare function getVersionCode(): Promise<string>;
+export declare function getUniqueBuildTag(): Promise<string>;
+export {};

package/src/version.js

@@ -1,142 +1,101 @@
-// @flow
 import fs from 'fs';
-import { gitInfo } from './git';
-import { hgInfo } from './hg';
-import { getCfg, getPkg } from './pkg';
-import { buildLog } from './run';
-
-export function getBuild(): string {
-  const arg = process.argv.find((el) => /^--buildNum=\d+$/.test(el));
-  return (arg && arg.substr(11)) || process.env.BUILD_NUMBER || '0';
+import { gitInfo } from './git.js';
+import { getCfg, getPkg } from './pkg.js';
+import { buildLog } from './run.js';
+export function getBuild() {
+    const arg = process.argv.find((el) => /^--buildNum=\d+$/.test(el));
+    return (arg && arg.substring(11)) || process.env.BUILD_NUMBER || '0';
 }
-
-export function getReleaseBranch(): string {
-  const { releaseBranch } = getCfg();
-  return releaseBranch || 'master';
+export function getReleaseBranch() {
+    const { releaseBranch } = getCfg();
+    return releaseBranch || 'master';
 }
-
-type RepoType = 'git' | 'hg' | 'unknown';
-export async function getRepoType(): Promise<RepoType> {
-  const { repoType } = getCfg();
-
-  return (
-    repoType ||
-    (fs.existsSync('./.hg')
-      ? 'hg'
-      : fs.existsSync('./.git')
-      ? 'git'
-      : 'unknown')
-  );
+var RepoType;
+(function (RepoType) {
+    RepoType["git"] = "git";
+    RepoType["hg"] = "hg";
+    RepoType["unknown"] = "unknown";
+})(RepoType || (RepoType = {}));
+export async function getRepoType() {
+    const { repoType } = getCfg();
+    return (repoType ||
+        (fs.existsSync('./.git')
+            ? RepoType.git
+            : fs.existsSync('./.hg')
+                ? RepoType.hg
+                : RepoType.unknown));
 }
-
-type RepoInfo = {
-  branch: string,
-  revision: string,
-};
-
-export async function getRepoInfo(): Promise<RepoInfo> {
-  const repoType = await getRepoType();
-  const { branch, revision } =
-    repoType === 'git'
-      ? await gitInfo()
-      : repoType === 'hg'
-      ? await hgInfo()
-      : {};
-  if (!branch || !revision) {
-    throw new Error('Failed to parse branch and revision from source repo.');
-  }
-  return { branch, revision };
+export async function getRepoInfo() {
+    const repoType = await getRepoType();
+    if (repoType !== RepoType.git) {
+        throw new Error(`Unsupported repo type: ${repoType}`);
+    }
+    const { branch, revision } = await gitInfo();
+    if (!branch || !revision) {
+        throw new Error('Failed to parse branch and revision from source repo.');
+    }
+    return { branch, revision };
 }
-
-export async function getDevBranch(): Promise<string> {
-  const { devBranch } = getCfg();
-  return devBranch || (await getRepoType()) === 'hg' ? 'default' : 'dev';
+export async function getDevBranch() {
+    const { devBranch } = getCfg();
+    return devBranch || ((await getRepoType()) === 'hg' ? 'default' : 'dev');
 }
-
-export async function getIsRelease(
-  passedBranch?: ?string = null,
-  releaseOverride?: ?boolean = null,
-): Promise<boolean> {
-  const branch = passedBranch || (await getRepoInfo()).branch;
-  return releaseOverride != null
-    ? releaseOverride
-    : process.argv.includes('--force-release-version')
-    ? true
-    : branch === getReleaseBranch();
+export async function getIsRelease(passedBranch = null, releaseOverride = null) {
+    const branch = passedBranch || (await getRepoInfo()).branch;
+    return releaseOverride != null
+        ? releaseOverride
+        : process.argv.includes('--force-release-version')
+            ? true
+            : branch === getReleaseBranch();
 }
-
 let cacheVersion = true;
-export function useVersionCache(useCache: boolean = true): void {
-  cacheVersion = useCache;
+export function useVersionCache(useCache = true) {
+    cacheVersion = useCache;
 }
-
-export type Version = {|
-  branch: string,
-  build: string,
-  info: string,
-  isRelease: boolean,
-  major: string,
-  minor: string,
-  name: string,
-  npm: string,
-  patch: string,
-  revision: string,
-  short: string,
-|};
-
 let version = null;
-export async function getVersion(
-  logIt: boolean = true,
-  release: ?boolean = null,
-): Promise<Version> {
-  if (!cacheVersion || version == null) {
-    const { version: pkgVers, name } = getPkg();
-    const { branch, revision } = await getRepoInfo();
-    const [, major, minor, patch] =
-      pkgVers.match(/^(\d+)\.(\d+)\.(\d+)$/) || [];
-    if (!major || !minor || !patch) {
-      throw new Error('Invalid version format in package.json');
-    }
-    const build = getBuild();
-    const isRelease = await getIsRelease(branch, release);
-    const short = `${major}.${minor}.${patch}`;
-    const npm = `${short}${isRelease ? '' : `-${branch}.${build}`}`;
-    const info = `${short}${
-      isRelease ? `+${build}.` : `-${branch}.${build}+`
-    }${revision}`;
-    version = {
-      name,
-      branch,
-      revision,
-      major,
-      minor,
-      patch,
-      build,
-      short,
-      isRelease,
-      npm,
-      info,
-    };
-    if (logIt) {
-      buildLog(`Building version ${info}`);
+export async function getVersion(logIt = true, release = null) {
+    if (!cacheVersion || version == null) {
+        const { name, version: pkgVers } = getPkg();
+        const { branch, revision } = await getRepoInfo();
+        const [, major, minor, patch] = pkgVers.match(/^(\d+)\.(\d+)\.(\d+)$/) || [];
+        if (!major || !minor || !patch) {
+            throw new Error('Invalid version format in package.json');
+        }
+        const build = getBuild();
+        const isRelease = await getIsRelease(branch, release);
+        const short = `${major}.${minor}.${patch}`;
+        const npm = `${short}${isRelease ? '' : `-${branch}.${build}`}`;
+        const info = `${short}${isRelease ? `+${build}.` : `-${branch}.${build}+`}${revision}`;
+        version = {
+            branch,
+            build,
+            info,
+            isRelease,
+            major,
+            minor,
+            name,
+            npm,
+            patch,
+            revision,
+            short,
+        };
+        if (logIt) {
+            buildLog(`Building version ${info}`);
+        }
     }
-  }
-  return version;
+    return version;
 }
-
-export async function getBanner(): Promise<string> {
-  const { copyright = '' } = getCfg();
-  const { info, name } = await getVersion();
-  const today = new Date();
-  return `${name} v${info} | (c) ${today.getFullYear()} ${copyright} | built on ${today.toISOString()}`;
+export async function getBanner() {
+    const { copyright = '' } = getCfg();
+    const { info, name } = await getVersion();
+    const today = new Date();
+    return `${name} v${info} | (c) ${today.getFullYear()} ${copyright} | built on ${today.toISOString()}`;
 }
-
-export async function getVersionCode(): Promise<string> {
-  return `// This file is auto-generated
+export async function getVersionCode() {
+    return `// This file is auto-generated
 export const version = ${JSON.stringify(await getVersion(), null, 2)}`;
 }
-
-export async function getUniqueBuildTag(): Promise<string> {
-  const { branch, revision, build } = await getVersion();
-  return `${branch}-${revision}-${build}`;
+export async function getUniqueBuildTag() {
+    const { branch, build, revision } = await getVersion();
+    return `${branch}-${revision}-${build}`;
 }

package/src/yarn.d.ts

@@ -0,0 +1,44 @@
+import { SpawnOptions, SpawnResult } from './cp.js';
+import { NpmConfig, NpmCreds } from './npm.js';
+export interface YarnOptions {
+    args?: string[];
+    spawnOptions?: SpawnOptions;
+}
+export declare function yarn({ args, spawnOptions, }?: YarnOptions): Promise<SpawnResult>;
+export declare const yarnFiles: string[];
+export interface YarnInstallOptions {
+    force?: boolean;
+    hashFilePath?: string;
+    nodeModulesPath?: string;
+}
+export declare function yarnInstall({ force, hashFilePath, nodeModulesPath, }?: YarnInstallOptions): Promise<void>;
+export interface YarnUpgradeOptions {
+    /**
+     * `false` by default
+     * we assume any package with an explicit version shouldn't be touched
+     */
+    all?: boolean;
+    /**
+     * Use `yarn outdated` to find packages that should be upgraded
+     * May include breaking changes (major version changes)
+     */
+    outdated?: boolean;
+}
+export declare function yarnUpgrade({ all, outdated, }?: YarnUpgradeOptions): Promise<void>;
+export interface YarnPublishOptions {
+    npmAuthToken?: string;
+    npmConfig?: NpmConfig;
+    npmCreds?: NpmCreds;
+    npmPath?: string;
+    publishPath?: string;
+    skipExisting?: boolean;
+    tag?: string;
+    workDir?: string;
+}
+export declare function yarnPublish({ npmAuthToken, npmConfig, npmCreds, npmPath, publishPath, skipExisting, tag, workDir: passedWorkDir, }?: YarnPublishOptions): Promise<boolean>;
+interface YarnPackOptions {
+    destination: string;
+    workDir?: string;
+}
+export declare function yarnPack({ destination, workDir, }: YarnPackOptions): Promise<string>;
+export {};