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

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/index.cjs

@@ -0,0 +1,56 @@
+'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 main = require('./vite-utils/config-builder/main.cjs');
+var types = require('./vite-utils/config-builder/shared/types.cjs');
+var helpers = require('./vite-utils/config-builder/shared/utils/helpers.cjs');
+var projectConfig = require('./vite-utils/config-builder/shared/utils/projectConfig.cjs');
+var viteCommand = require('./vite-utils/config-builder/shared/utils/viteCommand.cjs');
+var main$1 = require('./vite-utils/plugins/third-party-css-inject/main.cjs');
+var index$5 = require('./vite-utils/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;
+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/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/index.cjs

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

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/cjs/shared/utils.cjs

@@ -0,0 +1,36 @@
+'use strict';
+
+var devkit = require('@nx/devkit');
+var crypto = require('crypto');
+var fs = require('fs');
+var path = require('path');
+
+/**
+ * Reads and parses the package.json file from the given project path.
+ *
+ * @param {string} projectPath - The path to the project.
+ * @returns {Record<string, any>} - The parsed package.json data.
+ *
+ * @example
+ * const pkgJsonData = getPkgJson('/path/to/project');
+ */ const getPkgJson = (projectPath)=>{
+    try {
+        const data = fs.readFileSync(path.resolve(projectPath, './package.json'), 'utf-8');
+        return JSON.parse(data);
+    } catch (err) {
+        devkit.logger.error('Error reading or parsing package.json');
+        throw err;
+    }
+};
+/**
+ * Generates a random alphanumeric identifier of a specified length.
+ *
+ * @param {number} [length=8] - The length of the identifier to generate. Defaults to 8 if not specified.
+ * @returns {string} - A string representing a unique identifier.
+ */ function shortId(length = 8) {
+    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    return Array.from(crypto.randomBytes(length), (b)=>chars[b % chars.length]).join('');
+}
+
+exports.getPkgJson = getPkgJson;
+exports.shortId = shortId;

package/dist/cjs/vite-utils/config-builder/configs/app.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+const getAppConfig = (ctx)=>{
+    const { port } = ctx.projectConfig;
+    return {
+        server: {
+            port,
+            host: true
+        }
+    };
+};
+
+exports.getAppConfig = getAppConfig;

package/dist/cjs/vite-utils/config-builder/configs/base.cjs

@@ -0,0 +1,58 @@
+'use strict';
+
+var plugins = require('../plugins.cjs');
+var types = require('../shared/types.cjs');
+var helpers = require('../shared/utils/helpers.cjs');
+require('minimatch');
+require('../../../shared/logger.cjs');
+require('@nx/devkit');
+require('crypto');
+var fs = require('fs');
+var path = require('path');
+require('chalk');
+require('mri');
+require('vite');
+
+const getBaseConfig = (ctx)=>{
+    const { commonConfig, projectConfig, viteCmd } = ctx;
+    const { resolveEnvs, path: path$1 } = projectConfig;
+    const { stage, target, flags: cmdOverrides } = viteCmd;
+    const NODE_ENV = target === types.Target.BUILD ? types.ViteMode.PROD : types.ViteMode.DEV;
+    const sourcemap = cmdOverrides?.[types.Flag.SOURCEMAP] ?? stage !== types.Stage.PROD;
+    const envPrefix = `${commonConfig.envPrefix.toUpperCase()}_`;
+    const omittedStages = resolveEnvs.local ? [
+        types.Stage.DEV
+    ] : [
+        types.Stage.DEV,
+        types.Stage.LOCAL
+    ];
+    const envPath = `environments/environment.${stage}.ts`;
+    const fallbackEnvPath = `environments/environment.ts`;
+    // Verify if the local Environment file is present
+    const envFilePath = fs.existsSync(path.resolve(path$1, 'src', envPath)) ? envPath : fallbackEnvPath;
+    return {
+        envPrefix,
+        plugins: helpers.getPlugins(ctx, plugins.basePlugins, plugins.bundleAnalysisPlugin),
+        resolve: {
+            alias: {
+                ...helpers.when(resolveEnvs.default && !omittedStages.includes(stage), {
+                    '~env': envFilePath
+                })
+            }
+        },
+        define: {
+            'module.hot': false,
+            'process.env.DEBUG': null,
+            'process.env.NODE_ENV': JSON.stringify(NODE_ENV),
+            __vite_process_env_NODE_ENV: JSON.stringify(NODE_ENV)
+        },
+        build: {
+            sourcemap,
+            minify: true,
+            emptyOutDir: true,
+            cssCodeSplit: true
+        }
+    };
+};
+
+exports.getBaseConfig = getBaseConfig;

package/dist/cjs/vite-utils/config-builder/configs/index.cjs

@@ -0,0 +1,36 @@
+'use strict';
+
+var types = require('../shared/types.cjs');
+require('@nx/devkit');
+require('path');
+require('ramda');
+require('../../../shared/logger.cjs');
+require('crypto');
+require('fs');
+require('minimatch');
+require('chalk');
+require('mri');
+require('vite');
+var app = require('./app.cjs');
+var base = require('./base.cjs');
+var lib = require('./lib.cjs');
+var script = require('./script.cjs');
+
+const getConfig = (ctx, type = null)=>{
+    switch(type){
+        case types.ProjectType.APP:
+            return app.getAppConfig(ctx);
+        case types.ProjectType.LIB:
+            return lib.getLibConfig(ctx);
+        case types.ProjectType.SCRIPT:
+            return script.getScriptConfig(ctx);
+        default:
+            return base.getBaseConfig(ctx);
+    }
+};
+
+exports.getAppConfig = app.getAppConfig;
+exports.getBaseConfig = base.getBaseConfig;
+exports.getLibConfig = lib.getLibConfig;
+exports.getScriptConfig = script.getScriptConfig;
+exports.getConfig = getConfig;

package/dist/cjs/vite-utils/config-builder/configs/lib.cjs

@@ -0,0 +1,57 @@
+'use strict';
+
+var path = require('path');
+var plugins = require('../plugins.cjs');
+require('../shared/types.cjs');
+var helpers = require('../shared/utils/helpers.cjs');
+var projectConfig = require('../shared/utils/projectConfig.cjs');
+require('chalk');
+require('mri');
+require('vite');
+
+const getLibConfig = (ctx)=>{
+    const { projectConfig: projectConfig$1, commonConfig } = ctx;
+    const { externalizeLibGlob = [] } = commonConfig;
+    const { name, path: path$1, externalizeLibs } = projectConfig$1;
+    const entry = path.resolve(path$1, projectConfig$1.entry ?? 'src/index.ts');
+    const defaultExternals = {
+        react: true,
+        'react-dom': true,
+        'react/jsx-runtime': true
+    };
+    // Get external dependencies based on glob patterns
+    const externalDeps = projectConfig.getExternalDependencies(path$1, [
+        ...externalizeLibGlob,
+        ...externalizeLibs.glob
+    ]);
+    const rollupExternal = [
+        ...externalDeps,
+        ...Object.keys(helpers.when(externalizeLibs.default, defaultExternals))
+    ];
+    const rollupGlobals = {
+        react: 'React',
+        'react-dom': 'ReactDOM',
+        'react/jsx-runtime': 'ReactJsxRuntime'
+    };
+    return {
+        plugins: helpers.getPlugins(ctx, plugins.dtsPlugin),
+        build: {
+            lib: {
+                name,
+                entry,
+                formats: [
+                    'es'
+                ],
+                fileName: (format)=>`index.${format === 'es' ? 'mjs' : 'cjs'}`
+            },
+            rollupOptions: {
+                external: rollupExternal,
+                output: {
+                    globals: helpers.when(externalizeLibs.default, rollupGlobals)
+                }
+            }
+        }
+    };
+};
+
+exports.getLibConfig = getLibConfig;

package/dist/cjs/vite-utils/config-builder/configs/script.cjs

@@ -0,0 +1,46 @@
+'use strict';
+
+var path = require('path');
+var plugins = require('../plugins.cjs');
+require('../shared/types.cjs');
+var helpers = require('../shared/utils/helpers.cjs');
+require('minimatch');
+require('../../../shared/logger.cjs');
+require('@nx/devkit');
+require('crypto');
+require('fs');
+require('chalk');
+require('mri');
+require('vite');
+
+const getScriptConfig = (ctx)=>{
+    const { commonConfig, projectConfig } = ctx;
+    const { envPrefix } = commonConfig;
+    const { port } = projectConfig;
+    const { name, path: path$1, fileName, chunkPrefix } = projectConfig;
+    const entry = path.resolve(path$1, projectConfig.entry ?? 'src/main');
+    return {
+        plugins: helpers.getPlugins(ctx, plugins.injectCssIntoShadowDomPlugin, plugins.injectCssByJsPlugin),
+        server: {
+            port,
+            host: true
+        },
+        build: {
+            lib: {
+                name,
+                entry,
+                fileName,
+                formats: [
+                    'es'
+                ]
+            },
+            rollupOptions: {
+                output: {
+                    chunkFileNames: helpers.chunkName(`${envPrefix}-${chunkPrefix}`)
+                }
+            }
+        }
+    };
+};
+
+exports.getScriptConfig = getScriptConfig;

package/dist/cjs/vite-utils/config-builder/main.cjs

@@ -0,0 +1,42 @@
+'use strict';
+
+var vite = require('vite');
+var logger = require('../../shared/logger.cjs');
+var utils = require('../../shared/utils.cjs');
+var index = require('./configs/index.cjs');
+require('./shared/types.cjs');
+require('@nx/devkit');
+require('path');
+require('ramda');
+var projectConfig = require('./shared/utils/projectConfig.cjs');
+require('chalk');
+require('mri');
+
+/**
+ * Builds the configuration based on common and project-specific configurations.
+ *
+ * @param {CommonProjectConfig} commonConfig - The common configuration.
+ * @returns - Returns a function that accepts a project configuration and returns the Vite configuration.
+ */ const createConfigBuilder = (commonConfig)=>(projectConfig$1)=>{
+        try {
+            const localPkgJson = utils.getPkgJson(projectConfig$1.path);
+            const { cfg, viteCmd } = projectConfig.initializeConfig(commonConfig, projectConfig$1, localPkgJson);
+            const isDebug = logger.currentLogLevel === logger.LogLevel.DEBUG;
+            const { type, overrides } = cfg;
+            const ctx = {
+                viteCmd,
+                localPkgJson,
+                commonConfig,
+                projectConfig: cfg
+            };
+            const defaultConfig = projectConfig.mergeConfigs(index.getConfig(ctx), index.getConfig(ctx, type));
+            const config = projectConfig.mergeConfigs(defaultConfig, overrides);
+            if (isDebug) logger.logger.debug('Generated config:', config);
+            return vite.defineConfig(config);
+        } catch (err) {
+            logger.logger.error('buildConfig unexpected error:');
+            throw err;
+        }
+    };
+
+exports.createConfigBuilder = createConfigBuilder;

package/dist/cjs/vite-utils/config-builder/plugins.cjs

@@ -0,0 +1,93 @@
+'use strict';
+
+var vitePluginCommonjs = require('@originjs/vite-plugin-commonjs');
+var graphql = require('@rollup/plugin-graphql');
+var react = require('@vitejs/plugin-react-swc');
+var path = require('path');
+var rollupPluginVisualizer = require('rollup-plugin-visualizer');
+var cssInjectedByJsPlugin = require('vite-plugin-css-injected-by-js');
+var dts = require('vite-plugin-dts');
+var tsconfigPaths = require('vite-tsconfig-paths');
+require('vite');
+var index = require('../plugins/shadow-dom-inject-css/index.cjs');
+var types = require('./shared/types.cjs');
+var helpers = require('./shared/utils/helpers.cjs');
+require('minimatch');
+require('../../shared/logger.cjs');
+require('@nx/devkit');
+require('crypto');
+require('fs');
+require('chalk');
+require('mri');
+
+/**
+ * Base plugins configuration for apps and libs.
+ *
+ * Plugins configured:
+ * - vite-tsconfig-paths
+ * - @originjs/vite-plugin-commonjs
+ * - @rollup/plugin-graphql
+ * - @vitejs/plugin-react-swc
+ */ const basePlugins = {
+    generate: ()=>{
+        const projects = helpers.getNxTsConfigPaths();
+        return [
+            tsconfigPaths({
+                projects
+            }),
+            vitePluginCommonjs.viteCommonjs(),
+            graphql(),
+            react({
+                tsDecorators: true
+            })
+        ];
+    }
+};
+/**
+ * Plugin configuration for generating type declarations using vite-plugin-dts.
+ */ const dtsPlugin = {
+    generate: ({ projectConfig })=>[
+            dts({
+                tsconfigPath: path.resolve(projectConfig.path, 'tsconfig.lib.json'),
+                outDir: path.resolve(projectConfig.path, 'dist'),
+                entryRoot: path.resolve(projectConfig.path, 'src')
+            })
+        ],
+    condition: ({ projectConfig, viteCmd })=>viteCmd.stage !== types.Stage.LOCAL && projectConfig.dts == null ? true : !!projectConfig.dts
+};
+/**
+ * Plugin configuration for bundle analysis using rollup-plugin-visualizer.
+ */ const bundleAnalysisPlugin = {
+    generate: ({ projectConfig })=>[
+            rollupPluginVisualizer.visualizer({
+                emitFile: true,
+                projectRoot: path.resolve(projectConfig.path, 'dist'),
+                filename: 'bundle-analysis.html'
+            })
+        ],
+    condition: ({ viteCmd })=>viteCmd.flags?.[types.Flag.ANALYZE] === 'true'
+};
+/**
+ * Plugin configuration for injecting CSS into JS files
+ * using vite-plugin-css-injected-by-js.
+ */ const injectCssByJsPlugin = {
+    generate: (_)=>[
+            cssInjectedByJsPlugin()
+        ],
+    condition: ({ projectConfig })=>!projectConfig.shadowDom
+};
+/**
+ * Plugin configuration for injecting CSS into Shadow Dom.
+ * using local plugin.
+ */ const injectCssIntoShadowDomPlugin = {
+    generate: (_)=>[
+            index.injectCssIntoShadowDom()
+        ],
+    condition: ({ projectConfig })=>projectConfig.shadowDom
+};
+
+exports.basePlugins = basePlugins;
+exports.bundleAnalysisPlugin = bundleAnalysisPlugin;
+exports.dtsPlugin = dtsPlugin;
+exports.injectCssByJsPlugin = injectCssByJsPlugin;
+exports.injectCssIntoShadowDomPlugin = injectCssIntoShadowDomPlugin;

package/dist/cjs/vite-utils/config-builder/shared/types.cjs

@@ -0,0 +1,33 @@
+'use strict';
+
+exports.ViteMode = void 0;
+(function(ViteMode) {
+    ViteMode["PROD"] = "production";
+    ViteMode["DEV"] = "development";
+})(exports.ViteMode || (exports.ViteMode = {}));
+exports.Stage = void 0;
+(function(Stage) {
+    Stage["PROD"] = "prod";
+    Stage["DEV"] = "dev";
+    Stage["STAGING"] = "staging";
+    Stage["LOCAL"] = "local";
+})(exports.Stage || (exports.Stage = {}));
+exports.ProjectType = void 0;
+(function(ProjectType) {
+    ProjectType["APP"] = "app";
+    ProjectType["LIB"] = "lib";
+    ProjectType["SCRIPT"] = "script";
+})(exports.ProjectType || (exports.ProjectType = {}));
+exports.Flag = void 0;
+(function(Flag) {
+    Flag["SOURCEMAP"] = "source-maps";
+    Flag["ANALYZE"] = "analyze";
+    Flag["VERBOSE"] = "verbose";
+    Flag["VERBOSE_ALIAS"] = "v";
+})(exports.Flag || (exports.Flag = {}));
+exports.Target = void 0;
+(function(Target) {
+    Target["BUILD"] = "build";
+    Target["PREVIEW"] = "preview";
+    Target["SERVE"] = "serve";
+})(exports.Target || (exports.Target = {}));