@hubspot/local-dev-lib 4.0.4-beta.0 → 5.0.0-beta.0

package/lib/personalAccessKey.js

@@ -1,32 +1,26 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.updateConfigWithAccessToken = exports.authorizedScopesForPortalAndUser = exports.scopesOnAccessToken = exports.enabledFeaturesForPersonalAccessKey = exports.accessTokenForPersonalAccessKey = exports.getAccessToken = void 0;
-const moment_1 = __importDefault(require("moment"));
-const environments_1 = require("../constants/environments");
-const auth_1 = require("../constants/auth");
-const localDevAuth_1 = require("../api/localDevAuth");
-const sandboxHubs_1 = require("../api/sandboxHubs");
-const config_1 = require("../config");
-const config_2 = require("../constants/config");
-const developerTestAccounts_1 = require("../api/developerTestAccounts");
-const logger_1 = require("./logger");
-const lang_1 = require("../utils/lang");
-const errors_1 = require("../errors");
+import moment from 'moment';
+import { ENVIRONMENTS } from '../constants/environments.js';
+import { PERSONAL_ACCESS_KEY_AUTH_METHOD } from '../constants/auth.js';
+import { fetchAccessToken, fetchScopeAuthorizationData, } from '../api/localDevAuth.js';
+import { fetchSandboxHubData } from '../api/sandboxHubs.js';
+import { getConfigAccountById, getConfigAccountIfExists, updateConfigAccount, addConfigAccount, setConfigAccountAsDefault, } from '../config/index.js';
+import { HUBSPOT_ACCOUNT_TYPES } from '../constants/config.js';
+import { fetchDeveloperTestAccountData } from '../api/developerTestAccounts.js';
+import { logger } from './logger.js';
+import { i18n } from '../utils/lang.js';
+import { isHubSpotHttpError } from '../errors/index.js';
 const i18nKey = 'lib.personalAccessKey';
 const refreshRequests = new Map();
 function getRefreshKey(personalAccessKey, expiration) {
     return `${personalAccessKey}-${expiration || 'fresh'}`;
 }
