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

package/dist/esm/vite/config-builder/shared/types.d.mts

@@ -0,0 +1,155 @@
+import { ConfigEnv, LibraryOptions, UserConfig } from 'vite';
+import { LogLevel } from "../../../index-17143e35.js";
+declare enum ViteMode {
+    PROD = "production",
+    DEV = "development"
+}
+/**
+ * Project stages, it coincides with the target configurations of the project.json of NX.
+ * @readonly
+ * @enum {string}
+ */
+declare enum Stage {
+    PROD = "prod",
+    DEV = "dev",
+    STAGING = "staging",
+    LOCAL = "local"
+}
+declare enum ProjectType {
+    APP = "app",
+    LIB = "lib",
+    SCRIPT = "script"
+}
+declare enum Flag {
+    SOURCEMAP = "source-maps",
+    ANALYZE = "analyze",
+    VERBOSE = "verbose",
+    VERBOSE_ALIAS = "v"
+}
+declare enum Target {
+    BUILD = "build",
+    PREVIEW = "preview",
+    SERVE = "serve"
+}
+/**
+ * Vite Environment.
+ *
+ * @property {ViteMode} mode - Vite mode.
+ */
+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.
+ */
+type ExternalizeLibs = {
+    default: boolean;
+    glob: string | string[];
+};
+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.
+ */
+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;
+}
+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.
+ */
+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.
+ */
+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.
+ */
+interface Context {
+    commonConfig: CommonProjectConfig;
+    projectConfig: ProjectConfigInitialized;
+    viteCmd: ViteCommand;
+    localPkgJson: Record<string, any>;
+}
+/**
+ * Interface for plugin configuration.
+ */
+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;
+}
+export { ViteMode, Stage, ProjectType, Flag, Target, ViteEnv, ExternalizeLibs, ResolveEnvs, ProjectConfig, ProjectConfigInitialized, ViteCommand, CommonProjectConfig, Context, PluginConfig };

package/dist/{src/vite/config-builder/shared/types.js → esm/vite/config-builder/shared/types.mjs}

@@ -1,30 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    Flag: function() {
-        return Flag;
-    },
-    ProjectType: function() {
-        return ProjectType;
-    },
-    Stage: function() {
-        return Stage;
-    },
-    Target: function() {
-        return Target;
-    },
-    ViteMode: function() {
-        return ViteMode;
-    }
-});
 var ViteMode;
 (function(ViteMode) {
     ViteMode["PROD"] = "production";
@@ -56,3 +29,5 @@ var Target;
     Target["PREVIEW"] = "preview";
     Target["SERVE"] = "serve";
 })(Target || (Target = {}));
+
+export { Flag, ProjectType, Stage, Target, ViteMode };

package/dist/esm/vite/config-builder/shared/utils/helpers.d.mts

@@ -0,0 +1,71 @@
+import { PreRenderedChunk } from 'rollup';
+import { PluginOption } from 'vite';
+import { Context, PluginConfig } from "../types.js";
+/**
+ * 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 } }
+ */
+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"
+ */
+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: {}
+ */
+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.
+ */
+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']
+ */
+declare const getNxTsConfigPaths: () => string[];
+export { deepMerge, chunkName, when, getPlugins, getNxTsConfigPaths };

package/dist/esm/vite/config-builder/shared/utils/helpers.mjs

@@ -0,0 +1,90 @@
+import { readCachedProjectGraph } from '@nx/devkit';
+import { resolve } from 'path';
+import * as R from 'ramda';
+import '../../../../shared/logger.mjs';
+import { shortId } from '../../../../shared/utils.mjs';
+
+/**
+ * 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 } }
+ */ function deepMerge(v1, v2) {
+    if (Array.isArray(v1) && Array.isArray(v2)) {
+        return R.uniq(R.concat(v1, v2));
+    } else if (typeof v1 === 'object' && typeof v2 === 'object' && !R.isNil(v1) && !R.isNil(v2)) {
+        return R.mergeWith(deepMerge, v1, v2);
+    } else {
+        return v2;
+    }
+}
+/**
+ * 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"
+ */ const chunkName = (prefix)=>(x)=>{
+        const nameWithoutUnderscore = x.name.replace(/_/g, '');
+        const pre = prefix ? `${prefix}-` : '';
+        return `${pre}${nameWithoutUnderscore}-${shortId(8)}.js`;
+    };
+/**
+ * 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: {}
+ */ const when = (condition, obj)=>condition ? obj : {};
+/**
+ * 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.
+ */ const getPlugins = (ctx, ...pluginConfigs)=>pluginConfigs // Filters the plugins based on conditions
+    .filter((p)=>!p.condition || p.condition(ctx)) // Generates the configuration of each plugin and flattens the resulting array
+    .flatMap((p)=>p.generate(ctx));
+/**
+ * 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']
+ */ const getNxTsConfigPaths = ()=>{
+    const isValid = (p)=>p.data.root.startsWith('apps/') || p.data.root.startsWith('libs/');
+    const getTsConfigPath = (p)=>resolve(p.data.root, `tsconfig.${p.type === 'app' ? 'app' : 'lib'}.json`);
+    const graph = readCachedProjectGraph();
+    const projects = graph.nodes;
+    return Object.values(projects).filter(isValid).map(getTsConfigPath);
+};
+
+export { chunkName, deepMerge, getNxTsConfigPaths, getPlugins, when };

