build-strap 4.0.0-dev.46 → 4.0.0

package/src/flow.js

@@ -1,20 +0,0 @@
-// @flow
-import { spawn } from './cp';
-
-export type FlowOptions = {|
-  allBranches?: boolean,
-  incremental?: boolean,
-|};
-
-// Run the flow linter
-export async function flow(opts?: FlowOptions): Promise<string> {
-  const { allBranches = false, incremental = true } = opts || {};
-  return spawn(
-    'flow',
-    [
-      incremental ? 'status' : 'check',
-      ...(allBranches ? ['--show-all-branches'] : []),
-    ],
-    { stdio: 'inherit', shell: true },
-  );
-}

package/src/fs.js

@@ -1,96 +0,0 @@
-// @flow
-import fs from 'fs-extra';
-import path from 'path';
-import glob, { type Options as GlobOptions } from 'glob';
-import rimraf from 'rimraf';
-
-export const readFile = async (
-  file: string,
-  options:
-    | string
-    | {
-        encoding: string,
-        flag?: string,
-        ...
-      } = 'utf8',
-): Promise<string> => fs.readFile(file, options);
-
-export const writeFile = async (
-  file: string,
-  data: string | Buffer,
-  options?: string | Object,
-): Promise<void> => fs.writeFile(file, data, options);
-
-export const renameFile = async (
-  source: string,
-  target: string,
-): Promise<void> => fs.rename(source, target);
-
-export const copyFile = async (source: string, target: string): Promise<void> =>
-  fs.copyFile(source, target);
-
-export const readDir = async (
-  pattern: string,
-  options?: Object,
-): Promise<string[]> =>
-  new Promise((resolve, reject) =>
-    glob(pattern, options || {}, (err, result) =>
-      err ? reject(err) : resolve(result),
-    ),
-  );
-
-export const makeDir = async (name: string): Promise<void> =>
-  fs.ensureDir(name);
-
-export const moveDir = async (
-  source: string,
-  target: string,
-): Promise<void> => {
-  const dirs = await readDir('**/*.*', {
-    cwd: source,
-    nosort: true,
-    dot: true,
-  });
-  await Promise.all(
-    dirs.map(async (dir) => {
-      const from = path.resolve(source, dir);
-      const to = path.resolve(target, dir);
-      await makeDir(path.dirname(to));
-      await renameFile(from, to);
-    }),
-  );
-};
-
-export const copyDir = async (
-  source: string,
-  target: string,
-  fileGlob: string = '**/*.*',
-  globOptions?: ?Object = null,
-  renameFn: (name: string) => string = (n) => n,
-): Promise<void> => {
-  const paths = await readDir(fileGlob, {
-    cwd: source,
-    nosort: true,
-    nodir: true,
-    dot: true,
-    ...globOptions,
-  });
-  await Promise.all(
-    paths.map(async (p) => {
-      const from = path.resolve(source, p);
-      const to = path.resolve(target, renameFn(p));
-      await makeDir(path.dirname(to));
-      await copyFile(from, to);
-    }),
-  );
-};
-
-export const cleanDir = async (
-  pattern: string,
-  globOptions?: GlobOptions | boolean,
-): Promise<void> =>
-  new Promise((resolve, reject) =>
-    rimraf(pattern, { glob: globOptions }, (err) =>
-      err ? reject(err) : resolve(),
-    ),
-  );

package/src/git.js

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

package/src/hg.js

@@ -1,34 +0,0 @@
-// @flow
-import { exec } from './cp';
-
-export async function hg(args: string[], cwd?: string): Promise<string> {
-  // $FlowFixMe
-  return (await exec(`hg ${args.join(' ')}`, cwd ? { cwd } : {})).stdout;
-}
-
-export async function hgBranch(cwd?: string): Promise<string> {
-  return (await hg(['branch'], cwd)).replace(/[_+/]/g, '-').trim();
-}
-
-export async function hgRevId(cwd?: string): Promise<string> {
-  return (await hg(['id', '-i'], cwd)).replace(/[+]/g, '').trim();
-}
-
-type HgInfo = {
-  branch: string,
-  revision: string,
-};
-
-let info = null;
-export async function hgInfo(
-  noCache: boolean = false,
-  cwd?: string,
-): Promise<HgInfo> {
-  if (!info || noCache) {
-    info = {
-      branch: await hgBranch(cwd),
-      revision: await hgRevId(cwd),
-    };
-  }
-  return info;
-}

package/src/index.js

