@hubspot/local-dev-lib 0.0.2 → 0.0.3

package/src/lib/gitignore.js

@@ -0,0 +1,76 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkAndAddConfigToGitignore = void 0;
+const fs_extra_1 = require("fs-extra");
+const path_1 = __importDefault(require("path"));
+const findup_sync_1 = __importDefault(require("findup-sync"));
+const git_1 = require("../utils/git");
+const config_1 = require("../constants/config");
+const standardErrors_1 = require("../errors/standardErrors");
+const GITIGNORE_FILE = '.gitignore';
+// Get all .gitignore files since they can cascade down directory structures
+function getGitignoreFiles(configPath) {
+    const gitDir = (0, git_1.getGitComparisonDir)();
+    const files = [];
+    if (!gitDir) {
+        // Not in git
+        return files;
+    }
+    // Start findup from config dir
+    let cwd = configPath && path_1.default.dirname(configPath);
+    while (cwd) {
+        const ignorePath = (0, findup_sync_1.default)(GITIGNORE_FILE, { cwd });
+        const ignorePathComparisonDir = (0, git_1.makeComparisonDir)(ignorePath);
+        const gitComparisonDir = (0, git_1.makeComparisonDir)(gitDir);
+        if (ignorePath &&
+            ignorePathComparisonDir &&
+            gitComparisonDir &&
+            ignorePathComparisonDir.startsWith(gitComparisonDir)) {
+            const file = path_1.default.resolve(ignorePath);
+            files.push(file);
+            cwd = path_1.default.resolve(path_1.default.dirname(file) + '..');
+        }
+        else {
+            cwd = null;
+        }
+    }
+    return files;
+}
+function checkGitInclusion(configPath) {
+    const result = {
+        inGit: false,
+        configIgnored: false,
+        gitignoreFiles: [],
+    };
+    if ((0, git_1.isConfigPathInGitRepo)(configPath)) {
+        result.inGit = true;
+        result.gitignoreFiles = getGitignoreFiles(configPath);
+        if ((0, git_1.configFilenameIsIgnoredByGitignore)(result.gitignoreFiles, configPath)) {
+            // Found ignore statement in .gitignore that matches config filename
+            result.configIgnored = true;
+        }
+    }
+    return result;
+}
+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) {
+        (0, standardErrors_1.throwErrorWithMessage)('utils.git.configIgnore', {}, e);
+    }
+}
+exports.checkAndAddConfigToGitignore = checkAndAddConfigToGitignore;

package/src/lib/index.d.ts

@@ -0,0 +1,11 @@
+import { extractZipArchive as __extractZipArchive } from './archive';
+import { getValidEnv as __getValidEnv } from './environment';
+import { walk as __walk } from './fs';
+import { commaSeparatedValues as __commaSeparatedValues } from './text';
+import { getHubSpotApiOrigin as __getHubSpotApiOrigin } from './urls';
+export declare const extractZipArchive: typeof __extractZipArchive;
+export declare const getValidEnv: typeof __getValidEnv;
+export declare const walk: typeof __walk;
+export declare const commaSeparatedValues: typeof __commaSeparatedValues;
+export declare const getHubSpotApiOrigin: typeof __getHubSpotApiOrigin;
+export declare const getHubSpotWebsiteOrigin: (env: string) => string;

package/src/lib/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getHubSpotWebsiteOrigin = exports.getHubSpotApiOrigin = exports.commaSeparatedValues = exports.walk = exports.getValidEnv = exports.extractZipArchive = void 0;
+const archive_1 = require("./archive");
+const environment_1 = require("./environment");
+const fs_1 = require("./fs");
+const text_1 = require("./text");
+const urls_1 = require("./urls");
+exports.extractZipArchive = archive_1.extractZipArchive;
+exports.getValidEnv = environment_1.getValidEnv;
+exports.walk = fs_1.walk;
+exports.commaSeparatedValues = text_1.commaSeparatedValues;
+exports.getHubSpotApiOrigin = urls_1.getHubSpotApiOrigin;
+exports.getHubSpotWebsiteOrigin = urls_1.getHubSpotWebsiteOrigin;

