@hubspot/cli 6.2.2-experimental.1 → 6.2.2-experimental.2

package/lib/doctor/Doctor.d.ts

@@ -0,0 +1,21 @@
+import { DiagnosticInfoBuilder, DiagnosticInfo } from './DiagnosticInfoBuilder';
+export declare class Doctor {
+    accountId: number | null;
+    private diagnosis?;
+    private projectConfig?;
+    private diagnosticInfo?;
+    readonly diagnosticInfoBuilder: DiagnosticInfoBuilder;
+    constructor(diagnosticInfoBuilder?: DiagnosticInfoBuilder);
+    diagnose(): Promise<DiagnosticInfo>;
+    private performCliChecks;
+    private performProjectChecks;
+    private performCliConfigChecks;
+    private checkIfAccessTokenValid;
+    private checkIfNodeIsInstalled;
+    private checkIfNpmIsInstalled;
+    private checkCLIVersion;
+    private checkIfNpmInstallRequired;
+    private isValidJsonFile;
+    private checkProjectConfigJsonFiles;
+    private checkIfPortsAreAvailable;
+}

package/lib/doctor/Doctor.js

@@ -0,0 +1,328 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Doctor = void 0;
+const logger_1 = require("@hubspot/local-dev-lib/logger");
+const config_1 = require("@hubspot/local-dev-lib/config");
+const SpinniesManager_1 = __importDefault(require("../ui/SpinniesManager"));
+const dependencyManagement_1 = require("../dependencyManagement");
+const util_1 = __importDefault(require("util"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const Diagnosis_1 = require("./Diagnosis");
+const DiagnosticInfoBuilder_1 = require("./DiagnosticInfoBuilder");
+const portManager_1 = require("@hubspot/local-dev-lib/portManager");
+const ports_1 = require("@hubspot/local-dev-lib/constants/ports");
+const personalAccessKey_1 = require("@hubspot/local-dev-lib/personalAccessKey");
+const index_1 = require("@hubspot/local-dev-lib/errors/index");
+const urls_1 = require("@hubspot/local-dev-lib/urls");
+const ui_1 = require("../ui");
+const package_json_1 = __importDefault(require("../../package.json"));
+const { i18n } = require('../lang');
+const { uiLink } = require('../ui');
+const minMajorNodeVersion = 18;
+const i18nKey = `lib.doctor`;
+class Doctor {
+    accountId;
+    diagnosis;
+    projectConfig;
+    diagnosticInfo;
+    diagnosticInfoBuilder;
+    constructor(diagnosticInfoBuilder = new DiagnosticInfoBuilder_1.DiagnosticInfoBuilder(process)) {
+        SpinniesManager_1.default.init();
+        this.accountId = (0, config_1.getAccountId)();
+        this.diagnosticInfoBuilder = diagnosticInfoBuilder;
+    }
+    async diagnose() {
+        SpinniesManager_1.default.add('runningDiagnostics', {
+            text: i18n(`${i18nKey}.runningDiagnostics`),
+        });
+        this.diagnosticInfo = await this.diagnosticInfoBuilder.generateDiagnosticInfo();
+        this.projectConfig = this.diagnosticInfo?.project.config;
+        this.diagnosis = new Diagnosis_1.Diagnosis({
+            diagnosticInfo: this.diagnosticInfo,
+            accountId: this.accountId,
+        });
+        await Promise.all([
+            ...this.performCliChecks(),
+            ...this.performCliConfigChecks(),
+            ...(this.projectConfig?.projectConfig ? this.performProjectChecks() : []),
+        ]);
+        SpinniesManager_1.default.succeed('runningDiagnostics', {
+            text: i18n(`${i18nKey}.diagnosticsComplete`),
+            succeedColor: 'white',
+        });
+        this.diagnosticInfo.diagnosis = this.diagnosis.toString();
+        this.diagnosticInfo.errorCount = this.diagnosis.getErrorCount();
+        this.diagnosticInfo.warningCount = this.diagnosis.getWarningCount();
+        return this.diagnosticInfo;
+    }
+    performCliChecks() {
+        return [
+            this.checkIfNodeIsInstalled(),
+            this.checkIfNpmIsInstalled(),
+            this.checkCLIVersion(),
+        ];
+    }
+    performProjectChecks() {
+        return [
+            this.checkIfNpmInstallRequired(),
+            this.checkProjectConfigJsonFiles(),
+            this.checkIfPortsAreAvailable(),
+        ];
+    }
+    performCliConfigChecks() {
+        if (!this.diagnosticInfo?.config) {
+            this.diagnosis?.addCLIConfigSection({
+                type: 'error',
+                message: i18n(`${i18nKey}.diagnosis.cliConfig.noConfigFile`),
+                secondaryMessaging: i18n(`${i18nKey}.diagnosis.cliConfig.noConfigFileSecondary`, {
+                    command: (0, ui_1.uiCommandReference)('hs init'),
+                }),
+            });
+            return [];
+        }
+        return [this.checkIfAccessTokenValid()];
+    }
+    async checkIfAccessTokenValid() {
+        const localI18nKey = `${i18nKey}.accountChecks`;
+        try {
+            await (0, personalAccessKey_1.accessTokenForPersonalAccessKey)(this.accountId, true);
+            this.diagnosis?.addCLIConfigSection({
+                type: 'success',
+                message: i18n(`${localI18nKey}.active`),
+            });
+            this.diagnosis?.addCLIConfigSection({
+                type: 'success',
+                message: i18n(`${localI18nKey}.pak.valid`, {
+                    link: uiLink(i18n(`${localI18nKey}.pak.viewScopes`), `${(0, urls_1.getHubSpotWebsiteOrigin)(this.diagnosticInfoBuilder?.env || 'PROD')}/personal-access-key/${this.diagnosticInfo?.account.accountId}`),
+                }),
+            });
+        }
+        catch (error) {
+            const portalNotActive = (0, index_1.isSpecifiedError)(error, {
+                statusCode: 401,
+                category: 'INVALID_AUTHENTICATION',
+                subCategory: 'LocalDevAuthErrorType.PORTAL_NOT_ACTIVE',
+            }) ||
+                (0, index_1.isSpecifiedError)(error, {
+                    statusCode: 404,
+                    category: 'INVALID_AUTHENTICATION',
+                    subCategory: 'LocalDevAuthErrorType.INVALID_PORTAL_ID',
+                });
+            if (portalNotActive) {
+                this.diagnosis?.addCLIConfigSection({
+                    type: 'error',
+                    message: i18n(`${localI18nKey}.inactive`),
+                    secondaryMessaging: i18n(`${localI18nKey}.inactiveSecondary`, {
+                        command: (0, ui_1.uiCommandReference)(`hs accounts clean`),
+                    }),
+                });
+            }
+            else if ((0, index_1.isSpecifiedError)(error, {
+                statusCode: 401,
+                category: 'INVALID_AUTHENTICATION',
+                subCategory: 'LocalDevAuthErrorType.FAILED_TO_SIGN_REFRESH_TOKEN_DECODE',
+            })) {
+                this.diagnosis?.addCLIConfigSection({
+                    type: 'success',
+                    message: i18n(`${localI18nKey}.active`),
+                });
+                this.diagnosis?.addCLIConfigSection({
+                    type: 'error',
+                    message: i18n(`${localI18nKey}.pak.invalid`),
+                    secondaryMessaging: i18n(`${localI18nKey}.pak.invalidSecondary`, {
+                        command: (0, ui_1.uiCommandReference)(`hs auth`),
+                    }),
+                });
+            }
+            else {
+                this.diagnosis?.addCLIConfigSection({
+                    type: 'error',
+                    message: i18n(`${localI18nKey}.unableToDetermine`),
+                });
+            }
+        }
+    }
+    async checkIfNodeIsInstalled() {
+        const localI18nKey = `${i18nKey}.nodeChecks`;
+        if (!this.diagnosticInfo?.versions.node) {
+            return this.diagnosis?.addCliSection({
+                type: 'error',
+                message: i18n(`${localI18nKey}.unableToDetermine`),
+            });
+        }
+        const nodeVersion = this.diagnosticInfo?.versions.node?.split('.');
+        const currentNodeMajor = nodeVersion?.[0];
+        if (!currentNodeMajor || parseInt(currentNodeMajor) < minMajorNodeVersion) {
+            return this.diagnosis?.addCliSection({
+                type: 'warning',
+                message: i18n(`${localI18nKey}.minimumNotMet`, {
+                    nodeVersion: this.diagnosticInfo?.versions.node,
+                }),
+            });
+        }
+        this.diagnosis?.addCliSection({
+            type: 'success',
+            message: i18n(`${localI18nKey}.success`, {
+                nodeVersion: this.diagnosticInfo?.versions.node,
+            }),
+        });
+    }
+    async checkIfNpmIsInstalled() {
+        const localI18nKey = `${i18nKey}.npmChecks`;
+        const npmVersion = this.diagnosticInfo?.versions?.npm;
+        if (!npmVersion) {
+            return this.diagnosis?.addCliSection({
+                type: 'error',
+                message: i18n(`${localI18nKey}.notInstalled`),
+            });
+        }
+        this.diagnosis?.addCliSection({
+            type: 'success',
+            message: i18n(`${localI18nKey}.installed`, {
+                npmVersion,
+            }),
+        });
+    }
+    async checkCLIVersion() {
+        let latestCLIVersion;
+        try {
+            latestCLIVersion = await (0, dependencyManagement_1.getLatestCliVersion)();
+        }
+        catch (e) {
+            return this.diagnosis?.addCliSection({
+                type: 'error',
+                message: i18n(`${i18nKey}.hsChecks.unableToDetermine`),
+                secondaryMessaging: i18n(`${i18nKey}.hsChecks.unableToDetermineSecondary`, {
+                    command: (0, ui_1.uiCommandReference)(`hs --version`),
+                    link: uiLink(i18n(`${i18nKey}.hsChecks.unableToDetermineSecondaryLink`), `https://www.npmjs.com/package/${package_json_1.default.name}?activeTab=versions`),
+                }),
+            });
+        }
+        if (latestCLIVersion !== package_json_1.default.version) {
+            this.diagnosis?.addCliSection({
+                type: 'warning',
+                message: i18n(`${i18nKey}.hsChecks.notLatest`, {
+                    hsVersion: package_json_1.default.version,
+                }),
+                secondaryMessaging: i18n(`${i18nKey}.hsChecks.notLatestSecondary`, {
+                    hsVersion: package_json_1.default.version,
+                    command: (0, ui_1.uiCommandReference)(`npm install -g ${package_json_1.default.name}`),
+                }),
+            });
+        }
+        else {
+            this.diagnosis?.addCliSection({
+                type: 'success',
+                message: i18n(`${i18nKey}.hsChecks.latest`, {
+                    hsVersion: latestCLIVersion,
+                }),
+            });
+        }
+    }
+    async checkIfNpmInstallRequired() {
+        let foundError = false;
+        const localI18nKey = `${i18nKey}.projectDependenciesChecks`;
+        for (const packageFile of this.diagnosticInfo?.packageFiles || []) {
+            const packageDirName = path_1.default.dirname(packageFile);
+            try {
+                const needsInstall = await (0, dependencyManagement_1.hasMissingPackages)(path_1.default.join(this.projectConfig?.projectDir, packageDirName));
+                if (needsInstall) {
+                    foundError = true;
+                    this.diagnosis?.addProjectSection({
+                        type: 'warning',
+                        message: i18n(`${localI18nKey}.missingDependencies`, {
+                            dir: packageDirName,
+                        }),
+                        secondaryMessaging: i18n(`${localI18nKey}.missingDependenciesSecondary`, {
+                            command: (0, ui_1.uiCommandReference)('hs project install-deps'),
+                        }),
+                    });
+                }
+            }
+            catch (e) {
+                foundError = true;
+                if (!(await this.isValidJsonFile(packageFile))) {
+                    this.diagnosis?.addProjectSection({
+                        type: 'error',
+                        message: i18n(`${i18nKey}.files.invalidJson`, {
+                            filename: packageFile,
+                        }),
+                    });
+                }
+                else {
+                    this.diagnosis?.addProjectSection({
+                        type: 'error',
+                        message: i18n(`${localI18nKey}.unableToDetermine`, {
+                            dir: packageDirName,
+                        }),
+                    });
+                }
+                logger_1.logger.debug(e);
+            }
+        }
+        if (!foundError) {
+            this.diagnosis?.addProjectSection({
+                type: 'success',
+                message: i18n(`${localI18nKey}.success`),
+            });
+        }
+    }
+    async isValidJsonFile(filename) {
+        try {
+            const readFile = util_1.default.promisify(fs_1.default.readFile);
+            const fileContents = await readFile(filename);
+            JSON.parse(fileContents.toString());
+        }
+        catch (e) {
+            return false;
+        }
+        return true;
+    }
+    async checkProjectConfigJsonFiles() {
+        let foundError = false;
+        for (const jsonFile of this.diagnosticInfo?.jsonFiles || []) {
+            const fileToCheck = path_1.default.join(this.projectConfig?.projectDir, jsonFile);
+            if (!(await this.isValidJsonFile(fileToCheck))) {
+                foundError = true;
+                this.diagnosis?.addProjectSection({
+                    type: 'error',
+                    message: i18n(`${i18nKey}.files.invalidJson`, {
+                        filename: jsonFile,
+                    }),
+                });
+            }
+        }
+        if (!foundError) {
+            this.diagnosis?.addProjectSection({
+                type: 'success',
+                message: i18n(`${i18nKey}.files.validJson`),
+            });
+        }
+    }
+    async checkIfPortsAreAvailable() {
+        const localI18nKey = `${i18nKey}.port`;
+        if (await (0, portManager_1.isPortManagerPortAvailable)()) {
+            this.diagnosis?.addProjectSection({
+                type: 'success',
+                message: i18n(`${localI18nKey}.available`, {
+                    port: ports_1.PORT_MANAGER_SERVER_PORT,
+                }),
+            });
+            return;
+        }
+        this.diagnosis?.addProjectSection({
+            type: 'warning',
+            message: i18n(`${localI18nKey}.inUse`, {
+                port: ports_1.PORT_MANAGER_SERVER_PORT,
+            }),
+            secondaryMessaging: i18n(`${localI18nKey}.inUseSecondary`, {
+                command: (0, ui_1.uiCommandReference)('hs project dev'),
+            }),
+        });
+    }
+}
+exports.Doctor = Doctor;

package/lib/interpolation.d.ts

@@ -1 +1,8 @@
+export declare const helpers: {
+    [key: string]: (stringValue: string) => string;
+};
+type InterpolationData = {
+    [identifier: string]: string | number;
+};
+export declare function interpolate(stringValue: string, interpolationData: InterpolationData): string;
 export {};

package/lib/interpolation.js

@@ -1,7 +1,31 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-// @ts-nocheck
-const helpers = require('./interpolationHelpers');
+exports.helpers = void 0;
+exports.interpolate = interpolate;
+const chalk_1 = __importDefault(require("chalk"));
+exports.helpers = {
+    bold: function (stringValue) {
+        return chalk_1.default.bold(stringValue);
+    },
+    yellow: function (stringValue) {
+        return chalk_1.default.reset.yellow(stringValue);
+    },
+    green: function (stringValue) {
+        return chalk_1.default.reset.green(stringValue);
+    },
+    red: function (stringValue) {
+        return chalk_1.default.reset.red(stringValue);
+    },
+    cyan: function (stringValue) {
+        return chalk_1.default.cyan(stringValue);
+    },
+    orange: function (stringValue) {
+        return chalk_1.default.hex('#FC9900')(stringValue);
+    },
+};
 const delimiters = {
     interpolation: {
         start: '{{',
@@ -12,25 +36,16 @@ const delimiters = {
         end: '/',
     },
 };
-const isHelperIdentifier = identifier => {
+function isHelperIdentifier(identifier) {
     return (identifier.startsWith(delimiters.helpers.start) ||
         identifier.startsWith(delimiters.helpers.end));
-};
-const generateReplaceFn = (matchedText, startIndex, replacementString) => {
+}
+function generateReplaceFn(matchedText, startIndex, replacementString) {
     return currentStringValue => `${currentStringValue.slice(0, startIndex)}${replacementString !== null && replacementString !== undefined
         ? replacementString
         : ''}${currentStringValue.slice(startIndex + matchedText.length)}`;
-};
-/**
- * Interpolate a string with data
- * @param {string} stringValue - The string to interpolate
- * @param {object} interpolationData - The data to interpolate with
- * @returns {string} - The interpolated string
- * @example
- * interpolation('Hello {{name}}', { name: 'World' })
- * // 'Hello World'
- */
-const interpolation = (stringValue, interpolationData) => {
+}
+function interpolation(stringValue, interpolationData) {
     const interpolationIdentifierRegEx = new RegExp(`${delimiters.interpolation.start}(.*?)${delimiters.interpolation.end}`, 'g');
     const replaceQueue = [];
     let match;
@@ -40,23 +55,13 @@ const interpolation = (stringValue, interpolationData) => {
         const { 0: matchedText, 1: rawIdentifier, index } = match;
         const identifier = rawIdentifier.trim();
         if (identifier && !isHelperIdentifier(identifier)) {
-            replaceQueue.unshift(generateReplaceFn(matchedText, index, interpolationData[identifier]));
+            replaceQueue.unshift(generateReplaceFn(matchedText, index, String(interpolationData[identifier])));
         }
     }
     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
- * @param {object} helperIdentifier - Helper name
- * @param {function} helperFn - Helper function to call on string
- * @returns {string} - The modified string
- * @example
- * compileHelper('White {{#yellow}}yellow{{/yellow}}', 'yellow', (string) => { chalk.reset.yellow(string) }))))
- * // 'White yellow' (with 'yellow' colored yellow)
- */
-const compileHelper = (stringValue, helperIdentifier, helperFn) => {
+}
+function 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;
@@ -73,26 +78,14 @@ const compileHelper = (stringValue, helperIdentifier, helperFn) => {
     }
     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]);
