@hubspot/cli 6.2.1 → 6.2.2-experimental.0

package/lib/generate-selectors.js

@@ -1,161 +1,123 @@
+"use strict";
 const fs = require('fs');
 const { EXIT_CODES } = require('./enums/exitCodes');
 const { logger } = require('@hubspot/local-dev-lib/logger');
 const { i18n } = require('../lib/lang');
-
 const CSS_COMMENTS_REGEX = new RegExp(/\/\*.*\*\//, 'g');
-const CSS_PSEUDO_CLASS_REGEX = new RegExp(
-  /:active|:checked|:disabled|:empty|:enabled|:first-of-type|:focus|:hover|:in-range|:invalid|:link|:optional|:out-of-range|:read-only|:read-write|:required|:target|:valid|:visited/,
-  'g'
-);
+const CSS_PSEUDO_CLASS_REGEX = new RegExp(/:active|:checked|:disabled|:empty|:enabled|:first-of-type|:focus|:hover|:in-range|:invalid|:link|:optional|:out-of-range|:read-only|:read-write|:required|:target|:valid|:visited/, 'g');
 const i18nKey = 'commands.theme.subcommands.generateSelectors';
-
 let maxFieldsDepth = 0;
-
 function getMaxFieldsDepth() {
-  return maxFieldsDepth;
+    return maxFieldsDepth;
 }
-
 function findFieldsJsonPath(basePath) {
-  const _path = basePath.endsWith('/') ? basePath.slice(0, -1) : basePath;
-  if (!fs.existsSync(_path)) {
-    logger.error(
-      i18n(`${i18nKey}.errors.invalidPath`, {
-        themePath: basePath,
-      })
-    );
-    process.exit(EXIT_CODES.ERROR);
-  }
-  const files = fs.readdirSync(_path);
-
-  if (files.includes('fields.json')) {
-    return `${_path}/fields.json`;
-  }
-
-  for (let i = 0; i < files.length; i++) {
-    const fileName = files[i];
-    const isDirectory = fs.lstatSync(`${_path}/${fileName}`).isDirectory();
-
-    if (isDirectory && !fileName.includes('.module')) {
-      const fieldsJsonPath = findFieldsJsonPath(`${_path}/${fileName}`);
-      if (fieldsJsonPath) return fieldsJsonPath;
+    const _path = basePath.endsWith('/') ? basePath.slice(0, -1) : basePath;
+    if (!fs.existsSync(_path)) {
+        logger.error(i18n(`${i18nKey}.errors.invalidPath`, {
+            themePath: basePath,
+        }));
+        process.exit(EXIT_CODES.ERROR);
     }
-  }
-
-  return null;
+    const files = fs.readdirSync(_path);
+    if (files.includes('fields.json')) {
+        return `${_path}/fields.json`;
+    }
+    for (let i = 0; i < files.length; i++) {
+        const fileName = files[i];
+        const isDirectory = fs.lstatSync(`${_path}/${fileName}`).isDirectory();
+        if (isDirectory && !fileName.includes('.module')) {
+            const fieldsJsonPath = findFieldsJsonPath(`${_path}/${fileName}`);
+            if (fieldsJsonPath)
+                return fieldsJsonPath;
+        }
+    }
+    return null;
 }
-
 function combineThemeCss(basePath, cssString = '') {
-  const _path = basePath.endsWith('/') ? basePath.slice(0, -1) : basePath;
-  const isDirectory = fs.lstatSync(_path).isDirectory();
-
-  if (isDirectory) {
-    const filesList = fs.readdirSync(_path);
-    return filesList.reduce((css, fileName) => {
-      const newCss = combineThemeCss(`${_path}/${fileName}`);
-      return newCss ? `${css}\n${newCss}` : css;
-    }, cssString);
-  } else if (_path.includes('.css') && !_path.includes('.module')) {
-    return `${cssString}\n${fs.readFileSync(_path, 'utf8')}`;
-  }
-
-  return null;
+    const _path = basePath.endsWith('/') ? basePath.slice(0, -1) : basePath;
+    const isDirectory = fs.lstatSync(_path).isDirectory();
+    if (isDirectory) {
+        const filesList = fs.readdirSync(_path);
+        return filesList.reduce((css, fileName) => {
+            const newCss = combineThemeCss(`${_path}/${fileName}`);
+            return newCss ? `${css}\n${newCss}` : css;
+        }, cssString);
+    }
+    else if (_path.includes('.css') && !_path.includes('.module')) {
+        return `${cssString}\n${fs.readFileSync(_path, 'utf8')}`;
+    }
+    return null;
 }
-
 function setPreviewSelectors(fields, fieldPath, selectors, depth = 0) {
-  fields.forEach((field, index) => {
-    if (field.name === fieldPath[0]) {
-      if (field.children && fieldPath.length > 0) {
-        fields[index].children = setPreviewSelectors(
-          fields[index].children,
-          fieldPath.splice(1),
-          selectors,
-          (depth += 1)
-        );
-      } else {
-        if (!field.selectors) field.selectors = [];
-
-        if (depth > maxFieldsDepth) {
-          maxFieldsDepth = depth;
+    fields.forEach((field, index) => {
+        if (field.name === fieldPath[0]) {
+            if (field.children && fieldPath.length > 0) {
+                fields[index].children = setPreviewSelectors(fields[index].children, fieldPath.splice(1), selectors, (depth += 1));
+            }
+            else {
+                if (!field.selectors)
+                    field.selectors = [];
+                if (depth > maxFieldsDepth) {
+                    maxFieldsDepth = depth;
+                }
+                selectors.forEach(selector => {
+                    const fieldSelectors = field.selectors;
+                    selector = selector.replace(CSS_COMMENTS_REGEX, '');
+                    selector = selector.replace(CSS_PSEUDO_CLASS_REGEX, '').trim();
+                    if (!fieldSelectors.includes(selector) &&
+                        !selector.includes('@media')) {
+                        field.selectors = fieldSelectors.concat(selector);
+                    }
+                });
+            }
         }
-
-        selectors.forEach(selector => {
-          const fieldSelectors = field.selectors;
-          selector = selector.replace(CSS_COMMENTS_REGEX, '');
-          selector = selector.replace(CSS_PSEUDO_CLASS_REGEX, '').trim();
-
-          if (
-            !fieldSelectors.includes(selector) &&
-            !selector.includes('@media')
-          ) {
-            field.selectors = fieldSelectors.concat(selector);
-          }
-        });
-      }
-    }
-  });
-
-  return fields;
+    });
+    return fields;
 }
-
 function generateInheritedSelectors(fields) {
-  let finalFieldsJson = [...fields];
-
-  const _generateInheritedSelectors = fieldsToCheck => {
-    fieldsToCheck.forEach(field => {
-      if (field.children) {
-        _generateInheritedSelectors(field.children);
-      }
-
-      const fieldInheritance =
-        field.inherited_value && field.inherited_value.property_value_paths;
-      const fieldSelectors = field.selectors;
-
-      if (fieldSelectors && fieldInheritance) {
-        Object.values(fieldInheritance).forEach(path => {
-          const fieldPath = path.split('.');
-          if (fieldPath[0] === 'theme') {
-            finalFieldsJson = setPreviewSelectors(
-              finalFieldsJson,
-              fieldPath.splice(1),
-              fieldSelectors
-            );
-          }
+    let finalFieldsJson = [...fields];
+    const _generateInheritedSelectors = fieldsToCheck => {
+        fieldsToCheck.forEach(field => {
+            if (field.children) {
+                _generateInheritedSelectors(field.children);
+            }
+            const fieldInheritance = field.inherited_value && field.inherited_value.property_value_paths;
+            const fieldSelectors = field.selectors;
+            if (fieldSelectors && fieldInheritance) {
+                Object.values(fieldInheritance).forEach(path => {
+                    const fieldPath = path.split('.');
+                    if (fieldPath[0] === 'theme') {
+                        finalFieldsJson = setPreviewSelectors(finalFieldsJson, fieldPath.splice(1), fieldSelectors);
+                    }
+                });
+            }
         });
-      }
-    });
-  };
-
-  _generateInheritedSelectors(fields);
-
-  return finalFieldsJson;
+    };
+    _generateInheritedSelectors(fields);
+    return finalFieldsJson;
 }
-
 function generateSelectorsMap(fields, fieldKey = []) {
-  let selectorsMap = {};
-
-  fields.forEach(field => {
-    const { children, name, selectors } = field;
-    const _fieldKey = [...fieldKey, name];
-
-    if (field.children) {
-      selectorsMap = {
-        ...selectorsMap,
-        ...generateSelectorsMap(children, _fieldKey),
-      };
-    } else {
-      selectorsMap[_fieldKey.join('.')] = selectors;
-    }
-  });
-
-  return selectorsMap;
+    let selectorsMap = {};
+    fields.forEach(field => {
+        const { children, name, selectors } = field;
+        const _fieldKey = [...fieldKey, name];
+        if (field.children) {
+            selectorsMap = {
+                ...selectorsMap,
+                ...generateSelectorsMap(children, _fieldKey),
+            };
+        }
+        else {
+            selectorsMap[_fieldKey.join('.')] = selectors;
+        }
+    });
+    return selectorsMap;
 }
-
 module.exports = {
-  findFieldsJsonPath,
-  combineThemeCss,
-  setPreviewSelectors,
-  generateInheritedSelectors,
-  generateSelectorsMap,
-  getMaxFieldsDepth,
+    findFieldsJsonPath,
+    combineThemeCss,
+    setPreviewSelectors,
+    generateInheritedSelectors,
+    generateSelectorsMap,
+    getMaxFieldsDepth,
 };

package/lib/getFunctionArrays.d.ts

@@ -0,0 +1 @@
+export function getFunctionArrays(resp: any): any;

package/lib/getFunctionArrays.js

@@ -1,18 +1,17 @@
+"use strict";
 const moment = require('moment');
-
 const getFunctionArrays = resp => {
-  return resp.objects.map(func => {
-    const { route, method, created, updated, secretNames } = func;
-    return [
-      route,
-      method,
-      secretNames.join(', '),
-      moment(created).format(),
-      moment(updated).format(),
-    ];
-  });
+    return resp.objects.map(func => {
+        const { route, method, created, updated, secretNames } = func;
+        return [
+            route,
+            method,
+            secretNames.join(', '),
+            moment(created).format(),
+            moment(updated).format(),
+        ];
+    });
 };
-
 module.exports = {
-  getFunctionArrays,
+    getFunctionArrays,
 };

package/lib/hasFeature.d.ts

@@ -0,0 +1 @@
+export function hasFeature(accountId: any, feature: any): Promise<boolean>;

package/lib/hasFeature.js

@@ -1,15 +1,9 @@
-const {
-  fetchEnabledFeatures,
-} = require('@hubspot/local-dev-lib/api/localDevAuth');
-
+"use strict";
+const { fetchEnabledFeatures, } = require('@hubspot/local-dev-lib/api/localDevAuth');
 const hasFeature = async (accountId, feature) => {
-  const {
-    data: { enabledFeatures },
-  } = await fetchEnabledFeatures(accountId);
-
-  return enabledFeatures[feature];
+    const { data: { enabledFeatures }, } = await fetchEnabledFeatures(accountId);
+    return enabledFeatures[feature];
 };
-
 module.exports = {
-  hasFeature,
+    hasFeature,
 };

package/lib/hasFlag.d.ts

@@ -0,0 +1,2 @@
+export = hasFlag;
+declare function hasFlag(flag: any, argv?: string[]): boolean;

package/lib/hasFlag.js

@@ -1,15 +1,11 @@
+"use strict";
 const process = require('process');
-
 // See https://github.com/sindresorhus/has-flag/blob/main/index.js (License: https://github.com/sindresorhus/has-flag/blob/main/license)
-
 function hasFlag(flag, argv = process.argv) {
-  const prefix = flag.startsWith('-') ? '' : flag.length === 1 ? '-' : '--';
-  const position = argv.indexOf(prefix + flag);
-  const terminatorPosition = argv.indexOf('--');
-  return (
-    position !== -1 &&
-    (terminatorPosition === -1 || position < terminatorPosition)
-  );
+    const prefix = flag.startsWith('-') ? '' : flag.length === 1 ? '-' : '--';
+    const position = argv.indexOf(prefix + flag);
+    const terminatorPosition = argv.indexOf('--');
+    return (position !== -1 &&
+        (terminatorPosition === -1 || position < terminatorPosition));
 }
-
 module.exports = hasFlag;

package/lib/hublValidate.d.ts

@@ -0,0 +1,4 @@
+export function printHublValidationResult({ file, validation }: {
+    file: any;
+    validation: any;
+}): number;

package/lib/hublValidate.js

@@ -1,32 +1,28 @@
+"use strict";
 const { logger } = require('@hubspot/local-dev-lib/logger');
-
-const getErrorsFromHublValidationObject = validation =>
-  (validation && validation.meta && validation.meta.template_errors) || [];
-
+const getErrorsFromHublValidationObject = validation => (validation && validation.meta && validation.meta.template_errors) || [];
 function printHublValidationError(err) {
-  const { severity, message, lineno, startPosition } = err;
-  const method = severity === 'FATAL' ? 'error' : 'warn';
-  logger[method]('[%d, %d]: %s', lineno, startPosition, message);
+    const { severity, message, lineno, startPosition } = err;
+    const method = severity === 'FATAL' ? 'error' : 'warn';
+    logger[method]('[%d, %d]: %s', lineno, startPosition, message);
 }
-
 function printHublValidationResult({ file, validation }) {
-  let count = 0;
-  const errors = getErrorsFromHublValidationObject(validation);
-  if (!errors.length) {
-    return count;
-  }
-  logger.group(file);
-  errors.forEach(err => {
-    if (err.reason !== 'SYNTAX_ERROR') {
-      return;
+    let count = 0;
+    const errors = getErrorsFromHublValidationObject(validation);
+    if (!errors.length) {
+        return count;
     }
-    ++count;
-    printHublValidationError(err);
-  });
-  logger.groupEnd(file);
-  return count;
+    logger.group(file);
+    errors.forEach(err => {
+        if (err.reason !== 'SYNTAX_ERROR') {
+            return;
+        }
+        ++count;
+        printHublValidationError(err);
+    });
+    logger.groupEnd(file);
+    return count;
 }
-
 module.exports = {
-  printHublValidationResult,
+    printHublValidationResult,
 };

package/lib/interpolation.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Interpolate a string with data and compile helpers on the string
+ * @param {string} stringValue - The string to interpolate
+ * @param {object} interpolationData - The data to interpolate with
+ * @returns {string} - The interpolated and helper-compiled string
+ * @example
+ * interpolateAndCompile('Some {{#bold}}{{text}}{{/bold}} text', { text: 'awesomely bold' })
+ * // 'Some awsomely bold text' (with the words 'awesomely bold' in bold)
+ */
+export function interpolate(stringValue: string, interpolationData: object): string;

package/lib/interpolation.js

@@ -1,31 +1,24 @@
+"use strict";
 const helpers = require('./interpolationHelpers');
 const delimiters = {
-  interpolation: {
-    start: '{{',
-    end: '}}',
-  },
-  helpers: {
-    start: '#',
-    end: '/',
-  },
+    interpolation: {
+        start: '{{',
+        end: '}}',
+    },
+    helpers: {
+        start: '#',
+        end: '/',
+    },
 };
-
 const isHelperIdentifier = identifier => {
-  return (
-    identifier.startsWith(delimiters.helpers.start) ||
-    identifier.startsWith(delimiters.helpers.end)
-  );
+    return (identifier.startsWith(delimiters.helpers.start) ||
+        identifier.startsWith(delimiters.helpers.end));
 };
-
 const generateReplaceFn = (matchedText, startIndex, replacementString) => {
-  return currentStringValue =>
-    `${currentStringValue.slice(0, startIndex)}${
-      replacementString !== null && replacementString !== undefined
+    return currentStringValue => `${currentStringValue.slice(0, startIndex)}${replacementString !== null && replacementString !== undefined
         ? replacementString
-        : ''
-    }${currentStringValue.slice(startIndex + matchedText.length)}`;
+        : ''}${currentStringValue.slice(startIndex + matchedText.length)}`;
 };
-
 /**
  * Interpolate a string with data
  * @param {string} stringValue - The string to interpolate
@@ -36,34 +29,21 @@ const generateReplaceFn = (matchedText, startIndex, replacementString) => {
  * // 'Hello World'
  */
 const interpolation = (stringValue, interpolationData) => {
-  const interpolationIdentifierRegEx = new RegExp(
-    `${delimiters.interpolation.start}(.*?)${delimiters.interpolation.end}`,
-    'g'
-  );
-  const replaceQueue = [];
-  let match;
-
-  // while & reduce necessary because RegExp.exec is stateful and only runs
-  // from beginning to end of string
-  while ((match = interpolationIdentifierRegEx.exec(stringValue)) != null) {
-    const { 0: matchedText, 1: rawIdentifier, index } = match;
-    const identifier = rawIdentifier.trim();
-
-    if (identifier && !isHelperIdentifier(identifier)) {
-      replaceQueue.unshift(
-        generateReplaceFn(matchedText, index, interpolationData[identifier])
-      );
+    const interpolationIdentifierRegEx = new RegExp(`${delimiters.interpolation.start}(.*?)${delimiters.interpolation.end}`, 'g');
+    const replaceQueue = [];
+    let match;
+    // while & reduce necessary because RegExp.exec is stateful and only runs
+    // from beginning to end of string
+    while ((match = interpolationIdentifierRegEx.exec(stringValue)) != null) {
+        const { 0: matchedText, 1: rawIdentifier, index } = match;
+        const identifier = rawIdentifier.trim();
+        if (identifier && !isHelperIdentifier(identifier)) {
+            replaceQueue.unshift(generateReplaceFn(matchedText, index, interpolationData[identifier]));
+        }
     }
-  }
-
-  const compiledString = replaceQueue.reduce(
-    (currentValue, replaceFn) => replaceFn(currentValue),
-    stringValue
-  );
-
-  return compiledString;
+    const compiledString = replaceQueue.reduce((currentValue, replaceFn) => replaceFn(currentValue), stringValue);
+    return compiledString;
 };
-
 /**
  * Compile a string using a specified helper function
  * @param {string} stringValue - The string to modify
@@ -75,51 +55,28 @@ const interpolation = (stringValue, interpolationData) => {
  * // 'White yellow' (with 'yellow' colored yellow)
  */
 const compileHelper = (stringValue, helperIdentifier, helperFn) => {
-  const helperIdentifierRegEx = new RegExp(
-    `${delimiters.interpolation.start}(${delimiters.helpers.start}${helperIdentifier})${delimiters.interpolation.end}(.*?)${delimiters.interpolation.start}(${delimiters.helpers.end}${helperIdentifier})${delimiters.interpolation.end}`,
-    'g'
-  );
-  const replaceQueue = [];
-  let match;
-
-  // while & reduce necessary because RegExp.exec is stateful and only runs
-  // from beginning to end of string
-  while ((match = helperIdentifierRegEx.exec(stringValue)) != null) {
-    const {
-      0: matchedText,
-      1: rawHelperIdentifierStart,
-      2: innerText,
-      index,
-    } = match;
-    const identifier = rawHelperIdentifierStart
-      .replace(delimiters.helpers.start, '')
-      .trim();
-
-    if (identifier && helperFn) {
-      replaceQueue.unshift(
-        generateReplaceFn(matchedText, index, helperFn(innerText))
-      );
+    const helperIdentifierRegEx = new RegExp(`${delimiters.interpolation.start}(${delimiters.helpers.start}${helperIdentifier})${delimiters.interpolation.end}(.*?)${delimiters.interpolation.start}(${delimiters.helpers.end}${helperIdentifier})${delimiters.interpolation.end}`, 'g');
+    const replaceQueue = [];
+    let match;
+    // while & reduce necessary because RegExp.exec is stateful and only runs
+    // from beginning to end of string
+    while ((match = helperIdentifierRegEx.exec(stringValue)) != null) {
+        const { 0: matchedText, 1: rawHelperIdentifierStart, 2: innerText, index, } = match;
+        const identifier = rawHelperIdentifierStart
+            .replace(delimiters.helpers.start, '')
+            .trim();
+        if (identifier && helperFn) {
+            replaceQueue.unshift(generateReplaceFn(matchedText, index, helperFn(innerText)));
+        }
     }
-  }
-
-  const compiledString = replaceQueue.reduce(
-    (currentValue, replaceFn) => replaceFn(currentValue),
-    stringValue
-  );
-
-  return compiledString;
+    const compiledString = replaceQueue.reduce((currentValue, replaceFn) => replaceFn(currentValue), stringValue);
+    return compiledString;
 };
-
 const compileHelpers = stringValue => {
-  return Object.keys(helpers).reduce((currentStringValue, helperIdentifier) => {
-    return compileHelper(
-      currentStringValue,
-      helperIdentifier,
-      helpers[helperIdentifier]
-    );
-  }, stringValue);
+    return Object.keys(helpers).reduce((currentStringValue, helperIdentifier) => {
+        return compileHelper(currentStringValue, helperIdentifier, helpers[helperIdentifier]);
+    }, stringValue);
 };
-
 /**
  * Interpolate a string with data and compile helpers on the string
  * @param {string} stringValue - The string to interpolate
@@ -130,11 +87,10 @@ const compileHelpers = stringValue => {
  * // 'Some awsomely bold text' (with the words 'awesomely bold' in bold)
  */
 const interpolate = (stringValue, interpolationData) => {
-  const interpolatedString = interpolation(stringValue, interpolationData);
-  const helperCompiledString = compileHelpers(interpolatedString);
-  return helperCompiledString;
+    const interpolatedString = interpolation(stringValue, interpolationData);
+    const helperCompiledString = compileHelpers(interpolatedString);
+    return helperCompiledString;
 };
-
 module.exports = {
-  interpolate,
+    interpolate,
 };

package/lib/interpolationHelpers.d.ts

@@ -0,0 +1,6 @@
+export function bold(stringValue: any): string;
+export function yellow(stringValue: any): string;
+export function green(stringValue: any): string;
+export function red(stringValue: any): string;
+export function cyan(stringValue: any): string;
+export function orange(stringValue: any): string;

package/lib/interpolationHelpers.js

@@ -1,26 +1,26 @@
+"use strict";
 const chalk = require('chalk');
-
 /**
  * These helper methods are used to modify text output within the CLI. They
  * should all take in a string value and output a modified string value.
  */
 module.exports = {
-  bold: function(stringValue) {
-    return chalk.bold(stringValue);
-  },
-  yellow: function(stringValue) {
-    return chalk.reset.yellow(stringValue);
-  },
-  green: function(stringValue) {
-    return chalk.reset.green(stringValue);
-  },
-  red: function(stringValue) {
-    return chalk.reset.red(stringValue);
-  },
-  cyan: function(stringValue) {
-    return chalk.cyan(stringValue);
-  },
-  orange: function(stringValue) {
-    return chalk.hex('#FC9900')(stringValue);
-  },
+    bold: function (stringValue) {
+        return chalk.bold(stringValue);
+    },
+    yellow: function (stringValue) {
+        return chalk.reset.yellow(stringValue);
+    },
+    green: function (stringValue) {
+        return chalk.reset.green(stringValue);
+    },
+    red: function (stringValue) {
+        return chalk.reset.red(stringValue);
+    },
+    cyan: function (stringValue) {
+        return chalk.cyan(stringValue);
+    },
+    orange: function (stringValue) {
+        return chalk.hex('#FC9900')(stringValue);
+    },
 };

package/lib/lang.d.ts

@@ -0,0 +1,3 @@
+export function i18n(lookupDotNotation: any, options?: {}): any;
+export function setLangData(newLocale: any, newLangObj: any): void;
+export const MISSING_LANGUAGE_DATA_PREFIX: "[Missing language data]";