@hubspot/local-dev-lib 0.0.1-experimental.0

package/lib/github.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="node" />
+import { GithubReleaseData, GithubRepoFile, RepoPath, CloneGithubRepoOptions } from '../types/Github';
+export declare function fetchFileFromRepository(repoPath: RepoPath, filePath: string, ref: string): Promise<Buffer>;
+export declare function fetchReleaseData(repoPath: RepoPath, tag?: string): Promise<GithubReleaseData>;
+export declare function cloneGithubRepo(repoPath: RepoPath, dest: string, options?: CloneGithubRepoOptions): Promise<boolean>;
+export declare function fetchGitHubRepoContentFromDownloadUrl(dest: string, downloadUrl: string): Promise<void>;
+export declare function downloadGithubRepoContents(repoPath: RepoPath, contentPath: string, dest: string, ref?: string, filter?: (contentPiecePath: string, downloadPath: string) => boolean): Promise<void>;
+export declare function listGithubRepoContents(repoPath: RepoPath, contentPath: string, fileFilter?: 'file' | 'dir'): Promise<GithubRepoFile[]>;

package/lib/github.js

@@ -0,0 +1,167 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listGithubRepoContents = exports.downloadGithubRepoContents = exports.fetchGitHubRepoContentFromDownloadUrl = exports.cloneGithubRepo = exports.fetchReleaseData = exports.fetchFileFromRepository = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const archive_1 = require("./archive");
+const logger_1 = require("./logger");
+const github_1 = require("../api/github");
+const lang_1 = require("../utils/lang");
+const errors_1 = require("../errors");
+const i18nKey = 'lib.github';
+async function fetchFileFromRepository(repoPath, filePath, ref) {
+    try {
+        logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.fetchFileFromRepository.fetching`, {
+            path: `${repoPath}/${ref}/${filePath}`,
+        }));
+        const { data } = await (0, github_1.fetchRepoFile)(repoPath, filePath, ref);
+        return data;
+    }
+    catch (err) {
+        throw new Error((0, lang_1.i18n)(`${i18nKey}.fetchFileFromRepository.errors.fetchFail`), {
+            cause: err,
+        });
+    }
+}
+exports.fetchFileFromRepository = fetchFileFromRepository;
+// Fetches information about a specific release (Defaults to latest)
+async function fetchReleaseData(repoPath, tag) {
+    if (tag) {
+        tag = tag.trim().toLowerCase();
+        if (tag.length && tag[0] !== 'v') {
+            tag = `v${tag}`;
+        }
+    }
+    try {
+        const { data } = await (0, github_1.fetchRepoReleaseData)(repoPath, tag);
+        return data;
+    }
+    catch (err) {
+        throw new Error((0, lang_1.i18n)(`${i18nKey}.fetchReleaseData.errors.fetchFail`, {
+            tag: tag || 'latest',
+        }), { cause: err });
+    }
+}
+exports.fetchReleaseData = fetchReleaseData;
+async function downloadGithubRepoZip(repoPath, isRelease = false, options = {}) {
+    const { branch, tag } = options;
+    try {
+        let zipUrl;
+        if (isRelease) {
+            // If downloading a release, first get the release info using fetchReleaseData().
+            // Supports a custom tag, but will default to the latest release
+            const releaseData = await fetchReleaseData(repoPath, tag);
+            zipUrl = releaseData.zipball_url;
+            const { name } = releaseData;
+            logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.downloadGithubRepoZip.fetchingName`, { name }));
+        }
+        else {
+            // If downloading a repository, manually construct the zip url. This url supports both branches and tags as refs
+            logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.downloadGithubRepoZip.fetching`, { repoPath }));
+            const ref = branch || tag;
+            zipUrl = `https://api.github.com/repos/${repoPath}/zipball${ref ? `/${ref}` : ''}`;
+        }
+        const { data } = await (0, github_1.fetchRepoAsZip)(zipUrl);
+        logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.downloadGithubRepoZip.completed`));
+        return data;
+    }
+    catch (err) {
+        throw new Error((0, lang_1.i18n)(`${i18nKey}.downloadGithubRepoZip.errors.fetchFail`), {
+            cause: err,
+        });
+    }
+}
+async function cloneGithubRepo(repoPath, dest, options = {}) {
+    const { tag, isRelease, branch, sourceDir, type } = options;
+    const zip = await downloadGithubRepoZip(repoPath, isRelease, {
+        tag,
+        branch,
+    });
+    const repoName = repoPath.split('/')[1];
+    const success = await (0, archive_1.extractZipArchive)(zip, repoName, dest, { sourceDir });
+    if (success) {
+        logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.cloneGithubRepo.success`, {
+            type: type || '',
+            dest,
+        }));
+    }
+    return success;
+}
+exports.cloneGithubRepo = cloneGithubRepo;
+async function fetchGitHubRepoContentFromDownloadUrl(dest, downloadUrl) {
+    const resp = await (0, github_1.fetchRepoFileByDownloadUrl)(downloadUrl);
+    const contentType = resp.headers['content-type'];
+    let fileContents;
+    if (contentType.startsWith('text')) {
+        fileContents = Buffer.from(resp.data).toString('utf8');
+    }
+    else {
+        fileContents = resp.data;
+    }
+    fs_extra_1.default.outputFileSync(dest, fileContents);
+}
+exports.fetchGitHubRepoContentFromDownloadUrl = fetchGitHubRepoContentFromDownloadUrl;
+// Writes files from a public repository to the destination folder
+async function downloadGithubRepoContents(repoPath, contentPath, dest, ref, filter) {
+    fs_extra_1.default.ensureDirSync(path_1.default.dirname(dest));
+    try {
+        const { data: contentsResp } = await (0, github_1.fetchRepoContents)(repoPath, contentPath, ref);
+        const downloadContent = async (contentPiece) => {
+            const { path: contentPiecePath, download_url, type: contentPieceType, } = contentPiece;
+            const downloadPath = path_1.default.join(dest, contentPiecePath.replace(contentPath, ''));
+            if (filter && !filter(contentPiecePath, downloadPath)) {
+                return Promise.resolve();
+            }
+            logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.downloadGithubRepoContents.downloading`, {
+                contentPiecePath,
+                downloadUrl: download_url,
+                downloadPath,
+            }));
+            if (contentPieceType === 'dir') {
+                const { data: innerDirContent } = await (0, github_1.fetchRepoContents)(repoPath, contentPiecePath, ref);
+                await Promise.all(innerDirContent.map(downloadContent));
+                return Promise.resolve();
+            }
+            return fetchGitHubRepoContentFromDownloadUrl(downloadPath, download_url);
+        };
+        let contentPromises;
+        if (Array.isArray(contentsResp)) {
+            contentPromises = contentsResp.map(downloadContent);
+        }
+        else {
+            contentPromises = [downloadContent(contentsResp)];
+        }
+        await Promise.all(contentPromises);
+    }
+    catch (e) {
+        if ((0, errors_1.isSystemError)(e) && e?.error?.message) {
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.downloadGithubRepoContents.errors.fetchFail`, {
+                errorMessage: e.error.message,
+            }), { cause: e });
+        }
+        throw e;
+    }
+}
+exports.downloadGithubRepoContents = downloadGithubRepoContents;
+// Lists content from a public repository at the specified path
+async function listGithubRepoContents(repoPath, contentPath, fileFilter) {
+    try {
+        const { data: contentsResp } = await (0, github_1.fetchRepoContents)(repoPath, contentPath);
+        const filteredFiles = fileFilter && fileFilter != undefined
+            ? contentsResp.filter(item => item.type === fileFilter)
+            : contentsResp;
+        return filteredFiles;
+    }
+    catch (e) {
+        if ((0, errors_1.isHubSpotHttpError)(e) && e.data.message) {
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.downloadGithubRepoContents.errors.fetchFail`, {
+                errorMessage: e.data.message,
+            }));
+        }
+        throw e;
+    }
+}
+exports.listGithubRepoContents = listGithubRepoContents;

package/lib/gitignore.d.ts

@@ -0,0 +1,3 @@
+import { GitInclusionResult } from '../types/Config';
+export declare function checkAndAddConfigToGitignore(configPath: string): void;
+export declare function checkGitInclusion(configPath: string): GitInclusionResult;

package/lib/gitignore.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkGitInclusion = exports.checkAndAddConfigToGitignore = void 0;
+const fs_extra_1 = require("fs-extra");
+const path_1 = __importDefault(require("path"));
+const git_1 = require("../utils/git");
+const config_1 = require("../constants/config");
+const lang_1 = require("../utils/lang");
+const i18nKey = 'lib.gitignore';
+const GITIGNORE_FILE = '.gitignore';
+function checkAndAddConfigToGitignore(configPath) {
+    try {
+        const { configIgnored, gitignoreFiles } = checkGitInclusion(configPath);
+        if (configIgnored)
+            return;
+        let gitignoreFilePath = gitignoreFiles && gitignoreFiles.length ? gitignoreFiles[0] : null;
+        if (!gitignoreFilePath) {
+            gitignoreFilePath = path_1.default.resolve(configPath, GITIGNORE_FILE);
+            (0, fs_extra_1.writeFileSync)(gitignoreFilePath, '');
+        }
+        const gitignoreContents = (0, fs_extra_1.readFileSync)(gitignoreFilePath).toString();
+        const updatedContents = `${gitignoreContents.trim()}\n\n# HubSpot config file\n${config_1.DEFAULT_HUBSPOT_CONFIG_YAML_FILE_NAME}\n`;
+        (0, fs_extra_1.writeFileSync)(gitignoreFilePath, updatedContents);
+    }
+    catch (e) {
+        throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.configIgnore`), { cause: e });
+    }
+}
+exports.checkAndAddConfigToGitignore = checkAndAddConfigToGitignore;
+function checkGitInclusion(configPath) {
+    const result = {
+        inGit: false,
+        configIgnored: false,
+        gitignoreFiles: [],
+    };
+    if ((0, git_1.isConfigPathInGitRepo)(configPath)) {
+        result.inGit = true;
+        result.gitignoreFiles = (0, git_1.getGitignoreFiles)(configPath);
+        if ((0, git_1.configFilenameIsIgnoredByGitignore)(result.gitignoreFiles, configPath)) {
+            // Found ignore statement in .gitignore that matches config filename
+            result.configIgnored = true;
+        }
+    }
+    return result;
+}
+exports.checkGitInclusion = checkGitInclusion;

package/lib/hubdb.d.ts

@@ -0,0 +1,17 @@
+import { AxiosResponse } from 'axios';
+import { Row, Table } from '../types/Hubdb';
+export declare function addRowsToHubDbTable(accountId: number, tableId: string, rows?: Array<Row>): Promise<{
+    tableId: string;
+    rowCount: number;
+}>;
+export declare function createHubDbTable(accountId: number, src: string): Promise<{
+    tableId: string;
+    rowCount: number;
+}>;
+export declare function updateHubDbTable(accountId: number, tableId: string, src: string): Promise<AxiosResponse<Table, any>>;
+export declare function downloadHubDbTable(accountId: number, tableId: string, dest: string): Promise<{
+    filePath: string;
+}>;
+export declare function clearHubDbTableRows(accountId: number, tableId: string): Promise<{
+    deletedRowCount: number;
+}>;

package/lib/hubdb.js

@@ -0,0 +1,133 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearHubDbTableRows = exports.downloadHubDbTable = exports.updateHubDbTable = exports.createHubDbTable = exports.addRowsToHubDbTable = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const prettier_1 = __importDefault(require("prettier"));
+const hubdb_1 = require("../api/hubdb");
+const path_2 = require("./path");
+const lang_1 = require("../utils/lang");
+const i18nKey = 'lib.hubdb';
+function validateJsonPath(src) {
+    if (path_1.default.extname(src) !== '.json') {
+        throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.invalidJsonPath`));
+    }
+}
+function validateJsonFile(src) {
+    let stats;
+    try {
+        stats = fs_extra_1.default.statSync(src);
+    }
+    catch (err) {
+        throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.invalidJsonFile`, { src }), {
+            cause: err,
+        });
+    }
+    if (!stats.isFile()) {
+        throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.invalidJsonFile`, { src }));
+    }
+    validateJsonPath(src);
+}
+async function addRowsToHubDbTable(accountId, tableId, rows = []) {
+    const rowsToUpdate = rows.map(row => {
+        const values = row.values;
+        return {
+            childTableId: '0',
+            isSoftEditable: false,
+            ...row,
+            values,
+        };
+    });
+    if (rowsToUpdate.length > 0) {
+        await (0, hubdb_1.createRows)(accountId, tableId, rowsToUpdate);
+    }
+    const { data: { rowCount }, } = await (0, hubdb_1.publishTable)(accountId, tableId);
+    return {
+        tableId,
+        rowCount,
+    };
+}
+exports.addRowsToHubDbTable = addRowsToHubDbTable;
+async function createHubDbTable(accountId, src) {
+    validateJsonFile(src);
+    const table = fs_extra_1.default.readJsonSync(src);
+    const { rows, ...schema } = table;
+    const { data: { id }, } = await (0, hubdb_1.createTable)(accountId, schema);
+    return addRowsToHubDbTable(accountId, id, rows);
+}
+exports.createHubDbTable = createHubDbTable;
+async function updateHubDbTable(accountId, tableId, src) {
+    validateJsonFile(src);
+    const table = fs_extra_1.default.readJsonSync(src);
+    const { ...schema } = table;
+    return (0, hubdb_1.updateTable)(accountId, tableId, schema);
+}
+exports.updateHubDbTable = updateHubDbTable;
+function convertToJSON(table, rows) {
+    const { allowChildTables, allowPublicApiAccess, columns, dynamicMetaTags, enableChildTablePages, label, name, useForPages, } = table;
+    const cleanedColumns = columns
+        .filter(column => !column.deleted || !column.archived)
+        .map(({ 
+    /* eslint-disable @typescript-eslint/no-unused-vars */
+    id, deleted, archived, foreignIdsByName, foreignIdsById, 
+    /* eslint-enable @typescript-eslint/no-unused-vars */
+    ...cleanedColumn }) => cleanedColumn);
+    const cleanedRows = rows.map(row => {
+        return {
+            path: row.path,
+            name: row.name,
+            values: row.values,
+        };
+    });
+    return {
+        name,
+        useForPages,
+        label,
+        allowChildTables,
+        allowPublicApiAccess,
+        dynamicMetaTags,
+        enableChildTablePages,
+        columns: cleanedColumns,
+        rows: cleanedRows,
+    };
+}
+async function fetchAllRows(accountId, tableId) {
+    let rows = [];
+    let after = null;
+    do {
+        const axiosResponse = await (0, hubdb_1.fetchRows)(accountId, tableId, after ? { after } : undefined);
+        const { paging, results } = axiosResponse.data;
+        rows = rows.concat(results);
+        after = paging && paging.next ? paging.next.after : null;
+    } while (after !== null);
+    return rows;
+}
+async function downloadHubDbTable(accountId, tableId, dest) {
+    const { data: table } = await (0, hubdb_1.fetchTable)(accountId, tableId);
+    dest = path_1.default.resolve((0, path_2.getCwd)(), dest || `${table.name}.hubdb.json`);
+    if (fs_extra_1.default.pathExistsSync(dest)) {
+        validateJsonFile(dest);
+    }
+    else {
+        validateJsonPath(dest);
+    }
+    const rows = await fetchAllRows(accountId, tableId);
+    const tableToWrite = JSON.stringify(convertToJSON(table, rows));
+    const tableJson = await prettier_1.default.format(tableToWrite, {
+        parser: 'json',
+    });
+    await fs_extra_1.default.outputFile(dest, tableJson);
+    return { filePath: dest };
+}
+exports.downloadHubDbTable = downloadHubDbTable;
+async function clearHubDbTableRows(accountId, tableId) {
+    const rows = await fetchAllRows(accountId, tableId);
+    await (0, hubdb_1.deleteRows)(accountId, tableId, rows.map(row => row.id));
+    return {
+        deletedRowCount: rows.length,
+    };
+}
+exports.clearHubDbTableRows = clearHubDbTableRows;

