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

package/lib/cms/templates.d.ts

@@ -0,0 +1,65 @@
+export declare const ANNOTATION_KEYS: {
+    isAvailableForNewContent: string;
+    templateType: string;
+    label: string;
+    screenshotPath: string;
+    description: string;
+};
+export declare function getAnnotationValue(annotations: string, key: string): string | null;
+export declare function isCodedFile(filePath: string): boolean;
+declare const ASSET_PATHS: {
+    readonly 'page-template': "templates/page-template.html";
+    readonly partial: "templates/partial.html";
+    readonly 'global-partial': "templates/global-partial.html";
+    readonly 'email-template': "templates/email-template.html";
+    readonly 'blog-listing-template': "templates/blog-listing-template.html";
+    readonly 'blog-post-template': "templates/blog-post-template.html";
+    readonly 'search-template': "templates/search-template.html";
+    readonly section: "templates/section.html";
+};
+export declare function createTemplate(name: string, dest: string, type?: keyof typeof ASSET_PATHS, options?: {
+    allowExisting: boolean;
+}): Promise<void>;
+export declare const TEMPLATE_TYPES: {
+    unmapped: number;
+    email_base_template: number;
+    email: number;
+    landing_page_base_template: number;
+    landing_page: number;
+    blog_base: number;
+    blog: number;
+    blog_listing: number;
+    site_page: number;
+    blog_listing_context: number;
+    blog_post_context: number;
+    error_page: number;
+    subscription_preferences: number;
+    unsubscribe_confirmation: number;
+    unsubscribe_simple: number;
+    optin_email: number;
+    optin_followup_email: number;
+    optin_confirmation_page: number;
+    global_group: number;
+    password_prompt_page: number;
+    resubscribe_email: number;
+    unsubscribe_confirmation_email: number;
+    resubscribe_confirmation_email: number;
+    custom_module: number;
+    css: number;
+    js: number;
+    search_results: number;
+    membership_login: number;
+    membership_register: number;
+    membership_reset: number;
+    membership_reset_request: number;
+    drag_drop_email: number;
+    knowledge_article: number;
+    membership_email: number;
+    section: number;
+    global_content_partial: number;
+    simple_landing_page_template: number;
+    proposal: number;
+    blog_post: number;
+    quote: number;
+};
+export {};

package/lib/cms/templates.js

