@nizza/devkit 0.1.0-alpha.1 → 0.1.0-alpha.10

package/dist/cjs/executors/vtex-link/helpers.cjs

@@ -0,0 +1,206 @@
+'use strict';
+
+var devkit = require('@nx/devkit');
+var child_process = require('child_process');
+var fs = require('fs');
+var path = require('path');
+var util = require('util');
+require('../../shared/logger.cjs');
+var utils$1 = require('../../shared/utils.cjs');
+var utils = require('../shared/utils.cjs');
+var constants = require('./constants.cjs');
+
+const execAsync = util.promisify(child_process.exec);
+const getPkgJsonPath = (vtexProjectPath)=>path.resolve(vtexProjectPath, 'package.json');
+/**
+ * Links the local package to the VTEX environment.
+ *
+ * @param {SharedContext} ctx - The shared context containing paths and configurations.
+ * @returns {Promise<void>} A promise that resolves when the package is linked or rejects on error.
+ */ function vtexLink(ctx) {
+    const { vtexProjectPath } = ctx;
+    return new Promise((resolve, reject)=>{
+        devkit.logger.info('🔗 Linking package to VTEX...');
+        const link = child_process.spawn('vtex', [
+            'link',
+            '-u'
+        ], {
+            cwd: vtexProjectPath,
+            detached: true
+        });
+        link.stdout.on('data', (chunk)=>{
+            const data = chunk.toString('utf8');
+            if (data.includes(constants.ERROR_LINKING_FLAG)) {
+                reject('could not link package in VTEX');
+            }
+            if (data.includes(constants.SUCCESS_LINKING_FLAG)) {
+                link.pid && process.kill(-link.pid);
+                setTimeout(()=>{
+                    link.kill();
+                    devkit.logger.info('✅ Successfully linked package to VTEX.');
+                }, 200);
+                resolve();
+            }
+            devkit.logger.info(data);
+        });
+        link.on('error', (error)=>reject(error.message));
+    });
+}
+/**
+ * Updates the package.json file within the VTEX project to use the local version of the package.
+ *
+ * @param {SharedContext} ctx - The shared context containing paths and configurations.
+ * @param {string} packageName - The name of the package to link.
+ * @returns {Promise<void>} A promise that resolves when the package.json is updated.
+ */ async function changePackageJsonFromVtexProject(ctx, packageName) {
+    const { vtexProjectPath, projectName, packageOrg } = ctx;
+    const pkgJsonPath = getPkgJsonPath(vtexProjectPath);
+    // Make backup of package.json
+    await fs.promises.copyFile(pkgJsonPath, path.join(vtexProjectPath, 'package.json.nxback'));
+    devkit.logger.info('🔃 Created package.json backup.');
+    // Find and edit value "@${packageOrg}/${projectName}" dependency
+    const packageJson = utils$1.getPkgJson(vtexProjectPath);
+    const newPackageJson = {
+        ...packageJson,
+        dependencies: {
+            ...packageJson.dependencies,
+            [`@${packageOrg}/${projectName}`]: `file:./${packageName}`
+        }
+    };
+    await fs.promises.unlink(pkgJsonPath);
+    await fs.promises.writeFile(pkgJsonPath, JSON.stringify(newPackageJson, null, 2));
+    devkit.logger.info('📝 Updated package.json in VTEX project.');
+}
+/**
+ * Restores the original package.json from the backup created before modifications.
+ *
+ * @param {SharedContext} ctx - The shared context containing paths and configurations.
+ * @returns {Promise<void>} A promise that resolves when the package.json is restored.
+ */ async function restorePackageJsonFromVtexProject(ctx) {
+    const { vtexProjectPath } = ctx;
+    const pkgJsonPath = getPkgJsonPath(vtexProjectPath);
+    const backupFile = path.resolve(vtexProjectPath, 'package.json.nxback');
+    if (!fs.existsSync(backupFile)) return;
+    await fs.promises.unlink(pkgJsonPath);
+    await fs.promises.copyFile(backupFile, pkgJsonPath);
+    await fs.promises.unlink(backupFile);
+    devkit.logger.info('🔄 Restored package.json in VTEX project.');
+}
+/**
+ * Renames the generated package file with a unique identifier.
+ *
+ * @param {SharedContext} ctx - The shared context containing paths and configurations.
+ * @returns {Promise<string>} A promise that resolves with the new name of the package.
+ */ async function renamePackage(ctx) {
+    const { projectRoot, projectName, packageOrg } = ctx;
+    const packageJson = utils$1.getPkgJson('./');
+    const oldName = `${packageOrg}-${projectName}-${packageJson.version}.tgz`;
+    const oldPath = path.join(projectRoot, oldName);
+    const newName = `${packageOrg}-${projectName}-${packageJson.version}-${utils$1.shortId(8)}.tgz`;
+    const newPath = path.join(projectRoot, newName);
+    await fs.promises.rename(oldPath, newPath);
+    devkit.logger.info(`🏷️ New package name: ${newName}`);
+    return newName;
+}
+/**
+ * Creates a pnpm package for uploading to VTEX.
+ *
+ * @param {SharedContext} ctx - The shared context containing paths and configurations.
+ * @returns {Promise<string>} A promise that resolves with the name of the created package.
+ */ async function createPackage(ctx) {
+    const command = 'pnpm pack';
+    const { stderr } = await execAsync(command);
+    if (stderr) devkit.logger.error(stderr);
+    devkit.logger.info('📦 Package generated successfully.');
+    return renamePackage(ctx);
+}
+/**
+ * Searches for and lists all outdated packages in the VTEX project directory.
+ *
+ * @param {SharedContext} ctx - The shared context containing paths and configurations.
+ * @returns {Promise<string[]>} A promise that resolves with a list of deprecated package names.
+ */ async function findLastPackages(ctx) {
+    const { vtexProjectPath, projectName, packageOrg } = ctx;
+    const matchedFiles = [];
+    const files = await fs.promises.readdir(vtexProjectPath);
+    for (const file of files){
+        const regex = new RegExp(`^${packageOrg}-${projectName}-.*$`);
+        if (regex.test(file)) {
+            matchedFiles.push(file);
+            devkit.logger.info(`🔍 Found deprecated package: ${file}`);
+        }
+    }
+    return matchedFiles;
+}
+/**
+ * Removes all outdated packages in the VTEX project directory.
+ *
+ * @param {SharedContext} ctx - The shared context containing paths and configurations.
+ * @returns {Promise<void>} A promise that resolves when the old packages are removed.
+ */ async function removeOldPackages(ctx) {
+    const { vtexProjectPath } = ctx;
+    const files = await findLastPackages(ctx);
+    const toRemove = files.map((x)=>fs.promises.unlink(path.resolve(vtexProjectPath, x)));
+    await Promise.all(toRemove);
+    devkit.logger.info('🗑️ Removed old packages in VTEX project.');
+}
+/**
+ * Moves a package to the VTEX project directory.
+ *
+ * @param {SharedContext} ctx - The shared context containing paths and configurations.
+ * @param {string} packageName - The name of the package to move.
+ * @returns {Promise<void>} A promise that resolves when the package is moved successfully.
+ */ async function movePackage(ctx, packageName) {
+    const { vtexProjectPath } = ctx;
+    await fs.promises.rename(path.resolve(packageName), path.join(vtexProjectPath, packageName));
+    devkit.logger.info(`🚚 Moved package "${packageName}" to VTEX project.`);
+}
+/**
+ * Builds the package, moves it to the VTEX project, and updates the project's package.json.
+ *
+ * @param {SharedContext} ctx - The shared context containing paths and configurations.
+ * @returns {Promise<void>} A promise that resolves when the build is complete.
+ */ async function buildPackage(ctx) {
+    const packageName = await createPackage(ctx);
+    await Promise.all([
+        movePackage(ctx, packageName),
+        changePackageJsonFromVtexProject(ctx, packageName)
+    ]);
+}
+/**
+ * Cleans the VTEX project by removing old packages and restoring the original package.json.
+ *
+ * @param {SharedContext} ctx - The shared context containing paths and configurations.
+ * @returns {Promise<void>} A promise that resolves when the clean-up is complete.
+ */ async function clean(ctx) {
+    await Promise.all([
+        removeOldPackages(ctx),
+        restorePackageJsonFromVtexProject(ctx)
+    ]);
+}
+function validateEnvironment() {
+    if (!constants.VTEX_PROJECT_PATH) throw new Error('The NZ_VTEX_PROJECT environment variable is missing. Set it in the project root in a .env.local file.');
+}
+async function performRollback(sharedContext) {
+    await clean(sharedContext);
+    return utils.ok();
+}
+async function buildAndLink(sharedContext, skipLink = false) {
+    await clean(sharedContext);
+    await buildPackage(sharedContext);
+    if (!skipLink) await vtexLink(sharedContext);
+}
+
+exports.buildAndLink = buildAndLink;
+exports.buildPackage = buildPackage;
+exports.changePackageJsonFromVtexProject = changePackageJsonFromVtexProject;
+exports.clean = clean;
+exports.createPackage = createPackage;
+exports.findLastPackages = findLastPackages;
+exports.movePackage = movePackage;
+exports.performRollback = performRollback;
+exports.removeOldPackages = removeOldPackages;
+exports.renamePackage = renamePackage;
+exports.restorePackageJsonFromVtexProject = restorePackageJsonFromVtexProject;
+exports.validateEnvironment = validateEnvironment;
+exports.vtexLink = vtexLink;