package/lib/ignoreRules.d.ts

@@ -0,0 +1,3 @@
+export declare function shouldIgnoreFile(file: string, isInProject?: boolean): boolean;
+export declare function createIgnoreFilter(isInProject: boolean): (file: string) => boolean;
+export declare function ignoreFile(filePath: string): void;

package/lib/ignoreRules.js

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ignoreFile = exports.createIgnoreFilter = exports.shouldIgnoreFile = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const ignore_1 = __importDefault(require("ignore"));
+const findup_sync_1 = __importDefault(require("findup-sync"));
+const ignoreList = [
+    'fields.output.json',
+    'hubspot.config.yml',
+    'hubspot.config.yaml',
+    'node_modules',
+    '.*',
+    '*.log',
+    '*.swp',
+    '.env',
+    // # macOS
+    'Icon\\r',
+    '__MACOSX',
+    // # Linux
+    '~',
+    // # Emacs
+    '*~',
+    // # Windows
+    'Thumbs.db',
+    'ehthumbs.db',
+    'Desktop.ini',
+    '@eaDir', // Synology Diskstation "hidden" folder where the server stores thumbnails
+];
+const ignoreRules = (0, ignore_1.default)().add(ignoreList);
+let searchDomain = null;
+let loaded = false;
+function loadIgnoreConfig(isInProject = false) {
+    if (loaded) {
+        return;
+    }
+    // Temporary solution to improve serverless beta: https://git.hubteam.com/HubSpot/cms-devex-super-repo/issues/2
+    // Do not do this when in a developer project b/c we want the package-lock.json file uploaded.
+    if (!isInProject) {
+        ignoreRules.add('package-lock.json');
+    }
+    const file = (0, findup_sync_1.default)('.hsignore');
+    if (file) {
+        if (fs_1.default.existsSync(file)) {
+            ignoreRules.add(fs_1.default.readFileSync(file).toString());
+            searchDomain = path_1.default.dirname(file);
+        }
+    }
+    loaded = true;
+}
+function shouldIgnoreFile(file, isInProject = false) {
+    loadIgnoreConfig(isInProject);
+    const relativeTo = searchDomain || '/';
+    const relativePath = path_1.default.relative(relativeTo, file);
+    return !!relativePath && ignoreRules.ignores(relativePath);
+}
+exports.shouldIgnoreFile = shouldIgnoreFile;
+function createIgnoreFilter(isInProject) {
+    loadIgnoreConfig(isInProject);
+    return (file) => !shouldIgnoreFile(file);
+}
+exports.createIgnoreFilter = createIgnoreFilter;
+function ignoreFile(filePath) {
+    ignoreRules.add(filePath);
+}
+exports.ignoreFile = ignoreFile;