package/src/lib/modules.d.ts

@@ -0,0 +1,28 @@
+import { LogCallbacksArg } from '../types/LogCallbacks';
+import { PathInput } from '../types/Modules';
+export declare function isModuleFolder(pathInput: PathInput): boolean;
+export declare function isModuleFolderChild(pathInput: PathInput, ignoreLocales?: boolean): boolean;
+export declare const ValidationIds: {
+    SRC_REQUIRED: string;
+    DEST_REQUIRED: string;
+    MODULE_FOLDER_REQUIRED: string;
+    MODULE_TO_MODULE_NESTING: string;
+    MODULE_NESTING: string;
+};
+type ValidationResult = {
+    id: string;
+    message: string;
+};
+export declare function validateSrcAndDestPaths(src?: PathInput, dest?: PathInput): Promise<Array<ValidationResult>>;
+export declare const isModuleHTMLFile: (filePath: string) => boolean;
+export declare const isModuleCSSFile: (filePath: string) => boolean;
+type ModuleDefinition = {
+    contentTypes: Array<string>;
+    moduleLabel: string;
+    global: boolean;
+};
+declare const createModuleCallbackKeys: readonly ["creatingPath", "creatingModule"];
+export declare function createModule(moduleDefinition: ModuleDefinition, name: string, dest: string, options?: {
+    allowExistingDir: boolean;
+}, logCallbacks?: LogCallbacksArg<typeof createModuleCallbackKeys>): Promise<void>;
+export {};

package/src/lib/modules.js

