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

package/lib/archive.js

@@ -1,97 +1,68 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractZipArchive = void 0;
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const path_1 = __importStar(require("path"));
-const os_1 = require("os");
-const extract_zip_1 = __importDefault(require("extract-zip"));
-const logger_1 = require("./logger");
-const lang_1 = require("../utils/lang");
-const FileSystemError_1 = require("../models/FileSystemError");
-const fs_1 = require("./fs");
+import fs from 'fs-extra';
+import path, { join } from 'path';
+import { tmpdir } from 'os';
+import extract from 'extract-zip';
+import { logger } from './logger.js';
+import { i18n } from '../utils/lang.js';
+import { FileSystemError } from '../models/FileSystemError.js';
+import { walk } from './fs.js';
 const i18nKey = 'lib.archive';
 async function extractZip(name, zip, hideLogs = false) {
     const result = { extractDir: '', tmpDir: '' };
     const TMP_FOLDER_PREFIX = `hubspot-temp-${name}-`;
     if (!hideLogs) {
-        logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.extractZip.init`));
+        logger.log(i18n(`${i18nKey}.extractZip.init`));
     }
     // Write zip to disk
     let tmpZipPath = '';
     try {
-        result.tmpDir = await fs_extra_1.default.mkdtemp((0, path_1.join)((0, os_1.tmpdir)(), TMP_FOLDER_PREFIX));
-        tmpZipPath = (0, path_1.join)(result.tmpDir, 'hubspot-temp.zip');
-        await fs_extra_1.default.ensureFile(tmpZipPath);
-        await fs_extra_1.default.writeFile(tmpZipPath, zip, {
+        result.tmpDir = await fs.mkdtemp(join(tmpdir(), TMP_FOLDER_PREFIX));
+        tmpZipPath = join(result.tmpDir, 'hubspot-temp.zip');
+        await fs.ensureFile(tmpZipPath);
+        await fs.writeFile(tmpZipPath, zip, {
             mode: 0o777,
         });
     }
     catch (err) {
         if (tmpZipPath || result.tmpDir) {
-            throw new FileSystemError_1.FileSystemError({ cause: err }, {
+            throw new FileSystemError({ cause: err }, {
                 filepath: tmpZipPath || result.tmpDir,
                 operation: 'write',
             });
         }
         else {
-            throw new Error((0, lang_1.i18n)(`${i18nKey}.extractZip.errors.write`), {
+            throw new Error(i18n(`${i18nKey}.extractZip.errors.write`), {
                 cause: err,
             });
         }
     }
     // Extract zip
     try {
-        const tmpExtractPath = (0, path_1.join)(result.tmpDir, 'extracted');
-        await (0, extract_zip_1.default)(tmpZipPath, { dir: tmpExtractPath });
+        const tmpExtractPath = join(result.tmpDir, 'extracted');
+        await extract(tmpZipPath, { dir: tmpExtractPath });
         result.extractDir = tmpExtractPath;
     }
     catch (err) {
-        throw new Error((0, lang_1.i18n)(`${i18nKey}.extractZip.errors.extract`), {
+        throw new Error(i18n(`${i18nKey}.extractZip.errors.extract`), {
             cause: err,
         });
     }
-    logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.extractZip.success`));
+    logger.debug(i18n(`${i18nKey}.extractZip.success`));
     return result;
 }
 async function copySourceToDest(src, dest, { sourceDir, includesRootDir = true, hideLogs = false, handleCollision, } = {}) {
     try {
         if (!hideLogs) {
-            logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.copySourceToDest.init`));
+            logger.log(i18n(`${i18nKey}.copySourceToDest.init`));
         }
         const srcDirPath = [src];
         if (includesRootDir) {
-            const files = await fs_extra_1.default.readdir(src);
+            const files = await fs.readdir(src);
             const rootDir = files[0];
             if (!rootDir) {
-                logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.copySourceToDest.sourceEmpty`));
+                logger.debug(i18n(`${i18nKey}.copySourceToDest.sourceEmpty`));
                 // Create the dest path if it doesn't already exist
-                await fs_extra_1.default.ensureDir(dest);
+                await fs.ensureDir(dest);
                 // No root found so nothing to copy
                 return true;
             }
