@percy/cli-command 1.26.2-beta.0 → 1.26.3-alpha.4

package/dist/command.js

@@ -1,3 +1,8 @@
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
 import logger from '@percy/logger';
 import PercyConfig from '@percy/config';
 import { set, del } from '@percy/config/utils';
@@ -9,18 +14,15 @@ import parse from './parse.js';
 
 // Copies a command definition and adds built-in flags and config options.
 function withBuiltIns(definition) {
-  let def = {
-    ...definition
-  };
-  def.flags = [...(def.flags ?? [])];
+  var _def$flags, _def$config$schemas, _def$config$migration;
+  let def = _objectSpread({}, definition);
+  def.flags = [...((_def$flags = def.flags) !== null && _def$flags !== void 0 ? _def$flags : [])];
 
   // ensure built-ins aren't already overridden
   let addDedupedFlag = flag => {
     if (!def.flags.find(f => f.name === flag.name)) {
       let short = def.flags.find(f => f.short === flag.short);
-      def.flags.push(short ? del({
-        ...flag
-      }, 'short') : flag);
+      def.flags.push(short ? del(_objectSpread({}, flag), 'short') : flag);
     }
   };
 
@@ -43,11 +45,9 @@ function withBuiltIns(definition) {
   builtInFlags.GLOBAL.forEach(addDedupedFlag);
 
   // copy any existing config before adding to it
-  def.config = {
-    ...def.config
-  };
-  def.config.schemas = [...(def.config.schemas ?? [])];
-  def.config.migrations = [...(def.config.migrations ?? [])];
+  def.config = _objectSpread({}, def.config);
+  def.config.schemas = [...((_def$config$schemas = def.config.schemas) !== null && _def$config$schemas !== void 0 ? _def$config$schemas : [])];
+  def.config.migrations = [...((_def$config$migration = def.config.migrations) !== null && _def$config$migration !== void 0 ? _def$config$migration : [])];
 
   // add percy specific built-in config options
   if (def.percy) {
@@ -94,10 +94,9 @@ async function runCommandWithContext(parsed) {
     } = await import('@percy/core');
 
     // shallow merge with default options
-    let conf = {
-      server: false,
-      ...def.percy
-    };
+    let conf = _objectSpread({
+      server: false
+    }, def.percy);
     if (pkg) conf.clientInfo || (conf.clientInfo = `${pkg.name}/${pkg.version}`);
     conf.environmentInfo || (conf.environmentInfo = `node/${process.version}`);
     Object.defineProperty(context, 'percy', {
@@ -169,7 +168,8 @@ export function command(name, definition, callback) {
 
       // exit when appropriate
       if (err.exitCode !== 0) {
-        err.exitCode ?? (err.exitCode = 1);
+        var _err$exitCode;
+        (_err$exitCode = err.exitCode) !== null && _err$exitCode !== void 0 ? _err$exitCode : err.exitCode = 1;
         err.message || (err.message = `EEXIT: ${err.exitCode}`);
         if (definition.exitOnError) {
           process.exit(err.exitCode);

package/dist/help.js

@@ -1,3 +1,8 @@
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
 import logger from '@percy/logger';
 
 // Helper to return an argument's description including it's default value.
@@ -11,7 +16,8 @@ function argumentDescription(arg) {
 
 // Helper to return an array of visible argument usage-description pairs.
 async function visibleArguments(command) {
-  let args = command.definition.args ?? [];
+  var _command$definition$a;
+  let args = (_command$definition$a = command.definition.args) !== null && _command$definition$a !== void 0 ? _command$definition$a : [];
 
   // not hidden and not deprecated
   let visible = args.reduce((visible, arg) => {
@@ -50,7 +56,8 @@ function commandUsage(command) {
 
 // Helper to return an array of visible command usage-description pairs.
 async function visibleCommands(command, nested) {
-  let commands = command.definition.commands ?? [];
+  var _command$definition$c;
+  let commands = (_command$definition$c = command.definition.commands) !== null && _command$definition$c !== void 0 ? _command$definition$c : [];
   if (typeof commands === 'function') commands = await commands();
   let visible = [];
   for (let cmd of commands) {
@@ -59,11 +66,10 @@ async function visibleCommands(command, nested) {
 
     // create parent references and format subcommand names
     let name = command.parent ? `${command.name}:${cmd.name}` : cmd.name;
-    cmd = {
-      ...cmd,
+    cmd = _objectSpread(_objectSpread({}, cmd), {}, {
       name,
       parent: command
-    };
+    });
 
     // commands without callbacks are not visible themselves
     if (cmd.callback) {
@@ -213,10 +219,9 @@ export async function formatHelp(command) {
     top = top.parent;
   }
   if (top) name = `${top.name} ${name}`;
-  command = {
-    ...command,
+  command = _objectSpread(_objectSpread({}, command), {}, {
     name
-  };
+  });
 
   // include command description and own usage
   if (description) output.push(wrapString(description, maxWidth), '');

package/dist/legacy.js

@@ -1,3 +1,12 @@
+const _excluded = ["name"],
+  _excluded2 = ["char", "deprecated"];
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
 import { merge } from '@percy/config/utils';
 import { command } from './command.js';
 
@@ -8,42 +17,38 @@ export const legacyFlags = {
   discovery: {
     __percy__: {}
   },
-  string: def => ({
-    type: 'string',
-    ...def
-  }),
-  boolean: def => ({
-    type: 'boolean',
-    ...def
-  }),
-  integer: def => ({
-    type: 'integer',
-    ...def
-  })
+  string: def => _objectSpread({
+    type: 'string'
+  }, def),
+  boolean: def => _objectSpread({
+    type: 'boolean'
+  }, def),
+  integer: def => _objectSpread({
+    type: 'integer'
+  }, def)
 };
 
 // Maps a legacy arg that might have alternate properties
 function legacyArg(legacy) {
   let {
-    name,
-    ...def
-  } = legacy;
+      name
+    } = legacy,
+    def = _objectWithoutProperties(legacy, _excluded);
   // do not camelcase legacy attribute names
   def.attribute = name;
   // add name back to mapped options
-  return {
-    name,
-    ...def
-  };
+  return _objectSpread({
+    name
+  }, def);
 }
 
 // Maps a legacy flag that might have alternate properties
 function legacyFlag(name, legacy) {
   let {
-    char: short,
-    deprecated,
-    ...def
-  } = legacy;
+      char: short,
+      deprecated
+    } = legacy,
+    def = _objectWithoutProperties(legacy, _excluded2);
   // generic legacy type looks odd in help output
   if (def.type === 'option') def.type = 'value';
   // do not camelcase legacy attribute names
@@ -60,25 +65,24 @@ function legacyFlag(name, legacy) {
   }
 
   // add name and mapped short option
-  return {
+  return _objectSpread({
     name,
-    short,
-    ...def
-  };
+    short
+  }, def);
 }
 
 // Maps a legacy class-based command to the new functional syntax
 export function legacyCommand(name, constructor) {
-  var _constructor$args, _constructor$flags;
+  var _constructor$args, _constructor$flags, _constructor$flags$__, _constructor$flags2;
   let runner = command(name, {
     description: constructor.description,
     examples: constructor.examples,
     // map legacy args and flags
     args: (_constructor$args = constructor.args) === null || _constructor$args === void 0 ? void 0 : _constructor$args.map(legacyArg),
-    flags: Object.entries(constructor.flags ?? []).map(([name, def]) => legacyFlag(name, def)).filter(({
+    flags: Object.entries((_constructor$flags = constructor.flags) !== null && _constructor$flags !== void 0 ? _constructor$flags : []).map(([name, def]) => legacyFlag(name, def)).filter(({
       name
     }) => name !== '__percy__'),
-    percy: ((_constructor$flags = constructor.flags) === null || _constructor$flags === void 0 ? void 0 : _constructor$flags.__percy__) ?? true,
+    percy: (_constructor$flags$__ = (_constructor$flags2 = constructor.flags) === null || _constructor$flags2 === void 0 ? void 0 : _constructor$flags2.__percy__) !== null && _constructor$flags$__ !== void 0 ? _constructor$flags$__ : true,
     loose: constructor.strict === false,
     legacy: true
   }, async function* (ctx) {

package/dist/parse.js

@@ -1,3 +1,9 @@
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function _objectDestructuringEmpty(obj) { if (obj == null) throw new TypeError("Cannot destructure " + obj); }
 import logger from '@percy/logger';
 import { camelcase } from '@percy/config/utils';
 import { flagUsage } from './help.js';
@@ -29,7 +35,7 @@ function isFlag(option) {
 // options. If a command is found, parsed output is updated accordingly and the current input option
 // is removed from further processing. An implicit help command is also supported.
 async function maybeParseCommand(input, parsed) {
-  var _input$;
+  var _input$0$split, _input$;
   // a flag, no defined commands, or already parsed other options
   if (isFlag(input[0]) || !parsed.command.definition.commands || parsed.operators.size || parsed.argv.length) {
     return;
@@ -42,7 +48,7 @@ async function maybeParseCommand(input, parsed) {
   }
 
   // nested commands can be a single argument with command names separated by colons (:)
-  let names = ((_input$ = input[0]) === null || _input$ === void 0 ? void 0 : _input$.split(':')) ?? [];
+  let names = (_input$0$split = (_input$ = input[0]) === null || _input$ === void 0 ? void 0 : _input$.split(':')) !== null && _input$0$split !== void 0 ? _input$0$split : [];
   let command;
   for (let name of names) {
     var _parent$definition$co, _command;
@@ -136,7 +142,8 @@ async function maybeParseFlag(input, parsed) {
     if (flag.type === 'integer') value = parseInt(value, 10);
     if (flag.parse) value = await flag.parse(value);
     if (flag.multiple) {
-      value = (parsed.operators.get(flag) ?? []).concat(value);
+      var _parsed$operators$get;
+      value = ((_parsed$operators$get = parsed.operators.get(flag)) !== null && _parsed$operators$get !== void 0 ? _parsed$operators$get : []).concat(value);
     }
 
     // add this flag to the set of parsed operators
@@ -162,11 +169,11 @@ async function maybeParseFlag(input, parsed) {
 // returning true if any defined argument was found. Arguments are matched according to their
 // respective index and command-line position.
 async function maybeParseArg(input, parsed) {
-  var _parsed$command$defin;
+  var _parsed$__args_index_, _parsed$command$defin;
   if (isFlag(input[0])) return;
 
   // the argument index needs to be tracked since flag options can precede argument options
-  let index = parsed.__args_index__ ?? (parsed.__args_index__ = 0);
+  let index = (_parsed$__args_index_ = parsed.__args_index__) !== null && _parsed$__args_index_ !== void 0 ? _parsed$__args_index_ : parsed.__args_index__ = 0;
 
   // there are arguments left to parse
   if (index < ((_parsed$command$defin = parsed.command.definition.args) === null || _parsed$command$defin === void 0 ? void 0 : _parsed$command$defin.length)) {
@@ -273,11 +280,12 @@ function validateExclusiveFlag(flag, parsed) {
 // mapped to the replacement flag's attribute name. If a deprecated option is found in the provided
 // operators, a deprecation warning will be logged with any recommendation message.
 function attributeName(option, parsed) {
+  var _parsed$operators$get2;
   let {
     attribute,
     deprecated
   } = option;
-  let value = parsed.operators.get(option) ?? option.default;
+  let value = (_parsed$operators$get2 = parsed.operators.get(option)) !== null && _parsed$operators$get2 !== void 0 ? _parsed$operators$get2 : option.default;
   // the option's attribute name might be contingent on it's value
   let name = typeof attribute === 'function' ? attribute(value) : attribute;
   // default the attribute name to the camelcase name or short character
@@ -311,9 +319,8 @@ function attributeName(option, parsed) {
 async function normalizeCommand(command, properties) {
   var _ref;
   // shallow copy command definition
-  let {
-    ...definition
-  } = command.definition;
+  let _command$definition = command.definition,
+    definition = Object.assign({}, (_objectDestructuringEmpty(_command$definition), _command$definition));
 
   // evaluate commands if needed
   if (typeof definition.commands === 'function') {
@@ -321,11 +328,9 @@ async function normalizeCommand(command, properties) {
   }
 
   // create a shallow copy with additional properties
-  let normalized = {
-    ...command,
-    ...properties,
+  let normalized = _objectSpread(_objectSpread(_objectSpread({}, command), properties), {}, {
     definition
-  };
+  });
 
   // inherit parent package information by default
   normalized.packageInformation || (normalized.packageInformation = (_ref = (properties === null || properties === void 0 ? void 0 : properties.parent) || command.parent) === null || _ref === void 0 ? void 0 : _ref.packageInformation);
@@ -377,7 +382,8 @@ export async function parse(command, argv) {
   }
 
   // validate and map defined args
-  for (let arg of parsed.command.definition.args ?? []) {
+  for (let arg of (_parsed$command$defin2 = parsed.command.definition.args) !== null && _parsed$command$defin2 !== void 0 ? _parsed$command$defin2 : []) {
+    var _parsed$command$defin2;
     // collect last-minute env info
     await maybeParseEnv(arg, parsed);
     if (parsed.operators.has(arg)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@percy/cli-command",
-  "version": "1.26.2-beta.0",
+  "version": "1.26.3-alpha.4",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -9,7 +9,7 @@
   },
   "publishConfig": {
     "access": "public",
-    "tag": "beta"
+    "tag": "alpha"
   },
   "files": [
     "dist",
@@ -36,9 +36,9 @@
     "test:coverage": "yarn test --coverage"
   },
   "dependencies": {
-    "@percy/config": "1.26.2-beta.0",
-    "@percy/core": "1.26.2-beta.0",
-    "@percy/logger": "1.26.2-beta.0"
+    "@percy/config": "1.26.3-alpha.4",
+    "@percy/core": "1.26.3-alpha.4",
+    "@percy/logger": "1.26.3-alpha.4"
   },
-  "gitHead": "14191aa65d5da5190039ae0938c9fd8edab7cd28"
+  "gitHead": "d89ab97b8d5169eafd3eb42bdbbef41a2ac624ba"
 }