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

package/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/src/fs.js

@@ -1,96 +1,38 @@
-// @flow
 import fs from 'fs-extra';
+import glob from 'glob';
 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 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: 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 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: string,
-  globOptions?: GlobOptions | boolean,
-): Promise<void> =>
-  new Promise((resolve, reject) =>
-    rimraf(pattern, { glob: globOptions }, (err) =>
-      err ? reject(err) : resolve(),
-    ),
-  );
+export const cleanDir = async (pattern, globOptions) => new Promise((resolve, reject) => {
+    rimraf(pattern, { glob: globOptions }, (err) => err ? reject(err) : resolve());
+});

package/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/src/git.js

@@ -1,34 +1,24 @@
-// @flow
-import { exec } from './cp';
-
-export async function git(args: string[]): Promise<string> {
-  return (await exec(`git ${args.join(' ')}`)).stdout.toString();
+import { exec } from './cp.js';
+export async function git(args) {
+    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 gitBranch() {
+    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();
+export async function gitRevId() {
+    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;
+export async function gitInfo(noCache = false) {
+    if (!info || noCache) {
+        info = {
+            branch: await gitBranch(),
+            revision: await gitRevId(),
+        };
+    }
+    return info;
 }

package/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/src/index.js

@@ -1,26 +1,20 @@
-// @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';
+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/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/src/maps.js

@@ -1,62 +1,12 @@
-// @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 || {}),
-      }),
-    {},
-  );
-
+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
@@ -65,18 +15,9 @@ export const mapValues = <V, K: string, R>(
  * @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 || {}),
-      }),
-    {},
-  );
-
+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`.
@@ -86,26 +27,15 @@ export const mapValuesAsync = async <V, K: string, R>(
  * @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,
-    {},
-  );
-
+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 = <T: { ... }>(
-  obj: T,
-): $ObjMap<T, <V>(V) => $NonMaybeType<V>> => filterKeys(obj);
+export const filterNullish = (obj) => filterKeys(obj);

package/src/npm.d.ts

@@ -0,0 +1,48 @@
+import { SpawnOptions, SpawnResult } from './cp.js';
+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 const envNpmCreds: null | NpmCreds;
+export interface NpmOptions {
+    args?: string[];
+    npmPath?: string;
+    spawnOptions?: SpawnOptions;
+}
+export declare function npm({ args, spawnOptions, npmPath, }?: NpmOptions): Promise<SpawnResult>;
+export declare function npmGetVersions(packageName: string, npmPath?: string): Promise<string[]>;
+interface NpmWriteRcOptions {
+    authToken?: string;
+    creds?: NpmCreds | null;
+    outPath: string;
+    registry?: string;
+}
+export declare function npmWriteRc({ authToken, creds, outPath, registry, }: NpmWriteRcOptions): Promise<void>;
+export interface NpmPublishOptions {
+    npmAuthToken?: string;
+    npmConfig?: NpmConfig;
+    npmCreds?: NpmCreds;
+    npmPath?: string;
+    publishPath?: string;
+    skipExisting?: boolean;
+    tag?: string;
+    workDir?: string;
+}
+export declare function npmPublish({ npmAuthToken, npmConfig, npmCreds, npmPath, publishPath, skipExisting, tag, workDir: passedWorkDir, }?: 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 {};