@@ -0,0 +1,174 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createModule = exports.isModuleCSSFile = exports.isModuleHTMLFile = exports.validateSrcAndDestPaths = exports.ValidationIds = exports.isModuleFolderChild = exports.isModuleFolder = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_2 = require("./path");
+const walk_1 = require("../utils/fs/walk");
+const extensions_1 = require("../constants/extensions");
+const github_1 = require("./github");
+const standardErrors_1 = require("../errors/standardErrors");
+const logger_1 = require("../utils/logger");
+// Matches files named module.html
+const MODULE_HTML_EXTENSION_REGEX = new RegExp(/\.module(?:\/|\\)module\.html$/);
+// Matches files named module.css
+const MODULE_CSS_EXTENSION_REGEX = new RegExp(/\.module(?:\/|\\)module\.css$/);
+const isBool = (x) => !!x === x;
+function isPathInput(pathInput) {
+    return !!(pathInput &&
+        typeof pathInput.path === 'string' &&
+        (isBool(pathInput.isLocal) || isBool(pathInput.isHubSpot)));
+}
+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;
+// Ids for testing
+exports.ValidationIds = {
+    SRC_REQUIRED: 'SRC_REQUIRED',
+    DEST_REQUIRED: 'DEST_REQUIRED',
+    MODULE_FOLDER_REQUIRED: 'MODULE_FOLDER_REQUIRED',
+    MODULE_TO_MODULE_NESTING: 'MODULE_TO_MODULE_NESTING',
+    MODULE_NESTING: 'MODULE_NESTING',
+};
+const getValidationResult = (id, message) => ({ id, message });
+async function validateSrcAndDestPaths(src, dest) {
+    const results = [];
+    if (!isPathInput(src)) {
+        results.push(getValidationResult(exports.ValidationIds.SRC_REQUIRED, '`src` is required.'));
+    }
+    if (!isPathInput(dest)) {
+        results.push(getValidationResult(exports.ValidationIds.DEST_REQUIRED, '`dest` is required.'));
+    }
+    if (results.length || !src || !dest) {
+        return results;
+    }
+    const [_src, _dest] = [src, dest].map(inputPath => {
+        const result = { ...inputPath };
+        if (result.isLocal) {
+            result.path = path_1.default.resolve((0, path_2.getCwd)(), result.path);
+        }
+        else if (result.isHubSpot) {
+            result.path = path_1.default.posix.normalize(result.path);
+        }
+        return result;
+    });
+    // src is a .module folder and dest is within a module. (Nesting)
+    // e.g. `upload foo.module bar.module/zzz`
+    if (isModuleFolder(_src) && isModuleFolderChild(_dest)) {
+        return results.concat(getValidationResult(exports.ValidationIds.MODULE_TO_MODULE_NESTING, '`src` is a module path and `dest` is within a module.'));
+    }
+    // src is a .module folder but dest is not
+    // e.g. `upload foo.module bar`
+    if (isModuleFolder(_src) && !isModuleFolder(_dest)) {
+        return results.concat(getValidationResult(exports.ValidationIds.MODULE_FOLDER_REQUIRED, '`src` is a module path but `dest` is not.'));
+    }
+    // src is a folder that includes modules and dest is within a module. (Nesting)
+    if (_src.isLocal && isModuleFolderChild(_dest)) {
+        const stat = await fs_extra_1.default.stat(_src.path);
+        if (stat.isDirectory()) {
+            const files = await (0, walk_1.walk)(_src.path + 'l');
+            const srcHasModulesChildren = files.some(file => isModuleFolderChild({ ..._src, path: file }));
+            if (srcHasModulesChildren) {
+                return results.concat(getValidationResult(exports.ValidationIds.MODULE_NESTING, '`src` contains modules and `dest` is within a module.'));
+            }
+        }
+    }
+    return results;
+}
+exports.validateSrcAndDestPaths = validateSrcAndDestPaths;
+const isModuleHTMLFile = (filePath) => MODULE_HTML_EXTENSION_REGEX.test(filePath);
+exports.isModuleHTMLFile = isModuleHTMLFile;
+const isModuleCSSFile = (filePath) => MODULE_CSS_EXTENSION_REGEX.test(filePath);
+exports.isModuleCSSFile = isModuleCSSFile;
+const createModuleCallbackKeys = ['creatingPath', 'creatingModule'];
+async function createModule(moduleDefinition, name, dest, options = {
+    allowExistingDir: false,
+}, logCallbacks) {
+    const logger = (0, logger_1.makeTypedLogger)(logCallbacks, 'modules.createModule');
+    const writeModuleMeta = ({ contentTypes, moduleLabel, global }, dest) => {
+        const metaData = {
+            label: moduleLabel,
+            css_assets: [],
+            external_js: [],
+            global: global,
+            help_text: '',
+            host_template_types: contentTypes,
+            js_assets: [],
+            other_assets: [],
+            smart_type: 'NOT_SMART',
+            tags: [],
+            is_available_for_new_content: false,
+        };
+        fs_extra_1.default.writeJSONSync(dest, metaData, { spaces: 2 });
+    };
+    const moduleFileFilter = (src, dest) => {
+        const emailEnabled = moduleDefinition.contentTypes.includes('EMAIL');
+        switch (path_1.default.basename(src)) {
+            case 'meta.json':
+                writeModuleMeta(moduleDefinition, dest);
+                return false;
+            case 'module.js':
+            case 'module.css':
+                if (emailEnabled) {
+                    return false;
+                }
+                return true;
+            default:
+                return true;
+        }
+    };
+    const folderName = !name || name.endsWith('.module') ? name : `${name}.module`;
+    const destPath = path_1.default.join(dest, folderName);
+    if (!options.allowExistingDir && fs_extra_1.default.existsSync(destPath)) {
+        (0, standardErrors_1.throwErrorWithMessage)('modules.createModule', {
+            path: destPath,
+        });
+    }
+    else {
+        logger('creatingPath', {
+            path: destPath,
+        });
+        fs_extra_1.default.ensureDirSync(destPath);
+    }
+    logger('creatingModule', {
+        path: destPath,
+    });
+    await (0, github_1.downloadGithubRepoContents)('cms-sample-assets', 'modules/Sample.module', destPath, moduleFileFilter);
+}
+exports.createModule = createModule;