package/dist/{src/executors/vtex-link/helpers.d.ts → cjs/executors/vtex-link/helpers.d.cts}

@@ -1,11 +1,11 @@
-import type { SharedContext } from './types';
+import { SharedContext } from "../../types-1282e639.js";
 /**
  * Links the local package to the VTEX environment.
  *
  * @param {SharedContext} ctx - The shared context containing paths and configurations.
  * @returns {Promise<void>} A promise that resolves when the package is linked or rejects on error.
  */
-export declare function vtexLink(ctx: SharedContext): Promise<void>;
+declare function vtexLink(ctx: SharedContext): Promise<void>;
 /**
  * Updates the package.json file within the VTEX project to use the local version of the package.
  *
@@ -13,42 +13,42 @@ export declare function vtexLink(ctx: SharedContext): Promise<void>;
  * @param {string} packageName - The name of the package to link.
  * @returns {Promise<void>} A promise that resolves when the package.json is updated.
  */
-export declare function changePackageJsonFromVtexProject(ctx: SharedContext, packageName: string): Promise<void>;
+declare function changePackageJsonFromVtexProject(ctx: SharedContext, packageName: string): Promise<void>;
 /**
  * Restores the original package.json from the backup created before modifications.
  *
  * @param {SharedContext} ctx - The shared context containing paths and configurations.
  * @returns {Promise<void>} A promise that resolves when the package.json is restored.
  */