-async function getAccessToken(personalAccessKey, env = environments_1.ENVIRONMENTS.PROD, accountId) {
-    const axiosResponse = await (0, localDevAuth_1.fetchAccessToken)(personalAccessKey, env, accountId);
+export async function getAccessToken(personalAccessKey, env = ENVIRONMENTS.PROD, accountId) {
+    const axiosResponse = await fetchAccessToken(personalAccessKey, env, accountId);
     const response = axiosResponse.data;
     return {
         portalId: response.hubId,
         accessToken: response.oauthAccessToken,
-        expiresAt: (0, moment_1.default)(response.expiresAtMillis).toISOString(),
+        expiresAt: moment(response.expiresAtMillis).toISOString(),
         scopeGroups: response.scopeGroups,
         enabledFeatures: response.enabledFeatures,
         encodedOAuthRefreshToken: response.encodedOAuthRefreshToken,
@@ -34,12 +28,11 @@ async function getAccessToken(personalAccessKey, env = environments_1.ENVIRONMEN
         accountType: response.accountType,
     };
 }
-exports.getAccessToken = getAccessToken;
 async function refreshAccessToken(account) {
     const { personalAccessKey, env, accountId } = account;
     const accessTokenResponse = await getAccessToken(personalAccessKey, env, accountId);
     const { accessToken, expiresAt } = accessTokenResponse;
-    (0, config_1.updateConfigAccount)({
+    updateConfigAccount({
         ...account,
         auth: {
             tokenInfo: {
@@ -73,25 +66,25 @@ async function getNewAccessToken(account) {
     return accessTokenResponse;
 }
 async function getNewAccessTokenByAccountId(accountId) {
-    const account = (0, config_1.getConfigAccountById)(accountId);
+    const account = getConfigAccountById(accountId);
     if (!account) {
-        throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.accountNotFound`, { accountId }));
+        throw new Error(i18n(`${i18nKey}.errors.accountNotFound`, { accountId }));
     }
-    if (account.authType !== auth_1.PERSONAL_ACCESS_KEY_AUTH_METHOD.value) {
-        throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.invalidAuthType`, {
+    if (account.authType !== PERSONAL_ACCESS_KEY_AUTH_METHOD.value) {
+        throw new Error(i18n(`${i18nKey}.errors.invalidAuthType`, {
             accountId,
         }));
     }
     const accessTokenResponse = await getNewAccessToken(account);
     return accessTokenResponse;
 }
-async function accessTokenForPersonalAccessKey(accountId, forceRefresh = false) {
-    const account = (0, config_1.getConfigAccountById)(accountId);
+export async function accessTokenForPersonalAccessKey(accountId, forceRefresh = false) {
+    const account = getConfigAccountById(accountId);
     if (!account) {
-        throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.accountNotFound`, { accountId }));
+        throw new Error(i18n(`${i18nKey}.errors.accountNotFound`, { accountId }));
     }
-    if (account.authType !== auth_1.PERSONAL_ACCESS_KEY_AUTH_METHOD.value) {
-        throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.invalidAuthType`, {
+    if (account.authType !== PERSONAL_ACCESS_KEY_AUTH_METHOD.value) {
+        throw new Error(i18n(`${i18nKey}.errors.invalidAuthType`, {
             accountId,
         }));
     }
@@ -100,34 +93,30 @@ async function accessTokenForPersonalAccessKey(accountId, forceRefresh = false)
     const authDataExists = authTokenInfo && auth?.tokenInfo?.accessToken;
     if (!authDataExists ||
         forceRefresh ||
-        (0, moment_1.default)().add(5, 'minutes').isAfter((0, moment_1.default)(authTokenInfo.expiresAt))) {
+        moment().add(5, 'minutes').isAfter(moment(authTokenInfo.expiresAt))) {
         return getNewAccessToken(account).then(tokenInfo => tokenInfo.accessToken);
     }
     return auth.tokenInfo?.accessToken;
 }
-exports.accessTokenForPersonalAccessKey = accessTokenForPersonalAccessKey;
-async function enabledFeaturesForPersonalAccessKey(accountId) {
+export async function enabledFeaturesForPersonalAccessKey(accountId) {
     const accessTokenResponse = await getNewAccessTokenByAccountId(accountId);
     return accessTokenResponse?.enabledFeatures;
 }
-exports.enabledFeaturesForPersonalAccessKey = enabledFeaturesForPersonalAccessKey;
-async function scopesOnAccessToken(accountId) {
+export async function scopesOnAccessToken(accountId) {
     return (await getNewAccessTokenByAccountId(accountId)).scopeGroups;
 }
-exports.scopesOnAccessToken = scopesOnAccessToken;
-async function authorizedScopesForPortalAndUser(accountId) {
-    return (await (0, localDevAuth_1.fetchScopeAuthorizationData)(accountId)).data.results;
+export async function authorizedScopesForPortalAndUser(accountId) {
+    return (await fetchScopeAuthorizationData(accountId)).data.results;
 }
-exports.authorizedScopesForPortalAndUser = authorizedScopesForPortalAndUser;
-async function updateConfigWithAccessToken(token, personalAccessKey, env, name, makeDefault = false) {
+export async function updateConfigWithAccessToken(token, personalAccessKey, env, name, makeDefault = false) {
     const { portalId, accessToken, expiresAt, accountType } = token;
-    const account = (0, config_1.getConfigAccountIfExists)(portalId);
-    const accountEnv = env || account?.env || environments_1.ENVIRONMENTS.PROD;
+    const account = getConfigAccountIfExists(portalId);
+    const accountEnv = env || account?.env || ENVIRONMENTS.PROD;
     let parentAccountId;
     try {
-        if (accountType === config_2.HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX ||
-            accountType === config_2.HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX) {
-            const { data: sandboxDataResponse } = await (0, sandboxHubs_1.fetchSandboxHubData)(accessToken, portalId, accountEnv);
+        if (accountType === HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX ||
+            accountType === HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX) {
+            const { data: sandboxDataResponse } = await fetchSandboxHubData(accessToken, portalId, accountEnv);
             if (sandboxDataResponse.parentHubId) {
                 parentAccountId = sandboxDataResponse.parentHubId;
             }
@@ -135,14 +124,14 @@ async function updateConfigWithAccessToken(token, personalAccessKey, env, name,
     }
     catch (err) {
         // Log error but do not throw
-        if ((0, errors_1.isHubSpotHttpError)(err)) {
-            logger_1.logger.debug(err.message);
+        if (isHubSpotHttpError(err)) {
+            logger.debug(err.message);
         }
-        logger_1.logger.debug(err);
+        logger.debug(err);
     }
     try {
-        if (accountType === config_2.HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST) {
-            const { data: developerTestAccountResponse } = await (0, developerTestAccounts_1.fetchDeveloperTestAccountData)(accessToken, portalId, accountEnv);
+        if (accountType === HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST) {
+            const { data: developerTestAccountResponse } = await fetchDeveloperTestAccountData(accessToken, portalId, accountEnv);
             if (developerTestAccountResponse) {
                 parentAccountId = developerTestAccountResponse.parentPortalId;
             }
@@ -150,31 +139,30 @@ async function updateConfigWithAccessToken(token, personalAccessKey, env, name,
     }
     catch (err) {
         // Log error but do not throw
-        if ((0, errors_1.isHubSpotHttpError)(err)) {
-            logger_1.logger.debug(err.message);
+        if (isHubSpotHttpError(err)) {
+            logger.debug(err.message);
         }
-        logger_1.logger.debug(err);
+        logger.debug(err);
     }
     const updatedAccount = {
         accountId: portalId,
         accountType,
         personalAccessKey,
         name: name || account?.name,
-        authType: auth_1.PERSONAL_ACCESS_KEY_AUTH_METHOD.value,
+        authType: PERSONAL_ACCESS_KEY_AUTH_METHOD.value,
         auth: { tokenInfo: { accessToken, expiresAt } },
         parentAccountId,
         env: accountEnv,
     }; // Account may temporarily not have a name before prompted to add one in the CLI
     // Add new account if it doesn't exist, otherwise update existing account
     if (account) {
-        (0, config_1.updateConfigAccount)(updatedAccount);
+        updateConfigAccount(updatedAccount);
     }
     else {
-        (0, config_1.addConfigAccount)(updatedAccount);
+        addConfigAccount(updatedAccount);
     }
     if (makeDefault) {
-        (0, config_1.setConfigAccountAsDefault)(updatedAccount.accountId);
+        setConfigAccountAsDefault(updatedAccount.accountId);
     }
     return updatedAccount;
 }
-exports.updateConfigWithAccessToken = updateConfigWithAccessToken;

package/lib/portManager.d.ts

@@ -1,5 +1,5 @@
-import { RequestPortsData, ServerPortMap } from '../types/PortManager';
-export declare const BASE_URL: string;
+import { RequestPortsData, ServerPortMap } from '../types/PortManager.js';
+export declare const BASE_URL = "http://localhost:8080";
 export declare function isPortManagerPortAvailable(): Promise<boolean>;
 export declare function isPortManagerServerRunning(): Promise<boolean>;
 export declare function startPortManagerServer(): Promise<void>;

package/lib/portManager.js

@@ -1,66 +1,51 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.portManagerHasActiveServers = exports.deleteServerInstance = exports.getServerPortByInstanceId = exports.getActiveServers = exports.requestPorts = exports.stopPortManagerServer = exports.startPortManagerServer = exports.isPortManagerServerRunning = exports.isPortManagerPortAvailable = exports.BASE_URL = void 0;
-const axios_1 = __importDefault(require("axios"));
-const PortManagerServer_1 = require("../utils/PortManagerServer");
-const ports_1 = require("../constants/ports");
-const logger_1 = require("./logger");
-exports.BASE_URL = `http://localhost:${ports_1.PORT_MANAGER_SERVER_PORT}`;
-async function isPortManagerPortAvailable() {
-    return PortManagerServer_1.PortManagerServer.portAvailable();
-}
-exports.isPortManagerPortAvailable = isPortManagerPortAvailable;
-async function isPortManagerServerRunning() {
+import axios from 'axios';
+import { HEALTH_CHECK_PATH, PortManagerServer, SERVICE_HEALTHY, } from '../utils/PortManagerServer.js';
+import { PORT_MANAGER_SERVER_PORT } from '../constants/ports.js';
+import { logger } from './logger.js';
+export const BASE_URL = `http://localhost:${PORT_MANAGER_SERVER_PORT}`;
+export async function isPortManagerPortAvailable() {
+    return PortManagerServer.portAvailable();
+}
+export async function isPortManagerServerRunning() {
     try {
-        const { data } = await axios_1.default.get(`${exports.BASE_URL}${PortManagerServer_1.HEALTH_CHECK_PATH}`);
-        return data.status === PortManagerServer_1.SERVICE_HEALTHY;
+        const { data } = await axios.get(`${BASE_URL}${HEALTH_CHECK_PATH}`);
+        return data.status === SERVICE_HEALTHY;
     }
     catch (e) {
-        logger_1.logger.debug(e);
+        logger.debug(e);
         return false;
     }
 }
-exports.isPortManagerServerRunning = isPortManagerServerRunning;
-async function startPortManagerServer() {
+export async function startPortManagerServer() {
     const isRunning = await isPortManagerServerRunning();
     if (!isRunning) {
-        await PortManagerServer_1.PortManagerServer.init();
+        await PortManagerServer.init();
     }
 }
-exports.startPortManagerServer = startPortManagerServer;
-async function stopPortManagerServer() {
+export async function stopPortManagerServer() {
     const isRunning = await isPortManagerServerRunning();
     if (isRunning) {
-        await axios_1.default.post(`${exports.BASE_URL}/close`);
+        await axios.post(`${BASE_URL}/close`);
     }
 }
-exports.stopPortManagerServer = stopPortManagerServer;
-async function requestPorts(portData) {
-    const { data } = await axios_1.default.post(`${exports.BASE_URL}/servers`, {
+export async function requestPorts(portData) {
+    const { data } = await axios.post(`${BASE_URL}/servers`, {
         portData: portData,
     });
     return data.ports;
 }
-exports.requestPorts = requestPorts;
-async function getActiveServers() {
-    const { data } = await axios_1.default.get(`${exports.BASE_URL}/servers`);
+export async function getActiveServers() {
+    const { data } = await axios.get(`${BASE_URL}/servers`);
     return data.servers;
 }
-exports.getActiveServers = getActiveServers;
-async function getServerPortByInstanceId(serverInstanceId) {
-    const { data } = await axios_1.default.get(`${exports.BASE_URL}/servers/${serverInstanceId}`);
+export async function getServerPortByInstanceId(serverInstanceId) {
+    const { data } = await axios.get(`${BASE_URL}/servers/${serverInstanceId}`);
     return data.port;
 }
-exports.getServerPortByInstanceId = getServerPortByInstanceId;
-async function deleteServerInstance(serverInstanceId) {
-    await axios_1.default.delete(`${exports.BASE_URL}/servers/${serverInstanceId}`);
+export async function deleteServerInstance(serverInstanceId) {
+    await axios.delete(`${BASE_URL}/servers/${serverInstanceId}`);
 }
-exports.deleteServerInstance = deleteServerInstance;
-async function portManagerHasActiveServers() {
-    const { data } = await axios_1.default.get(`${exports.BASE_URL}/servers`);
+export async function portManagerHasActiveServers() {
+    const { data } = await axios.get(`${BASE_URL}/servers`);
     return data.count > 0;
 }
-exports.portManagerHasActiveServers = portManagerHasActiveServers;

package/lib/text.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toKebabCase = exports.commaSeparatedValues = void 0;
-function commaSeparatedValues(arr, conjunction = 'and', ifempty = '') {
+export function commaSeparatedValues(arr, conjunction = 'and', ifempty = '') {
     const l = arr.length;
     if (!l)
         return ifempty;
@@ -13,8 +10,7 @@ function commaSeparatedValues(arr, conjunction = 'and', ifempty = '') {
     arr[l - 1] = `${conjunction} ${arr[l - 1]}`;
     return arr.join(', ');
 }
-exports.commaSeparatedValues = commaSeparatedValues;
-function toKebabCase(str) {
+export function toKebabCase(str) {
     if (!str) {
         return '';
     }
@@ -24,4 +20,3 @@ function toKebabCase(str) {
         .join('-')
         .toLowerCase();
 }
-exports.toKebabCase = toKebabCase;

package/lib/trackUsage.d.ts

@@ -1,3 +1,3 @@
-export declare const CMS_CLI_USAGE_PATH: string;
-export declare const VSCODE_USAGE_PATH: string;
+export declare const CMS_CLI_USAGE_PATH = "content/filemapper/v1/cms-cli-usage";
+export declare const VSCODE_USAGE_PATH = "content/filemapper/v1/vscode-extension-usage";
 export declare function trackUsage(eventName: string, eventClass: string, meta?: {}, accountId?: number): Promise<void>;

package/lib/trackUsage.js

@@ -1,18 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.trackUsage = exports.VSCODE_USAGE_PATH = exports.CMS_CLI_USAGE_PATH = void 0;
-const client_1 = require("../http/client");
-const getAxiosConfig_1 = require("../http/getAxiosConfig");
-const logger_1 = require("./logger");
-const http_1 = require("../http");
-const config_1 = require("../config");
-const fileMapper_1 = require("../api/fileMapper");
-const lang_1 = require("../utils/lang");
-const environment_1 = require("./environment");
+import { httpClient } from '../http/client.js';
+import { getAxiosConfig } from '../http/getAxiosConfig.js';
+import { logger } from './logger.js';
+import { http } from '../http/index.js';
+import { getConfigAccountById, getConfigAccountEnvironment, } from '../config/index.js';
+import { FILE_MAPPER_API_PATH } from '../api/fileMapper.js';
+import { i18n } from '../utils/lang.js';
+import { getValidEnv } from './environment.js';
 const i18nKey = 'lib.trackUsage';
-exports.CMS_CLI_USAGE_PATH = `${fileMapper_1.FILE_MAPPER_API_PATH}/cms-cli-usage`;
-exports.VSCODE_USAGE_PATH = `${fileMapper_1.FILE_MAPPER_API_PATH}/vscode-extension-usage`;
-async function trackUsage(eventName, eventClass, meta = {}, accountId) {
+export const CMS_CLI_USAGE_PATH = `${FILE_MAPPER_API_PATH}/cms-cli-usage`;
+export const VSCODE_USAGE_PATH = `${FILE_MAPPER_API_PATH}/vscode-extension-usage`;
+export async function trackUsage(eventName, eventClass, meta = {}, accountId) {
     const usageEvent = {
         accountId,
         eventName,
@@ -23,47 +20,47 @@ async function trackUsage(eventName, eventClass, meta = {}, accountId) {
         VSCODE_EXTENSION_INTERACTION: 'vscode-extension-interaction',
         CLI_INTERACTION: 'cli-interaction',
     };
-    let path = fileMapper_1.FILE_MAPPER_API_PATH;
+    let path = FILE_MAPPER_API_PATH;
     switch (eventName) {
         case EVENT_TYPES.CLI_INTERACTION:
-            path = exports.CMS_CLI_USAGE_PATH;
+            path = CMS_CLI_USAGE_PATH;
             break;
         case EVENT_TYPES.VSCODE_EXTENSION_INTERACTION:
-            path = exports.VSCODE_USAGE_PATH;
+            path = VSCODE_USAGE_PATH;
             break;
         default:
-            logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.invalidEvent`, { eventName }));
+            logger.debug(i18n(`${i18nKey}.invalidEvent`, { eventName }));
     }
-    const account = accountId && (0, config_1.getConfigAccountById)(accountId);
+    const account = accountId && getConfigAccountById(accountId);
     if (account && account.authType === 'personalaccesskey') {
-        logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.sendingEventAuthenticated`));
+        logger.debug(i18n(`${i18nKey}.sendingEventAuthenticated`));
         try {
-            await http_1.http.post(accountId, {
+            await http.post(accountId, {
                 url: `${path}/authenticated`,
                 data: usageEvent,
                 resolveWithFullResponse: true,
             });
             return;
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
         }
         catch (e) {
-            logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.retryingEventUnauthenticated`));
+            logger.debug(i18n(`${i18nKey}.retryingEventUnauthenticated`));
         }
     }
     const env = accountId
-        ? (0, config_1.getConfigAccountEnvironment)(accountId)
-        : (0, environment_1.getValidEnv)();
-    const axiosConfig = (0, getAxiosConfig_1.getAxiosConfig)({
+        ? getConfigAccountEnvironment(accountId)
+        : getValidEnv();
+    const axiosConfig = getAxiosConfig({
         env,
         url: path,
         data: usageEvent,
         resolveWithFullResponse: true,
     });
-    logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.sendingEventUnauthenticated`));
+    logger.debug(i18n(`${i18nKey}.sendingEventUnauthenticated`));
     try {
-        await (0, client_1.httpClient)({ ...axiosConfig, method: 'post' });
+        await httpClient({ ...axiosConfig, method: 'post' });
     }
     catch (e) {
-        logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.unauthenticatedSendFailed`));
+        logger.debug(i18n(`${i18nKey}.unauthenticatedSendFailed`));
     }
 }
-exports.trackUsage = trackUsage;

package/lib/urls.js

@@ -1,16 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getHubSpotApiOrigin = exports.getHubSpotWebsiteOrigin = void 0;
-const environments_1 = require("../constants/environments");
+import { ENVIRONMENTS } from '../constants/environments.js';
 function getEnvUrlString(env) {
     if (typeof env !== 'string') {
         return '';
     }
-    return env.toLowerCase() === environments_1.ENVIRONMENTS.QA ? environments_1.ENVIRONMENTS.QA : '';
+    return env.toLowerCase() === ENVIRONMENTS.QA ? ENVIRONMENTS.QA : '';
 }
-const getHubSpotWebsiteOrigin = (env) => `https://app.hubspot${getEnvUrlString(env)}.com`;
-exports.getHubSpotWebsiteOrigin = getHubSpotWebsiteOrigin;
-function getHubSpotApiOrigin(env, useLocalHost) {
+export const getHubSpotWebsiteOrigin = (env) => `https://app.hubspot${getEnvUrlString(env)}.com`;
+export function getHubSpotApiOrigin(env, useLocalHost) {
     let domain;
     const domainOverride = process.env.HUBAPI_DOMAIN_OVERRIDE;
     if (domainOverride && typeof domainOverride === 'string') {
@@ -21,4 +17,3 @@ function getHubSpotApiOrigin(env, useLocalHost) {
     }
     return `https://${domain}.com`;
 }
-exports.getHubSpotApiOrigin = getHubSpotApiOrigin;

package/models/FileSystemError.d.ts

@@ -1,4 +1,4 @@
-import { FileSystemErrorContext } from '../types/Error';
+import { FileSystemErrorContext } from '../types/Error.js';
 export declare const FilerSystemErrorName = "FilerSystemError";
 export declare class FileSystemError extends Error {
     private context;

package/models/FileSystemError.js

@@ -1,36 +1,33 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FileSystemError = exports.FilerSystemErrorName = void 0;
-const lang_1 = require("../utils/lang");
-const errors_1 = require("../errors");
+import { i18n } from '../utils/lang.js';
+import { isSystemError } from '../errors/index.js';
 const i18nKey = 'errors.fileSystemErrors';
-exports.FilerSystemErrorName = 'FilerSystemError';
-class FileSystemError extends Error {
+export const FilerSystemErrorName = 'FilerSystemError';
+export class FileSystemError extends Error {
     context;
     constructor(options, context) {
         super('', options);
-        this.name = exports.FilerSystemErrorName;
+        this.name = FilerSystemErrorName;
         this.context = context;
         if (context) {
             let fileAction = '';
             if (context.operation === 'read') {
-                fileAction = (0, lang_1.i18n)(`${i18nKey}.readAction`);
+                fileAction = i18n(`${i18nKey}.readAction`);
             }
             else if (context.operation === 'write') {
-                fileAction = (0, lang_1.i18n)(`${i18nKey}.writeAction`);
+                fileAction = i18n(`${i18nKey}.writeAction`);
             }
             else {
-                fileAction = (0, lang_1.i18n)(`${i18nKey}.otherAction`);
+                fileAction = i18n(`${i18nKey}.otherAction`);
             }
             const filepath = context.filepath
                 ? `"${context.filepath}"`
-                : (0, lang_1.i18n)(`${i18nKey}.unknownFilepath`);
+                : i18n(`${i18nKey}.unknownFilepath`);
             const messages = [
-                (0, lang_1.i18n)(`${i18nKey}.baseMessage`, { fileAction, filepath }),
+                i18n(`${i18nKey}.baseMessage`, { fileAction, filepath }),
             ];
             // Many `fs` errors will be `SystemError`s
-            if ((0, errors_1.isSystemError)(options?.cause)) {
-                messages.push((0, lang_1.i18n)(`${i18nKey}.baseMessage`, {
+            if (isSystemError(options?.cause)) {
+                messages.push(i18n(`${i18nKey}.baseMessage`, {
                     errorMessage: options?.cause?.message || '',
                 }));
             }
@@ -45,4 +42,3 @@ class FileSystemError extends Error {
         return baseString;
     }
 }
-exports.FileSystemError = FileSystemError;

package/models/HubSpotConfigError.d.ts

@@ -1,4 +1,4 @@
-import { HubSpotConfigErrorType, HubSpotConfigOperation } from '../types/Config';
+import { HubSpotConfigErrorType, HubSpotConfigOperation } from '../types/Config.js';
 export declare class HubSpotConfigError extends Error {
     type: HubSpotConfigErrorType;
     operation: HubSpotConfigOperation;

package/models/HubSpotConfigError.js

@@ -1,18 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HubSpotConfigError = void 0;
-const config_1 = require("../constants/config");
-const lang_1 = require("../utils/lang");
+import { HUBSPOT_CONFIG_ERROR_TYPES, HUBSPOT_CONFIG_OPERATIONS, } from '../constants/config.js';
+import { i18n } from '../utils/lang.js';
 const NAME = 'HubSpotConfigError';
 const OPERATION_TEXT = {
-    [config_1.HUBSPOT_CONFIG_OPERATIONS.READ]: 'reading',
-    [config_1.HUBSPOT_CONFIG_OPERATIONS.WRITE]: 'writing to',
-    [config_1.HUBSPOT_CONFIG_OPERATIONS.DELETE]: 'deleting',
+    [HUBSPOT_CONFIG_OPERATIONS.READ]: 'reading',
+    [HUBSPOT_CONFIG_OPERATIONS.WRITE]: 'writing to',
+    [HUBSPOT_CONFIG_OPERATIONS.DELETE]: 'deleting',
 };
 function isEnvironmentError(type) {
-    return type === config_1.HUBSPOT_CONFIG_ERROR_TYPES.INVALID_ENVIRONMENT_VARIABLES;
+    return type === HUBSPOT_CONFIG_ERROR_TYPES.INVALID_ENVIRONMENT_VARIABLES;
 }
-class HubSpotConfigError extends Error {
+export class HubSpotConfigError extends Error {
     type;
     operation;
     constructor(message, type, operation, options) {
@@ -20,7 +17,7 @@ class HubSpotConfigError extends Error {
             ? 'environment variables'
             : 'file';
         const operationText = OPERATION_TEXT[operation];
-        const withBaseMessage = (0, lang_1.i18n)('models.HubSpotConfigError.baseMessage', {
+        const withBaseMessage = i18n('models.HubSpotConfigError.baseMessage', {
             configType,
             message: message ? `: ${message}` : '',
             operation: operationText,
@@ -31,4 +28,3 @@ class HubSpotConfigError extends Error {
         this.operation = operation;
     }
 }
-exports.HubSpotConfigError = HubSpotConfigError;

package/models/HubSpotHttpError.d.ts

@@ -1,4 +1,4 @@
-import { HubSpotHttpErrorContext } from '../types/Error';
+import { HubSpotHttpErrorContext } from '../types/Error.js';
 export declare const HubSpotHttpErrorName = "HubSpotHttpError";
 export declare class HubSpotHttpError<T = any> extends Error {
     status?: number;