package/src/lib/path.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+import path from 'path';
+export declare function convertToUnixPath(_path: string): string;
+export declare function convertToLocalFileSystemPath(_path: string): string;
+export declare function splitLocalPath(filepath: string, pathImplementation?: path.PlatformPath): Array<string>;
+export declare function splitHubSpotPath(filepath: string): Array<string>;
+export declare function getCwd(): string;
+export declare function getExt(filepath: string): string;
+export declare function isAllowedExtension(filepath: string): boolean;
+export declare function getAbsoluteFilePath(_path: string): string;

package/src/lib/path.js

@@ -0,0 +1,84 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAbsoluteFilePath = exports.isAllowedExtension = exports.getExt = exports.getCwd = exports.splitHubSpotPath = exports.splitLocalPath = exports.convertToLocalFileSystemPath = exports.convertToUnixPath = void 0;
+const path_1 = __importDefault(require("path"));
+const unixify_1 = __importDefault(require("unixify"));
+const extensions_1 = require("../constants/extensions");
+function convertToUnixPath(_path) {
+    return (0, unixify_1.default)(path_1.default.normalize(_path));
+}
+exports.convertToUnixPath = convertToUnixPath;
+function convertToWindowsPath(_path) {
+    const rgx = new RegExp(`\\${path_1.default.posix.sep}`, 'g');
+    return path_1.default.normalize(_path).replace(rgx, path_1.default.win32.sep);
+}
+function convertToLocalFileSystemPath(_path) {
+    switch (path_1.default.sep) {
+        case path_1.default.posix.sep:
+            return convertToUnixPath(_path);
+        case path_1.default.win32.sep:
+            return convertToWindowsPath(_path);
+        default:
+            return path_1.default.normalize(_path);
+    }
+}
+exports.convertToLocalFileSystemPath = convertToLocalFileSystemPath;
+function removeTrailingSlashFromSplits(parts) {
+    if (parts.length > 1 && parts[parts.length - 1] === '') {
+        return parts.slice(0, parts.length - 1);
+    }
+    return parts;
+}
+// Splits a filepath for local file system sources.
+function splitLocalPath(filepath, pathImplementation = path_1.default) {
+    if (!filepath)
+        return [];
+    const { sep } = pathImplementation;
+    const rgx = new RegExp(`\\${sep}+`, 'g');
+    const parts = pathImplementation.normalize(filepath).split(rgx);
+    // Restore posix root if present
+    if (sep === path_1.default.posix.sep && parts[0] === '') {
+        parts[0] = '/';
+    }
+    return removeTrailingSlashFromSplits(parts);
+}
+exports.splitLocalPath = splitLocalPath;
+// Splits a filepath for remote sources (HubSpot).
+function splitHubSpotPath(filepath) {
+    if (!filepath)
+        return [];
+    const rgx = new RegExp(`\\${path_1.default.posix.sep}+`, 'g');
+    const parts = convertToUnixPath(filepath).split(rgx);
+    // Restore root if present
+    if (parts[0] === '') {
+        parts[0] = '/';
+    }
+    return removeTrailingSlashFromSplits(parts);
+}
+exports.splitHubSpotPath = splitHubSpotPath;
+function getCwd() {
+    if (process.env.INIT_CWD) {
+        return process.env.INIT_CWD;
+    }
+    return process.cwd();
+}
+exports.getCwd = getCwd;
+function getExt(filepath) {
+    if (typeof filepath !== 'string')
+        return '';
+    const ext = path_1.default.extname(filepath).trim().toLowerCase();
+    return ext[0] === '.' ? ext.slice(1) : ext;
+}
+exports.getExt = getExt;
+function isAllowedExtension(filepath) {
+    const ext = getExt(filepath);
+    return extensions_1.ALLOWED_EXTENSIONS.has(ext);
+}
+exports.isAllowedExtension = isAllowedExtension;
+function getAbsoluteFilePath(_path) {
+    return path_1.default.resolve(getCwd(), _path);
+}
+exports.getAbsoluteFilePath = getAbsoluteFilePath;