@@ -0,0 +1,107 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TEMPLATE_TYPES = exports.createTemplate = exports.isCodedFile = exports.getAnnotationValue = exports.ANNOTATION_KEYS = void 0;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const github_1 = require("../github");
+const logger_1 = require("../logger");
+const lang_1 = require("../../utils/lang");
+const i18nKey = 'lib.cms.templates';
+// Matches the .html file extension, excluding module.html
+const TEMPLATE_EXTENSION_REGEX = new RegExp(/(?<!module)\.html$/);
+// Matches an annotation value, ending at space, newline, or end of string
+const ANNOTATION_VALUE_REGEX = ':\\s?([\\S|\\s]*?)(\n|$)';
+exports.ANNOTATION_KEYS = {
+    isAvailableForNewContent: 'isAvailableForNewContent',
+    templateType: 'templateType',
+    label: 'label',
+    screenshotPath: 'screenshotPath',
+    // 'description' is specific to Sections
+    description: 'description',
+};
+function getAnnotationValue(annotations, key) {
+    const valueRegex = new RegExp(`${key}${ANNOTATION_VALUE_REGEX}`);
+    const match = annotations.match(valueRegex);
+    return match ? match[1].trim() : null;
+}
+exports.getAnnotationValue = getAnnotationValue;
+/*
+ * Returns true if:
+ * .html extension (ignoring module.html)
+ */
+function isCodedFile(filePath) {
+    return TEMPLATE_EXTENSION_REGEX.test(filePath);
+}
+exports.isCodedFile = isCodedFile;
+const ASSET_PATHS = {
+    'page-template': 'templates/page-template.html',
+    partial: 'templates/partial.html',
+    'global-partial': 'templates/global-partial.html',
+    'email-template': 'templates/email-template.html',
+    'blog-listing-template': 'templates/blog-listing-template.html',
+    'blog-post-template': 'templates/blog-post-template.html',
+    'search-template': 'templates/search-template.html',
+    section: 'templates/section.html',
+};
+async function createTemplate(name, dest, type = 'page-template', options = { allowExisting: false }) {
+    const assetPath = ASSET_PATHS[type];
+    const filename = name.endsWith('.html') ? name : `${name}.html`;
+    const filePath = path_1.default.join(dest, filename);
+    if (!options.allowExisting && fs_extra_1.default.existsSync(filePath)) {
+        throw new Error((0, lang_1.i18n)(`${i18nKey}.createTemplate.errors.pathExists`, {
+            path: filePath,
+        }));
+    }
+    logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.createTemplate.creatingPath`, { path: dest }));
+    fs_extra_1.default.mkdirp(dest);
+    logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.createTemplate.creatingFile`, {
+        path: filePath,
+    }));
+    await (0, github_1.downloadGithubRepoContents)('HubSpot/cms-sample-assets', assetPath, filePath);
+}
+exports.createTemplate = createTemplate;
+exports.TEMPLATE_TYPES = {
+    unmapped: 0,
+    email_base_template: 1,
+    email: 2,
+    landing_page_base_template: 3,
+    landing_page: 4,
+    blog_base: 5,
+    blog: 6,
+    blog_listing: 42,
+    site_page: 8,
+    blog_listing_context: 9,
+    blog_post_context: 10,
+    error_page: 11,
+    subscription_preferences: 12,
+    unsubscribe_confirmation: 13,
+    unsubscribe_simple: 14,
+    optin_email: 15,
+    optin_followup_email: 16,
+    optin_confirmation_page: 17,
+    global_group: 18,
+    password_prompt_page: 19,
+    resubscribe_email: 20,
+    unsubscribe_confirmation_email: 21,
+    resubscribe_confirmation_email: 22,
+    custom_module: 23,
+    css: 24,
+    js: 25,
+    search_results: 27,
+    membership_login: 29,
+    membership_register: 30,
+    membership_reset: 31,
+    membership_reset_request: 32,
+    drag_drop_email: 34,
+    knowledge_article: 35,
+    membership_email: 36,
+    section: 37,
+    global_content_partial: 38,
+    simple_landing_page_template: 39,
+    proposal: 40,
+    blog_post: 41,
+    quote: 43,
+};

package/lib/cms/themes.d.ts

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

package/lib/cms/themes.js

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

package/lib/cms/uploadFolder.d.ts

@@ -0,0 +1,7 @@
+import { FieldsJs } from './handleFieldsJS';
+import { FileMapperInputOptions } from '../../types/Files';
+import { UploadFolderResults, CommandOptions, FilePathsByType } from '../../types/Files';
+import { Mode } from '../../types/Files';
+export declare function getFilesByType(filePaths: Array<string>, projectDir: string, rootWriteDir: string | null, commandOptions: CommandOptions): Promise<[FilePathsByType, Array<FieldsJs>]>;
+export declare function uploadFolder(accountId: number, src: string, dest: string, fileMapperOptions: FileMapperInputOptions, commandOptions?: CommandOptions, filePaths?: Array<string>, mode?: Mode | null): Promise<Array<UploadFolderResults>>;
+export declare function hasUploadErrors(results: Array<UploadFolderResults>): boolean;

package/lib/cms/uploadFolder.js

