@hubspot/local-dev-lib 0.0.2 → 0.0.3

package/src/types/Utils.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/utils/encoding.d.ts

@@ -0,0 +1 @@
+export declare function base64EncodeString(valueToEncode: string): string;

package/src/utils/encoding.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.base64EncodeString = void 0;
+function base64EncodeString(valueToEncode) {
+    if (typeof valueToEncode !== 'string') {
+        return valueToEncode;
+    }
+    const stringBuffer = Buffer.from(valueToEncode);
+    return encodeURIComponent(stringBuffer.toString('base64'));
+}
+exports.base64EncodeString = base64EncodeString;

package/src/utils/environment.d.ts

@@ -0,0 +1 @@
+export declare function getValidEnv(env: string, maskedProductionValue?: string): string;

package/src/utils/environment.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getValidEnv = void 0;
+const environments_1 = require("../constants/environments");
+function getValidEnv(env, maskedProductionValue) {
+    const prodValue = maskedProductionValue
+        ? maskedProductionValue
+        : environments_1.ENVIRONMENTS.PROD;
+    const returnVal = typeof env &&
+        typeof env === 'string' &&
+        env.toLowerCase() === environments_1.ENVIRONMENTS.QA
+        ? environments_1.ENVIRONMENTS.QA
+        : prodValue;
+    return returnVal;
+}
+exports.getValidEnv = getValidEnv;

package/src/utils/escapeRegExp.d.ts

@@ -0,0 +1 @@
+export declare function escapeRegExp(string: string): string;

package/src/utils/escapeRegExp.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.escapeRegExp = void 0;
+function escapeRegExp(string) {
+    return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); // $& means the whole matched string
+}
+exports.escapeRegExp = escapeRegExp;

package/src/utils/fieldsJS.d.ts

@@ -0,0 +1,3 @@
+type FieldsArray<T> = Array<T | FieldsArray<T>>;
+export declare function fieldsArrayToJson<T>(fields: FieldsArray<T>): string;
+export {};

package/src/utils/fieldsJS.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fieldsArrayToJson = void 0;
+/*
+ * Polyfill for `Array.flat(Infinity)` since the `flat` is only available for Node v11+
+ * https://stackoverflow.com/a/15030117
+ */
+function flattenArray(arr) {
+    return arr.reduce((flat, toFlatten) => {
+        return flat.concat(Array.isArray(toFlatten) ? flattenArray(toFlatten) : toFlatten);
+    }, []);
+}
+//Transform fields array to JSON
+function fieldsArrayToJson(fields) {
+    const flattened = flattenArray(fields);
+    return JSON.stringify(flattened, null, 2);
+}
+exports.fieldsArrayToJson = fieldsArrayToJson;

package/src/utils/files.d.ts

@@ -0,0 +1,3 @@
+export declare function getThemeJSONPath(path: string): string | null;
+export declare function getThemeNameFromPath(filePath: string): string | undefined;
+export declare function getThemePreviewUrl(filePath: string, accountId: number): string | undefined;

package/src/utils/files.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getThemePreviewUrl = exports.getThemeNameFromPath = exports.getThemeJSONPath = void 0;
+const findup_sync_1 = __importDefault(require("findup-sync"));
+const urls_1 = require("./urls");
+const environments_1 = require("../constants/environments");
+const CLIConfiguration_1 = __importDefault(require("../config/CLIConfiguration"));
+function getThemeJSONPath(path) {
+    return (0, findup_sync_1.default)('theme.json', {
+        cwd: path,
+        nocase: true,
+    });
+}
+exports.getThemeJSONPath = getThemeJSONPath;
+function getThemeNameFromPath(filePath) {
+    const themeJSONPath = getThemeJSONPath(filePath);
+    if (!themeJSONPath)
+        return;
+    const pathParts = themeJSONPath.split('/');
+    if (pathParts.length < 2)
+        return;
+    return pathParts[pathParts.length - 2];
+}
+exports.getThemeNameFromPath = getThemeNameFromPath;
+function getThemePreviewUrl(filePath, accountId) {
+    const themeName = getThemeNameFromPath(filePath);
+    if (!themeName)
+        return;
+    const baseUrl = (0, urls_1.getHubSpotWebsiteOrigin)(CLIConfiguration_1.default.getEnv() === 'qa' ? environments_1.ENVIRONMENTS.QA : environments_1.ENVIRONMENTS.PROD);
+    return `${baseUrl}/theme-previewer/${accountId}/edit/${encodeURIComponent(themeName)}`;
+}
+exports.getThemePreviewUrl = getThemePreviewUrl;