package/src/lib/text.d.ts

@@ -0,0 +1 @@
+export declare function commaSeparatedValues(arr: Array<string>, conjunction?: string, ifempty?: string): string;

package/src/lib/text.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.commaSeparatedValues = void 0;
+function commaSeparatedValues(arr, conjunction = 'and', ifempty = '') {
+    const l = arr.length;
+    if (!l)
+        return ifempty;
+    if (l < 2)
+        return arr[0];
+    if (l < 3)
+        return arr.join(` ${conjunction} `);
+    arr = arr.slice();
+    arr[l - 1] = `${conjunction} ${arr[l - 1]}`;
+    return arr.join(', ');
+}
+exports.commaSeparatedValues = commaSeparatedValues;

package/src/lib/urls.d.ts

@@ -0,0 +1,2 @@
+export declare const getHubSpotWebsiteOrigin: (env: string) => string;
+export declare function getHubSpotApiOrigin(env?: string, useLocalHost?: boolean): string;

package/src/lib/urls.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getHubSpotApiOrigin = exports.getHubSpotWebsiteOrigin = void 0;
+const environments_1 = require("../constants/environments");
+function getEnvUrlString(env) {
+    if (typeof env !== 'string') {
+        return '';
+    }
+    return env.toLowerCase() === environments_1.ENVIRONMENTS.QA ? environments_1.ENVIRONMENTS.QA : '';
+}
+const getHubSpotWebsiteOrigin = (env) => `https://app.hubspot${getEnvUrlString(env)}.com`;
+exports.getHubSpotWebsiteOrigin = getHubSpotWebsiteOrigin;
+function getHubSpotApiOrigin(env, useLocalHost) {
+    let domain = process.env.HUBAPI_DOMAIN_OVERRIDE;
+    if (!domain || typeof domain !== 'string') {
+        domain = `${useLocalHost ? 'local' : 'api'}.hubapi${getEnvUrlString(env)}`;
+    }
+    return `https://${domain}.com`;
+}
+exports.getHubSpotApiOrigin = getHubSpotApiOrigin;

package/src/types/Accounts.d.ts

@@ -0,0 +1,50 @@
+import { DEFAULT_MODES } from '../constants/config';
+import { ValueOf } from './Utils';
+export type AuthType = 'personalaccesskey' | 'apikey' | 'oauth2';
+export interface CLIAccount {
+    name?: string;
+    accountId: number;
+    defaultMode?: ValueOf<typeof DEFAULT_MODES>;
+    env?: string;
+    authType?: AuthType;
+    auth?: object;
+    sandboxAccountType?: string | null;
+    parentAccountId?: number | null;
+    apiKey?: string;
+    personalAccessKey?: string;
+}
+export type PersonalAccessKeyTokenInfo = {
+    accessToken: string;
+    expiresAt: string;
+};
+export type OauthTokenInfo = {
+    refreshToken?: string;
+};
+export interface PersonalAccessKeyAccount extends CLIAccount {
+    authType: 'personalaccesskey';
+    auth?: {
+        tokenInfo: PersonalAccessKeyTokenInfo;
+    };
+    personalAccessKey: string;
+}
+export interface OAuthAccount extends CLIAccount {
+    authType: 'oauth2';
+    auth?: {
+        clientId?: string;
+        clientSecret?: string;
+        scopes?: Array<string>;
+        tokenInfo?: OauthTokenInfo;
+    };
+}
+export interface APIKeyAccount extends CLIAccount {
+    authType: 'apikey';
+    apiKey: string;
+}
+export interface FlatAccountFields<T extends OauthTokenInfo | PersonalAccessKeyTokenInfo> extends CLIAccount {
+    tokenInfo?: T;
+    clientId?: string;
+    clientSecret?: string;
+    scopes?: Array<string>;
+    apiKey?: string;
+    personalAccessKey?: string;
+}