+}
+function compileHelpers(stringValue) {
+    return Object.keys(exports.helpers).reduce((currentStringValue, helperIdentifier) => {
+        return compileHelper(currentStringValue, helperIdentifier, exports.helpers[helperIdentifier]);
     }, stringValue);
-};
-/**
- * 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)
- */
-const interpolate = (stringValue, interpolationData) => {
+}
+function interpolate(stringValue, interpolationData) {
     const interpolatedString = interpolation(stringValue, interpolationData);
     const helperCompiledString = compileHelpers(interpolatedString);
     return helperCompiledString;
-};
-module.exports = {
-    interpolate,
-};
+}

package/lib/lang.d.ts

@@ -1 +1,9 @@
+export declare const MISSING_LANGUAGE_DATA_PREFIX = "[Missing language data]";
+type LanguageObject = {
+    [key: string]: string | LanguageObject;
+};
+export declare function i18n(lookupDotNotation: string, options?: {
+    [identifier: string]: string | number;
+}): string;
+export declare function setLangData(newLocale: string, newLangObj: LanguageObject): void;
 export {};

package/lib/lang.js

@@ -1,55 +1,65 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-// @ts-nocheck
-const util = require('util');
-const path = require('path');
-const fs = require('fs-extra');
-const yaml = require('js-yaml');
-const { logger } = require('@hubspot/local-dev-lib/logger');
-const { interpolate } = require('./interpolation');
-const MISSING_LANGUAGE_DATA_PREFIX = '[Missing language data]';
+exports.MISSING_LANGUAGE_DATA_PREFIX = void 0;
+exports.i18n = i18n;
+exports.setLangData = setLangData;
+const util_1 = __importDefault(require("util"));
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const js_yaml_1 = __importDefault(require("js-yaml"));
+const logger_1 = require("@hubspot/local-dev-lib/logger");
+const interpolation_1 = require("./interpolation");
+exports.MISSING_LANGUAGE_DATA_PREFIX = '[Missing language data]';
 let locale;
 let languageObj;