package/src/utils/fs/read.d.ts

@@ -0,0 +1,4 @@
+import { FileData } from '../../types/Files';
+export declare function getFileInfoAsync(dir: string, file: string): Promise<FileData>;
+export declare function flattenAndRemoveSymlinks(filesData: Array<FileData>): Array<string>;
+export declare function read(dir: string): Promise<Array<string>>;

package/src/utils/fs/read.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.read = exports.flattenAndRemoveSymlinks = exports.getFileInfoAsync = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const files_1 = require("../../constants/files");
+function getFileInfoAsync(dir, file) {
+    return new Promise((resolve, reject) => {
+        const filepath = path_1.default.join(dir, file);
+        fs_1.default.lstat(filepath, (error, stats) => {
+            if (error) {
+                reject(error);
+            }
+            let type = files_1.STAT_TYPES.FILE;
+            if (stats.isSymbolicLink()) {
+                type = files_1.STAT_TYPES.SYMBOLIC_LINK;
+            }
+            else if (stats.isDirectory()) {
+                type = files_1.STAT_TYPES.DIRECTORY;
+            }
+            resolve({ filepath, type });
+        });
+    });
+}
+exports.getFileInfoAsync = getFileInfoAsync;
+function flattenAndRemoveSymlinks(filesData) {
+    return filesData.reduce((acc, fileData) => {
+        switch (fileData.type) {
+            case files_1.STAT_TYPES.FILE:
+                return acc.concat(fileData.filepath);
+            case files_1.STAT_TYPES.DIRECTORY:
+                return acc.concat(fileData.files || []);
+            case files_1.STAT_TYPES.SYMBOLIC_LINK:
+                return acc;
+            default:
+                return acc;
+        }
+    }, []);
+}
+exports.flattenAndRemoveSymlinks = flattenAndRemoveSymlinks;
+async function read(dir) {
+    const processFiles = (files) => Promise.all(files.map(file => getFileInfoAsync(dir, file)));
+    return fs_1.default.promises
+        .readdir(dir)
+        .then(processFiles)
+        .then(flattenAndRemoveSymlinks)
+        .catch(err => {
+        console.debug(err);
+        return [];
+    });
+}
+exports.read = read;

package/src/utils/fs/walk.d.ts

@@ -0,0 +1,2 @@
+export declare function listFilesInDir(dir: string): Array<string>;
+export declare function walk(dir: string): Promise<Array<string>>;

package/src/utils/fs/walk.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.walk = exports.listFilesInDir = void 0;
+const fs_1 = __importDefault(require("fs"));
+const read_1 = require("./read");
+const files_1 = require("../../constants/files");
+const standardErrors_1 = require("../../errors/standardErrors");
+function listFilesInDir(dir) {
+    return fs_1.default
+        .readdirSync(dir, { withFileTypes: true })
+        .filter(file => !file.isDirectory())
+        .map(file => file.name);
+}
+exports.listFilesInDir = listFilesInDir;
+const generateRecursiveFilePromise = async (dir, file) => {
+    return (0, read_1.getFileInfoAsync)(dir, file).then(fileData => {
+        return new Promise(resolve => {
+            if (fileData.type === files_1.STAT_TYPES.DIRECTORY) {
+                walk(fileData.filepath).then(files => {
+                    resolve({ ...fileData, files });
+                });
+            }
+            else {
+                resolve(fileData);
+            }
+        });
+    });
+};
+async function walk(dir) {
+    function processFiles(files) {
+        return Promise.all(files.map(file => generateRecursiveFilePromise(dir, file)));
+    }
+    return fs_1.default.promises
+        .readdir(dir)
+        .then(processFiles)
+        .then(read_1.flattenAndRemoveSymlinks)
+        .catch(err => {
+        (0, standardErrors_1.throwError)(err);
+    });
+}
+exports.walk = walk;

