@hubspot/local-dev-lib 0.0.2 → 0.0.4

package/utils/lang.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.i18n = exports.interpolate = void 0;
+const path_1 = require("path");
+const fs_extra_1 = require("fs-extra");
+const js_yaml_1 = require("js-yaml");
+const MISSING_LANGUAGE_DATA_PREFIX = '[Missing language data]';
+let locale = '';
+let languageObj;
+function loadLanguageFromYaml() {
+    if (languageObj)
+        return;
+    try {
+        const nodeLocale = Intl.DateTimeFormat()
+            .resolvedOptions()
+            .locale.split('-')[0];
+        const languageFilePath = (0, path_1.join)(__dirname, `../lang/${nodeLocale}.lyaml`);
+        const languageFileExists = (0, fs_extra_1.existsSync)(languageFilePath);
+        // Fall back to using the default language file
+        locale = languageFileExists ? nodeLocale : 'en';
+        languageObj = (0, js_yaml_1.load)((0, fs_extra_1.readFileSync)((0, path_1.join)(__dirname, `../lang/${locale}.lyaml`), 'utf8'));
+    }
+    catch (e) {
+        throw new Error(`Error loading language data: ${e}`);
+    }
+}
+function getTextValue(lookupDotNotation) {
+    const lookupProps = [locale, ...lookupDotNotation.split('.')];
+    const missingTextData = `${MISSING_LANGUAGE_DATA_PREFIX}: ${lookupProps.join('.')}`;
+    let textValue = languageObj;
+    let previouslyCheckedProp = lookupProps[0];
+    lookupProps.forEach(prop => {
+        previouslyCheckedProp = prop;
+        if (typeof textValue === 'object') {
+            textValue = textValue[prop];
+        }
+        else {
+            console.debug(`Unable to access language property: ${lookupProps.join('.')}. Failed to access prop "${previouslyCheckedProp}".`);
+        }
+    });
+    if (typeof textValue !== 'string') {
+        return missingTextData;
+    }
+    return textValue;
+}
+const delimiters = {
+    interpolation: {
+        start: '{{',
+        end: '}}',
+    },
+};
+function generateReplaceFn(matchedText, startIndex, replacementString) {
+    return function (currentStringValue) {
+        return `${currentStringValue.slice(0, startIndex)}${replacementString || ''}${currentStringValue.slice(startIndex + matchedText.length)}`;
+    };
+}
+function interpolate(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) {
+            replaceQueue.unshift(generateReplaceFn(matchedText, index, interpolationData[identifier]));
+        }
+    }
+    const compiledString = replaceQueue.reduce((currentValue, replaceFn) => replaceFn(currentValue), stringValue);
+    return compiledString;
+}
+exports.interpolate = interpolate;
+function i18n(lookupDotNotation, options = {}) {
+    if (typeof lookupDotNotation !== 'string') {
+        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;
+}
+exports.i18n = i18n;
+loadLanguageFromYaml();

package/utils/logger.d.ts

@@ -0,0 +1,10 @@
+import { LogCallbacks } from '../types/LogCallbacks';
+export declare function log<T extends string>(key: T, callbacks?: LogCallbacks<T>, debugKey?: string, debugInterpolation?: {
+    [key: string]: string | number;
+}): void;
+export declare function makeTypedLogger<T extends readonly string[]>(callbacks?: LogCallbacks<T[number]>, debugKey?: string): (key: T[number], debugInterpolation?: {
+    [key: string]: string | number;
+} | undefined) => void;
+export declare function debug(identifier: string, interpolation?: {
+    [key: string]: string | number;
+}): void;

package/utils/logger.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.debug = exports.makeTypedLogger = exports.log = void 0;
+const lang_1 = require("./lang");
+function log(key, callbacks, debugKey, debugInterpolation) {
+    if (callbacks && callbacks[key]) {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        callbacks[key]();
+    }
+    else if (debugKey) {
+        debug(debugKey, debugInterpolation);
+    }
+}
+exports.log = log;
+function makeTypedLogger(callbacks, debugKey) {
+    return (key, debugInterpolation) => log(key, callbacks, `${debugKey}.${key}`, debugInterpolation);
+}
+exports.makeTypedLogger = makeTypedLogger;
+function debug(identifier, interpolation) {
+    console.debug((0, lang_1.i18n)(`debug.${identifier}`, interpolation));
+}
+exports.debug = debug;

package/utils/modules.d.ts

@@ -0,0 +1,4 @@
+import { PathInput } from '../types/Modules';
+export declare function isPathInput(pathInput?: PathInput): boolean;
+export declare function isModuleFolder(pathInput: PathInput): boolean;
+export declare function isModuleFolderChild(pathInput: PathInput, ignoreLocales?: boolean): boolean;

package/utils/modules.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isModuleFolderChild = exports.isModuleFolder = exports.isPathInput = void 0;
+const path_1 = __importDefault(require("path"));
+const path_2 = require("../lib/path");
+const extensions_1 = require("../constants/extensions");
+const standardErrors_1 = require("../errors/standardErrors");
+const isBool = (x) => !!x === x;
+function isPathInput(pathInput) {
+    return !!(pathInput &&
+        typeof pathInput.path === 'string' &&
+        (isBool(pathInput.isLocal) || isBool(pathInput.isHubSpot)));
+}
+exports.isPathInput = isPathInput;
+function throwInvalidPathInput(pathInput) {
+    if (isPathInput(pathInput))
+        return;
+    (0, standardErrors_1.throwTypeErrorWithMessage)('modules.throwInvalidPathInput');
+}
+function isModuleFolder(pathInput) {
+    throwInvalidPathInput(pathInput);
+    const _path = pathInput.isHubSpot
+        ? path_1.default.posix.normalize(pathInput.path)
+        : path_1.default.normalize(pathInput.path);
+    return (0, path_2.getExt)(_path) === extensions_1.MODULE_EXTENSION;
+}
+exports.isModuleFolder = isModuleFolder;
+function isModuleFolderChild(pathInput, ignoreLocales = false) {
+    throwInvalidPathInput(pathInput);
+    let pathParts = [];
+    if (pathInput.isLocal) {
+        pathParts = (0, path_2.splitLocalPath)(pathInput.path);
+    }
+    else if (pathInput.isHubSpot) {
+        pathParts = (0, path_2.splitHubSpotPath)(pathInput.path);
+    }
+    const { length } = pathParts;
+    // Not a child path?
+    if (length <= 1)
+        return false;
+    // Check if we should ignore this file
+    if (ignoreLocales && pathParts.find(part => part === '_locales')) {
+        return false;
+    }
+    // Check if any parent folders are module folders.
+    return pathParts
+        .slice(0, length - 1)
+        .some(part => isModuleFolder({ ...pathInput, path: part }));
+}
+exports.isModuleFolderChild = isModuleFolderChild;