-const loadLanguageFromYaml = () => {
+function loadLanguageFromYaml() {
     if (languageObj)
         return;
     try {
         const nodeLocale = Intl.DateTimeFormat()
             .resolvedOptions()
             .locale.split('-')[0];
-        const languageFilePath = path.join(__dirname, `../lang/${nodeLocale}.lyaml`);
-        const languageFileExists = fs.existsSync(languageFilePath);
+        const languageFilePath = path_1.default.join(__dirname, `../lang/${nodeLocale}.lyaml`);
+        const languageFileExists = fs_extra_1.default.existsSync(languageFilePath);
         // Fall back to using the default language file
         locale = languageFileExists ? nodeLocale : 'en';
-        languageObj = yaml.load(fs.readFileSync(path.join(__dirname, `../lang/${locale}.lyaml`), 'utf8'));
-        logger.debug('Loaded language data: ', util.inspect(languageObj, true, 999, true));
+        languageObj = js_yaml_1.default.load(fs_extra_1.default.readFileSync(path_1.default.join(__dirname, `../lang/${locale}.lyaml`), 'utf8'));
+        logger_1.logger.debug('Loaded language data: ', util_1.default.inspect(languageObj, true, 999, true));
     }
     catch (e) {
-        logger.error('Error loading language data: ', e);
+        logger_1.logger.error('Error loading language data: ', e);
     }
-};
-const getTextValue = lookupDotNotation => {
+}
+function getTextValue(lookupDotNotation) {
     const lookupProps = [locale, ...lookupDotNotation.split('.')];
-    const missingTextData = `${MISSING_LANGUAGE_DATA_PREFIX}: ${lookupProps.join('.')}`;
+    const missingTextData = `${exports.MISSING_LANGUAGE_DATA_PREFIX}: ${lookupProps.join('.')}`;
     let textValue = languageObj;
     let previouslyCheckedProp = lookupProps[0];
     try {
         lookupProps.forEach(prop => {
-            textValue = textValue[prop];
+            if (textValue && typeof textValue === 'object') {
+                textValue = textValue[prop];
+            }
             previouslyCheckedProp = prop;
         });
     }
     catch (e) {
-        logger.debug(`Unable to access language property: ${lookupProps.join('.')}. Failed to access prop "${previouslyCheckedProp}".`);
-        logger.error('Unable to access language property.');
+        logger_1.logger.debug(`Unable to access language property: ${lookupProps.join('.')}. Failed to access prop "${previouslyCheckedProp}".`);
+        logger_1.logger.error('Unable to access language property.');
         return missingTextData;
     }
     if (!textValue) {
         return missingTextData;
     }
+    if (typeof textValue !== 'string') {
+        return missingTextData;
+    }
     return textValue;
-};
-const i18n = (lookupDotNotation, options = {}) => {
+}
+function i18n(lookupDotNotation, options = {}) {
     if (!languageObj) {
         loadLanguageFromYaml();
     }
@@ -57,15 +67,10 @@ const i18n = (lookupDotNotation, options = {}) => {
         throw new Error(`i18n must be passed a string value for lookupDotNotation, received ${typeof lookupDotNotation}`);
     }
     const textValue = getTextValue(lookupDotNotation);
-    const shouldInterpolate = !textValue.startsWith(MISSING_LANGUAGE_DATA_PREFIX);
-    return shouldInterpolate ? interpolate(textValue, options) : textValue;
-};
-const setLangData = (newLocale, newLangObj) => {
+    const shouldInterpolate = !textValue.startsWith(exports.MISSING_LANGUAGE_DATA_PREFIX);
+    return shouldInterpolate ? (0, interpolation_1.interpolate)(textValue, options) : textValue;
+}
+function setLangData(newLocale, newLangObj) {
     locale = newLocale;
     languageObj = newLangObj;
-};
-module.exports = {
-    i18n,
-    setLangData,
-    MISSING_LANGUAGE_DATA_PREFIX,
-};
+}