package/dist/esm/vite/config-builder/shared/utils/projectConfig.d.mts

@@ -0,0 +1,60 @@
+import { UserConfig } from 'vite';
+import { CommonProjectConfig, ProjectConfig, ProjectConfigInitialized } from "../types.js";
+/**
+ * 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);
+ */
+declare const initializeConfig: (ccfg: CommonProjectConfig, pcfg: ProjectConfig, localPkgJson: Record<string, any>) => {
+    viteCmd: import("../types.js").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.
+ */
+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']
+ */
+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"
+ */
+declare function getInitials(input: string): string;
+export { initializeConfig, mergeConfigs, getExternalDependencies, getInitials };

package/dist/esm/vite/config-builder/shared/utils/projectConfig.mjs

@@ -0,0 +1,109 @@
+import { minimatch } from 'minimatch';
+import { LogLevel, setLogLevel, logger } from '../../../../shared/logger.mjs';
+import { getPkgJson } from '../../../../shared/utils.mjs';
+import { Flag } from '../types.mjs';
+import { deepMerge } from './helpers.mjs';
+import { getViteCommand } from './viteCommand.mjs';
+
+/**
+ * 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);
+ */ const initializeConfig = (ccfg, pcfg, localPkgJson)=>{
+    const { envPrefix } = ccfg;
+    const localPkgName = localPkgJson['name'];
+    const { name = localPkgName, overrides = {}, shadowDom = false, chunkPrefix = getInitials(localPkgName), resolveEnvs = {
+        default: true,
+        local: true
+    }, fileName = `${envPrefix}-${chunkPrefix}-index`, externalizeLibs = {
+        default: true,
+        glob: []
+    } } = pcfg;
+    const viteCmd = getViteCommand(pcfg.viteEnv.mode);
+    const isVerbose = Object.keys(viteCmd.flags).some((x)=>[
+            Flag.VERBOSE,
+            Flag.VERBOSE_ALIAS
+        ].includes(x));
+    const logLevel = isVerbose ? LogLevel.DEBUG : pcfg.logLevel ?? LogLevel.INFO;
+    setLogLevel(logLevel);
+    return {
+        viteCmd,
+        cfg: {
+            ...pcfg,
+            name,
+            fileName,
+            logLevel,
+            overrides,
+            chunkPrefix,
+            shadowDom,
+            resolveEnvs,
+            externalizeLibs: externalizeLibs
+        }
+    };
+};
+/**
+ * Handles merging configurations and logs any errors.
+ *
+ * @param {UserConfig} defaultConfig - The default configuration.
+ * @param {UserConfig} overrides - The overrides configuration.
+ * @returns {UserConfig} - The merged configuration.
+ */ const mergeConfigs = (defaultConfig, overrides)=>{
+    try {
+        return deepMerge(defaultConfig, overrides);
+    } catch (err) {
+        logger.error('Error merging vite configs: ', err);
+        return defaultConfig;
+    }
+};
+/**
+ * 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']
+ */ const getExternalDependencies = (path, globs = [])=>{
+    const pkgJson = getPkgJson(path); // Assumes getLocalPkgJson is a function that reads and parses package.json
+    const dependencies = Object.keys(pkgJson.dependencies || {});
+    const globPatterns = Array.isArray(globs) ? globs : [
+        globs
+    ];
+    return dependencies.filter((dep)=>globPatterns.some((pattern)=>minimatch(dep, pattern)));
+};
+/**
+ * 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"
+ */ function getInitials(input) {
+    const cleanedInput = input.includes('@') ? input.split('/')[1] : input;
+    const words = cleanedInput?.split('-');
+    const initials = words?.map((word)=>word.charAt(0)).join('');
+    return initials ?? '';
+}
+
+export { getExternalDependencies, getInitials, initializeConfig, mergeConfigs };

package/dist/esm/vite/config-builder/shared/utils/viteCommand.d.mts

@@ -0,0 +1,24 @@
+import { ViteMode, ViteCommand } from "../types.js";
+/**
+ * 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: {} }
+ */
+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' }
+ */
+declare function getViteCmdFlags(commandString: string | undefined): Record<string, string>;
+export { getViteCommand, getViteCmdFlags };

package/dist/esm/vite/config-builder/shared/utils/viteCommand.mjs

@@ -0,0 +1,56 @@
+import chalk from 'chalk';
+import argv from 'mri';
+import { loadEnv } from 'vite';
+import { ViteMode, Stage, Target } from '../types.mjs';
+
+/**
+ * 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: {} }
+ */ function getViteCommand(mode) {
+    const nxEnv = loadEnv(mode, process.cwd(), 'NX');
+    const nxCommandString = process?.env?.['npm_package_scripts_nx'];
+    const modeIsProd = mode === ViteMode.PROD;
+    const stage = (nxEnv?.['NX_TASK_TARGET_CONFIGURATION']) ?? (modeIsProd ? Stage.PROD : Stage.DEV);
+    const target = nxEnv?.['NX_TASK_TARGET_TARGET'] ?? Target.BUILD;
+    const flags = getViteCmdFlags(nxCommandString);
+    const showIn = {
+        prod: (...args)=>modeIsProd && console.log(...args),
+        dev: (...args)=>!modeIsProd && console.log(...args)
+    };
+    try {
+        showIn.prod(chalk.cyan('Build Stage:'), chalk.green(stage));
+        showIn.dev(chalk.green('  ➜ '), chalk.bold.white(`Stage:  `), chalk.cyan(stage));
+    } catch  {
+        showIn.prod(console.log('Build Stage:', stage));
+        showIn.dev(console.log(`  ➜  Stage:  `, stage));
+    }
+    return {
+        stage,
+        target,
+        flags
+    };
+}
+/**
+ * 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' }
+ */ function getViteCmdFlags(commandString) {
+    if (!commandString) return {};
+    const cleanedCommandString = commandString.replace(/"/g, '');
+    const args = argv(cleanedCommandString.split(' '));
+    delete args['_'];
+    return args;
+}
+
+export { getViteCmdFlags, getViteCommand };

package/dist/esm/vite/plugins/shadow-dom-inject-css/index.d.mts

@@ -0,0 +1,7 @@
+import { ViteDevServer } from 'vite';
+declare function injectCssIntoShadowDom(): {
+    name: string;
+    configureServer(_server: ViteDevServer): void;
+    transform(src: string, id: string): void;
+};
+export { injectCssIntoShadowDom };

package/dist/esm/vite/plugins/shadow-dom-inject-css/index.mjs

@@ -0,0 +1,27 @@
+function injectCssIntoShadowDom() {
+    const fileRegex = /\.(css)$/;
+    let server;
+    return {
+        name: 'nizza:inject-css-into-shadow-dom',
+        configureServer (_server) {
+            server = _server;
+        },
+        transform (src, id) {
+            if (server) {
+                const relativeId = /\/lib\/.*/.exec(id)?.[0].replace('/lib/', '');
+                if (fileRegex.test(id)) {
+                    server.ws.send({
+                        type: 'custom',
+                        event: 'inject-css-into-shadow-dom:hot-updated',
+                        data: {
+                            id: relativeId,
+                            content: src
+                        }
+                    });
+                }
+            }
+        }
+    };
+}
+
+export { injectCssIntoShadowDom };

package/dist/esm/vite/plugins/third-party-css-inject/main.d.mts

@@ -0,0 +1,17 @@
+import { Plugin } from 'vite';
+interface Execute {
+    function: (data?: string) => void;
+    listen: string;
+    observer: string;
+}
+interface ThirdPartyCssInjectPlugin {
+    topExecutionPriority?: boolean;
+    execute?: Execute[];
+}
+/**
+ * Inject the CSS compiled with JS.
+ *
+ * @return {Plugin}
+ */
+declare function thirdPartyCssInjectPlugin({ topExecutionPriority, execute }?: ThirdPartyCssInjectPlugin | undefined): Plugin;
+export { Execute, ThirdPartyCssInjectPlugin, thirdPartyCssInjectPlugin };