-export declare function restorePackageJsonFromVtexProject(ctx: SharedContext): Promise<void>;
+declare function restorePackageJsonFromVtexProject(ctx: SharedContext): Promise<void>;
 /**
  * Renames the generated package file with a unique identifier.
  *
  * @param {SharedContext} ctx - The shared context containing paths and configurations.
  * @returns {Promise<string>} A promise that resolves with the new name of the package.
  */
-export declare function renamePackage(ctx: SharedContext): Promise<string>;
+declare function renamePackage(ctx: SharedContext): Promise<string>;
 /**
  * Creates a pnpm package for uploading to VTEX.
  *
  * @param {SharedContext} ctx - The shared context containing paths and configurations.
  * @returns {Promise<string>} A promise that resolves with the name of the created package.
  */
-export declare function createPackage(ctx: SharedContext): Promise<string>;
+declare function createPackage(ctx: SharedContext): Promise<string>;
 /**
  * Searches for and lists all outdated packages in the VTEX project directory.
  *
  * @param {SharedContext} ctx - The shared context containing paths and configurations.
  * @returns {Promise<string[]>} A promise that resolves with a list of deprecated package names.
  */
-export declare function findLastPackages(ctx: SharedContext): Promise<string[]>;
+declare function findLastPackages(ctx: SharedContext): Promise<string[]>;
 /**
  * Removes all outdated packages in the VTEX project directory.
  *
  * @param {SharedContext} ctx - The shared context containing paths and configurations.
  * @returns {Promise<void>} A promise that resolves when the old packages are removed.
  */