package/lib/process.d.ts

@@ -1 +1,12 @@
+interface KeyPress {
+    ctrl?: boolean;
+    shift?: boolean;
+    alt?: boolean;
+    meta?: boolean;
+    name?: string;
+}
+export declare function handleExit(callback: (onTerminate: {
+    isSIGHUP: boolean;
+}) => void): void;
+export declare function handleKeypress(callback: (onKeyPress: KeyPress) => void): void;
 export {};

package/lib/process.js

@@ -1,11 +1,15 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-// @ts-nocheck
-const readline = require('readline');
-const { logger, setLogLevel, LOG_LEVEL, } = require('@hubspot/local-dev-lib/logger');
-const { i18n } = require('./lang');
+exports.handleExit = handleExit;
+exports.handleKeypress = handleKeypress;
+const readline_1 = __importDefault(require("readline"));
+const logger_1 = require("@hubspot/local-dev-lib/logger");
+const lang_1 = require("./lang");
 const i18nKey = 'lib.process';
-const handleExit = callback => {
+function handleExit(callback) {
     const terminationSignals = [
         'beforeExit',
         'SIGINT', // Terminal trying to interrupt (Ctrl + C)
@@ -25,17 +29,17 @@ const handleExit = callback => {
                 const isSIGHUP = signal === 'SIGHUP';
                 // Prevent logs when terminal closes
                 if (isSIGHUP) {
-                    setLogLevel(LOG_LEVEL.NONE);
+                    (0, logger_1.setLogLevel)(logger_1.LOG_LEVEL.NONE);
                 }
-                logger.debug(i18n(`${i18nKey}.exitDebug`, { signal }));
+                logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.exitDebug`, { signal }));
                 await callback({ isSIGHUP });
             }
         });
     });
-};
-const handleKeypress = callback => {
-    readline.createInterface(process.stdin, process.stdout);
-    readline.emitKeypressEvents(process.stdin);
+}
+function handleKeypress(callback) {
+    readline_1.default.createInterface(process.stdin, process.stdout);
+    readline_1.default.emitKeypressEvents(process.stdin);
     if (process.stdin.isTTY) {
         process.stdin.setRawMode(true);
     }
@@ -45,8 +49,4 @@ const handleKeypress = callback => {
             callback(key);
         }
     });
-};
-module.exports = {
-    handleExit,
-    handleKeypress,
-};
+}