@hubspot/local-dev-lib 0.6.1-experimental.0 → 0.6.3-experimental.0

package/lib/cms/uploadFolder.js

@@ -1,59 +1,53 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.hasUploadErrors = exports.uploadFolder = exports.getFilesByType = void 0;
-const path_1 = __importDefault(require("path"));
-const p_queue_1 = __importDefault(require("p-queue"));
-const handleFieldsJS_1 = require("./handleFieldsJS");
-const fileMapper_1 = require("../fileMapper");
-const fileMapper_2 = require("../../api/fileMapper");
-const modules_1 = require("../../utils/cms/modules");
-const escapeRegExp_1 = require("../escapeRegExp");
-const path_2 = require("../path");
-const errors_1 = require("../../errors");
-const logger_1 = require("../logger");
-const files_1 = require("../../constants/files");
-const lang_1 = require("../../utils/lang");
-const HubSpotHttpError_1 = require("../../models/HubSpotHttpError");
+import path from 'path';
+import PQueue from 'p-queue';
+import { isConvertableFieldJs, FieldsJs, createTmpDirSync, cleanupTmpDirSync, } from './handleFieldsJS.js';
+import { getFileMapperQueryValues } from '../fileMapper.js';
+import { upload } from '../../api/fileMapper.js';
+import { isModuleFolderChild } from '../../utils/cms/modules.js';
+import { escapeRegExp } from '../escapeRegExp.js';
+import { convertToUnixPath, getExt } from '../path.js';
+import { isAuthError, isHubSpotHttpError } from '../../errors/index.js';
+import { logger } from '../logger.js';
+import { FILE_TYPES, FILE_UPLOAD_RESULT_TYPES } from '../../constants/files.js';
+import { i18n } from '../../utils/lang.js';
+import { HubSpotHttpError } from '../../models/HubSpotHttpError.js';
 const i18nKey = 'lib.cms.uploadFolder';