-export declare function removeOldPackages(ctx: SharedContext): Promise<void>;
+declare function removeOldPackages(ctx: SharedContext): Promise<void>;
 /**
  * Moves a package to the VTEX project directory.
  *
@@ -56,22 +56,22 @@ export declare function removeOldPackages(ctx: SharedContext): Promise<void>;
  * @param {string} packageName - The name of the package to move.
  * @returns {Promise<void>} A promise that resolves when the package is moved successfully.
  */
-export declare function movePackage(ctx: SharedContext, packageName: string): Promise<void>;
+declare function movePackage(ctx: SharedContext, packageName: string): Promise<void>;
 /**
  * Builds the package, moves it to the VTEX project, and updates the project's package.json.
  *
  * @param {SharedContext} ctx - The shared context containing paths and configurations.
  * @returns {Promise<void>} A promise that resolves when the build is complete.
  */
-export declare function buildPackage(ctx: SharedContext): Promise<void>;
+declare function buildPackage(ctx: SharedContext): Promise<void>;
 /**
  * Cleans the VTEX project by removing old packages and restoring the original package.json.
  *
  * @param {SharedContext} ctx - The shared context containing paths and configurations.
  * @returns {Promise<void>} A promise that resolves when the clean-up is complete.
  */
-export declare function clean(ctx: SharedContext): Promise<void>;
-export declare function validateEnvironment(): void;
-export declare function performRollback(sharedContext: SharedContext): Promise<import("../shared").ExecutorResponse>;
-export declare function buildAndLink(sharedContext: SharedContext, skipLink?: boolean): Promise<void>;
-//# sourceMappingURL=helpers.d.ts.map
+declare function clean(ctx: SharedContext): Promise<void>;
+declare function validateEnvironment(): void;
+declare function performRollback(sharedContext: SharedContext): Promise<import("../../index-f6330edc.js").ExecutorResponse>;
+declare function buildAndLink(sharedContext: SharedContext, skipLink?: boolean): Promise<void>;
+export { vtexLink, changePackageJsonFromVtexProject, restorePackageJsonFromVtexProject, renamePackage, createPackage, findLastPackages, removeOldPackages, movePackage, buildPackage, clean, validateEnvironment, performRollback, buildAndLink };

package/dist/cjs/executors/vtex-link/index.cjs

@@ -0,0 +1,30 @@
+'use strict';
+
+var path = require('path');
+var utils = require('../shared/utils.cjs');
+var helpers = require('./helpers.cjs');
+
+const VTEX_PROJECT_PATH = process.env.NZ_VTEX_PROJECT;
+async function runExecutor(opts, ctx) {
+    try {
+        const { rollback, skipLink, packageOrg } = opts;
+        const projectName = ctx.projectName || '';
+        helpers.validateEnvironment();
+        const projectConfig = utils.getProjectConfig(ctx);
+        const projectRoot = projectConfig.root;
+        const vtexProjectPath = path.resolve(VTEX_PROJECT_PATH, 'react');
+        const sharedContext = {
+            packageOrg,
+            projectRoot,
+            projectName,
+            vtexProjectPath
+        };
+        if (rollback) return await helpers.performRollback(sharedContext);
+        await helpers.buildAndLink(sharedContext, skipLink);
+        return utils.ok();
+    } catch (error) {
+        return utils.err(error);
+    }
+}
+
+module.exports = runExecutor;

package/dist/cjs/executors/vtex-link/index.d.cts

@@ -0,0 +1,5 @@
+import { ExecutorContext } from '@nx/devkit';
+import { ExecutorResponse } from "../../index-f6330edc.js";
+import { ExecutorOptions } from "../../types-1282e639.js";
+declare function runExecutor(opts: ExecutorOptions, ctx: ExecutorContext): Promise<ExecutorResponse>;
+export { runExecutor as default };

