@nizza/devkit 0.2.0-beta.6 → 0.2.1

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

@@ -9,33 +9,52 @@ 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() {
+const readPreJson = async ()=>{
     try {
         const data = await promises.readFile(preJsonPath, 'utf8');
-        preJson = JSON.parse(data);
+        return JSON.parse(data);
     } catch  {
-        preJson = {
+        return {
             mode: 'exit'
         };
     }
-    // Execute "version" command using @changeset/cli
+};
+const executeCommand = async (command)=>{
     try {
-        const { mode } = preJson;
+        const { stdout, stderr } = await execAsync(command);
+        devkit.logger.info(stdout);
+        if (stderr) devkit.logger.warn(`⚠️ ${stderr}`);
+    } catch (error) {
+        devkit.logger.error('❌ An error occurred while executing the command!');
+        throw error;
+    }
+};
+const handlePrereleaseMode = async (mode, exitMode)=>{
+    if (exitMode) {
         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`);
+            devkit.logger.info('ℹ️ Prerelease mode has not been entered. No need to exit.');
         } else {
-            devkit.logger.info(`🚀 Prerelease mode has been previously entered`);
+            await executeCommand('pnpm changeset pre exit');
+            devkit.logger.info('✅ Successfully exited prerelease mode');
         }
+    } else {
+        if (mode === 'exit') {
+            await executeCommand('pnpm changeset pre enter beta');
+            devkit.logger.info('🚀 Successfully entered prerelease mode');
+        } else {
+            devkit.logger.info('🔄 Prerelease mode has been previously entered');
+        }
+    }
+};
+const main = async ()=>{
+    const args = process.argv.slice(2);
+    const exitMode = args.includes('--exit');
+    try {
+        const preJson = await readPreJson();
+        await handlePrereleaseMode(preJson.mode, exitMode);
     } catch (error) {
-        devkit.logger.error('❌ An error occurred!');
+        devkit.logger.error('❌ An unexpected error occurred!');
         throw error;
     }
-}
+};
 main();
-
-exports.main = main;

package/dist/cjs/scripts/index.cjs

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

package/dist/esm/scripts/changeset-pre-mode.mjs

@@ -7,33 +7,52 @@ import { promisify } from 'util';
 const execAsync = promisify(exec);
 const changesetDir = resolve('.changeset');
 const preJsonPath = resolve(changesetDir, 'pre.json');
-let preJson;
-async function main() {
+const readPreJson = async ()=>{
     try {
         const data = await readFile(preJsonPath, 'utf8');
-        preJson = JSON.parse(data);
+        return JSON.parse(data);
     } catch  {
-        preJson = {
+        return {
             mode: 'exit'
         };
     }
-    // Execute "version" command using @changeset/cli
+};
+const executeCommand = async (command)=>{
     try {
-        const { mode } = preJson;
+        const { stdout, stderr } = await execAsync(command);
+        logger.info(stdout);
+        if (stderr) logger.warn(`⚠️ ${stderr}`);
+    } catch (error) {
+        logger.error('❌ An error occurred while executing the command!');
+        throw error;
+    }
+};
+const handlePrereleaseMode = async (mode, exitMode)=>{
+    if (exitMode) {
         if (mode === 'exit') {
-            const command = `pnpm changeset pre enter beta`;
-            const { stdout, stderr } = await execAsync(command);
-            logger.info(stdout);
-            logger.info(stderr);
-            logger.info(`🚀 Successfully enter prerelease mode`);
+            logger.info('ℹ️ Prerelease mode has not been entered. No need to exit.');
         } else {
-            logger.info(`🚀 Prerelease mode has been previously entered`);
+            await executeCommand('pnpm changeset pre exit');
+            logger.info('✅ Successfully exited prerelease mode');
         }
+    } else {
+        if (mode === 'exit') {
+            await executeCommand('pnpm changeset pre enter beta');
+            logger.info('🚀 Successfully entered prerelease mode');
+        } else {
+            logger.info('🔄 Prerelease mode has been previously entered');
+        }
+    }
+};
+const main = async ()=>{
+    const args = process.argv.slice(2);
+    const exitMode = args.includes('--exit');
+    try {
+        const preJson = await readPreJson();
+        await handlePrereleaseMode(preJson.mode, exitMode);
     } catch (error) {
-        logger.error('❌ An error occurred!');
+        logger.error('❌ An unexpected error occurred!');
         throw error;
     }
-}
+};
 main();
-
-export { main };

package/dist/esm/scripts/index.mjs

@@ -1 +1 @@
-export { main } from './changeset-pre-mode.mjs';
+import './changeset-pre-mode.mjs';

package/dist/index.d.ts

@@ -0,0 +1,376 @@
+// Generated by dts-bundle-generator v7.2.0
+
+import { ExecutorContext } from '@nx/devkit';
+import { PreRenderedChunk } from 'rollup';
+import { ConfigEnv, LibraryOptions, Plugin, PluginOption, UserConfig, ViteDevServer } from 'vite';
+
+export type ExecutorResponse = {
+	success: boolean;
+};
+export interface ExecutorOptions {
+	s3Bucket: string;
+	cloudFrontId: string;
+	buildTarget: string;
+	assetsDir: string;
+	rootDir?: string;
+	skipBuild?: boolean;
+	typings?: boolean;
+	dryRun?: boolean;
+	ignoreConfigs?: string[];
+}
+export function deployExecutor(opts: ExecutorOptions, ctx: ExecutorContext): Promise<ExecutorResponse>;
+export interface ExecutorOptions {
+}
+declare function runExecutor(_opts: ExecutorOptions, ctx: ExecutorContext): Promise<ExecutorResponse>;
+export interface ExecutorOptions {
+	unlink?: boolean;
+}
+declare function runExecutor(opts: ExecutorOptions, context: ExecutorContext): Promise<ExecutorResponse>;
+export interface ExecutorOptions {
+	tag: string;
+	dryRun?: boolean;
+}
+declare function runExecutor(opts: ExecutorOptions, ctx: ExecutorContext): Promise<ExecutorResponse>;
+export interface ExecutorOptions {
+}
+declare function runExecutor(_opts: ExecutorOptions, ctx: ExecutorContext): Promise<ExecutorResponse>;
+declare function runExecutor(_opts: any, ctx: ExecutorContext): Promise<ExecutorResponse>;
+export interface ExecutorOptions {
+	packageOrg: string;
+	rollback?: boolean;
+	skipLink?: boolean;
+}
+declare function runExecutor(opts: ExecutorOptions, ctx: ExecutorContext): Promise<ExecutorResponse>;
+declare enum LogLevel {
+	ERROR = 0,
+	WARN = 1,
+	INFO = 2,
+	DEBUG = 3
+}
+export declare enum ViteMode {
+	PROD = "production",
+	DEV = "development"
+}
+/**
+ * Project stages, it coincides with the target configurations of the project.json of NX.
+ * @readonly
+ * @enum {string}
+ */
+export declare enum Stage {
+	PROD = "prod",
+	DEV = "dev",
+	LOCAL = "local"
+}
+export declare enum ProjectType {
+	APP = "app",
+	LIB = "lib",
+	SCRIPT = "script"
+}
+export declare enum Flag {
+	SOURCEMAP = "source-maps",
+	ANALYZE = "analyze",
+	VERBOSE = "verbose",
+	VERBOSE_ALIAS = "v",
+	HTTPS = "https"
+}
+export declare enum Target {
+	BUILD = "build",
+	PREVIEW = "preview",
+	SERVE = "serve"
+}
+/**
+ * Vite Environment.
+ *
+ * @property {ViteMode} mode - Vite mode.
+ */
+export type ViteEnv = ConfigEnv & {
+	mode: ViteMode;
+};
+/**
+ * Externalizing libraries.
+ *
+ * @property {boolean} default - React externalizes and other common dependencies,
+ * this only applies to libraries.
+ * @property {boolean} glob - Glob expression or list of glob expressions to exclude
+ * dependencies from the package.json.
+ */
+export type ExternalizeLibs = {
+	default: boolean;
+	glob: string | string[];
+};
+export type ResolveEnvs = {
+	default: boolean;
+	local: boolean;
+};
+/**
+ * Project configuration.
+ *
+ * @property {ProjectType} type - Type of the project.
+ * @property {string} path - Path of the project.
+ * @property {string} entry - Path of the file entry point.
+ * @property {string} name - Name of the project, it is also used to define the name of the library.
+ * @property {string} port - Server port.
+ * @property {boolean} debug - Print data purification data.
+ * @property {boolean} dts - Control if the .d.ts files are generated, by default it is True.
+ * @property {Partial<ResolveEnvs>} resolveEnvs - Flag for resolving environment.
+ * @property {boolean} shadowDom - If component is render into shadow dom.
+ * @property {Partial<ExternalizeLibs>} externalizeLibs - Configuration for externalizing libraries.
+ * @property {LibraryOptions['fileName']} fileName - Output file name for library.
+ * @property {string} fileName - Prefix for chunk file name.
+ * @property {ViteEnv} viteEnv - Vite environment configuration.
+ * @property {UserConfig} overrides - Overrides for vite configuration.
+ */
+export interface ProjectConfig {
+	type: ProjectType;
+	path: string;
+	entry?: string;
+	name?: string;
+	port?: number;
+	logLevel?: LogLevel;
+	dts?: boolean;
+	resolveEnvs?: Partial<ResolveEnvs>;
+	shadowDom?: boolean;
+	externalizeLibs?: Partial<ExternalizeLibs>;
+	fileName?: LibraryOptions["fileName"];
+	chunkPrefix?: string;
+	viteEnv: ViteEnv;
+	overrides?: UserConfig;
+}
+export interface ProjectConfigInitialized extends ProjectConfig {
+	name: string;
+	fileName: string;
+	chunkPrefix: string;
+	logLevel: LogLevel;
+	overrides: UserConfig;
+	shadowDom: boolean;
+	resolveEnvs: ResolveEnvs;
+	externalizeLibs: ExternalizeLibs;
+}
+/**
+ * Vite command details.
+ * @interface
+ * @property {Stage} stage - Stage of the project.
+ * @property {string} target - Command name.
+ * @property {Record<string, any>} flags - Flags for customize command.
+ */
+export interface ViteCommand {
+	stage: Stage;
+	target: string;
+	flags: Record<string, any>;
+}
+/**
+ * Common project configuration.
+ *
+ * @property {string} envPrefix - Prefix in lowercase for environment variables and output files.
+ * @property {boolean} externalizeLibGlob - Glob expression or list of glob expressions to exclude
+ * dependencies from the package.json.
+ */
+export interface CommonProjectConfig {
+	envPrefix: string;
+	externalizeLibGlob?: string | string[];
+}
+/**
+ * Config builder context.
+ *
+ * @property {CommonProjectConfig} commonConfig - Common configuration for the project.
+ * @property {ProjectConfigInitialized} projectConfig - Initialized project configuration.
+ * @property {ViteCommandDetail} viteCmd - Vite command details.
+ */
+export interface Context {
+	commonConfig: CommonProjectConfig;
+	projectConfig: ProjectConfigInitialized;
+	viteCmd: ViteCommand;
+	localPkgJson: Record<string, any>;
+}
+/**
+ * Interface for plugin configuration.
+ */
+export interface PluginConfig {
+	/**
+	 * Generates plugin(s) based on the provided configuration.
+	 * @param {Context} ctx - The main configuration object.
+	 * @returns {any[]} An array of plugins.
+	 */
+	generate: (ctx: Context) => any[];
+	/**
+	 * Condition to determine if the plugin(s) should be included.
+	 * @param {Context} ctx - The main configuration object.
+	 * @returns {boolean} True if the plugin(s) should be included; false otherwise.
+	 */
+	condition?: (ctx: Context) => boolean;
+}
+/**
+ * Deeply merges two objects, combining their properties.
+ *
+ * @param {Record<string, any>} v1 - The first object.
+ * @param {Record<string, any>} v2 - The second object.
+ * @returns {Record<string, any>} - The merged object.
+ *
+ * @example
+ * const obj1 = { a: 1, b: { c: 2 } };
+ * const obj2 = { b: { d: 3 } };
+ * const merged = deepMerge(obj1, obj2);  // Outputs: { a: 1, b: { c: 2, d: 3 } }
+ */
+export declare function deepMerge(v1: Record<string, any>, v2: Record<string, any>): Record<string, any>;
+/**
+ * Generates a name for js files.
+ *
+ * @param {string} [prefix] - An optional prefix for the chunk name.
+ * @returns - A function that takes an item and generates a chunk name.
+ *
+ * @example
+ * const generateChunkName = chunkName('prefix');
+ * const name = generateChunkName({ name: 'example' });  // Outputs: "prefix-example-Aj3_Dk7_2j.js"
+ */
+export declare const chunkName: (prefix?: string) => (x: PreRenderedChunk) => string;
+/**
+ * Returns the given object if the condition is true, otherwise returns null.
+ *
+ * @param {any} condition - The condition to evaluate.
+ * @param {Record<string, any>} obj - The object to return if the condition is true.
+ * @returns {Record<string, any> | null} - The object or null based on the condition.
+ *
+ * @example
+ * const obj = { a: 1 };
+ * const result = when(true, obj);  // Outputs: { a: 1 }
+ * const result2 = when(false, obj);  // Outputs: {}
+ */
+export declare const when: (condition: any, obj: Record<string, any>) => Record<string, any>;
+/**
+ * Filters and generates plugin configurations based on conditions and the provided context.
+ *
+ * @param {Context} ctx - The main configuration object.
+ * @returns {any[]} - An array of generated plugin configurations.
+ */
+export declare const getPlugins: (ctx: Context, ...pluginConfigs: PluginConfig[]) => PluginOption[];
+/**
+ * Gets the paths to the tsconfig files for all relevant projects.
+ *
+ * @returns {string[]} - An array containing paths to tsconfig files for both app and lib projects.
+ *
+ * @example
+ * const projects = {
+ *   'my-app': {
+ *     type: 'app',
+ *     data: { root: 'apps/my-app' }
+ *   },
+ *   'my-lib': {
+ *     type: 'lib',
+ *     data: { root: 'libs/my-lib' }
+ *   }
+ * };
+ *
+ * const tsConfigPaths = getTsConfigPaths(projects);
+ * console.log(tsConfigPaths);
+ * // Output:
+ * // ['apps/my-app/tsconfig.app.json', 'libs/my-lib/tsconfig.lib.json']
+ */
+export declare const getNxTsConfigPaths: () => string[];
+/**
+ * Initializes the project configuration with default values.
+ *
+ * @example
+ * const config = { type: ProjectType.APP, path: '/path/to/project', viteEnv: { mode: ViteMode.DEV } };
+ * const initializedConfig = initializeConfig(config);
+ */
+export declare const initializeConfig: (ccfg: CommonProjectConfig, pcfg: ProjectConfig, localPkgJson: Record<string, any>) => {
+	viteCmd: ViteCommand;
+	cfg: ProjectConfigInitialized;
+};
+/**
+ * Handles merging configurations and logs any errors.
+ *
+ * @param {UserConfig} defaultConfig - The default configuration.
+ * @param {UserConfig} overrides - The overrides configuration.
+ * @returns {UserConfig} - The merged configuration.
+ */
+export declare const mergeConfigs: (defaultConfig: UserConfig, overrides: UserConfig) => UserConfig;
+/**
+ * Resolves glob patterns to actual package names found in package.json dependencies.
+ * This function is used to determine which packages should be treated as external
+ * in a Rollup or Vite build configuration.
+ *
+ * @param {string} path - The base path where package.json is located.
+ * @param {string | string[]} globs - A glob pattern or an array of glob patterns to match dependencies against.
+ * @returns {string[]} An array of package names that match the given glob patterns.
+ *
+ * @example
+ * // Example of using `getExternalDependencies` to find all dependencies starting with "my-lib" and "lodash"
+ * const projectPath = '/path/to/project';
+ * const globs = ['my-lib*', 'lodash'];
+ * const externalDependencies = getExternalDependencies(projectPath, globs);
+ * console.log(externalDependencies);
+ * // Output might be: ['my-lib/utils', 'my-lib/core', 'lodash']
+ */
+export declare const getExternalDependencies: (path: string, globs?: string | string[]) => string[];
+/**
+ * Generates a string of initials based on the input string,
+ * following certain rules:
+ * 1. A word is considered as a sequence of characters
+ * separated by hyphens.
+ * 2. If the string contains '@', any characters before
+ * and including the next '/' are ignored.
+ * 3. The first character of each word is taken to form
+ * the initials.
+ *
+ * @param {string} input - The input string from which to generate the initials.
+ * @returns {string} The initials formed by taking the first character
+ * of each word, after applying the specified rules.
+ *
+ * @example
+ * getInitials("player-script"); // returns "ps"
+ * getInitials("ssv-admin"); // returns "sa"
+ * getInitials("@nizza/customize-live"); // returns "cl"
+ */
+export declare function getInitials(input: string): string;
+/**
+ * Retrieves the Vite command details.
+ *
+ * @param {ViteMode} mode - The Vite mode.
+ * @returns {ViteCommand} - The command details.
+ *
+ * @example
+ * const command = getViteCommand(ViteMode.PROD);
+ * // Outputs: { stage: Stage.PROD, target: 'build', flags: {} }
+ */
+export declare function getViteCommand(mode: ViteMode): ViteCommand;
+/**
+ * Parses the command string to extract flags.
+ *
+ * @param {string | undefined} commandString - The command string.
+ * @returns {Record<string, string>} - The flags extracted from the command string.
+ *
+ * @example
+ * const flags = getViteCmdFlags('nx run core:build --source-maps');
+ * // Outputs: { 'source-maps: 'true' }
+ */
+export declare function getViteCmdFlags(commandString: string | undefined): Record<string, string>;
+/**
+ * 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.
+ */
+export declare const createConfigBuilder: (commonConfig: CommonProjectConfig) => (projectConfig: ProjectConfig) => UserConfig;
+export interface Execute {
+	function: (data?: string) => void;
+	listen: string;
+	observer: string;
+}
+export interface ThirdPartyCssInjectPlugin {
+	topExecutionPriority?: boolean;
+	execute?: Execute[];
+}
+/**
+ * Inject the CSS compiled with JS.
+ *
+ * @return {Plugin}
+ */
+export declare function thirdPartyCssInjectPlugin({ topExecutionPriority, execute }?: ThirdPartyCssInjectPlugin | undefined): Plugin;
+export declare function injectCssIntoShadowDom(): {
+	name: string;
+	configureServer(_server: ViteDevServer): void;
+	transform(src: string, id: string): void;
+};
+
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nizza/devkit",
-  "version": "0.2.0-beta.6",
+  "version": "0.2.1",
   "type": "module",
   "main": "dist/cjs/index.cjs",
   "module": "dist/esm/index.mjs",