@nizza/devkit 0.1.0-alpha.2 → 0.1.0-alpha.3

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

@@ -0,0 +1,98 @@
+import { readCachedProjectGraph } from '@nx/devkit';
+import { nanoid } from 'nanoid';
+import { resolve } from 'path';
+import * as R from 'ramda';
+
+/**
+ * Generates a short ID string.
+ *
+ * @param {number} length - The length of the ID to generate.
+ * @returns {string} - The generated ID.
+ *
+ * @example
+ * const id = shortId(10);  // Outputs: "Aj3_Dk7_2j"
+ */ const shortId = (length)=>nanoid(length);
+/**
+ * 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, shortId, when };

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

@@ -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.js

@@ -0,0 +1,109 @@
+import { minimatch } from 'minimatch';
+import { LogLevel, logger, setLogLevel } from '../../../../shared/logger.js';
+import { getPkgJson } from '../../../../shared/utils.js';
+import { Flag } from '../types.js';
+import { deepMerge } from './helpers.js';
+import { getViteCommand } from './viteCommand.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);
+ */ 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.ts

@@ -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.js

@@ -0,0 +1,56 @@
+import chalk from 'chalk';
+import argv from 'mri';
+import { loadEnv } from 'vite';
+import { ViteMode, Stage, Target } 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: {} }
+ */ 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.ts

@@ -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.js

@@ -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.ts

@@ -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 };

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

@@ -0,0 +1,45 @@
+import { removeLinkStyleSheets, buildCSSInjectionCode } from './utils.js';
+
+/**
+ * Inject the CSS compiled with JS.
+ *
+ * @return {Plugin}
+ */ function thirdPartyCssInjectPlugin({ topExecutionPriority, execute } = {
+    topExecutionPriority: true,
+    execute: []
+}) {
+    //Globally so we can add it to legacy and non-legacy bundle.
+    let config;
+    return {
+        apply: 'build',
+        enforce: 'post',
+        name: 'nizza:third-party-css-inject',
+        configResolved (_config) {
+            config = _config;
+        },
+        async generateBundle (opts, bundle) {
+            if (config.build.ssr) {
+                return;
+            }
+            const htmlFiles = Object.keys(bundle).filter((i)=>i.endsWith('.html'));
+            const cssAssets = Object.keys(bundle).filter((i)=>bundle[i]?.type == 'asset' && bundle[i]?.fileName.endsWith('.css'));
+            const jsAssets = Object.keys(bundle).filter((i)=>bundle[i]?.type == 'chunk' && bundle[i]?.fileName.match(/.[cm]?js$/) != null && !bundle[i]?.fileName.includes('polyfill'));
+            for (const name of htmlFiles){
+                const htmlChunk = bundle[name];
+                let replacedHtml = htmlChunk.source;
+                cssAssets.forEach((cssName)=>{
+                    replacedHtml = removeLinkStyleSheets(replacedHtml, cssName);
+                    htmlChunk.source = replacedHtml;
+                });
+            }
+            const jsAsset = bundle[jsAssets[0]];
+            const cssInjectionCode = await buildCSSInjectionCode(execute);
+            const appCode = jsAsset.code;
+            jsAsset.code = topExecutionPriority ? '' : appCode;
+            jsAsset.code += cssInjectionCode ? cssInjectionCode.code : '';
+            jsAsset.code += !topExecutionPriority ? '' : appCode;
+        }
+    };
+}
+
+export { thirdPartyCssInjectPlugin };

package/dist/esm/vite/plugins/third-party-css-inject/utils.d.ts

@@ -0,0 +1,5 @@
+import { OutputChunk } from 'rollup';
+import { Execute } from "../../../index-3080371d.js";
+declare function buildCSSInjectionCode(execute?: Execute[]): Promise<OutputChunk | null | any>;
+declare function removeLinkStyleSheets(html: string, cssFileName: string): string;
+export { buildCSSInjectionCode, removeLinkStyleSheets };

package/dist/esm/vite/plugins/third-party-css-inject/utils.js