package/dist/cjs/index-0ce2daf7.d.ts

@@ -0,0 +1,2 @@
+export * from "./index-3080371d.js";
+export * from "./vite/plugins/shadow-dom-inject-css/index.js";

package/dist/cjs/index-17143e35.d.ts

@@ -0,0 +1,2 @@
+export * from "./shared/logger.js";
+export * from "./shared/utils.js";

package/dist/cjs/index-3080371d.d.ts

@@ -0,0 +1,3 @@
+import { thirdPartyCssInjectPlugin } from "./vite/plugins/third-party-css-inject/main.js";
+export * from "./vite/plugins/third-party-css-inject/main.js";
+export { thirdPartyCssInjectPlugin as default };

package/dist/cjs/index-f6330edc.d.ts

@@ -0,0 +1,2 @@
+export * from "./types-7377dcc9.js";
+export * from "./executors/shared/utils.js";

package/dist/cjs/index.cjs

@@ -0,0 +1,71 @@
+'use strict';
+
+var index = require('./executors/deploy/index.cjs');
+var index$1 = require('./executors/environments/index.cjs');
+var index$2 = require('./executors/publish/index.cjs');
+var index$3 = require('./executors/update-executors-file/index.cjs');
+var index$4 = require('./executors/vtex-link/index.cjs');
+var logger = require('./shared/logger.cjs');
+var utils = require('./shared/utils.cjs');
+var main = require('./vite/config-builder/main.cjs');
+var types = require('./vite/config-builder/shared/types.cjs');
+var helpers = require('./vite/config-builder/shared/utils/helpers.cjs');
+var projectConfig = require('./vite/config-builder/shared/utils/projectConfig.cjs');
+var viteCommand = require('./vite/config-builder/shared/utils/viteCommand.cjs');
+var main$1 = require('./vite/plugins/third-party-css-inject/main.cjs');
+var index$5 = require('./vite/plugins/shadow-dom-inject-css/index.cjs');
+
+
+
+exports.deployExecutor = index;
+exports.environmentsExecutor = index$1;
+exports.publishExecutor = index$2;
+exports.updateExecutorsFileExecutor = index$3;
+exports.vtexLinkExecutor = index$4;
+Object.defineProperty(exports, 'LogLevel', {
+	enumerable: true,
+	get: function () { return logger.LogLevel; }
+});
+Object.defineProperty(exports, 'currentLogLevel', {
+	enumerable: true,
+	get: function () { return logger.currentLogLevel; }
+});
+exports.logger = logger.logger;
+exports.setLogLevel = logger.setLogLevel;
+exports.combineGlobStyles = utils.combineGlobStyles;
+exports.getPkgJson = utils.getPkgJson;
+exports.shortId = utils.shortId;
+exports.createConfigBuilder = main.createConfigBuilder;
+Object.defineProperty(exports, 'Flag', {
+	enumerable: true,
+	get: function () { return types.Flag; }
+});
+Object.defineProperty(exports, 'ProjectType', {
+	enumerable: true,
+	get: function () { return types.ProjectType; }
+});
+Object.defineProperty(exports, 'Stage', {
+	enumerable: true,
+	get: function () { return types.Stage; }
+});
+Object.defineProperty(exports, 'Target', {
+	enumerable: true,
+	get: function () { return types.Target; }
+});
+Object.defineProperty(exports, 'ViteMode', {
+	enumerable: true,
+	get: function () { return types.ViteMode; }
+});
+exports.chunkName = helpers.chunkName;
+exports.deepMerge = helpers.deepMerge;
+exports.getNxTsConfigPaths = helpers.getNxTsConfigPaths;
+exports.getPlugins = helpers.getPlugins;
+exports.when = helpers.when;
+exports.getExternalDependencies = projectConfig.getExternalDependencies;
+exports.getInitials = projectConfig.getInitials;
+exports.initializeConfig = projectConfig.initializeConfig;
+exports.mergeConfigs = projectConfig.mergeConfigs;
+exports.getViteCmdFlags = viteCommand.getViteCmdFlags;
+exports.getViteCommand = viteCommand.getViteCommand;
+exports.thirdPartyCssInjectPlugin = main$1.thirdPartyCssInjectPlugin;
+exports.injectCssIntoShadowDom = index$5.injectCssIntoShadowDom;

