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

package/lib/fileManager.js

@@ -1,74 +1,67 @@
-"use strict";
 // FILE MANAGER - not to be confused with fileMapper.ts
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.downloadFileOrFolder = exports.uploadFolder = void 0;
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const path_1 = __importDefault(require("path"));
-const fileManager_1 = require("../api/fileManager");
-const fs_1 = require("./fs");
-const logger_1 = require("./logger");
-const ignoreRules_1 = require("./ignoreRules");
-const http_1 = require("../http");
-const escapeRegExp_1 = require("./escapeRegExp");
-const path_2 = require("./path");
-const lang_1 = require("../utils/lang");
-const errors_1 = require("../errors");
-const FileSystemError_1 = require("../models/FileSystemError");
+import fs from 'fs-extra';
+import path from 'path';
+import { uploadFile, fetchStat, fetchFiles, fetchFolders, } from '../api/fileManager.js';
+import { walk } from './fs.js';
+import { logger } from './logger.js';
+import { createIgnoreFilter } from './ignoreRules.js';
+import { http } from '../http/index.js';
+import { escapeRegExp } from './escapeRegExp.js';
+import { getCwd, convertToUnixPath, convertToLocalFileSystemPath, } from './path.js';
+import { i18n } from '../utils/lang.js';
+import { isAuthError, isHubSpotHttpError } from '../errors/index.js';
+import { FileSystemError } from '../models/FileSystemError.js';
 const i18nKey = 'lib.fileManager';