package/lib/logger.d.ts

@@ -0,0 +1,56 @@
+import { Chalk } from 'chalk';
+export declare const LOG_LEVEL: {
+    NONE: number;
+    DEBUG: number;
+    LOG: number;
+    WARN: number;
+    ERROR: number;
+};
+/**
+ * Chalk styles for logger strings.
+ */
+export declare const Styles: {
+    debug: Chalk & {
+        supportsColor: import("chalk").ColorSupport;
+    };
+    log: Chalk & {
+        supportsColor: import("chalk").ColorSupport;
+    };
+    success: Chalk & {
+        supportsColor: import("chalk").ColorSupport;
+    };
+    info: Chalk & {
+        supportsColor: import("chalk").ColorSupport;
+    };
+    warn: Chalk & {
+        supportsColor: import("chalk").ColorSupport;
+    };
+    error: Chalk & {
+        supportsColor: import("chalk").ColorSupport;
+    };
+};
+export declare function stylize(label: string, style: Chalk, args: any[]): any[];
+export declare class Logger {
+    error(...args: any[]): void;
+    warn(...args: any[]): void;
+    log(...args: any[]): void;
+    success(...args: any[]): void;
+    info(...args: any[]): void;
+    debug(...args: any[]): void;
+    group(...args: any[]): void;
+    groupEnd(): void;
+}
+export declare function setLogger(logger: Logger): void;
+export declare function setLogLevel(level: number): void;
+export declare function shouldLog(level: number): boolean;
+export declare function getLogLevel(): number;
+export declare const logger: {
+    error(...args: any[]): void;
+    warn(...args: any[]): void;
+    log(...args: any[]): void;
+    success(...args: any[]): void;
+    info(...args: any[]): void;
+    debug(...args: any[]): void;
+    group(...args: any[]): void;
+    groupEnd(): void;
+};