@@ -102,19 +73,19 @@ async function copySourceToDest(src, dest, { sourceDir, includesRootDir = true,
             sourceDirs.push(...(Array.isArray(sourceDir) ? new Set(sourceDir) : [sourceDir]));
         }
         if (sourceDirs.length === 0) {
-            const projectSrcDir = (0, path_1.join)(...srcDirPath);
-            await fs_extra_1.default.copy(projectSrcDir, dest);
+            const projectSrcDir = join(...srcDirPath);
+            await fs.copy(projectSrcDir, dest);
         }
         else {
             for (let i = 0; i < sourceDirs.length; i++) {
-                const projectSrcDir = (0, path_1.join)(...srcDirPath, sourceDirs[i]);
+                const projectSrcDir = join(...srcDirPath, sourceDirs[i]);
                 let collisions = [];
                 let filesWithoutCollisions = [];
-                if (fs_extra_1.default.existsSync(dest) &&
+                if (fs.existsSync(dest) &&
                     handleCollision &&
                     typeof handleCollision === 'function') {
-                    const existingFiles = (await (0, fs_1.walk)(dest, ['node_modules'])).map(file => path_1.default.normalize(path_1.default.relative(dest, file)));
-                    const newFiles = (await (0, fs_1.walk)(projectSrcDir, ['node_modules'])).map(file => path_1.default.relative(projectSrcDir, file));
+                    const existingFiles = (await walk(dest, ['node_modules'])).map(file => path.normalize(path.relative(dest, file)));
+                    const newFiles = (await walk(projectSrcDir, ['node_modules'])).map(file => path.relative(projectSrcDir, file));
                     // Find files that exist in the same positions in both directories
                     collisions = existingFiles.filter(currentFile => newFiles.includes(currentFile));
                     filesWithoutCollisions = newFiles.filter(currentFile => !collisions.includes(currentFile));
@@ -127,19 +98,19 @@ async function copySourceToDest(src, dest, { sourceDir, includesRootDir = true,
                         src: projectSrcDir,
                         collisions,
                     });
-                    await Promise.all(filesWithoutCollisions.map(currentFile => fs_extra_1.default.copy(path_1.default.join(projectSrcDir, currentFile), path_1.default.join(dest, currentFile))));
+                    await Promise.all(filesWithoutCollisions.map(currentFile => fs.copy(path.join(projectSrcDir, currentFile), path.join(dest, currentFile))));
                 }
                 else {
-                    await fs_extra_1.default.copy(projectSrcDir, dest);
+                    await fs.copy(projectSrcDir, dest);
                 }
             }
         }
-        logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.copySourceToDest.success`));
+        logger.debug(i18n(`${i18nKey}.copySourceToDest.success`));
         return true;
     }
     catch (err) {
-        logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.copySourceToDest.error`, { dest }));
-        throw new FileSystemError_1.FileSystemError({ cause: err }, {
+        logger.debug(i18n(`${i18nKey}.copySourceToDest.error`, { dest }));
+        throw new FileSystemError({ cause: err }, {
             filepath: dest,
             operation: 'write',
         });
@@ -149,13 +120,13 @@ async function cleanupTempDir(tmpDir) {
     if (!tmpDir)
         return;
     try {
-        await fs_extra_1.default.remove(tmpDir);
+        await fs.remove(tmpDir);
     }
     catch (e) {
-        logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.cleanupTempDir.error`, { tmpDir }));
+        logger.debug(i18n(`${i18nKey}.cleanupTempDir.error`, { tmpDir }));
     }
 }
-async function extractZipArchive(zip, name, dest, { sourceDir, includesRootDir, hideLogs, handleCollision, } = {}) {
+export async function extractZipArchive(zip, name, dest, { sourceDir, includesRootDir, hideLogs, handleCollision, } = {}) {
     let success = false;
     if (zip) {
         const { extractDir, tmpDir } = await extractZip(name, zip, hideLogs);
@@ -171,4 +142,3 @@ async function extractZipArchive(zip, name, dest, { sourceDir, includesRootDir,
     }
     return success;
 }
-exports.extractZipArchive = extractZipArchive;

package/lib/cms/functions.d.ts

@@ -1,4 +1,4 @@
-import { FunctionConfig, FunctionConfigInfo, FunctionInfo, FunctionOptions } from '../../types/Functions';
+import { FunctionConfig, FunctionConfigInfo, FunctionInfo, FunctionOptions } from '../../types/Functions.js';
 export declare function isObjectOrFunction(value: object): boolean;
 export declare function createEndpoint(endpointMethod: string, filename: string): {
     method: string;

package/lib/cms/functions.js

@@ -1,31 +1,23 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createFunction = exports.createConfig = exports.createEndpoint = exports.isObjectOrFunction = void 0;
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const path_1 = __importDefault(require("path"));
-const findup_sync_1 = __importDefault(require("findup-sync"));
-const path_2 = require("../path");
-const github_1 = require("../github");
-const logger_1 = require("../logger");
-const lang_1 = require("../../utils/lang");
-const FileSystemError_1 = require("../../models/FileSystemError");
+import fs from 'fs-extra';
+import path from 'path';
+import findup from 'findup-sync';
+import { getCwd } from '../path.js';
+import { fetchFileFromRepository } from '../github.js';
+import { logger } from '../logger.js';
+import { i18n } from '../../utils/lang.js';
+import { FileSystemError } from '../../models/FileSystemError.js';
 const i18nKey = 'lib.cms.functions';
-function isObjectOrFunction(value) {
+export function isObjectOrFunction(value) {
     const type = typeof value;
     return value != null && (type === 'object' || type === 'function');
 }
-exports.isObjectOrFunction = isObjectOrFunction;
-function createEndpoint(endpointMethod, filename) {
+export function createEndpoint(endpointMethod, filename) {
     return {
         method: endpointMethod || 'GET',
         file: filename,
     };
 }
-exports.createEndpoint = createEndpoint;
-function createConfig({ endpointPath, endpointMethod, functionFile, }) {
+export function createConfig({ endpointPath, endpointMethod, functionFile, }) {
     return {
         runtime: 'nodejs18.x',
         version: '1.0',
@@ -36,21 +28,20 @@ function createConfig({ endpointPath, endpointMethod, functionFile, }) {
         },
     };
 }
-exports.createConfig = createConfig;
 function writeConfig(configFilePath, config) {
     const configJson = JSON.stringify(config, null, '  ');
-    fs_extra_1.default.writeFileSync(configFilePath, configJson);
+    fs.writeFileSync(configFilePath, configJson);
 }
 function updateExistingConfig(configFilePath, { endpointPath, endpointMethod, functionFile }) {
     let configString;
     try {
-        configString = fs_extra_1.default.readFileSync(configFilePath).toString();
+        configString = fs.readFileSync(configFilePath).toString();
     }
     catch (err) {
-        logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.updateExistingConfig.unableToReadFile`, {
+        logger.debug(i18n(`${i18nKey}.updateExistingConfig.unableToReadFile`, {
             configFilePath,
         }));
-        throw new FileSystemError_1.FileSystemError({ cause: err }, {
+        throw new FileSystemError({ cause: err }, {
             filepath: configFilePath,
             operation: 'read',
         });
@@ -60,22 +51,22 @@ function updateExistingConfig(configFilePath, { endpointPath, endpointMethod, fu
         config = JSON.parse(configString);
     }
     catch (err) {
-        logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.updateExistingConfig.invalidJSON`, {
+        logger.debug(i18n(`${i18nKey}.updateExistingConfig.invalidJSON`, {
             configFilePath,
         }));
-        throw new FileSystemError_1.FileSystemError({ cause: err }, {
+        throw new FileSystemError({ cause: err }, {
             filepath: configFilePath,
             operation: 'read',
         });
     }
     if (!isObjectOrFunction(config)) {
-        throw new Error((0, lang_1.i18n)(`${i18nKey}.updateExistingConfig.errors.configIsNotObjectError`, {
+        throw new Error(i18n(`${i18nKey}.updateExistingConfig.errors.configIsNotObjectError`, {
             configFilePath,
         }));
     }
     if (config.endpoints) {
         if (config.endpoints[endpointPath]) {
-            throw new Error((0, lang_1.i18n)(`${i18nKey}.updateExistingConfig.errors.endpointAreadyExistsError`, {
+            throw new Error(i18n(`${i18nKey}.updateExistingConfig.errors.endpointAreadyExistsError`, {
                 configFilePath,
                 endpointPath,
             }));
@@ -93,65 +84,65 @@ function updateExistingConfig(configFilePath, { endpointPath, endpointMethod, fu
         writeConfig(configFilePath, config);
     }
     catch (err) {
-        logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.updateExistingConfig.couldNotUpdateFile`, {
+        logger.debug(i18n(`${i18nKey}.updateExistingConfig.couldNotUpdateFile`, {
             configFilePath,
         }));
-        throw new FileSystemError_1.FileSystemError({ cause: err }, {
+        throw new FileSystemError({ cause: err }, {
             filepath: configFilePath,
             operation: 'read',
         });
     }
 }
-async function createFunction(functionInfo, dest, options = {}) {
+export async function createFunction(functionInfo, dest, options = {}) {
     const { functionsFolder, filename, endpointPath, endpointMethod } = functionInfo;
     const allowExistingFile = options.allowExistingFile || false;
-    const ancestorFunctionsConfig = (0, findup_sync_1.default)('serverless.json', {
-        cwd: (0, path_2.getCwd)(),
+    const ancestorFunctionsConfig = findup('serverless.json', {
+        cwd: getCwd(),
         nocase: true,
     });
     if (ancestorFunctionsConfig) {
-        throw new Error((0, lang_1.i18n)(`${i18nKey}.createFunction.errors.nestedConfigError`, {
-            ancestorConfigPath: path_1.default.dirname(ancestorFunctionsConfig),
+        throw new Error(i18n(`${i18nKey}.createFunction.errors.nestedConfigError`, {
+            ancestorConfigPath: path.dirname(ancestorFunctionsConfig),
         }));
     }
     const folderName = functionsFolder.endsWith('.functions')
         ? functionsFolder
         : `${functionsFolder}.functions`;
     const functionFile = filename.endsWith('.js') ? filename : `${filename}.js`;
-    const destPath = path_1.default.join(dest, folderName);
-    if (fs_extra_1.default.existsSync(destPath)) {
-        logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.createFunction.destPathAlreadyExists`, {
+    const destPath = path.join(dest, folderName);
+    if (fs.existsSync(destPath)) {
+        logger.log(i18n(`${i18nKey}.createFunction.destPathAlreadyExists`, {
             path: destPath,
         }));
     }
     else {
-        fs_extra_1.default.mkdirp(destPath);
-        logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.createFunction.createdDest`, {
+        fs.mkdirp(destPath);
+        logger.log(i18n(`${i18nKey}.createFunction.createdDest`, {
             path: destPath,
         }));
     }
-    const functionFilePath = path_1.default.join(destPath, functionFile);
-    const configFilePath = path_1.default.join(destPath, 'serverless.json');
-    if (!allowExistingFile && fs_extra_1.default.existsSync(functionFilePath)) {
-        throw new Error((0, lang_1.i18n)(`${i18nKey}.createFunction.errors.jsFileConflictError`, {
+    const functionFilePath = path.join(destPath, functionFile);
+    const configFilePath = path.join(destPath, 'serverless.json');
+    if (!allowExistingFile && fs.existsSync(functionFilePath)) {
+        throw new Error(i18n(`${i18nKey}.createFunction.errors.jsFileConflictError`, {
             functionFilePath,
         }));
     }
-    const result = await (0, github_1.fetchFileFromRepository)('HubSpot/cms-sample-assets', 'functions/sample-function.js', 'main');
-    fs_extra_1.default.writeFileSync(functionFilePath, result);
-    logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.createFunction.createdFunctionFile`, {
+    const result = await fetchFileFromRepository('HubSpot/cms-sample-assets', 'functions/sample-function.js', 'main');
+    fs.writeFileSync(functionFilePath, result);
+    logger.log(i18n(`${i18nKey}.createFunction.createdFunctionFile`, {
         path: functionFilePath,
     }));
-    if (fs_extra_1.default.existsSync(configFilePath)) {
+    if (fs.existsSync(configFilePath)) {
         updateExistingConfig(configFilePath, {
             endpointPath,
             endpointMethod,
             functionFile,
         });
-        logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.createFunction.createdFunctionFile`, {
+        logger.log(i18n(`${i18nKey}.createFunction.createdFunctionFile`, {
             path: functionFilePath,
         }));
-        logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.createFunction.success`, {
+        logger.log(i18n(`${i18nKey}.createFunction.success`, {
             endpointPath: endpointPath,
             folderName,
         }));
@@ -162,21 +153,20 @@ async function createFunction(functionInfo, dest, options = {}) {
             writeConfig(configFilePath, config);
         }
         catch (err) {
-            logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.createFunction.failedToCreateFile`, {
+            logger.debug(i18n(`${i18nKey}.createFunction.failedToCreateFile`, {
                 configFilePath,
             }));
-            throw new FileSystemError_1.FileSystemError({ cause: err }, {
+            throw new FileSystemError({ cause: err }, {
                 filepath: configFilePath,
                 operation: 'write',
             });
         }
-        logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.createFunction.createdConfigFile`, {
+        logger.log(i18n(`${i18nKey}.createFunction.createdConfigFile`, {
             path: configFilePath,
         }));
-        logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.createFunction.success`, {
+        logger.log(i18n(`${i18nKey}.createFunction.success`, {
             endpointPath: endpointPath,
             folderName,
         }));
     }
 }
-exports.createFunction = createFunction;

package/lib/cms/handleFieldsJS.js

@@ -1,19 +1,15 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.cleanupTmpDirSync = exports.createTmpDirSync = exports.isConvertableFieldJs = exports.FieldsJs = void 0;
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const os_1 = __importDefault(require("os"));
-const path_1 = __importDefault(require("path"));
-const child_process_1 = require("child_process");
-const escapeRegExp_1 = require("../escapeRegExp");
-const modules_1 = require("../../utils/cms/modules");
-const logger_1 = require("../logger");
-const lang_1 = require("../../utils/lang");
+import fs from 'fs-extra';
+import os from 'os';
+import path from 'path';
+import { fork } from 'child_process';
+import { fileURLToPath } from 'url';
+import { escapeRegExp } from '../escapeRegExp.js';
+import { isModuleFolderChild } from '../../utils/cms/modules.js';
+import { logger } from '../logger.js';
+import { i18n } from '../../utils/lang.js';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const i18nKey = 'lib.cms.handleFieldsJs';
-class FieldsJs {
+export class FieldsJs {
     projectDir;
     filePath;
     rootWriteDir;
@@ -40,12 +36,12 @@ class FieldsJs {
     // Converts a fields.js file into a fields.json file, writes, and returns of fields.json
     convertFieldsJs(writeDir) {
         const filePath = this.filePath;
-        const dirName = path_1.default.dirname(filePath);
+        const dirName = path.dirname(filePath);
         return new Promise((resolve, reject) => {
             const fieldOptionsAsString = Array.isArray(this.fieldOptions)
                 ? this.fieldOptions.join(',')
                 : this.fieldOptions;
-            const convertFieldsProcess = (0, child_process_1.fork)(path_1.default.join(__dirname, './processFieldsJs.js'), [], {
+            const convertFieldsProcess = fork(path.join(__dirname, './processFieldsJs.js'), [], {
                 cwd: dirName,
                 env: {
                     dirName,
@@ -54,7 +50,7 @@ class FieldsJs {
                     writeDir,
                 },
             });
-            logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.convertFieldsJs.creating`, {
+            logger.debug(i18n(`${i18nKey}.convertFieldsJs.creating`, {
                 pid: convertFieldsProcess.pid || '',
             }));
             convertFieldsProcess.on('message', function (message) {
@@ -66,12 +62,12 @@ class FieldsJs {
                 }
             });
             convertFieldsProcess.on('close', () => {
-                logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.convertFieldsJs.terminating`, {
+                logger.debug(i18n(`${i18nKey}.convertFieldsJs.terminating`, {
                     pid: convertFieldsProcess.pid || '',
                 }));
             });
         }).catch((e) => {
-            throw new Error((0, lang_1.i18n)(`${i18nKey}.convertFieldsJs.errors.errorConverting`, { filePath }), { cause: e });
+            throw new Error(i18n(`${i18nKey}.convertFieldsJs.errors.errorConverting`, { filePath }), { cause: e });
         });
     }
     /**
@@ -80,18 +76,18 @@ class FieldsJs {
      * Ex: path/to/tmp/example.module/fields.json => path/to/project/example.module/fields.output.json
      */
     saveOutput() {
-        if (!this.outputPath || !fs_extra_1.default.existsSync(this.outputPath)) {
-            throw new Error((0, lang_1.i18n)(`${i18nKey}.saveOutput.errors.saveFailed`, {
+        if (!this.outputPath || !fs.existsSync(this.outputPath)) {
+            throw new Error(i18n(`${i18nKey}.saveOutput.errors.saveFailed`, {
                 path: this.filePath,
             }));
         }
-        const relativePath = path_1.default.relative(this.rootWriteDir, path_1.default.dirname(this.outputPath));
-        const savePath = path_1.default.join(this.projectDir, relativePath, 'fields.output.json');
+        const relativePath = path.relative(this.rootWriteDir, path.dirname(this.outputPath));
+        const savePath = path.join(this.projectDir, relativePath, 'fields.output.json');
         try {
-            fs_extra_1.default.copyFileSync(this.outputPath, savePath);
+            fs.copyFileSync(this.outputPath, savePath);
         }
         catch (err) {
-            throw new Error((0, lang_1.i18n)(`${i18nKey}.saveOutput.errors.saveFailed`, { path: savePath }), { cause: err });
+            throw new Error(i18n(`${i18nKey}.saveOutput.errors.saveFailed`, { path: savePath }), { cause: err });
         }
     }
     /**
@@ -101,51 +97,47 @@ class FieldsJs {
      * Ex: If rootWriteDir = 'path/to/temp', filePath = 'projectRoot/sample.module/fields.js'. Then getWriteDir() => path/to/temp/sample.module
      */
     getWriteDir() {
-        const projectDirRegex = new RegExp(`^${(0, escapeRegExp_1.escapeRegExp)(this.projectDir)}`);
+        const projectDirRegex = new RegExp(`^${escapeRegExp(this.projectDir)}`);
         const relativePath = this.filePath.replace(projectDirRegex, '');
-        return path_1.default.dirname(path_1.default.join(this.rootWriteDir, relativePath));
+        return path.dirname(path.join(this.rootWriteDir, relativePath));
     }
     getOutputPathPromise() {
         const writeDir = this.getWriteDir();
         return this.convertFieldsJs(writeDir).then(outputPath => outputPath);
     }
 }
-exports.FieldsJs = FieldsJs;
 /**
  * Determines if file is a convertable fields.js file i.e., if it is called
  * 'fields.js' and in a root or in a module folder, and if convertFields flag is true.
  */
-function isConvertableFieldJs(rootDir, filePath, convertFields = false) {
+export function isConvertableFieldJs(rootDir, filePath, convertFields = false) {
     const allowedFieldsNames = ['fields.js', 'fields.mjs', 'fields.cjs'];
-    const regex = new RegExp(`^${(0, escapeRegExp_1.escapeRegExp)(rootDir)}`);
-    const relativePath = path_1.default.dirname(filePath.replace(regex, ''));
-    const baseName = path_1.default.basename(filePath);
-    const inModuleFolder = (0, modules_1.isModuleFolderChild)({ path: filePath, isLocal: true });
+    const regex = new RegExp(`^${escapeRegExp(rootDir)}`);
+    const relativePath = path.dirname(filePath.replace(regex, ''));
+    const baseName = path.basename(filePath);
+    const inModuleFolder = isModuleFolderChild({ path: filePath, isLocal: true });
     return !!(convertFields &&
         allowedFieldsNames.includes(baseName) &&
-        (inModuleFolder || relativePath == path_1.default.sep));
+        (inModuleFolder || relativePath == path.sep));
 }
-exports.isConvertableFieldJs = isConvertableFieldJs;
 // Try creating tempdir
-function createTmpDirSync(prefix) {
+export function createTmpDirSync(prefix) {
     let tmpDir;
     try {
-        tmpDir = fs_extra_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), prefix));
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
     }
     catch (err) {
-        throw new Error((0, lang_1.i18n)(`${i18nKey}.createTmpDirSync.errors.writeFailed`), {
+        throw new Error(i18n(`${i18nKey}.createTmpDirSync.errors.writeFailed`), {
             cause: err,
         });
     }
     return tmpDir;
 }
-exports.createTmpDirSync = createTmpDirSync;
 // Try cleaning up resources from os's tempdir
-function cleanupTmpDirSync(tmpDir) {
-    fs_extra_1.default.rm(tmpDir, { recursive: true }, err => {
+export function cleanupTmpDirSync(tmpDir) {
+    fs.rm(tmpDir, { recursive: true }, err => {
         if (err) {
-            throw new Error((0, lang_1.i18n)(`${i18nKey}.cleanupTmpDirSync.errors.deleteFailed`), { cause: err });
+            throw new Error(i18n(`${i18nKey}.cleanupTmpDirSync.errors.deleteFailed`), { cause: err });
         }
     });
 }
-exports.cleanupTmpDirSync = cleanupTmpDirSync;

package/lib/cms/modules.d.ts

@@ -1,5 +1,5 @@
-import { PathInput, ValidationResult, ModuleDefinition } from '../../types/Modules';
-import { GithubRepoFile } from '../../types/Github';
+import { PathInput, ValidationResult, ModuleDefinition } from '../../types/Modules.js';
+import { GithubRepoFile } from '../../types/Github.js';
 export declare const ValidationIds: {
     SRC_REQUIRED: string;
     DEST_REQUIRED: string;