package/src/types/Accounts.js

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

package/src/types/CLIOptions.d.ts

@@ -0,0 +1,3 @@
+export interface CLIOptions {
+    useEnv?: boolean;
+}

package/src/types/CLIOptions.js

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

package/src/types/Config.d.ts

@@ -0,0 +1,10 @@
+import { CLIAccount } from './Accounts';
+export interface CLIConfig {
+    accounts: Array<CLIAccount>;
+    allowUsageTracking?: boolean;
+    defaultAccount?: string | number;
+    defaultMode?: string;
+    httpTimeout?: number;
+    env?: string;
+    httpUseLocalhost?: boolean;
+}

package/src/types/Config.js

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

package/src/types/Error.d.ts

@@ -0,0 +1,31 @@
+export interface BaseError extends Error {
+    name: string;
+    message: string;
+    errno?: number | null;
+    code?: string | null;
+    syscall?: string | null;
+    reason?: string;
+    statusCode?: number;
+}
+export interface StatusCodeError extends BaseError {
+    name: 'StatusCodeError';
+    statusCode: number;
+    message: string;
+    response: {
+        request: {
+            href: string;
+            method: string;
+        };
+        body: {
+            [key: string]: string;
+        };
+        headers: {
+            [key: string]: string;
+        };
+    };
+}
+export interface GithubError extends BaseError {
+    error: {
+        message?: string;
+    };
+}

package/src/types/Error.js

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

package/src/types/Files.d.ts

@@ -0,0 +1,8 @@
+import { ValueOf } from '../types/Utils';
+import { STAT_TYPES } from '../constants/files';
+export type StatType = ValueOf<typeof STAT_TYPES>;
+export type FileData = {
+    filepath: string;
+    files?: Array<string>;
+    type: StatType;
+};

package/src/types/Files.js

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

package/src/types/Github.d.ts

@@ -0,0 +1,58 @@
+type GithubAuthor = {
+    login: string;
+    id: number;
+    node_id: string;
+    avatar_url: string;
+    gravatar_id: string;
+    url: string;
+    html_url: string;
+    followers_url: string;
+    following_url: string;
+    gists_url: string;
+    starred_url: string;
+    subscriptions_url: string;
+    organizations_url: string;
+    repos_url: string;
+    events_url: string;
+    received_events_url: string;
+    type: string;
+    site_admin: boolean;
+};
+export type GithubReleaseData = {
+    url: string;
+    assets_url: string;
+    upload_url: string;
+    html_url: string;
+    id: number;
+    author: GithubAuthor;
+    node_id: string;
+    tag_name: string;
+    target_commitish: string;
+    name: string;
+    draft: boolean;
+    prerelease: boolean;
+    created_at: string;
+    published_at: string;
+    assets: Array<object>;
+    tarball_url: string;
+    zipball_url: string;
+    body: string;
+    mentions_count: number;
+};
+export type GithubRepoFile = {
+    name: string;
+    path: string;
+    sha: string;
+    size: number;
+    url: string;
+    html_url: string;
+    git_url: string;
+    download_url: string;
+    type: string;
+    _links: {
+        self: string;
+        git: string;
+        html: string;
+    };
+};
+export {};

package/src/types/Github.js

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

package/src/types/LogCallbacks.d.ts

@@ -0,0 +1,6 @@
+export type LogCallbacks<T extends string> = {
+    [key in T]?: () => void;
+};
+export type LogCallbacksArg<T extends readonly string[]> = {
+    [key in T[number]]?: () => void;
+};

package/src/types/LogCallbacks.js

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

package/src/types/Modules.d.ts

@@ -0,0 +1,5 @@
+export type PathInput = {
+    isLocal?: boolean;
+    isHubSpot?: boolean;
+    path: string;
+};

package/src/types/Modules.js

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

package/src/types/Utils.d.ts

@@ -0,0 +1 @@
+export type ValueOf<T> = T[keyof T];