package/dist/cjs/index.d.cts

@@ -0,0 +1,10 @@
+export { default as deployExecutor } from "./executors/deploy/index.js";
+export { default as environmentsExecutor } from "./executors/environments/index.js";
+export { default as publishExecutor } from "./executors/publish/index.js";
+export { default as updateExecutorsFileExecutor } from "./executors/update-executors-file/index.js";
+export { default as vtexLinkExecutor } from "./executors/vtex-link/index.js";
+export * from "./index-17143e35.js";
+export * from "./vite/config-builder/main.js";
+export * from "./index-f6330edc.js";
+export * from "./index-0ce2daf7.js";
+//# sourceMappingURL=index.d.cts.map

package/dist/cjs/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","sourceRoot":"","sources":["../../src/index.ts","../../src/executors/index.ts","../../src/vite/config-builder/index.ts","../../src/vite/index.ts"],"names":[],"mappings":";;;;;AACA,oCAAyB"}

package/dist/cjs/scripts/changeset-pre-mode.cjs

@@ -0,0 +1,41 @@
+'use strict';
+
+var devkit = require('@nx/devkit');
+var child_process = require('child_process');
+var promises = require('fs/promises');
+var path = require('path');
+var util = require('util');
+
+const execAsync = util.promisify(child_process.exec);
+const changesetDir = path.resolve('.changeset');
+const preJsonPath = path.resolve(changesetDir, 'pre.json');
+let preJson;
+async function main() {
+    try {
+        const data = await promises.readFile(preJsonPath, 'utf8');
+        preJson = JSON.parse(data);
+    } catch  {
+        preJson = {
+            mode: 'exit'
+        };
+    }
+    // Execute "version" command using @changeset/cli
+    try {
+        const { mode } = preJson;
+        if (mode === 'exit') {
+            const command = `pnpm changeset pre enter beta`;
+            const { stdout, stderr } = await execAsync(command);
+            devkit.logger.info(stdout);
+            devkit.logger.info(stderr);
+            devkit.logger.info(`🚀 Successfully enter prerelease mode`);
+        } else {
+            devkit.logger.info(`🚀 Prerelease mode has been previously entered`);
+        }
+    } catch (error) {
+        devkit.logger.error('❌ An error occurred!');
+        throw error;
+    }
+}
+main();
+
+exports.main = main;

package/dist/cjs/scripts/changeset-pre-mode.d.cts

@@ -0,0 +1,2 @@
+declare function main(): Promise<void>;
+export { main };

package/dist/cjs/scripts/index.cjs

@@ -0,0 +1,7 @@
+'use strict';
+
+var changesetPreMode = require('./changeset-pre-mode.cjs');
+
+
+
+exports.main = changesetPreMode.main;

package/dist/cjs/scripts/index.d.cts

@@ -0,0 +1 @@
+export * from "./changeset-pre-mode.js";

package/dist/cjs/shared/logger.cjs