@@ -1,26 +0,0 @@
-// @flow
-export * from './ant';
-export * from './artifactory';
-export * from './cert';
-export * from './clean';
-export * from './copy';
-export * from './cp';
-export * from './docker';
-export * from './docker.container';
-export * from './docker.network';
-export * from './docker.volume';
-export * from './dockerCleanup';
-export * from './dockerCompose';
-export * from './flow';
-export * from './fs';
-export * from './git';
-export * from './hg';
-export * from './inline-resources';
-export * from './npm';
-export * from './pkg';
-export * from './publish';
-export * from './run';
-export * from './test';
-export * from './tgz';
-export * from './version';
-export * from './yarn';

package/src/inline-resources.js

@@ -1,157 +0,0 @@
-// @flow
-import glob from 'glob';
-import path from 'path';
-import fs from 'fs';
-import { readFile, writeFile } from './fs';
-
-type DependencyMap = {
-  [string]: string[],
-};
-// So we know to copy extra files when a dependency is modified
-export const dependencies: DependencyMap = {};
-
-function recordDependency(parent, child): void {
-  dependencies[child] = dependencies[child] || [];
-  if (!dependencies[child].includes(parent)) {
-    dependencies[child].push(parent);
-  }
-}
-
-/**
- * Inline resources in a tsc/ngc compilation.
- * @param projectPath {string} Path to the project.
- */
-export async function inlineResources(projectPath: string): Promise<void> {
-  // Match only TypeScript files in projectPath.
-  const files = glob.sync('**/*.ts', { cwd: projectPath });
-
-  // For each file, inline the templates and styles under it and write the new file.
-  await Promise.all(
-    files.map(async (filePath) => {
-      const fullFilePath = path.join(projectPath, filePath);
-      const content = await readFile(fullFilePath, 'utf-8');
-      const inlined = inlineResourcesFromString(content, (url) => {
-        // Resolve the template url.
-        const templatePath = path.join(path.dirname(fullFilePath), url);
-        recordDependency(fullFilePath, templatePath);
-        return templatePath;
-      });
-      await writeFile(fullFilePath, inlined);
-    }),
-  );
-}
-
-export function requireResourcesLoader(content: string): string {
-  return [requireTemplate, requireStyle, removeModuleId].reduce(
-    (c, fn) => fn(c, '!raw-loader!'),
-    content,
-  );
-}
-
-// This is a webpack loader
-export function webpackInlineResourceLoader(content: string): string {
-  this.cacheable(true);
-  const dir = this.context;
-  const that = this;
-  return inlineResourcesFromString(content, (url) => {
-    // Resolve the template url.
-    const fullPath = path.join(dir, url);
-    // Make sure this file gets watched
-    that.addDependency(fullPath);
-    return fullPath;
-  });
-}
-
-export type UrlResolver = (url: string) => string;
-
-/**
- * Inline resources from a string content.
- * @param content {string} The source file's content.
- * @param urlResolver {Function} A resolver that takes a URL and return a path.
- * @returns {string} The content with resources inlined.
- */
-export function inlineResourcesFromString(
-  content: string,
-  urlResolver: UrlResolver,
-): string {
-  // Curry through the inlining functions.
-  return [inlineTemplate, inlineStyle, removeModuleId].reduce(
-    (c, fn) => fn(c, urlResolver),
-    content,
-  );
-}
-
-// The cbFn is given the template url, and should return the string to replace it
-function processTemplate(content: string, cbFn: UrlResolver) {
-  return content.replace(
-    /templateUrl:\s*'([^']+?\.html)'/g,
-    (m, templateUrl) => `template: ${cbFn(templateUrl)}`,
-  );
-}
-
-/**
- * Inline the templates for a source file. Simply search for instances of `templateUrl: ...` and
- * replace with `template: ...` (with the content of the file included).
- * @param content {string} The source file's content.
- * @param urlResolver {Function} A resolver that takes a URL and return a path.
- * @return {string} The content with all templates inlined.
- */
-function inlineTemplate(content: string, urlResolver: UrlResolver): string {
-  return processTemplate(
-    content,
-    (templateUrl) =>
-      `\`${fs
-        .readFileSync(urlResolver(templateUrl), 'utf-8')
-        .replace(/([\n\r]\s*)+/gm, ' ')}\``,
-  );
-}
-
-function requireTemplate(content: string, loader: string = ''): string {
-  return processTemplate(content, (url) => `require('${loader}${url}')`);
-}
-
-// The cbFn is given the url of a single css file, and should return the string to replace it
-function processStyle(content: string, cbFn: UrlResolver): string {
-  return content.replace(
-    /styleUrls:\s*(\[[\s\S]*?\])/gm,
-    (m, styleUrls) =>
-      // eslint-disable-next-line no-eval
-      `styles: [${eval(styleUrls)
-        .map((styleUrl) => cbFn(styleUrl))
-        .join(',\n')}]`,
-  );
-}
-
-/**
- * Inline the styles for a source file. Simply search for instances of `styleUrls: [...]` and
- * replace with `styles: [...]` (with the content of the file included).
- * @param urlResolver {Function} A resolver that takes a URL and return a path.
- * @param content {string} The source file's content.
- * @return {string} The content with all styles inlined.
- */
-function inlineStyle(content: string, urlResolver: UrlResolver): string {
-  return processStyle(
-    content,
-    (styleUrl) =>
-      `\`${fs
-        .readFileSync(urlResolver(styleUrl), 'utf-8')
-        .replace(/([\n\r]\s*)+/gm, ' ')}\``,
-  );
-}
-
-function requireStyle(content: string, loader: string = ''): string {
-  return processStyle(content, (url) => `require('${loader}${url}')`);
-}
-
-/**
- * Remove every mention of `moduleId: module.id`.
- * @param content {string} The source file's content.
- * @returns {string} The content with all moduleId: mentions removed.
- */
-function removeModuleId(
-  content: string,
-  // eslint-disable-next-line no-unused-vars
-  urlResolver?: UrlResolver | string,
-): string {
-  return content.replace(/\s*moduleId:\s*module\.id\s*,?\s*/gm, '');
-}