@@ -0,0 +1,97 @@
+import { build } from 'vite';
+
+const cssInjectedByJsId = '\0vite/all-css';
+const waitForElement = (selector, observerElementName = 'body')=>{
+    const getElement = (selector)=>document.querySelector(selector);
+    return new Promise((resolve)=>{
+        if (getElement(selector)) return resolve(getElement(selector));
+        const observer = new MutationObserver(()=>{
+            if (getElement(selector)) {
+                resolve(getElement(selector));
+                observer.disconnect();
+            }
+        });
+        let observerElement = document.body;
+        switch(observerElementName){
+            case 'body':
+                observerElement = document.body;
+                break;
+            case 'head':
+                observerElement = document.head;
+                break;
+            default:
+                observerElement = document.body;
+                break;
+        }
+        observer.observe(observerElement, {
+            childList: true,
+            subtree: true
+        });
+    });
+};
+async function buildCSSInjectionCode(execute) {
+    const res = await build({
+        root: '',
+        configFile: false,
+        logLevel: 'error',
+        plugins: [
+            injectionCSSCodePlugin(execute)
+        ],
+        build: {
+            write: false,
+            target: 'es2015',
+            minify: 'esbuild',
+            assetsDir: '',
+            rollupOptions: {
+                input: {
+                    'all-css': cssInjectedByJsId
+                },
+                output: {
+                    format: 'iife',
+                    manualChunks: undefined
+                }
+            }
+        }
+    });
+    const _cssChunk = Array.isArray(res) ? res[0] : res;
+    if (!('output' in _cssChunk)) return null;
+    return _cssChunk.output[0];
+}
+/**
+ * @param {string} cssToInject
+ * @param {string|null} styleId
+ * @return {Plugin}
+ */ function injectionCSSCodePlugin(execute) {
+    return {
+        name: 'vite:third-party-css-inject',
+        // @ts-ignore
+        resolveId (id) {
+            if (id == cssInjectedByJsId) {
+                return id;
+            }
+        },
+        // @ts-ignore
+        load (id) {
+            if (id == cssInjectedByJsId) {
+                let executeJs = [];
+                if (execute?.length) {
+                    executeJs = execute.map((executeData, index)=>{
+                        return `waitForElement('${executeData.observer}', '${executeData.listen}').then((elm)=>{
+              const extra${index}=${executeData.function};extra${index}(elm)
+            });`;
+                    });
+                }
+                return `try{if(typeof document != 'undefined'){
+        const waitForElement=${waitForElement.toString()};
+        ${executeJs.join(' ')}
+      }}catch(e){console.error('vite-third-party-css-inject-plugin', e);}`;
+            }
+        }
+    };
+}
+function removeLinkStyleSheets(html, cssFileName) {
+    const removeCSS = new RegExp(`<link rel=".*"[^>]*?href=".*/?${cssFileName}"[^>]*?>`);
+    return html.replace(removeCSS, '');
+}
+
+export { buildCSSInjectionCode, removeLinkStyleSheets };

package/dist/executors.json

@@ -0,0 +1,29 @@
+{
+  "executors": {
+    "environments": {
+      "implementation": "./dist/cjs/executors/environments/index.js",
+      "schema": "./dist/cjs/executors/environments/schema.json",
+      "description": "Configure project with custom environments"
+    },
+    "vtex-link": {
+      "implementation": "./dist/cjs/executors/vtex-link/index.js",
+      "schema": "./dist/cjs/executors/vtex-link/schema.json",
+      "description": "Links a package to a VTEX project."
+    },
+    "publish": {
+      "implementation": "./dist/cjs/executors/publish/index.js",
+      "schema": "./dist/cjs/executors/publish/schema.json",
+      "description": "publish executor"
+    },
+    "update-executors-file": {
+      "implementation": "./dist/cjs/executors/update-executors-file/index.js",
+      "schema": "./dist/cjs/executors/update-executors-file/schema.json",
+      "description": "update-executors-file executor"
+    },
+    "deploy": {
+      "implementation": "./dist/cjs/executors/deploy/index.js",
+      "schema": "./dist/cjs/executors/deploy/schema.json",
+      "description": "deploy executor"
+    }
+  }
+}