@@ -0,0 +1,98 @@
+'use strict';
+
+var chalk = require('chalk');
+var R = require('ramda');
+
+exports.LogLevel = void 0;
+(function(LogLevel) {
+    LogLevel[LogLevel["ERROR"] = 0] = "ERROR";
+    LogLevel[LogLevel["WARN"] = 1] = "WARN";
+    LogLevel[LogLevel["INFO"] = 2] = "INFO";
+    LogLevel[LogLevel["DEBUG"] = 3] = "DEBUG";
+})(exports.LogLevel || (exports.LogLevel = {}));
+// Default log level
+exports.currentLogLevel = 2;
+/**
+ * Object mapping log levels to console log functions.
+ *
+ * @constant {Object} logFunctions
+ */ const logFunctions = {
+    [0]: console.error,
+    [1]: console.warn,
+    [2]: console.info,
+    [3]: console.debug
+};
+/**
+ * Object mapping log levels to chalk color functions.
+ *
+ * @constant {Object} colorFunctions
+ */ const colorFunctions = {
+    [0]: chalk.red,
+    [1]: chalk.yellow,
+    [2]: chalk.blue,
+    [3]: chalk.magenta
+};
+const getLogLevelKey = (value)=>{
+    return Object.keys(exports.LogLevel).find((key)=>exports.LogLevel[key] === value);
+};
+/**
+ * Sets the log level for the logger.
+ * Only logs at this level and above will be displayed.
+ *
+ * @param {LogLevel} level - The log level to set.
+ * @example
+ * // Set log level to WARN
+ * setLogLevel(LogLevel.WARN);
+ *
+ * // Now only WARN and ERROR logs will be displayed
+ * logger.debug('Debug message');  // Will not be logged
+ * logger.info('Info message');  // Will not be logged
+ * logger.warn('Warn message');  // Will be logged
+ * logger.error('Error message');  // Will be logged
+ */ const setLogLevel = (level)=>{
+    exports.currentLogLevel = level;
+};
+/**
+ * Takes a list of arguments, stringifies each argument, and joins
+ * them with a newline character.
+ *
+ * @param {any[]} args - The arguments to process.
+ * @returns {string} - The processed string.
+ */ const processArgs = R.pipe(R.map((arg)=>JSON.stringify(arg, null, 2)), R.join('\n'));
+/**
+ * Formats the log message with a timestamp, log level, and any additional variables.
+ *
+ * @param {LogLevel} level - The log level.
+ * @param {string} message - The message to log.
+ * @param {any[]} rest - Any additional variables to log.
+ * @returns {string} - The formatted log message.
+ */ const formatMessage = (level, message, ...rest)=>{
+    const levelKey = getLogLevelKey(level);
+    const timestamp = `${new Date().toLocaleTimeString()}`;
+    const formattedRest = rest.length ? `\n${processArgs(rest)}` : '';
+    return `${timestamp} [${levelKey}] ${message}${formattedRest}`;
+};
+/**
+ * Generates a log function for a specific log level.
+ *
+ * @param {LogLevel} level - The log level.
+ * @returns - The log function.
+ */ const log = (level)=>(message, ...rest)=>{
+        if (level > exports.currentLogLevel) return; // Skip logging if level is below the current log level
+        const pipeline = R.pipe(()=>formatMessage(level, message, ...rest), colorFunctions[level], logFunctions[level]);
+        const errPipeline = R.pipe((err)=>`Failed to log message: ${err.message}`, colorFunctions[0], logFunctions[0]);
+        try {
+            pipeline();
+        } catch (err) {
+            errPipeline(err);
+        }
+    };
+const logger = {
+    error: log(0),
+    warn: log(1),
+    info: log(2),
+    debug: log(3)
+};
+
+exports.logger = logger;
+exports.setLogLevel = setLogLevel;

package/dist/{src/logger.d.ts → cjs/shared/logger.d.cts}

@@ -1,13 +1,13 @@
 /**
  * Enum representing the different log levels.
  */
-export declare enum LogLevel {
+declare enum LogLevel {
     ERROR = 0,
     WARN = 1,
     INFO = 2,
     DEBUG = 3
 }
-export declare let currentLogLevel: LogLevel;
+declare let currentLogLevel: LogLevel;
 /**
  * Sets the log level for the logger.
  * Only logs at this level and above will be displayed.
@@ -23,12 +23,11 @@ export declare let currentLogLevel: LogLevel;
  * logger.warn('Warn message');  // Will be logged
  * logger.error('Error message');  // Will be logged
  */
-export declare const setLogLevel: (level: LogLevel) => void;
-export declare const logger: {
+declare const setLogLevel: (level: LogLevel) => void;
+declare const logger: {
     error: (message: string, ...rest: any[]) => void;
     warn: (message: string, ...rest: any[]) => void;
     info: (message: string, ...rest: any[]) => void;
     debug: (message: string, ...rest: any[]) => void;
 };
-export default logger;
-//# sourceMappingURL=logger.d.ts.map
+export { LogLevel, currentLogLevel, setLogLevel, logger };