@@ -0,0 +1,202 @@
+"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");
+const i18nKey = 'lib.cms.uploadFolder';
+const queue = new p_queue_1.default({
+    concurrency: 10,
+});
+function getFileType(filePath) {
+    const extension = (0, path_2.getExt)(filePath);
+    const moduleFolder = (0, modules_1.isModuleFolderChild)({ path: filePath, isLocal: true });
+    if (moduleFolder)
+        return files_1.FILE_TYPES.module;
+    switch (extension) {
+        case 'js':
+        case 'css':
+            return files_1.FILE_TYPES.cssAndJs;
+        case 'html':
+            return files_1.FILE_TYPES.template;
+        case 'json':
+            return files_1.FILE_TYPES.json;
+        default:
+            return files_1.FILE_TYPES.other;
+    }
+}
+async function getFilesByType(filePaths, projectDir, rootWriteDir, commandOptions) {
+    const { convertFields, fieldOptions } = commandOptions;
+    const projectDirRegex = new RegExp(`^${(0, escapeRegExp_1.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) => {
+        return {
+            ...acc,
+            [fileType]: [],
+        };
+    }, {});
+    for (const filePath of filePaths) {
+        const fileType = getFileType(filePath);
+        const relPath = filePath.replace(projectDirRegex, '');
+        if (!convertFields) {
+            filePathsByType[fileType].push(filePath);
+            continue;
+        }
+        const convertableFields = (0, handleFieldsJS_1.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();
+            /*
+             * 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.
+             */
+            if (fieldsJs.rejected)
+                continue;
+            fieldsJsObjects.push(fieldsJs);
+            filePathsByType[rootOrModule].push(fieldsJs.outputPath || '');
+        }
+        else {
+            filePathsByType[fileType].push(filePath);
+        }
+    }
+    return [filePathsByType, fieldsJsObjects];
+}
+exports.getFilesByType = getFilesByType;
+const defaultUploadAttemptCallback = (file, destPath) => logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.uploadFolder.attempt`, {
+    file: file || '',
+    destPath,
+}));
+const defaultUploadSuccessCallback = (file, destPath) => logger_1.logger.log((0, lang_1.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);
+    }
+    else if (error instanceof Error) {
+        logger_1.logger.debug(error.message);
+    }
+};
+const defaultUploadRetryCallback = (file, destPath) => logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.uploadFolder.retry`, { file, destPath }));
+const defaultUploadFinalErrorCallback = (accountId, file, destPath, error) => {
+    const retryFailed = (0, lang_1.i18n)(`${i18nKey}.uploadFolder.retryFailed`, {
+        file,
+        destPath,
+    });
+    logger_1.logger.debug(retryFailed);
+    throw new HubSpotHttpError_1.HubSpotHttpError(retryFailed, { cause: error }, {
+        accountId,
+        request: destPath,
+        payload: file,
+    });
+};
+async function uploadFolder(accountId, src, dest, fileMapperOptions, commandOptions = {}, filePaths = [], mode = null) {
+    const { saveOutput, convertFields, onAttemptCallback, onSuccessCallback, onFirstErrorCallback, onRetryCallback, onFinalErrorCallback, } = commandOptions;
+    const _onAttemptCallback = onAttemptCallback || defaultUploadAttemptCallback;
+    const _onSuccessCallback = onSuccessCallback || defaultUploadSuccessCallback;
+    const _onFirstErrorCallback = onFirstErrorCallback || defaultUploadFirstErrorCallback;
+    const _onRetryCallback = onRetryCallback || defaultUploadRetryCallback;
+    const _onFinalErrorCallback = onFinalErrorCallback || defaultUploadFinalErrorCallback;
+    const tmpDir = convertFields
+        ? (0, handleFieldsJS_1.createTmpDirSync)('hubspot-temp-fieldsjs-output-')
+        : null;
+    const regex = new RegExp(`^${(0, escapeRegExp_1.escapeRegExp)(src)}`);
+    const apiOptions = (0, fileMapper_1.getFileMapperQueryValues)(mode, fileMapperOptions);
+    const failures = [];
+    let fieldsJsPaths = [];
+    let tmpDirRegex;
+    const [filesByType, fieldsJsObjects] = await getFilesByType(filePaths, src, tmpDir, commandOptions);
+    const fileList = Object.values(filesByType);
+    if (fieldsJsObjects.length) {
+        fieldsJsPaths = fieldsJsObjects.map(fieldsJs => {
+            return { outputPath: fieldsJs.outputPath, filePath: fieldsJs.filePath };
+        });
+        tmpDirRegex = new RegExp(`^${(0, escapeRegExp_1.escapeRegExp)(tmpDir || '')}`);
+    }
+    function uploadFile(file) {
+        const fieldsJsFileInfo = fieldsJsPaths.find(f => f.outputPath === file);
+        const originalFilePath = fieldsJsFileInfo
+            ? fieldsJsFileInfo.filePath
+            : file;
+        // files in fieldsJsPaths always belong to the tmp directory.
+        const relativePath = file.replace(fieldsJsFileInfo ? tmpDirRegex : regex, '');
+        const destPath = (0, path_2.convertToUnixPath)(path_1.default.join(dest, relativePath));
+        return async () => {
+            _onAttemptCallback(originalFilePath, destPath);
+            try {
+                await (0, fileMapper_2.upload)(accountId, file, destPath, apiOptions);
+                _onSuccessCallback(originalFilePath, destPath);
+            }
+            catch (err) {
+                if ((0, errors_1.isAuthError)(err)) {
+                    throw err;
+                }
+                _onFirstErrorCallback(file, destPath, err);
+                failures.push({
+                    file,
+                    destPath,
+                });
+            }
+        };
+    }
+    for (let i = 0; i < fileList.length; i++) {
+        const filesToUpload = fileList[i];
+        await queue.addAll(filesToUpload.map(uploadFile));
+    }
+    const results = await queue
+        .addAll(failures.map(({ file, destPath }) => {
+        return async () => {
+            _onRetryCallback(file, destPath);
+            try {
+                await (0, fileMapper_2.upload)(accountId, file, destPath, apiOptions);
+                _onSuccessCallback(file, destPath);
+                return {
+                    resultType: files_1.FILE_UPLOAD_RESULT_TYPES.SUCCESS,
+                    error: null,
+                    file,
+                };
+            }
+            catch (error) {
+                if ((0, errors_1.isAuthError)(error)) {
+                    throw error;
+                }
+                _onFinalErrorCallback(accountId, file, destPath, error);
+                return {
+                    resultType: files_1.FILE_UPLOAD_RESULT_TYPES.FAILURE,
+                    error,
+                    file,
+                };
+            }
+        };
+    }))
+        .finally(() => {
+        if (!convertFields)
+            return;
+        if (saveOutput) {
+            fieldsJsObjects.forEach(fieldsJs => fieldsJs.saveOutput());
+        }
+        (0, handleFieldsJS_1.cleanupTmpDirSync)(tmpDir || '');
+    });
+    return results;
+}
+exports.uploadFolder = uploadFolder;
+function hasUploadErrors(results) {
+    return results.some(result => result.resultType === files_1.FILE_UPLOAD_RESULT_TYPES.FAILURE);
+}
+exports.hasUploadErrors = hasUploadErrors;

package/lib/cms/validate.d.ts

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

package/lib/cms/validate.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.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];
+    if (!(files && files.length)) {
+        return [];
+    }
+    return Promise.all(files
+        .filter(file => extensions_1.HUBL_EXTENSIONS.has((0, path_1.getExt)(file)))
+        .map(async (file) => {
+        const source = await fs_extra_1.default.readFile(file, { encoding: 'utf8' });
+        if (!(source && source.trim())) {
+            const result = { file, validation: null };
+            if (callback) {
+                callback(result);
+            }
+            return result;
+        }
+        const { data: validation } = await (0, validateHubl_1.validateHubl)(accountId, source);
+        const result = {
+            file,
+            validation,
+        };
+        if (callback) {
+            callback(result);
+        }
+        return result;
+    }));
+}
+exports.lint = lint;

package/lib/cms/watch.d.ts

@@ -0,0 +1,4 @@
+import chokidar from 'chokidar';
+import { WatchOptions, WatchErrorHandler } from '../../types/Files';
+import { UploadFolderResults } from '../../types/Files';
+export declare function watch(accountId: number, src: string, dest: string, { mode, 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

@@ -0,0 +1,201 @@
+"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");
+const i18nKey = 'lib.cms.watch';
+const queue = new p_queue_1.default({
+    concurrency: 10,
+});
+function _notifyOfThemePreview(filePath, accountId) {
+    if (queue.size > 0)
+        return;
+    const previewUrl = (0, themes_1.getThemePreviewUrl)(filePath, accountId);
+    if (!previewUrl)
+        return;
+    logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.notifyOfThemePreview`, {
+        previewUrl,
+    }));
+}
+const notifyOfThemePreview = (0, debounce_1.default)(_notifyOfThemePreview, 1000);
+const defaultOnUploadFileError = (file, dest, accountId) => (error) => {
+    const uploadFailedMessage = (0, lang_1.i18n)(`${i18nKey}.uploadFailed`, {
+        file,
+        dest,
+    });
+    logger_1.logger.debug(uploadFailedMessage);
+    throw new HubSpotHttpError_1.HubSpotHttpError(uploadFailedMessage, {
+        cause: error,
+    }, {
+        accountId,
+        request: dest,
+        payload: file,
+    });
+};
+async function uploadFile(accountId, file, dest, options, mode = 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 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 }));
+        return;
+    }
+    if ((0, ignoreRules_1.shouldIgnoreFile)(file)) {
+        logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.skipIgnoreRule`, { file }));
+        return;
+    }
+    let fieldsJs = undefined;
+    if (convertFields) {
+        fieldsJs = await new handleFieldsJS_1.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'));
+    }
+    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)(mode, options);
+    queue.add(() => {
+        return (0, fileMapper_2.upload)(accountId, fileToUpload, dest, apiOptions)
+            .then(() => {
+            logger_1.logger.log((0, lang_1.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));
+        });
+    });
+}
+async function deleteRemoteFile(accountId, filePath, remoteFilePath) {
+    if ((0, ignoreRules_1.shouldIgnoreFile)(filePath)) {
+        logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.skipIgnoreRule`, { file: filePath }));
+        return;
+    }
+    logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.deleteAttempt`, { remoteFilePath }));
+    return queue.add(() => {
+        return (0, fileMapper_2.deleteFile)(accountId, remoteFilePath)
+            .then(() => {
+            logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.deleteSuccess`, { remoteFilePath }));
+            notifyOfThemePreview(filePath, accountId);
+        })
+            .catch(error => {
+            logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.deleteFailed`, {
+                remoteFilePath,
+            }));
+            if ((0, errors_1.isHubSpotHttpError)(error)) {
+                error.updateContext({
+                    accountId,
+                    request: remoteFilePath,
+                });
+            }
+            throw error;
+        });
+    });
+}
+function watch(accountId, src, dest, { mode, remove, disableInitial, notify, commandOptions, filePaths, }, postInitialUploadCallback = null, onUploadFolderError, onQueueAddError, onUploadFileError) {
+    const regex = new RegExp(`^${(0, escapeRegExp_1.escapeRegExp)(src)}`);
+    if (notify) {
+        (0, ignoreRules_1.ignoreFile)(notify);
+    }
+    const watcher = chokidar_1.default.watch(src, {
+        ignoreInitial: true,
+        ignored: (file) => (0, ignoreRules_1.shouldIgnoreFile)(file),
+    });
+    function getDesignManagerPath(file) {
+        const relativePath = file.replace(regex, '');
+        return (0, path_2.convertToUnixPath)(path_1.default.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, mode || null).then(result => {
+            logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.folderUploadSuccess`, {
+                src,
+                dest,
+                accountId,
+            }));
+            if (postInitialUploadCallback) {
+                postInitialUploadCallback(result);
+            }
+        });
+        if (onUploadFolderError) {
+            uploadFolderPromise.catch(onUploadFolderError);
+        }
+    }
+    watcher.on('ready', () => {
+        logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.ready`, { src }));
+    });
+    watcher.on('add', async (filePath) => {
+        const destPath = getDesignManagerPath(filePath);
+        const uploadPromise = uploadFile(accountId, filePath, destPath, {
+            src,
+            commandOptions,
+        }, mode, onUploadFileError);
+        (0, notify_1.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)) {
+                return;
+            }
+            const remotePath = getDesignManagerPath(filePath);
+            if ((0, ignoreRules_1.shouldIgnoreFile)(filePath)) {
+                logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.skipIgnoreRule`, { file: filePath }));
+                return;
+            }
+            logger_1.logger.debug((0, lang_1.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`, {
+                        type,
+                        remoteFilePath: remotePath,
+                    }));
+                });
+                if (onQueueAddError) {
+                    queueAddPromise.catch(onQueueAddError);
+                }
+                (0, notify_1.triggerNotify)(notify, 'Removed', filePath, deletePromise);
+                return deletePromise;
+            });
+        };
+        watcher.on('unlink', deleteFileOrFolder('file'));
+        watcher.on('unlinkDir', deleteFileOrFolder('folder'));
+    }
+    watcher.on('change', async (filePath) => {
+        const destPath = getDesignManagerPath(filePath);
+        const uploadPromise = uploadFile(accountId, filePath, destPath, {
+            src,
+            commandOptions,
+        }, mode, onUploadFileError);
+        (0, notify_1.triggerNotify)(notify, 'Changed', filePath, uploadPromise);
+    });
+    return watcher;
+}
+exports.watch = watch;