package/src/utils/git.d.ts

@@ -0,0 +1,4 @@
+export declare function makeComparisonDir(filepath: string | null): string | null;
+export declare const getGitComparisonDir: () => string | null;
+export declare function isConfigPathInGitRepo(configPath: string): boolean;
+export declare function configFilenameIsIgnoredByGitignore(ignoreFiles: Array<string>, configPath: string): boolean;

package/src/utils/git.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configFilenameIsIgnoredByGitignore = exports.isConfigPathInGitRepo = exports.getGitComparisonDir = exports.makeComparisonDir = void 0;
+const fs_extra_1 = require("fs-extra");
+const path_1 = __importDefault(require("path"));
+const ignore_1 = __importDefault(require("ignore"));
+const findup_sync_1 = __importDefault(require("findup-sync"));
+function makeComparisonDir(filepath) {
+    if (typeof filepath !== 'string')
+        return null;
+    // Append sep to make comparisons easier e.g. 'foos'.startsWith('foo')
+    return path_1.default.dirname(path_1.default.resolve(filepath)).toLowerCase() + path_1.default.sep;
+}
+exports.makeComparisonDir = makeComparisonDir;
+const getGitComparisonDir = () => makeComparisonDir((0, findup_sync_1.default)('.git'));
+exports.getGitComparisonDir = getGitComparisonDir;
+function isConfigPathInGitRepo(configPath) {
+    const gitDir = (0, exports.getGitComparisonDir)();
+    if (!gitDir)
+        return false;
+    const configDir = makeComparisonDir(configPath);
+    if (!configDir)
+        return false;
+    return configDir.startsWith(gitDir);
+}
+exports.isConfigPathInGitRepo = isConfigPathInGitRepo;
+function configFilenameIsIgnoredByGitignore(ignoreFiles, configPath) {
+    return ignoreFiles.some(gitignore => {
+        const gitignoreContents = (0, fs_extra_1.readFileSync)(gitignore).toString();
+        const gitignoreConfig = (0, ignore_1.default)().add(gitignoreContents);
+        if (gitignoreConfig.ignores(path_1.default.relative(path_1.default.dirname(gitignore), configPath))) {
+            return true;
+        }
+        return false;
+    });
+}
+exports.configFilenameIsIgnoredByGitignore = configFilenameIsIgnoredByGitignore;

package/src/utils/handleFieldsJS.d.ts

@@ -0,0 +1,35 @@
+export declare class FieldsJs {
+    projectDir: string;
+    filePath: string;
+    rootWriteDir: string;
+    rejected: boolean;
+    fieldOptions: string;
+    outputPath?: string;
+    constructor(projectDir: string, filePath: string, rootWriteDir?: string, fieldOptions?: string);
+    init(): Promise<this>;
+    convertFieldsJs(writeDir: string): Promise<string | void>;
+    /**
+     * If there has been a fields.json written to the output path, then copy it from the output
+     * directory to the project directory, respecting the path within the output directory.
+     * Ex: path/to/tmp/example.module/fields.json => path/to/project/example.module/fields.output.json
+     */
+    saveOutput(): void;
+    /**
+     * Resolves the relative path to the fields.js within the project directory and returns
+     * directory name to write to in rootWriteDir directory.
+     *
+     * Ex: If rootWriteDir = 'path/to/temp', filePath = 'projectRoot/sample.module/fields.js'. Then getWriteDir() => path/to/temp/sample.module
+     */
+    getWriteDir(): string;
+    getOutputPathPromise(): Promise<string | void>;
+}
+type FieldsArray<T> = Array<T | FieldsArray<T>>;
+export declare function fieldsArrayToJson<T>(fields: FieldsArray<T>): string;
+/**
+ * Determines if file is a convertable fields.js file i.e., if it is called
+ * 'fields.js' and in a root or in a module folder, and if convertFields flag is true.
+ */
+export declare function isConvertableFieldJs(rootDir: string, filePath: string, convertFields?: boolean): boolean;
+export declare function createTmpDirSync(prefix: string): string;
+export declare function cleanupTmpDirSync(tmpDir: string): void;
+export {};