-async function uploadFolder(accountId, src, dest) {
-    const regex = new RegExp(`^${(0, escapeRegExp_1.escapeRegExp)(src)}`);
-    const files = await (0, fs_1.walk)(src);
-    const filesToUpload = files.filter((0, ignoreRules_1.createIgnoreFilter)(false));
+export async function uploadFolder(accountId, src, dest) {
+    const regex = new RegExp(`^${escapeRegExp(src)}`);
+    const files = await walk(src);
+    const filesToUpload = files.filter(createIgnoreFilter(false));
     const len = filesToUpload.length;
     for (let index = 0; index < len; index++) {
         const file = filesToUpload[index];
         const relativePath = file.replace(regex, '');
-        const destPath = (0, path_2.convertToUnixPath)(path_1.default.join(dest, relativePath));
-        logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.uploadStarted`, {
+        const destPath = convertToUnixPath(path.join(dest, relativePath));
+        logger.debug(i18n(`${i18nKey}.uploadStarted`, {
             file,
             destPath,
             accountId,
         }));
         try {
-            await (0, fileManager_1.uploadFile)(accountId, file, destPath);
-            logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.uploadSuccess`, { file, destPath }));
+            await uploadFile(accountId, file, destPath);
+            logger.log(i18n(`${i18nKey}.uploadSuccess`, { file, destPath }));
         }
         catch (err) {
-            if ((0, errors_1.isHubSpotHttpError)(err)) {
+            if (isHubSpotHttpError(err)) {
                 err.updateContext({
                     filepath: file,
                     dest: destPath,
                 });
                 throw err;
             }
-            throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.uploadFailed`, {
+            throw new Error(i18n(`${i18nKey}.errors.uploadFailed`, {
                 file,
                 destPath,
             }));
         }
     }
 }
-exports.uploadFolder = uploadFolder;
 async function skipExisting(overwrite, filepath) {
     if (overwrite) {
         return false;
     }
-    if (await fs_extra_1.default.pathExists(filepath)) {
-        logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.skippedExisting`, { filepath }));
+    if (await fs.pathExists(filepath)) {
+        logger.log(i18n(`${i18nKey}.skippedExisting`, { filepath }));
         return true;
     }
     return false;
 }
 async function downloadFile(accountId, file, dest, overwrite) {
     const fileName = `${file.name}.${file.extension}`;
-    const destPath = (0, path_2.convertToLocalFileSystemPath)(path_1.default.join(dest, fileName));
+    const destPath = convertToLocalFileSystemPath(path.join(dest, fileName));
     if (await skipExisting(overwrite || false, destPath)) {
         return;
     }
-    await http_1.http.getOctetStream(accountId, {
+    await http.getOctetStream(accountId, {
         baseURL: file.url,
         url: '',
     }, destPath);
@@ -79,7 +72,7 @@ async function fetchAllPagedFiles(accountId, folderId, includeArchived) {
     let count = 0;
     let offset = 0;
     while (totalFiles === null || count < totalFiles) {
-        const { data: response } = await (0, fileManager_1.fetchFiles)(accountId, folderId, offset, includeArchived);
+        const { data: response } = await fetchFiles(accountId, folderId, offset, includeArchived);
         if (totalFiles === null) {
             totalFiles = response.total_count;
         }
@@ -91,26 +84,26 @@ async function fetchAllPagedFiles(accountId, folderId, includeArchived) {
 }
 async function fetchFolderContents(accountId, folder, dest, overwrite, includeArchived) {
     try {
-        await fs_extra_1.default.ensureDir(dest);
+        await fs.ensureDir(dest);
     }
     catch (err) {
-        throw new FileSystemError_1.FileSystemError({ cause: err }, {
+        throw new FileSystemError({ cause: err }, {
             dest,
             accountId,
             operation: 'write',
         });
     }
     const files = await fetchAllPagedFiles(accountId, folder.id, includeArchived);
-    logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.fetchingFiles`, {
+    logger.debug(i18n(`${i18nKey}.fetchingFiles`, {
         fileCount: files.length,
         folderName: folder.name || '',
     }));
     for (const file of files) {
         await downloadFile(accountId, file, dest, overwrite);
     }
-    const { data: { objects: folders }, } = await (0, fileManager_1.fetchFolders)(accountId, folder.id);
+    const { data: { objects: folders }, } = await fetchFolders(accountId, folder.id);
     for (const folder of folders) {
-        const nestedFolder = path_1.default.join(dest, folder.name);
+        const nestedFolder = path.join(dest, folder.name);
         await fetchFolderContents(accountId, folder, nestedFolder, overwrite, includeArchived);
     }
 }
@@ -118,18 +111,18 @@ async function fetchFolderContents(accountId, folder, dest, overwrite, includeAr
 async function downloadFolder(accountId, src, dest, folder, overwrite, includeArchived) {
     let absolutePath;
     if (folder.name) {
-        absolutePath = (0, path_2.convertToLocalFileSystemPath)(path_1.default.resolve((0, path_2.getCwd)(), dest, folder.name));
+        absolutePath = convertToLocalFileSystemPath(path.resolve(getCwd(), dest, folder.name));
     }
     else {
-        absolutePath = (0, path_2.convertToLocalFileSystemPath)(path_1.default.resolve((0, path_2.getCwd)(), dest));
+        absolutePath = convertToLocalFileSystemPath(path.resolve(getCwd(), dest));
     }
-    logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.fetchFolderStarted`, {
+    logger.log(i18n(`${i18nKey}.fetchFolderStarted`, {
         src,
         path: absolutePath,
         accountId,
     }));
     await fetchFolderContents(accountId, folder, absolutePath, overwrite, includeArchived);
-    logger_1.logger.success((0, lang_1.i18n)(`${i18nKey}.fetchFolderSuccess`, {
+    logger.success(i18n(`${i18nKey}.fetchFolderSuccess`, {
         src,
         dest,
     }));
@@ -137,24 +130,24 @@ async function downloadFolder(accountId, src, dest, folder, overwrite, includeAr
 // Download a single file and write to local file system.
 async function downloadSingleFile(accountId, src, dest, file, overwrite, includeArchived) {
     if (!includeArchived && file.archived) {
-        throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.archivedFile`, { src }));
+        throw new Error(i18n(`${i18nKey}.errors.archivedFile`, { src }));
     }
     if (file.hidden) {
-        throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.hiddenFile`, { src }));
+        throw new Error(i18n(`${i18nKey}.errors.hiddenFile`, { src }));
     }
-    logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.fetchFileStarted`, {
+    logger.log(i18n(`${i18nKey}.fetchFileStarted`, {
         src,
         dest,
         accountId,
     }));
     await downloadFile(accountId, file, dest, overwrite);
-    logger_1.logger.success((0, lang_1.i18n)(`${i18nKey}.fetchFileSuccess`, {
+    logger.success(i18n(`${i18nKey}.fetchFileSuccess`, {
         src,
         dest,
     }));
 }
 // Lookup path in file manager and initiate download
-async function downloadFileOrFolder(accountId, src, dest, overwrite, includeArchived) {
+export async function downloadFileOrFolder(accountId, src, dest, overwrite, includeArchived) {
     try {
         if (src == '/') {
             // Filemanager API treats 'None' as the root
@@ -162,7 +155,7 @@ async function downloadFileOrFolder(accountId, src, dest, overwrite, includeArch
             await downloadFolder(accountId, src, dest, rootFolder, overwrite, includeArchived);
         }
         else {
-            const { data: { file, folder }, } = await (0, fileManager_1.fetchStat)(accountId, src);
+            const { data: { file, folder }, } = await fetchStat(accountId, src);
             if (file) {
                 await downloadSingleFile(accountId, src, dest, file, overwrite, includeArchived);
             }
@@ -172,7 +165,7 @@ async function downloadFileOrFolder(accountId, src, dest, overwrite, includeArch
         }
     }
     catch (err) {
-        if ((0, errors_1.isAuthError)(err)) {
+        if (isAuthError(err)) {
             err.updateContext({
                 request: src,
                 accountId,
@@ -181,4 +174,3 @@ async function downloadFileOrFolder(accountId, src, dest, overwrite, includeArch
         throw err;
     }
 }
-exports.downloadFileOrFolder = downloadFileOrFolder;

package/lib/fileMapper.d.ts

@@ -1,4 +1,4 @@
-import { FileMapperNode, CmsPublishMode, FileMapperOptions, FileMapperInputOptions, PathTypeData, RecursiveFileMapperCallback } from '../types/Files';
+import { FileMapperNode, CmsPublishMode, FileMapperOptions, FileMapperInputOptions, PathTypeData, RecursiveFileMapperCallback } from '../types/Files.js';
 export declare function isPathToFile(filepath: string): boolean;
 export declare function isPathToModule(filepath: string): boolean;
 export declare function isPathToRoot(filepath: string): boolean;

package/lib/fileMapper.js

@@ -1,53 +1,43 @@
-"use strict";
 // FILE MAPPER - not to be confused with fileManager.ts
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.downloadFileOrFolder = exports.fetchFolderFromApi = exports.writeUtimes = exports.recurseFolder = exports.getTypeDataFromPath = exports.getFileMapperQueryValues = exports.isPathToHubspot = exports.isPathToRoot = exports.isPathToModule = exports.isPathToFile = void 0;
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const path_1 = __importDefault(require("path"));
-const p_queue_1 = __importDefault(require("p-queue"));
-const path_2 = require("./path");
-const logger_1 = require("./logger");
-const fileMapper_1 = require("../api/fileMapper");
-const extensions_1 = require("../constants/extensions");
-const files_1 = require("../constants/files");
-const errors_1 = require("../errors");
-const lang_1 = require("../utils/lang");
-const FileSystemError_1 = require("../models/FileSystemError");
+import fs from 'fs-extra';
+import path from 'path';
+import PQueue from 'p-queue';
+import { getCwd, getExt, convertToLocalFileSystemPath, isAllowedExtension, } from './path.js';
+import { logger } from './logger.js';
+import { fetchFileStream, download, downloadDefault, } from '../api/fileMapper.js';
+import { MODULE_EXTENSION, FUNCTIONS_EXTENSION, JSR_ALLOWED_EXTENSIONS, } from '../constants/extensions.js';
+import { CMS_PUBLISH_MODE } from '../constants/files.js';
+import { isTimeoutError } from '../errors/index.js';
+import { i18n } from '../utils/lang.js';
+import { FileSystemError } from '../models/FileSystemError.js';
 const i18nKey = 'lib.fileMapper';
-const queue = new p_queue_1.default({
+const queue = new PQueue({
     concurrency: 10,
 });
-function isPathToFile(filepath) {
-    const ext = (0, path_2.getExt)(filepath);
-    return !!ext && ext !== extensions_1.MODULE_EXTENSION && ext !== extensions_1.FUNCTIONS_EXTENSION;
+export function isPathToFile(filepath) {
+    const ext = getExt(filepath);
+    return !!ext && ext !== MODULE_EXTENSION && ext !== FUNCTIONS_EXTENSION;
 }
-exports.isPathToFile = isPathToFile;
-function isPathToModule(filepath) {
-    const ext = (0, path_2.getExt)(filepath);
-    return ext === extensions_1.MODULE_EXTENSION;
+export function isPathToModule(filepath) {
+    const ext = getExt(filepath);
+    return ext === MODULE_EXTENSION;
 }
-exports.isPathToModule = isPathToModule;
-function isPathToRoot(filepath) {
+export function isPathToRoot(filepath) {
     if (typeof filepath !== 'string')
         return false;
     // Root pattern matches empty strings and: / \
     return /^(\/|\\)?$/.test(filepath.trim());
 }
-exports.isPathToRoot = isPathToRoot;
-function isPathToHubspot(filepath) {
+export function isPathToHubspot(filepath) {
     if (typeof filepath !== 'string')
         return false;
     return /^(\/|\\)?@hubspot/i.test(filepath.trim());
 }
-exports.isPathToHubspot = isPathToHubspot;
 function useApiBuffer(cmsPublishMode) {
-    return cmsPublishMode === files_1.CMS_PUBLISH_MODE.draft;
+    return cmsPublishMode === CMS_PUBLISH_MODE.draft;
 }
 // Determines API param based on publish mode and options
-function getFileMapperQueryValues(cmsPublishMode, { staging, assetVersion } = {}) {
+export function getFileMapperQueryValues(cmsPublishMode, { staging, assetVersion } = {}) {
     return {
         params: {
             buffer: useApiBuffer(cmsPublishMode),
@@ -56,7 +46,6 @@ function getFileMapperQueryValues(cmsPublishMode, { staging, assetVersion } = {}
         },
     };
 }
-exports.getFileMapperQueryValues = getFileMapperQueryValues;
 // Determines version number to log based on input.options
 function getAssetVersionIdentifier(assetVersion, src) {
     if (typeof assetVersion !== 'undefined' &&
@@ -72,15 +61,16 @@ function validateFileMapperNode(node) {
     let json;
     try {
         json = JSON.stringify(node, null, 2);
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
     }
     catch (err) {
         json = node;
     }
-    throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.invalidNode`, {
+    throw new Error(i18n(`${i18nKey}.errors.invalidNode`, {
         json: JSON.stringify(json),
     }));
 }
-function getTypeDataFromPath(src) {
+export function getTypeDataFromPath(src) {
     const isModule = isPathToModule(src);
     const isHubspot = isPathToHubspot(src);
     const isFile = !isModule && isPathToFile(src);
@@ -94,8 +84,7 @@ function getTypeDataFromPath(src) {
         isFolder,
     };
 }
-exports.getTypeDataFromPath = getTypeDataFromPath;
-function recurseFolder(node, callback, filepath = '', depth = 0) {
+export function recurseFolder(node, callback, filepath = '', depth = 0) {
     validateFileMapperNode(node);
     const isRootFolder = node.folder && depth === 0;
     if (isRootFolder) {
@@ -104,7 +93,7 @@ function recurseFolder(node, callback, filepath = '', depth = 0) {
         }
     }
     else {
-        filepath = path_1.default.join(filepath, node.name);
+        filepath = path.join(filepath, node.name);
     }
     let __break = callback(node, filepath, depth);
     if (__break === false)
@@ -115,28 +104,26 @@ function recurseFolder(node, callback, filepath = '', depth = 0) {
     });
     return depth === 0 ? false : __break;
 }
-exports.recurseFolder = recurseFolder;
-async function writeUtimes(accountId, filepath, node) {
+export async function writeUtimes(accountId, filepath, node) {
     try {
         const now = new Date();
         const atime = node.createdAt ? new Date(node.createdAt) : now;
         const mtime = node.updatedAt ? new Date(node.updatedAt) : now;
-        await fs_extra_1.default.utimes(filepath, atime, mtime);
+        await fs.utimes(filepath, atime, mtime);
     }
     catch (err) {
-        throw new FileSystemError_1.FileSystemError({ cause: err }, {
+        throw new FileSystemError({ cause: err }, {
             filepath,
             accountId,
             operation: 'write',
         });
     }
 }
-exports.writeUtimes = writeUtimes;
 async function skipExisting(filepath, overwrite = false) {
     if (overwrite) {
         return false;
     }
-    if (await fs_extra_1.default.pathExists(filepath)) {
+    if (await fs.pathExists(filepath)) {
         return true;
     }
     return false;
@@ -146,21 +133,21 @@ async function fetchAndWriteFileStream(accountId, srcPath, filepath, cmsPublishM
         return;
     }
     if (await skipExisting(filepath, options.overwrite)) {
-        logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.skippedExisting`, { filepath }));
+        logger.log(i18n(`${i18nKey}.skippedExisting`, { filepath }));
         return;
     }
-    if (!(0, path_2.isAllowedExtension)(srcPath, Array.from(extensions_1.JSR_ALLOWED_EXTENSIONS))) {
-        throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.invalidFileType`, { srcPath }));
+    if (!isAllowedExtension(srcPath, Array.from(JSR_ALLOWED_EXTENSIONS))) {
+        throw new Error(i18n(`${i18nKey}.errors.invalidFileType`, { srcPath }));
     }
-    const node = await (0, fileMapper_1.fetchFileStream)(accountId, srcPath, filepath, getFileMapperQueryValues(cmsPublishMode, options));
+    const node = await fetchFileStream(accountId, srcPath, filepath, getFileMapperQueryValues(cmsPublishMode, options));
     await writeUtimes(accountId, filepath, node);
 }
 // Writes an individual file or folder (not recursive).  If file source is missing, the
 //file is fetched.
 async function writeFileMapperNode(accountId, filepath, node, cmsPublishMode, options = {}) {
-    const localFilepath = (0, path_2.convertToLocalFileSystemPath)(path_1.default.resolve(filepath));
+    const localFilepath = convertToLocalFileSystemPath(path.resolve(filepath));
     if (await skipExisting(localFilepath, options.overwrite)) {
-        logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.skippedExisting`, {
+        logger.log(i18n(`${i18nKey}.skippedExisting`, {
             filepath: localFilepath,
         }));
         return true;
@@ -169,19 +156,20 @@ async function writeFileMapperNode(accountId, filepath, node, cmsPublishMode, op
         try {
             await fetchAndWriteFileStream(accountId, node.path, localFilepath, cmsPublishMode, options);
             return true;
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
         }
         catch (err) {
             return false;
         }
     }
     try {
-        await fs_extra_1.default.ensureDir(localFilepath);
-        logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.wroteFolder`, {
+        await fs.ensureDir(localFilepath);
+        logger.log(i18n(`${i18nKey}.wroteFolder`, {
             filepath: localFilepath,
         }));
     }
     catch (err) {
-        throw new FileSystemError_1.FileSystemError({ cause: err }, {
+        throw new FileSystemError({ cause: err }, {
             filepath: localFilepath,
             accountId,
             operation: 'write',
@@ -192,31 +180,31 @@ async function writeFileMapperNode(accountId, filepath, node, cmsPublishMode, op
 async function downloadFile(accountId, src, destPath, cmsPublishMode, options = {}) {
     const { isFile, isHubspot } = getTypeDataFromPath(src);
     if (!isFile) {
-        throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.invalidRequest`, { src }));
+        throw new Error(i18n(`${i18nKey}.errors.invalidRequest`, { src }));
     }
     try {
-        const dest = path_1.default.resolve(destPath);
-        const cwd = (0, path_2.getCwd)();
+        const dest = path.resolve(destPath);
+        const cwd = getCwd();
         let filepath;
         if (dest === cwd) {
             // Dest: CWD
-            filepath = path_1.default.resolve(cwd, path_1.default.basename(src));
+            filepath = path.resolve(cwd, path.basename(src));
         }
         else if (isPathToFile(dest)) {
             // Dest: file path
-            filepath = path_1.default.isAbsolute(dest) ? dest : path_1.default.resolve(cwd, dest);
+            filepath = path.isAbsolute(dest) ? dest : path.resolve(cwd, dest);
         }
         else {
             // Dest: folder path
-            const name = path_1.default.basename(src);
-            filepath = path_1.default.isAbsolute(dest)
-                ? path_1.default.resolve(dest, name)
-                : path_1.default.resolve(cwd, dest, name);
+            const name = path.basename(src);
+            filepath = path.isAbsolute(dest)
+                ? path.resolve(dest, name)
+                : path.resolve(cwd, dest, name);
         }
-        const localFsPath = (0, path_2.convertToLocalFileSystemPath)(filepath);
+        const localFsPath = convertToLocalFileSystemPath(filepath);
         await fetchAndWriteFileStream(accountId, src, localFsPath, cmsPublishMode, options);
         await queue.onIdle();
-        logger_1.logger.success((0, lang_1.i18n)(`${i18nKey}.completedFetch`, {
+        logger.success(i18n(`${i18nKey}.completedFetch`, {
             src,
             version: getAssetVersionIdentifier(options.assetVersion, src),
             dest,
@@ -224,39 +212,38 @@ async function downloadFile(accountId, src, destPath, cmsPublishMode, options =
     }
     catch (err) {
         const error = err;
-        if (isHubspot && (0, errors_1.isTimeoutError)(error)) {
-            throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.assetTimeout`), { cause: error });
+        if (isHubspot && isTimeoutError(error)) {
+            throw new Error(i18n(`${i18nKey}.errors.assetTimeout`), { cause: error });
         }
         else {
-            throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.failedToFetchFile`, { src, dest: destPath }), { cause: error });
+            throw new Error(i18n(`${i18nKey}.errors.failedToFetchFile`, { src, dest: destPath }), { cause: error });
         }
     }
 }
-async function fetchFolderFromApi(accountId, src, cmsPublishMode, options = {}) {
+export async function fetchFolderFromApi(accountId, src, cmsPublishMode, options = {}) {
     const { isRoot, isFolder, isHubspot } = getTypeDataFromPath(src);
     if (!isFolder) {
-        throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.invalidFetchFolderRequest`, {
+        throw new Error(i18n(`${i18nKey}.errors.invalidFetchFolderRequest`, {
             src,
         }));
     }
     const srcPath = isRoot ? '@root' : src;
     const queryValues = getFileMapperQueryValues(cmsPublishMode, options);
     const { data: node } = isHubspot
-        ? await (0, fileMapper_1.downloadDefault)(accountId, srcPath, queryValues)
-        : await (0, fileMapper_1.download)(accountId, srcPath, queryValues);
-    logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.folderFetch`, { src, accountId }));
+        ? await downloadDefault(accountId, srcPath, queryValues)
+        : await download(accountId, srcPath, queryValues);
+    logger.log(i18n(`${i18nKey}.folderFetch`, { src, accountId }));
     return node;
 }
-exports.fetchFolderFromApi = fetchFolderFromApi;
 async function downloadFolder(accountId, src, destPath, cmsPublishMode, options = {}) {
     try {
         const node = await fetchFolderFromApi(accountId, src, cmsPublishMode, options);
         if (!node) {
             return;
         }
-        const dest = path_1.default.resolve(destPath);
-        const rootPath = dest === (0, path_2.getCwd)()
-            ? (0, path_2.convertToLocalFileSystemPath)(path_1.default.resolve(dest, node.name))
+        const dest = path.resolve(destPath);
+        const rootPath = dest === getCwd()
+            ? convertToLocalFileSystemPath(path.resolve(dest, node.name))
             : dest;
         let success = true;
         recurseFolder(node, (childNode, filepath) => {
@@ -264,7 +251,7 @@ async function downloadFolder(accountId, src, destPath, cmsPublishMode, options
                 const succeeded = await writeFileMapperNode(accountId, filepath || '', childNode, cmsPublishMode, options);
                 if (succeeded === false) {
                     success = false;
-                    logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.errors.failedToFetchFile`, {
+                    logger.debug(i18n(`${i18nKey}.errors.failedToFetchFile`, {
                         src: childNode.path,
                         dest: filepath || '',
                     }));
@@ -274,7 +261,7 @@ async function downloadFolder(accountId, src, destPath, cmsPublishMode, options
         }, rootPath);
         await queue.onIdle();
         if (success) {
-            logger_1.logger.success((0, lang_1.i18n)(`${i18nKey}.completedFolderFetch`, {
+            logger.success(i18n(`${i18nKey}.completedFolderFetch`, {
                 src,
                 version: getAssetVersionIdentifier(options.assetVersion, src),
                 dest,
@@ -282,16 +269,16 @@ async function downloadFolder(accountId, src, destPath, cmsPublishMode, options
         }
         else {
             // TODO: Fix this exception. It is triggering the catch block so this error is being rewritten
-            throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.incompleteFetch`, { src }));
+            throw new Error(i18n(`${i18nKey}.errors.incompleteFetch`, { src }));
         }
     }
     catch (err) {
         const error = err;
-        if ((0, errors_1.isTimeoutError)(error)) {
-            throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.assetTimeout`), { cause: error });
+        if (isTimeoutError(error)) {
+            throw new Error(i18n(`${i18nKey}.errors.assetTimeout`), { cause: error });
         }
         else {
-            throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.failedToFetchFolder`, { src, dest: destPath }), { cause: err });
+            throw new Error(i18n(`${i18nKey}.errors.failedToFetchFolder`, { src, dest: destPath }), { cause: err });
         }
     }
 }
@@ -302,7 +289,7 @@ async function downloadFolder(accountId, src, destPath, cmsPublishMode, options
  * @param {FileMapperInputArguments} input
  * @returns {Promise}
  */
-async function downloadFileOrFolder(accountId, src, dest, cmsPublishMode, options = {}) {
+export async function downloadFileOrFolder(accountId, src, dest, cmsPublishMode, options = {}) {
     if (!src) {
         return;
     }
@@ -314,4 +301,3 @@ async function downloadFileOrFolder(accountId, src, dest, cmsPublishMode, option
         await downloadFolder(accountId, src, dest, cmsPublishMode, options);
     }
 }
-exports.downloadFileOrFolder = downloadFileOrFolder;

package/lib/fs.d.ts

@@ -1,4 +1,4 @@
-import { FileData } from '../types/Files';
+import { FileData } from '../types/Files.js';
 export declare function getFileInfoAsync(dir: string, file: string): Promise<FileData>;
 export declare function flattenAndRemoveSymlinks(filesData: Array<FileData>): Array<string>;
 export declare function walk(dir: string, ignoreDirs?: string[]): Promise<Array<string>>;