build-strap 4.0.0-dev.2 → 4.0.0-dev.3

package/npm.d.ts

@@ -11,8 +11,16 @@ export declare type NpmConfig = {
     registry?: string;
 };
 export declare function getNpmConfig(): NpmConfig;
+export declare const envNpmCreds: null | NpmCreds;
 export declare function npmExec(args: string[], npmPath?: string): Promise<string>;
 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;

package/npm.js

@@ -8,7 +8,7 @@ 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;
+export 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();
@@ -22,6 +22,19 @@ export async function npmGetVersions(packageName, npmPath) {
         return [];
     }
 }
+export async function npmWriteRc({ authToken, creds, outPath, registry, }) {
+    // Write out .npmrc with credentials
+    const theRegistry = registry || 'https://registry.npmjs.org/';
+    const [, host] = /^(?:http(?:s)?:\/\/)?(.+)$/.exec(theRegistry) || [];
+    await fs.mkdirp(path.dirname(outPath));
+    await fs.writeFile(outPath, `registry=${theRegistry}
+${authToken ? `//${host}:_authToken=${authToken}` : ''}
+${creds
+        ? `_auth=${Buffer.from(`${creds.username}:${creds.password}`).toString('base64')}
+always-auth=true
+email=${creds.email}`
+        : ''}`);
+}
 export async function npmPublish({ npmAuthToken, npmConfig, npmCreds, npmPath, publishPath = '.', skipExisting = false, tag, workDir: passedWorkDir, } = {}) {
     const creds = npmCreds || envNpmCreds;
     const authToken = npmAuthToken || process.env.NPM_TOKEN;
@@ -42,16 +55,12 @@ export async function npmPublish({ npmAuthToken, npmConfig, npmCreds, npmPath, p
     }
     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=\${NPM_TOKEN}` : ''}
-${creds
-            ? `_auth=${Buffer.from(`${creds.username}:${creds.password}`).toString('base64')}
-always-auth=true
-email=${creds.email}`
-            : ''}`);
+        await npmWriteRc({
+            authToken: authToken ? `\${NPM_TOKEN}` : undefined,
+            creds,
+            outPath: path.join(workDir, '.npmrc'),
+            registry,
+        });
     }
     const existing = await npmGetVersions(name, npmPath);
     const { branch, isRelease, npm: npmVersion } = await getVersion();
@@ -81,6 +90,7 @@ email=${creds.email}`
             ...process.env,
             NPM_TOKEN: authToken,
         },
+        shell: true,
         stdio: 'inherit',
     });
     return true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "build-strap",
-  "version": "4.0.0-dev.2",
+  "version": "4.0.0-dev.3",
   "description": "Node scripts for building things",
   "license": "MIT",
   "authors": [

package/yarn.d.ts

@@ -1,4 +1,5 @@
 import { SpawnOptions, SpawnResult } from './cp.js';
+import { NpmConfig, NpmCreds } from './npm.js';
 export interface YarnOptions {
     args?: string[];
     spawnOptions?: SpawnOptions;
@@ -24,3 +25,20 @@ export interface YarnUpgradeOptions {
     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 {};

package/yarn.js

@@ -2,9 +2,11 @@ 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 { envNpmCreds, getNpmConfig, npmGetVersions, npmWriteRc, } from './npm.js';
+import { getPkg, getPkgName } from './pkg.js';
 import { buildLog } from './run.js';
 import { generateFileHash } from './tgz.js';
+import { getDevBranch, getVersion } from './version.js';
 export async function yarn({ args = [], spawnOptions, } = {}) {
     const localYarn = path.join(path.dirname(process.execPath), '/node_modules/yarn/bin/yarn.js');
     const spawnOpts = {
@@ -73,3 +75,87 @@ export async function yarnUpgrade({ all = false, outdated = false, } = {}) {
     }
     await yarn({ args: ['upgrade'] });
 }
+export async function yarnPublish({ npmAuthToken, npmConfig, npmCreds, npmPath, publishPath = '.', skipExisting = false, tag, workDir: passedWorkDir, } = {}) {
+    const creds = npmCreds || envNpmCreds;
+    const authToken = npmAuthToken || process.env.NPM_TOKEN;
+    const name = getPkgName();
+    const { access, 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 (creds || registry || authToken) {
+        // Write out .npmrc with credentials
+        await npmWriteRc({
+            authToken: authToken ? `\${NPM_TOKEN}` : undefined,
+            creds,
+            outPath: path.join(workDir, '.npmrc'),
+            registry,
+        });
+    }
+    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 yarn({
+        args: [
+            'publish',
+            resolvedPath,
+            '--tag',
+            tag ||
+                (isRelease
+                    ? 'latest'
+                    : branch === (await getDevBranch())
+                        ? 'next'
+                        : 'branch'),
+            ...(access ? ['--access', access] : []),
+        ],
+        spawnOptions: {
+            cwd: workDir,
+            env: {
+                ...process.env,
+                FORCE_COLOR: 'true',
+                NPM_TOKEN: authToken,
+            },
+            shell: true,
+            stdio: 'inherit',
+        },
+    });
+    return true;
+}
+export async function yarnPack({ destination, workDir = '.', }) {
+    if (destination) {
+        await fs.ensureDir(destination);
+    }
+    const { stdout } = await yarn({
+        args: [
+            'pack',
+            ...(destination ? ['--filename', path.resolve(destination)] : []),
+        ],
+        spawnOptions: {
+            captureOutput: true,
+            cwd: path.resolve(workDir),
+            env: {
+                ...process.env,
+                FORCE_COLOR: 'true',
+            },
+            pipeOutput: true,
+        },
+    });
+    console.log({ stdout });
+    return path.resolve(destination || '.', stdout.trim());
+}