package/src/utils/handleFieldsJS.js

@@ -0,0 +1,158 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanupTmpDirSync = exports.createTmpDirSync = exports.isConvertableFieldJs = exports.fieldsArrayToJson = exports.FieldsJs = void 0;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const escapeRegExp_1 = require("./escapeRegExp");
+const modules_1 = require("../lib/modules");
+const logger_1 = require("./logger");
+const standardErrors_1 = require("../errors/standardErrors");
+const i18nKey = 'utils.handleFieldsJs';
+class FieldsJs {
+    projectDir;
+    filePath;
+    rootWriteDir;
+    rejected;
+    fieldOptions;
+    outputPath;
+    constructor(projectDir, filePath, rootWriteDir, fieldOptions = '') {
+        this.projectDir = projectDir;
+        this.filePath = filePath;
+        this.fieldOptions = fieldOptions;
+        this.rejected = false;
+        // Create tmpDir if no writeDir is given.
+        this.rootWriteDir =
+            rootWriteDir === undefined
+                ? createTmpDirSync('hubspot-temp-fieldsjs-output-')
+                : rootWriteDir;
+    }
+    async init() {
+        const outputPath = await this.getOutputPathPromise();
+        this.outputPath = this.rejected ? undefined : outputPath;
+        return this;
+    }
+    // Converts a fields.js file into a fields.json file, writes, and returns of fields.json
+    convertFieldsJs(writeDir) {
+        const filePath = this.filePath;
+        const dirName = path_1.default.dirname(filePath);
+        return new Promise((resolve, reject) => {
+            const convertFieldsProcess = (0, child_process_1.fork)(path_1.default.join(__dirname, './processFieldsJs.js'), [], {
+                cwd: dirName,
+                env: {
+                    dirName,
+                    fieldOptions: this.fieldOptions,
+                    filePath,
+                    writeDir,
+                },
+            });
+            (0, logger_1.debug)(`${i18nKey}.convertFieldsJs.creating`, {
+                pid: convertFieldsProcess.pid || '',
+            });
+            convertFieldsProcess.on('message', function (message) {
+                if (message.action === 'ERROR') {
+                    reject(message.message);
+                }
+                else if (message.action === 'COMPLETE') {
+                    resolve(message.finalPath);
+                }
+            });
+            convertFieldsProcess.on('close', () => {
+                (0, logger_1.debug)(`${i18nKey}.convertFieldsJs.terminating`, {
+                    pid: convertFieldsProcess.pid || '',
+                });
+            });
+        }).catch((e) => {
+            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.convertFieldsJs`, { filePath }, e);
+        });
+    }
+    /**
+     * If there has been a fields.json written to the output path, then copy it from the output
+     * directory to the project directory, respecting the path within the output directory.
+     * Ex: path/to/tmp/example.module/fields.json => path/to/project/example.module/fields.output.json
+     */
+    saveOutput() {
+        if (!this.outputPath || !fs_extra_1.default.existsSync(this.outputPath)) {
+            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.saveOutput`, { path: this.filePath });
+        }
+        const relativePath = path_1.default.relative(this.rootWriteDir, path_1.default.dirname(this.outputPath));
+        const savePath = path_1.default.join(this.projectDir, relativePath, 'fields.output.json');
+        try {
+            fs_extra_1.default.copyFileSync(this.outputPath, savePath);
+        }
+        catch (err) {
+            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.saveOutput`, { path: savePath }, err);
+        }
+    }
+    /**
+     * Resolves the relative path to the fields.js within the project directory and returns
+     * directory name to write to in rootWriteDir directory.
+     *
+     * Ex: If rootWriteDir = 'path/to/temp', filePath = 'projectRoot/sample.module/fields.js'. Then getWriteDir() => path/to/temp/sample.module
+     */
+    getWriteDir() {
+        const projectDirRegex = new RegExp(`^${(0, escapeRegExp_1.escapeRegExp)(this.projectDir)}`);
+        const relativePath = this.filePath.replace(projectDirRegex, '');
+        return path_1.default.dirname(path_1.default.join(this.rootWriteDir, relativePath));
+    }
+    getOutputPathPromise() {
+        const writeDir = this.getWriteDir();
+        return this.convertFieldsJs(writeDir).then(outputPath => outputPath);
+    }
+}
+exports.FieldsJs = FieldsJs;
+/*
+ * Polyfill for `Array.flat(Infinity)` since the `flat` is only available for Node v11+
+ * https://stackoverflow.com/a/15030117
+ */
+function flattenArray(arr) {
+    return arr.reduce((flat, toFlatten) => {
+        return flat.concat(Array.isArray(toFlatten) ? flattenArray(toFlatten) : toFlatten);
+    }, []);
+}
+//Transform fields array to JSON
+function fieldsArrayToJson(fields) {
+    const flattened = flattenArray(fields);
+    return JSON.stringify(flattened, null, 2);
+}
+exports.fieldsArrayToJson = fieldsArrayToJson;
+/**
+ * Determines if file is a convertable fields.js file i.e., if it is called
+ * 'fields.js' and in a root or in a module folder, and if convertFields flag is true.
+ */
+function isConvertableFieldJs(rootDir, filePath, convertFields = false) {
+    const allowedFieldsNames = ['fields.js', 'fields.mjs', 'fields.cjs'];
+    const regex = new RegExp(`^${(0, escapeRegExp_1.escapeRegExp)(rootDir)}`);
+    const relativePath = path_1.default.dirname(filePath.replace(regex, ''));
+    const baseName = path_1.default.basename(filePath);
+    const inModuleFolder = (0, modules_1.isModuleFolderChild)({ path: filePath, isLocal: true });
+    return !!(convertFields &&
+        allowedFieldsNames.includes(baseName) &&
+        (inModuleFolder || relativePath == '/'));
+}
+exports.isConvertableFieldJs = isConvertableFieldJs;
+// Try creating tempdir
+function createTmpDirSync(prefix) {
+    let tmpDir;
+    try {
+        tmpDir = fs_extra_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), prefix));
+    }
+    catch (err) {
+        (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.createTmpDirSync`, {}, err);
+    }
+    return tmpDir;
+}
+exports.createTmpDirSync = createTmpDirSync;
+// Try cleaning up resources from os's tempdir
+function cleanupTmpDirSync(tmpDir) {
+    fs_extra_1.default.rm(tmpDir, { recursive: true }, err => {
+        if (err) {
+            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.cleanupTmpDirSync`, {}, err);
+        }
+    });
+}
+exports.cleanupTmpDirSync = cleanupTmpDirSync;

package/src/utils/interpolation.d.ts

@@ -0,0 +1,5 @@
+type InterpolationData = {
+    [identifier: string]: string | number;
+};
+export declare function interpolate(stringValue: string, interpolationData: InterpolationData): string;
+export {};

package/src/utils/interpolation.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.interpolate = void 0;
+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;

package/src/utils/lang.d.ts

@@ -0,0 +1,8 @@
+type InterpolationData = {
+    [identifier: string]: string | number;
+};
+export declare function interpolate(stringValue: string, interpolationData: InterpolationData): string;
+export declare function i18n(lookupDotNotation: string, options?: {
+    [identifier: string]: string | number;
+}): string;
+export {};

package/src/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/src/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/src/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/src/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;