package/lib/logger.js

@@ -0,0 +1,146 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-explicit-any */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = exports.getLogLevel = exports.shouldLog = exports.setLogLevel = exports.setLogger = exports.Logger = exports.stylize = exports.Styles = exports.LOG_LEVEL = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+exports.LOG_LEVEL = {
+    NONE: 0,
+    DEBUG: 1,
+    LOG: 2,
+    WARN: 4,
+    ERROR: 8,
+};
+/**
+ * Chalk styles for logger strings.
+ */
+exports.Styles = {
+    debug: chalk_1.default.reset.blue,
+    log: chalk_1.default.reset,
+    success: chalk_1.default.reset.green,
+    info: chalk_1.default.reset.white,
+    warn: chalk_1.default.reset.yellow,
+    error: chalk_1.default.reset.red,
+};
+function stylize(label, style, args) {
+    const styledLabel = style(label);
+    const [firstArg, ...rest] = args;
+    if (typeof firstArg === 'string') {
+        return [`${styledLabel} ${firstArg}`, ...rest];
+    }
+    return [styledLabel, ...args];
+}
+exports.stylize = stylize;
+class Logger {
+    error(...args) {
+        console.error(...stylize('[ERROR]', exports.Styles.error, args));
+    }
+    warn(...args) {
+        console.warn(...stylize('[WARNING]', exports.Styles.warn, args));
+    }
+    log(...args) {
+        console.log(...args);
+    }
+    success(...args) {
+        console.log(...stylize('[SUCCESS]', exports.Styles.success, args));
+    }
+    info(...args) {
+        console.info(...stylize('[INFO]', exports.Styles.info, args));
+    }
+    debug(...args) {
+        console.debug(...stylize('[DEBUG]', exports.Styles.log, args));
+    }
+    group(...args) {
+        console.group(...args);
+    }
+    groupEnd() {
+        console.groupEnd();
+    }
+}
+exports.Logger = Logger;
+let currentLogger = new Logger();
+let currentLogLevel = exports.LOG_LEVEL.ERROR;
+function setLogger(logger) {
+    currentLogger = logger;
+}
+exports.setLogger = setLogger;
+function setLogLevel(level) {
+    switch (level) {
+        case exports.LOG_LEVEL.DEBUG:
+            currentLogLevel =
+                exports.LOG_LEVEL.DEBUG | exports.LOG_LEVEL.LOG | exports.LOG_LEVEL.WARN | exports.LOG_LEVEL.ERROR;
+            break;
+        case exports.LOG_LEVEL.LOG:
+            currentLogLevel = exports.LOG_LEVEL.LOG | exports.LOG_LEVEL.WARN | exports.LOG_LEVEL.ERROR;
+            break;
+        case exports.LOG_LEVEL.WARN:
+            currentLogLevel = exports.LOG_LEVEL.WARN | exports.LOG_LEVEL.ERROR;
+            break;
+        case exports.LOG_LEVEL.ERROR:
+            currentLogLevel = exports.LOG_LEVEL.ERROR;
+            break;
+        case exports.LOG_LEVEL.NONE:
+        default:
+            currentLogLevel = exports.LOG_LEVEL.NONE;
+    }
+}
+exports.setLogLevel = setLogLevel;
+function shouldLog(level) {
+    return !!(currentLogLevel & level);
+}
+exports.shouldLog = shouldLog;
+function getLogLevel() {
+    switch (currentLogLevel) {
+        case exports.LOG_LEVEL.DEBUG | exports.LOG_LEVEL.LOG | exports.LOG_LEVEL.WARN | exports.LOG_LEVEL.ERROR:
+            return exports.LOG_LEVEL.DEBUG;
+        case exports.LOG_LEVEL.LOG | exports.LOG_LEVEL.WARN | exports.LOG_LEVEL.ERROR:
+            return exports.LOG_LEVEL.LOG;
+        case exports.LOG_LEVEL.WARN | exports.LOG_LEVEL.ERROR:
+            return exports.LOG_LEVEL.WARN;
+        case exports.LOG_LEVEL.ERROR:
+            return exports.LOG_LEVEL.ERROR;
+        default:
+            return exports.LOG_LEVEL.NONE;
+    }
+}
+exports.getLogLevel = getLogLevel;
+exports.logger = {
+    error(...args) {
+        if (shouldLog(exports.LOG_LEVEL.ERROR)) {
+            currentLogger.error(...args);
+        }
+    },
+    warn(...args) {
+        if (shouldLog(exports.LOG_LEVEL.WARN)) {
+            currentLogger.warn(...args);
+        }
+    },
+    log(...args) {
+        if (shouldLog(exports.LOG_LEVEL.LOG)) {
+            currentLogger.log(...args);
+        }
+    },
+    success(...args) {
+        if (shouldLog(exports.LOG_LEVEL.LOG)) {
+            currentLogger.success(...args);
+        }
+    },
+    info(...args) {
+        if (shouldLog(exports.LOG_LEVEL.LOG)) {
+            currentLogger.info(...args);
+        }
+    },
+    debug(...args) {
+        if (shouldLog(exports.LOG_LEVEL.DEBUG)) {
+            currentLogger.debug(...args);
+        }
+    },
+    group(...args) {
+        currentLogger.group(...args);
+    },
+    groupEnd() {
+        currentLogger.groupEnd();
+    },
+};

package/lib/notify.d.ts

@@ -0,0 +1 @@
+export declare function triggerNotify(filePathToNotify: string | undefined, actionType: string, filePath: string, actionPromise: Promise<void>): void;