package/src/maps.js

@@ -1,111 +0,0 @@
-// @flow
-// Util functions for using objects as maps and preserving type information
-
-/**
- * An object with arbitrary keys, where every key's value is of the same type.
- */
-export type ObjMap<V, K: string = string> = {
-  +[K]: V,
-};
-// Alias for above, generics in opposite order (for backwards compat)
-export type MapObj<K, V> = ObjMap<V, K>;
-
-/**
- * Given an input object, return an array of the keys.
- * This is a wrapper around the standard `Object.keys` that preserves type information.
- * @param {ObjMap} obj the input object
- * @returns {Array} an array of keys. These will always be strings, but flow may assign
- * a more specific type when possible
- */
-export const keys = <V, K: string = string>(obj?: ?ObjMap<V, K>): K[] =>
-  (Object.keys(obj || {}): any);
-
-/**
- * Given an input object, return an array of the values.
- * This is a wrapper around the standard `Object.values` that preserves type information.
- * @param {ObjMap} obj the input object
- * @returns {Array} an array of values
- */
-export const values = <V, K: string = string>(obj?: ?ObjMap<V, K>): V[] =>
-  (Object.values(obj || {}): any);
-
-/**
- * Given a `ObjMap`, return an array of the entries.
- * This is a wrapper around the standard `Object.entries` that preserves type information.
- * It assumes an object with homogenous values.
- * @param {ObjMap} obj the input object
- * @returns {Array} an array of entry [key, value] tuples
- */
-export const entries = <V, K: string = string>(obj?: ?ObjMap<V, K>): [K, V][] =>
-  (Object.entries(obj || {}): any);
-
-/**
- * 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 = <V, K: string, R>(
-  obj?: ?ObjMap<V, K>,
-  map: (V, K, ObjMap<V, K>) => R,
-): ObjMap<R, K> =>
-  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 <V, K: string, R>(
-  obj?: ?ObjMap<V, K>,
-  map: (V, K, ObjMap<V, K>) => Promise<R>,
-): Promise<ObjMap<R, K>> =>
-  entries(obj).reduce(
-    async (acc, [k, v]) =>
-      Object.assign(await acc, {
-        [k]: await map(v, k, obj || {}),
-      }),
-    {},
-  );
-
-/**
- * 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 = <V, K: string = string>(
-  obj?: ?ObjMap<V, K>,
-  filter?: (V, K, ObjMap<V, K>) => boolean = (v) => v != null,
-): ObjMap<V, K> =>
-  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 = <T: { ... }>(
-  obj: T,
-): $ObjMap<T, <V>(V) => $NonMaybeType<V>> => filterKeys(obj);

package/src/npm.js

@@ -1,144 +0,0 @@
-// @flow
-import { platform } from 'os';
-import path from 'path';
-import fs from 'fs-extra';
-
-import { spawn, exec } from './cp';
-import { getCfg, getPkgName } from './pkg';
-import { getVersion, getDevBranch } from './version';
-import { buildLog } from './run';
-
-export type NpmCreds = {
-  username: string,
-  password: string,
-  email: string,
-};
-
-export type NpmConfig = {
-  publish: boolean,
-  registry?: string,
-  access?: 'public' | 'restricted',
-  dryRun?: boolean,
-};
-
-export function getNpmConfig(): NpmConfig {
-  return getCfg().npm || {};
-}
-
-const envNpmCreds: ?NpmCreds =
-  (process.env.NPM_CREDS && JSON.parse(process.env.NPM_CREDS)) || null;
-
-const npmExe = (npmPath?: string) =>
-  npmPath || (platform() === 'win32' ? 'npm.cmd' : 'npm');
-
-export async function npmExec(
-  args: string[],
-  npmPath?: string,
-): Promise<string> {
-  return (await exec(`${npmExe(npmPath)} ${args.join(' ')}`)).stdout.toString();
-}
-
-export async function npmGetVersions(
-  packageName: string,
-  npmPath?: string,
-): Promise<string[]> {
-  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 type NpmPublishOptions = {|
-  publishPath: string, // distDir, or package.tgz file
-  npmConfig?: NpmConfig,
-  npmCreds?: NpmCreds,
-  npmAuthToken?: string,
-  tag?: string,
-  skipExisting?: boolean,
-  npmPath?: string, // path to executable
-|};
-
-export async function npmPublish({
-  publishPath,
-  npmConfig,
-  npmCreds,
-  npmAuthToken,
-  tag,
-  skipExisting = false,
-  npmPath,
-}: NpmPublishOptions = {}): Promise<boolean> {
-  const creds = npmCreds || envNpmCreds;
-  const authToken = npmAuthToken || process.env.NPM_TOKEN;
-  const name = getPkgName();
-  const { publish, registry, access, dryRun } = npmConfig || getNpmConfig();
-  if (!publish) {
-    buildLog(
-      'npm publish info missing from package.json, skipping npm publish',
-    );
-    return false;
-  }
-  const resolvedPath = path.resolve(publishPath);
-  const workDir = (await fs.stat(resolvedPath)).isDirectory()
-    ? resolvedPath
-    : path.dirname(resolvedPath);
-  if (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 { isRelease, npm: npmVersion, branch } = 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'] : []),
-    ],
-    {
-      stdio: 'inherit',
-      cwd: workDir,
-    },
-  );
-  return true;
-}

package/src/pkg.js

@@ -1,80 +0,0 @@
-// @flow
-import type { ArtifactoryConfig } from './artifactory';
-import type { CertConfig } from './cert';
-import type { DockerConfig } from './docker';
-import type { NpmConfig } from './npm';
-
-export type BuildStrapConfig = {
-  repoType?: 'git' | 'hg',
-  copyright?: string,
-  releaseBranch?: string,
-  devBranch?: string,
-  artifactory?: ArtifactoryConfig,
-  cert?: CertConfig,
-  docker?: DockerConfig,
-  npm?: NpmConfig,
-};
-
-type StringMap = {
-  [string]: string,
-};
-
-export type PackageJson = {
-  name: string,
-  version: string,
-  description?: string,
-  private?: boolean,
-  license?: string,
-  authors?: string[],
-  repository?: string,
-  main?: string,
-  dependencies?: StringMap,
-  devDependencies?: StringMap,
-  peerDependencies?: StringMap,
-  engines?: StringMap,
-  scripts?: StringMap,
-  // our addition
-  buildStrap: BuildStrapConfig,
-};
-
-let _pkg: ?PackageJson = null;
-export function getPkg(): PackageJson {
-  if (_pkg == null) {
-    throw new Error(
-      'Must call setPkg() with package.json content before building.',
-    );
-  }
-  return _pkg;
-}
-
-export function getCfg(): BuildStrapConfig {
-  return getPkg().buildStrap || {};
-}
-
-export function setPkg(p: PackageJson) {
-  _pkg = p;
-}
-
-const pkgNameRegex = /^(?:(@[^/]+)\/)?(.+)$/i;
-
-export function getPkgName(includeScope: boolean = false): string {
-  const pkg = getPkg();
-  if (!(pkg.name && pkg.name.length)) {
-    throw new Error(
-      'Package name not found in package.json, but this is a required property!',
-    );
-  }
-  if (includeScope) {
-    return pkg.name;
-  }
-  const [, , shortName] = pkg.name.match(pkgNameRegex) || [];
-  if (!shortName) {
-    throw new Error('Package name in package.json has invalid format.');
-  }
-  return shortName;
-}
-
-export function getPkgScope(): ?string {
-  const pkgName = getPkgName(true);
-  return pkgName.match(pkgNameRegex)?.[1] || null;
-}