package/package.json

@@ -1,12 +1,43 @@
 {
   "name": "@nizza/devkit",
-  "version": "0.1.0-alpha.2",
+  "version": "0.1.0-alpha.3",
+  "main": "dist/cjs/index.js",
+  "module": "dist/esm/index.js",
   "source": "src/index.ts",
-  "main": "dist/src/index.js",
-  "types": "dist/src/index.d.ts",
+  "types": "dist/esm/index.d.ts",
   "files": [
     "dist"
   ],
-  "dependencies": {},
-  "executors": "./executors.json"
+  "dependencies": {
+    "chalk": "^4",
+    "minimatch": "^9.0.3",
+    "mri": "^1.2.0",
+    "nanoid": "^5.0.2",
+    "ramda": "^0.29.1",
+    "semver": "^7.5.4"
+  },
+  "executors": "./executors.json",
+  "devDependencies": {
+    "@rollup/plugin-commonjs": "^25.0.7",
+    "@rollup/plugin-json": "^6.0.1",
+    "@rollup/plugin-node-resolve": "^15.2.3",
+    "@swc/core": "~1.3.95",
+    "rollup": "^4.2.0",
+    "rollup-plugin-copy": "^3.5.0",
+    "rollup-plugin-delete": "^2.0.0",
+    "rollup-plugin-swc3": "^0.10.3",
+    "rollup-plugin-ts": "^3.4.5"
+  },
+  "peerDependencies": {
+    "@nx/devkit": "17.0.2",
+    "@originjs/vite-plugin-commonjs": "^1.0.3",
+    "@rollup/plugin-graphql": "^2.0.4",
+    "@vitejs/plugin-react-swc": "^3.4.1",
+    "rollup-plugin-visualizer": "^5.9.2",
+    "vite": "^4.5.0",
+    "vite-plugin-css-injected-by-js": "^3.3.0",
+    "vite-plugin-dts": "^3.6.3",
+    "vite-tsconfig-paths": "^4.2.1"
+  },
+  "scripts": {}
 }

package/dist/package.json

@@ -1,13 +0,0 @@
-{
-  "name": "@nizza/devkit",
-  "version": "0.1.0-alpha.2",
-  "source": "src/index.ts",
-  "main": "./src/index.js",
-  "types": "dist/src/index.d.ts",
-  "files": [
-    "dist"
-  ],
-  "dependencies": {},
-  "executors": "./executors.json",
-  "type": "commonjs"
-}

package/dist/src/executors/deploy/executor.d.ts

@@ -1,11 +0,0 @@
-import { type ExecutorContext } from '@nx/devkit';
-import { type ExecutorResponse } from '../shared';
-export interface ExecutorOptions {
-    s3BucketPath: string;
-    cloudFrontDistributionId: string;
-    cloudFrontInvalidationPaths: string[];
-    buildTarget: string;
-    skipBuild?: boolean;
-}
-export default function deployExecutor(opts: ExecutorOptions, ctx: ExecutorContext): Promise<ExecutorResponse>;
-//# sourceMappingURL=executor.d.ts.map

package/dist/src/executors/deploy/executor.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"executor.d.ts","sourceRoot":"","sources":["../../../../src/executors/deploy/executor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,YAAY,CAAC;AAClD,OAAO,EAKL,KAAK,gBAAgB,EACtB,MAAM,WAAW,CAAC;AAOnB,MAAM,WAAW,eAAe;IAC9B,YAAY,EAAE,MAAM,CAAC;IACrB,wBAAwB,EAAE,MAAM,CAAC;IACjC,2BAA2B,EAAE,MAAM,EAAE,CAAC;IACtC,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,wBAA8B,cAAc,CAC1C,IAAI,EAAE,eAAe,EACrB,GAAG,EAAE,eAAe,GACnB,OAAO,CAAC,gBAAgB,CAAC,CAyB3B"}