-const queue = new p_queue_1.default({
+const queue = new PQueue({
     concurrency: 10,
 });
 function getFileType(filePath) {
-    const extension = (0, path_2.getExt)(filePath);
-    const moduleFolder = (0, modules_1.isModuleFolderChild)({ path: filePath, isLocal: true });
+    const extension = getExt(filePath);
+    const moduleFolder = isModuleFolderChild({ path: filePath, isLocal: true });
     if (moduleFolder)
-        return files_1.FILE_TYPES.module;
+        return FILE_TYPES.module;
     switch (extension) {
         case 'js':
         case 'css':
-            return files_1.FILE_TYPES.cssAndJs;
+            return FILE_TYPES.cssAndJs;
         case 'html':
-            return files_1.FILE_TYPES.template;
+            return FILE_TYPES.template;
         case 'json':
-            return files_1.FILE_TYPES.json;
+            return FILE_TYPES.json;
         default:
-            return files_1.FILE_TYPES.other;
+            return FILE_TYPES.other;
     }
 }
 function isMetaJsonFile(filePath) {
-    return path_1.default.basename(filePath).toLowerCase() === 'meta.json';
+    return path.basename(filePath).toLowerCase() === 'meta.json';
 }
 function resolveUploadPath(file, fieldsJsPaths, tmpDirRegex, regex, dest) {
     const fieldsJsFileInfo = fieldsJsPaths.find(f => f.outputPath === file);
     const relativePath = file.replace(fieldsJsFileInfo ? tmpDirRegex : regex, '');
-    const destPath = (0, path_2.convertToUnixPath)(path_1.default.join(dest, relativePath));
+    const destPath = convertToUnixPath(path.join(dest, relativePath));
     const originalFilePath = fieldsJsFileInfo ? fieldsJsFileInfo.filePath : file;
     return { fieldsJsFileInfo, relativePath, destPath, originalFilePath };
 }
-async function getFilesByType(filePaths, projectDir, rootWriteDir, commandOptions) {
+export async function getFilesByType(filePaths, projectDir, rootWriteDir, commandOptions) {
     const { convertFields, fieldOptions } = commandOptions;
-    const projectDirRegex = new RegExp(`^${(0, escapeRegExp_1.escapeRegExp)(projectDir)}`);
+    const projectDirRegex = new RegExp(`^${escapeRegExp(projectDir)}`);
     const fieldsJsObjects = [];
     // Create object with key-value pairs of form { FileType.type: [] }
-    const filePathsByType = Object.values(files_1.FILE_TYPES).reduce((acc, fileType) => {
+    const filePathsByType = Object.values(FILE_TYPES).reduce((acc, fileType) => {
         return {
             ...acc,
             [fileType]: [],
@@ -66,10 +60,10 @@ async function getFilesByType(filePaths, projectDir, rootWriteDir, commandOption
             filePathsByType[fileType].push(filePath);
             continue;
         }
-        const convertableFields = (0, handleFieldsJS_1.isConvertableFieldJs)(projectDir, filePath, convertFields);
+        const convertableFields = isConvertableFieldJs(projectDir, filePath, convertFields);
         if (convertableFields) {
-            const rootOrModule = path_1.default.dirname(relPath) === '/' ? files_1.FILE_TYPES.json : files_1.FILE_TYPES.module;
-            const fieldsJs = await new handleFieldsJS_1.FieldsJs(projectDir, filePath, rootWriteDir, fieldOptions).init();
+            const rootOrModule = path.dirname(relPath) === '/' ? FILE_TYPES.json : FILE_TYPES.module;
+            const fieldsJs = await new FieldsJs(projectDir, filePath, rootWriteDir, fieldOptions).init();
             /*
              * A fields.js will be rejected if the promise is rejected or if the some other error occurs.
              * We handle this gracefully by not adding the failed fields.js to the object list.
@@ -85,32 +79,31 @@ async function getFilesByType(filePaths, projectDir, rootWriteDir, commandOption
     }
     return [filePathsByType, fieldsJsObjects];
 }
-exports.getFilesByType = getFilesByType;
-const defaultUploadAttemptCallback = (file, destPath) => logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.uploadFolder.attempt`, {
+const defaultUploadAttemptCallback = (file, destPath) => logger.debug(i18n(`${i18nKey}.uploadFolder.attempt`, {
     file: file || '',
     destPath,
 }));
-const defaultUploadSuccessCallback = (file, destPath) => logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.uploadFolder.success`, {
+const defaultUploadSuccessCallback = (file, destPath) => logger.log(i18n(`${i18nKey}.uploadFolder.success`, {
     file: file || '',
     destPath,
 }));
 const defaultUploadFirstErrorCallback = (file, destPath, error) => {
-    logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.uploadFolder.failed`, { file, destPath }));
-    if ((0, errors_1.isHubSpotHttpError)(error)) {
-        logger_1.logger.debug(error.data);
+    logger.debug(i18n(`${i18nKey}.uploadFolder.failed`, { file, destPath }));
+    if (isHubSpotHttpError(error)) {
+        logger.debug(error.data);
     }
     else if (error instanceof Error) {
-        logger_1.logger.debug(error.message);
+        logger.debug(error.message);
     }
 };
-const defaultUploadRetryCallback = (file, destPath) => logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.uploadFolder.retry`, { file, destPath }));
+const defaultUploadRetryCallback = (file, destPath) => logger.debug(i18n(`${i18nKey}.uploadFolder.retry`, { file, destPath }));
 const defaultUploadFinalErrorCallback = (accountId, file, destPath, error) => {
-    const retryFailed = (0, lang_1.i18n)(`${i18nKey}.uploadFolder.retryFailed`, {
+    const retryFailed = i18n(`${i18nKey}.uploadFolder.retryFailed`, {
         file,
         destPath,
     });
-    logger_1.logger.debug(retryFailed);
-    throw new HubSpotHttpError_1.HubSpotHttpError(retryFailed, { cause: error }, {
+    logger.debug(retryFailed);
+    throw new HubSpotHttpError(retryFailed, { cause: error }, {
         accountId,
         request: destPath,
         payload: file,
@@ -122,7 +115,7 @@ async function uploadMetaJsonFiles(moduleFiles, uploadFile) {
         await queue.addAll(moduleMetaJsonFiles.map(uploadFile));
     }
 }
-async function uploadFolder(accountId, src, dest, fileMapperOptions, commandOptions = {}, filePaths = [], cmsPublishMode = null) {
+export async function uploadFolder(accountId, src, dest, fileMapperOptions, commandOptions = {}, filePaths = [], cmsPublishMode = null) {
     const { saveOutput, convertFields, onAttemptCallback, onSuccessCallback, onFirstErrorCallback, onRetryCallback, onFinalErrorCallback, } = commandOptions;
     const _onAttemptCallback = onAttemptCallback || defaultUploadAttemptCallback;
     const _onSuccessCallback = onSuccessCallback || defaultUploadSuccessCallback;
@@ -130,13 +123,13 @@ async function uploadFolder(accountId, src, dest, fileMapperOptions, commandOpti
     const _onRetryCallback = onRetryCallback || defaultUploadRetryCallback;
     const _onFinalErrorCallback = onFinalErrorCallback || defaultUploadFinalErrorCallback;
     const tmpDir = convertFields
-        ? (0, handleFieldsJS_1.createTmpDirSync)('hubspot-temp-fieldsjs-output-')
+        ? createTmpDirSync('hubspot-temp-fieldsjs-output-')
         : null;
-    const regex = new RegExp(`^${(0, escapeRegExp_1.escapeRegExp)(src)}`);
-    const apiOptions = (0, fileMapper_1.getFileMapperQueryValues)(cmsPublishMode, fileMapperOptions);
+    const regex = new RegExp(`^${escapeRegExp(src)}`);
+    const apiOptions = getFileMapperQueryValues(cmsPublishMode, fileMapperOptions);
     const failures = [];
     let fieldsJsPaths = [];
-    const tmpDirRegex = new RegExp(`^${(0, escapeRegExp_1.escapeRegExp)(tmpDir || '')}`);
+    const tmpDirRegex = new RegExp(`^${escapeRegExp(tmpDir || '')}`);
     const [filesByType, fieldsJsObjects] = await getFilesByType(filePaths, src, tmpDir, commandOptions);
     if (fieldsJsObjects.length) {
         fieldsJsPaths = fieldsJsObjects.map(fieldsJs => {
@@ -148,11 +141,11 @@ async function uploadFolder(accountId, src, dest, fileMapperOptions, commandOpti
         return async () => {
             _onAttemptCallback(originalFilePath, destPath);
             try {
-                await (0, fileMapper_2.upload)(accountId, file, destPath, apiOptions);
+                await upload(accountId, file, destPath, apiOptions);
                 _onSuccessCallback(originalFilePath, destPath);
             }
             catch (err) {
-                if ((0, errors_1.isAuthError)(err)) {
+                if (isAuthError(err)) {
                     throw err;
                 }
                 _onFirstErrorCallback(file, destPath, err);
@@ -164,11 +157,11 @@ async function uploadFolder(accountId, src, dest, fileMapperOptions, commandOpti
         };
     }
     // Upload all meta.json files first
-    await uploadMetaJsonFiles(filesByType[files_1.FILE_TYPES.module] || [], uploadFile);
+    await uploadMetaJsonFiles(filesByType[FILE_TYPES.module] || [], uploadFile);
     // Collect all remaining files for upload
     const deferredFiles = [];
     Object.entries(filesByType).forEach(([fileType, files]) => {
-        if (fileType === files_1.FILE_TYPES.module) {
+        if (fileType === FILE_TYPES.module) {
             // Add non-meta.json module files
             deferredFiles.push(...files.filter(f => !isMetaJsonFile(f)));
         }
@@ -186,21 +179,21 @@ async function uploadFolder(accountId, src, dest, fileMapperOptions, commandOpti
         return async () => {
             _onRetryCallback(file, destPath);
             try {
-                await (0, fileMapper_2.upload)(accountId, file, destPath, apiOptions);
+                await upload(accountId, file, destPath, apiOptions);
                 _onSuccessCallback(file, destPath);
                 return {
-                    resultType: files_1.FILE_UPLOAD_RESULT_TYPES.SUCCESS,
+                    resultType: FILE_UPLOAD_RESULT_TYPES.SUCCESS,
                     error: null,
                     file,
                 };
             }
             catch (error) {
-                if ((0, errors_1.isAuthError)(error)) {
+                if (isAuthError(error)) {
                     throw error;
                 }
                 _onFinalErrorCallback(accountId, file, destPath, error);
                 return {
-                    resultType: files_1.FILE_UPLOAD_RESULT_TYPES.FAILURE,
+                    resultType: FILE_UPLOAD_RESULT_TYPES.FAILURE,
                     error,
                     file,
                 };
@@ -213,12 +206,10 @@ async function uploadFolder(accountId, src, dest, fileMapperOptions, commandOpti
         if (saveOutput) {
             fieldsJsObjects.forEach(fieldsJs => fieldsJs.saveOutput());
         }
-        (0, handleFieldsJS_1.cleanupTmpDirSync)(tmpDir || '');
+        cleanupTmpDirSync(tmpDir || '');
     });
     return results;
 }
-exports.uploadFolder = uploadFolder;
-function hasUploadErrors(results) {
-    return results.some(result => result.resultType === files_1.FILE_UPLOAD_RESULT_TYPES.FAILURE);
+export function hasUploadErrors(results) {
+    return results.some(result => result.resultType === FILE_UPLOAD_RESULT_TYPES.FAILURE);
 }
-exports.hasUploadErrors = hasUploadErrors;

package/lib/cms/validate.d.ts

@@ -1,2 +1,2 @@
-import { LintResult } from '../../types/HublValidation';
+import { LintResult } from '../../types/HublValidation.js';
 export declare function lint(accountId: number, filepath: string, callback?: (lintResult: LintResult) => number): Promise<Array<Partial<LintResult>> | void>;

package/lib/cms/validate.js

@@ -1,24 +1,18 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.lint = void 0;
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const extensions_1 = require("../../constants/extensions");
-const validateHubl_1 = require("../../api/validateHubl");
-const fs_1 = require("../fs");
-const path_1 = require("../path");
-async function lint(accountId, filepath, callback) {
-    const stats = await fs_extra_1.default.stat(filepath);
-    const files = stats.isDirectory() ? await (0, fs_1.walk)(filepath) : [filepath];
+import fs from 'fs-extra';
+import { HUBL_EXTENSIONS } from '../../constants/extensions.js';
+import { validateHubl } from '../../api/validateHubl.js';
+import { walk } from '../fs.js';
+import { getExt } from '../path.js';
+export async function lint(accountId, filepath, callback) {
+    const stats = await fs.stat(filepath);
+    const files = stats.isDirectory() ? await walk(filepath) : [filepath];
     if (!(files && files.length)) {
         return [];
     }
     return Promise.all(files
-        .filter(file => extensions_1.HUBL_EXTENSIONS.has((0, path_1.getExt)(file)))
+        .filter(file => HUBL_EXTENSIONS.has(getExt(file)))
         .map(async (file) => {
-        const source = await fs_extra_1.default.readFile(file, { encoding: 'utf8' });
+        const source = await fs.readFile(file, { encoding: 'utf8' });
         if (!(source && source.trim())) {
             const result = { file, validation: null };
             if (callback) {
@@ -26,7 +20,7 @@ async function lint(accountId, filepath, callback) {
             }
             return result;
         }
-        const { data: validation } = await (0, validateHubl_1.validateHubl)(accountId, source);
+        const { data: validation } = await validateHubl(accountId, source);
         const result = {
             file,
             validation,
@@ -37,4 +31,3 @@ async function lint(accountId, filepath, callback) {
         return result;
     }));
 }
-exports.lint = lint;

package/lib/cms/watch.d.ts

@@ -1,4 +1,4 @@
 import chokidar from 'chokidar';
-import { WatchOptions, WatchErrorHandler } from '../../types/Files';
-import { UploadFolderResults } from '../../types/Files';
+import { WatchOptions, WatchErrorHandler } from '../../types/Files.js';
+import { UploadFolderResults } from '../../types/Files.js';
 export declare function watch(accountId: number, src: string, dest: string, { cmsPublishMode, remove, disableInitial, notify, commandOptions, filePaths, }: WatchOptions, postInitialUploadCallback?: ((result: Array<UploadFolderResults>) => void) | null, onUploadFolderError?: WatchErrorHandler, onQueueAddError?: WatchErrorHandler, onUploadFileError?: (file: string, dest: string, accountId: number) => WatchErrorHandler): chokidar.FSWatcher;

package/lib/cms/watch.js

@@ -1,48 +1,42 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.watch = void 0;
-const path_1 = __importDefault(require("path"));
-const chokidar_1 = __importDefault(require("chokidar"));
-const p_queue_1 = __importDefault(require("p-queue"));
-const debounce_1 = __importDefault(require("debounce"));
-const handleFieldsJS_1 = require("./handleFieldsJS");
-const uploadFolder_1 = require("./uploadFolder");
-const ignoreRules_1 = require("../ignoreRules");
-const fileMapper_1 = require("../fileMapper");
-const fileMapper_2 = require("../../api/fileMapper");
-const escapeRegExp_1 = require("../escapeRegExp");
-const path_2 = require("../path");
-const notify_1 = require("../notify");
-const themes_1 = require("./themes");
-const logger_1 = require("../logger");
-const lang_1 = require("../../utils/lang");
-const HubSpotHttpError_1 = require("../../models/HubSpotHttpError");
-const errors_1 = require("../../errors");
+import path from 'path';
+import chokidar from 'chokidar';
+import PQueue from 'p-queue';
+import debounce from 'debounce';
+import { isConvertableFieldJs, FieldsJs } from './handleFieldsJS.js';
+import { uploadFolder } from './uploadFolder.js';
+import { shouldIgnoreFile, ignoreFile } from '../ignoreRules.js';
+import { getFileMapperQueryValues } from '../fileMapper.js';
+import { upload, deleteFile } from '../../api/fileMapper.js';
+import { escapeRegExp } from '../escapeRegExp.js';
+import { convertToUnixPath, isAllowedExtension, getCwd } from '../path.js';
+import { triggerNotify } from '../notify.js';
+import { getThemePreviewUrl, getThemeJSONPath } from './themes.js';
+import { logger } from '../logger.js';
+import { i18n } from '../../utils/lang.js';
+import { HubSpotHttpError } from '../../models/HubSpotHttpError.js';
+import { isHubSpotHttpError } from '../../errors/index.js';
 const i18nKey = 'lib.cms.watch';
-const queue = new p_queue_1.default({
+const queue = new PQueue({
     concurrency: 10,
 });
 function _notifyOfThemePreview(filePath, accountId) {
     if (queue.size > 0)
         return;
-    const previewUrl = (0, themes_1.getThemePreviewUrl)(filePath, accountId);
+    const previewUrl = getThemePreviewUrl(filePath, accountId);
     if (!previewUrl)
         return;
-    logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.notifyOfThemePreview`, {
+    logger.log(i18n(`${i18nKey}.notifyOfThemePreview`, {
         previewUrl,
     }));
 }
-const notifyOfThemePreview = (0, debounce_1.default)(_notifyOfThemePreview, 1000);
+const notifyOfThemePreview = debounce(_notifyOfThemePreview, 1000);
 const defaultOnUploadFileError = (file, dest, accountId) => (error) => {
-    const uploadFailedMessage = (0, lang_1.i18n)(`${i18nKey}.uploadFailed`, {
+    const uploadFailedMessage = i18n(`${i18nKey}.uploadFailed`, {
         file,
         dest,
     });
-    logger_1.logger.debug(uploadFailedMessage);
-    throw new HubSpotHttpError_1.HubSpotHttpError(uploadFailedMessage, {
+    logger.debug(uploadFailedMessage);
+    throw new HubSpotHttpError(uploadFailedMessage, {
         cause: error,
     }, {
         accountId,
@@ -52,61 +46,61 @@ const defaultOnUploadFileError = (file, dest, accountId) => (error) => {
 };
 async function uploadFile(accountId, file, dest, options, cmsPublishMode = null, onUploadFileError = defaultOnUploadFileError) {
     const src = options.src;
-    const absoluteSrcPath = path_1.default.resolve((0, path_2.getCwd)(), file);
-    const themeJsonPath = (0, themes_1.getThemeJSONPath)(absoluteSrcPath);
+    const absoluteSrcPath = path.resolve(getCwd(), file);
+    const themeJsonPath = getThemeJSONPath(absoluteSrcPath);
     const projectRoot = themeJsonPath
-        ? path_1.default.dirname(themeJsonPath)
-        : path_1.default.dirname((0, path_2.getCwd)());
-    const convertFields = (0, handleFieldsJS_1.isConvertableFieldJs)(src, file, options.commandOptions.convertFields);
-    if (!(0, path_2.isAllowedExtension)(file) && !convertFields) {
-        logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.skipUnsupportedExtension`, { file }));
+        ? path.dirname(themeJsonPath)
+        : path.dirname(getCwd());
+    const convertFields = isConvertableFieldJs(src, file, options.commandOptions.convertFields);
+    if (!isAllowedExtension(file) && !convertFields) {
+        logger.debug(i18n(`${i18nKey}.skipUnsupportedExtension`, { file }));
         return;
     }
-    if ((0, ignoreRules_1.shouldIgnoreFile)(file)) {
-        logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.skipIgnoreRule`, { file }));
+    if (shouldIgnoreFile(file)) {
+        logger.debug(i18n(`${i18nKey}.skipIgnoreRule`, { file }));
         return;
     }
     let fieldsJs = undefined;
     if (convertFields) {
-        fieldsJs = await new handleFieldsJS_1.FieldsJs(projectRoot, absoluteSrcPath, undefined, options.fieldOptions).init();
+        fieldsJs = await new FieldsJs(projectRoot, absoluteSrcPath, undefined, options.fieldOptions).init();
         if (fieldsJs.rejected)
             return;
         // Ensures that the dest path is a .json. The user might pass '.js' accidentally - this ensures it just works.
-        dest = (0, path_2.convertToUnixPath)(path_1.default.join(path_1.default.dirname(dest), 'fields.json'));
+        dest = convertToUnixPath(path.join(path.dirname(dest), 'fields.json'));
     }
     const fileToUpload = convertFields && fieldsJs?.outputPath ? fieldsJs.outputPath : file;
-    logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.uploadAttempt`, { file, dest }));
-    const apiOptions = (0, fileMapper_1.getFileMapperQueryValues)(cmsPublishMode, options);
+    logger.debug(i18n(`${i18nKey}.uploadAttempt`, { file, dest }));
+    const apiOptions = getFileMapperQueryValues(cmsPublishMode, options);
     queue.add(() => {
-        return (0, fileMapper_2.upload)(accountId, fileToUpload, dest, apiOptions)
+        return upload(accountId, fileToUpload, dest, apiOptions)
             .then(() => {
-            logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.uploadSuccess`, { file, dest }));
+            logger.log(i18n(`${i18nKey}.uploadSuccess`, { file, dest }));
             notifyOfThemePreview(file, accountId);
         })
             .catch(() => {
-            logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.uploadFailed`, { file, dest }));
-            logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.uploadRetry`, { file, dest }));
-            return (0, fileMapper_2.upload)(accountId, file, dest, apiOptions).catch(onUploadFileError(file, dest, accountId));
+            logger.debug(i18n(`${i18nKey}.uploadFailed`, { file, dest }));
+            logger.debug(i18n(`${i18nKey}.uploadRetry`, { file, dest }));
+            return upload(accountId, file, dest, apiOptions).catch(onUploadFileError(file, dest, accountId));
         });
     });
 }
 async function deleteRemoteFile(accountId, filePath, remoteFilePath) {
-    if ((0, ignoreRules_1.shouldIgnoreFile)(filePath)) {
-        logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.skipIgnoreRule`, { file: filePath }));
+    if (shouldIgnoreFile(filePath)) {
+        logger.debug(i18n(`${i18nKey}.skipIgnoreRule`, { file: filePath }));
         return;
     }
-    logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.deleteAttempt`, { remoteFilePath }));
+    logger.debug(i18n(`${i18nKey}.deleteAttempt`, { remoteFilePath }));
     return queue.add(() => {
-        return (0, fileMapper_2.deleteFile)(accountId, remoteFilePath)
+        return deleteFile(accountId, remoteFilePath)
             .then(() => {
-            logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.deleteSuccess`, { remoteFilePath }));
+            logger.log(i18n(`${i18nKey}.deleteSuccess`, { remoteFilePath }));
             notifyOfThemePreview(filePath, accountId);
         })
             .catch(error => {
-            logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.deleteFailed`, {
+            logger.debug(i18n(`${i18nKey}.deleteFailed`, {
                 remoteFilePath,
             }));
-            if ((0, errors_1.isHubSpotHttpError)(error)) {
+            if (isHubSpotHttpError(error)) {
                 error.updateContext({
                     accountId,
                     request: remoteFilePath,
@@ -116,23 +110,23 @@ async function deleteRemoteFile(accountId, filePath, remoteFilePath) {
         });
     });
 }
-function watch(accountId, src, dest, { cmsPublishMode, remove, disableInitial, notify, commandOptions, filePaths, }, postInitialUploadCallback = null, onUploadFolderError, onQueueAddError, onUploadFileError) {
-    const regex = new RegExp(`^${(0, escapeRegExp_1.escapeRegExp)(src)}`);
+export function watch(accountId, src, dest, { cmsPublishMode, remove, disableInitial, notify, commandOptions, filePaths, }, postInitialUploadCallback = null, onUploadFolderError, onQueueAddError, onUploadFileError) {
+    const regex = new RegExp(`^${escapeRegExp(src)}`);
     if (notify) {
-        (0, ignoreRules_1.ignoreFile)(notify);
+        ignoreFile(notify);
     }
-    const watcher = chokidar_1.default.watch(src, {
+    const watcher = chokidar.watch(src, {
         ignoreInitial: true,
-        ignored: (file) => (0, ignoreRules_1.shouldIgnoreFile)(file),
+        ignored: (file) => shouldIgnoreFile(file),
     });
     function getDesignManagerPath(file) {
         const relativePath = file.replace(regex, '');
-        return (0, path_2.convertToUnixPath)(path_1.default.join(dest, relativePath));
+        return convertToUnixPath(path.join(dest, relativePath));
     }
     if (!disableInitial) {
         // Use uploadFolder so that failures of initial upload are retried
-        const uploadFolderPromise = (0, uploadFolder_1.uploadFolder)(accountId, src, dest, {}, commandOptions, filePaths, cmsPublishMode || null).then(result => {
-            logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.folderUploadSuccess`, {
+        const uploadFolderPromise = uploadFolder(accountId, src, dest, {}, commandOptions, filePaths, cmsPublishMode || null).then(result => {
+            logger.log(i18n(`${i18nKey}.folderUploadSuccess`, {
                 src,
                 dest,
                 accountId,
@@ -146,7 +140,7 @@ function watch(accountId, src, dest, { cmsPublishMode, remove, disableInitial, n
         }
     }
     watcher.on('ready', () => {
-        logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.ready`, { src }));
+        logger.log(i18n(`${i18nKey}.ready`, { src }));
     });
     watcher.on('add', async (filePath) => {
         const destPath = getDesignManagerPath(filePath);
@@ -154,26 +148,26 @@ function watch(accountId, src, dest, { cmsPublishMode, remove, disableInitial, n
             src,
             commandOptions,
         }, cmsPublishMode, onUploadFileError);
-        (0, notify_1.triggerNotify)(notify, 'Added', filePath, uploadPromise);
+        triggerNotify(notify, 'Added', filePath, uploadPromise);
     });
     if (remove) {
         const deleteFileOrFolder = (type) => (filePath) => {
             // If it's a fields.js file that is in a module folder or the root, then ignore because it will not exist on the server.
-            if ((0, handleFieldsJS_1.isConvertableFieldJs)(src, filePath, commandOptions.convertFields)) {
+            if (isConvertableFieldJs(src, filePath, commandOptions.convertFields)) {
                 return;
             }
             const remotePath = getDesignManagerPath(filePath);
-            if ((0, ignoreRules_1.shouldIgnoreFile)(filePath)) {
-                logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.skipIgnoreRule`, { file: filePath }));
+            if (shouldIgnoreFile(filePath)) {
+                logger.debug(i18n(`${i18nKey}.skipIgnoreRule`, { file: filePath }));
                 return;
             }
-            logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.deleteAttemptWithType`, {
+            logger.debug(i18n(`${i18nKey}.deleteAttemptWithType`, {
                 type,
                 remoteFilePath: remotePath,
             }));
             const queueAddPromise = queue.add(() => {
                 const deletePromise = deleteRemoteFile(accountId, filePath, remotePath).then(() => {
-                    logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.deleteSuccessWithType`, {
+                    logger.log(i18n(`${i18nKey}.deleteSuccessWithType`, {
                         type,
                         remoteFilePath: remotePath,
                     }));
@@ -181,7 +175,7 @@ function watch(accountId, src, dest, { cmsPublishMode, remove, disableInitial, n
                 if (onQueueAddError) {
                     queueAddPromise.catch(onQueueAddError);
                 }
-                (0, notify_1.triggerNotify)(notify, 'Removed', filePath, deletePromise);
+                triggerNotify(notify, 'Removed', filePath, deletePromise);
                 return deletePromise;
             });
         };
@@ -194,8 +188,7 @@ function watch(accountId, src, dest, { cmsPublishMode, remove, disableInitial, n
             src,
             commandOptions,
         }, cmsPublishMode, onUploadFileError);
-        (0, notify_1.triggerNotify)(notify, 'Changed', filePath, uploadPromise);
+        triggerNotify(notify, 'Changed', filePath, uploadPromise);
     });
     return watcher;
 }
-exports.watch = watch;

package/lib/crm.d.ts

@@ -1,4 +1,4 @@
-import { ImportRequest } from '../types/Crm';
+import { ImportRequest } from '../types/Crm.js';
 export declare function getImportDataRequest(fileName: string): {
     importRequest: ImportRequest;
     dataFileNames: string[];

package/lib/crm.js

@@ -1,48 +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.validateImportRequestFile = exports.getImportDataRequest = void 0;
-const path_1 = __importDefault(require("path"));
-const path_2 = require("./path");
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const lang_1 = require("../utils/lang");
-function getImportDataRequest(fileName) {
+import path from 'path';
+import { getCwd } from './path.js';
+import fs from 'fs-extra';
+import { i18n } from '../utils/lang.js';
+export function getImportDataRequest(fileName) {
     validateImportRequestFile(fileName);
-    const importRequest = fs_extra_1.default.readJsonSync(path_1.default.resolve((0, path_2.getCwd)(), fileName));
+    const importRequest = fs.readJsonSync(path.resolve(getCwd(), fileName));
     const dataFileNames = importRequest.files.map(file => file.fileName);
     // allow relative paths in the provided import request
     importRequest.files = importRequest.files.map(file => ({
         ...file,
-        fileName: path_1.default.basename(file.fileName),
+        fileName: path.basename(file.fileName),
     }));
     if (dataFileNames.length === 0) {
-        throw new Error((0, lang_1.i18n)('lib.crm.importData.errors.noFiles'));
+        throw new Error(i18n('lib.crm.importData.errors.noFiles'));
     }
     dataFileNames.forEach(fileName => {
         if (!fileExists(fileName)) {
-            throw new Error((0, lang_1.i18n)('lib.crm.importData.errors.fileNotFound', { fileName }));
+            throw new Error(i18n('lib.crm.importData.errors.fileNotFound', { fileName }));
         }
     });
     return { importRequest, dataFileNames };
 }
-exports.getImportDataRequest = getImportDataRequest;
-function validateImportRequestFile(fileName) {
+export function validateImportRequestFile(fileName) {
     if (!fileExists(fileName)) {
-        throw new Error((0, lang_1.i18n)('lib.crm.importData.errors.fileNotFound', { fileName }));
+        throw new Error(i18n('lib.crm.importData.errors.fileNotFound', { fileName }));
     }
-    if (path_1.default.extname(fileName) !== '.json') {
-        throw new Error((0, lang_1.i18n)('lib.crm.importData.errors.notJson'));
+    if (path.extname(fileName) !== '.json') {
+        throw new Error(i18n('lib.crm.importData.errors.notJson'));
     }
 }
-exports.validateImportRequestFile = validateImportRequestFile;
 function fileExists(_path) {
     try {
-        const absoluteSrcPath = path_1.default.resolve((0, path_2.getCwd)(), _path);
+        const absoluteSrcPath = path.resolve(getCwd(), _path);
         if (!absoluteSrcPath)
             return false;
-        const stats = fs_extra_1.default.statSync(absoluteSrcPath);
+        const stats = fs.statSync(absoluteSrcPath);
         const isFile = stats.isFile();
         if (!isFile) {
             return false;

package/lib/customObjects.d.ts

@@ -1,4 +1,4 @@
-import { Schema } from '../types/Schemas';
+import { Schema } from '../types/Schemas.js';
 export declare function getResolvedPath(dest?: string, name?: string): string;
 export declare function writeSchemaToDisk(schema: Schema, dest?: string): Promise<void>;
 export declare function downloadSchemas(accountId: number, dest?: string): Promise<Array<Schema>>;