@nx/vue 17.0.0-beta.4

package/src/generators/stories/stories.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.storiesGenerator = exports.createAllStories = void 0;
+const devkit_1 = require("@nx/devkit");
+const path_1 = require("path");
+const versions_1 = require("../../utils/versions");
+const component_story_1 = require("./lib/component-story");
+const minimatch = require("minimatch");
+async function createAllStories(tree, projectName, interactionTests, js, projectConfiguration, ignorePaths) {
+    const { sourceRoot, root } = projectConfiguration;
+    let componentPaths = [];
+    const pathsToCheck = [
+        (0, devkit_1.joinPathFragments)(sourceRoot, 'app'),
+        (0, devkit_1.joinPathFragments)(sourceRoot, 'components'), // Additional component folder
+    ];
+    for (const p of pathsToCheck) {
+        (0, devkit_1.visitNotIgnoredFiles)(tree, p, (path) => {
+            // Ignore private files starting with "_".
+            if ((0, path_1.basename)(path).startsWith('_'))
+                return;
+            if (ignorePaths?.some((pattern) => minimatch(path, pattern)))
+                return;
+            if (path.endsWith('.vue')) {
+                // Let's see if the .stories.* file exists
+                const ext = path.slice(path.lastIndexOf('.'));
+                const storyPathJs = `${path.split(ext)[0]}.stories.js`;
+                const storyPathTs = `${path.split(ext)[0]}.stories.ts`;
+                if (!tree.exists(storyPathJs) && !tree.exists(storyPathTs)) {
+                    componentPaths.push(path);
+                }
+            }
+        });
+    }
+    await Promise.all(componentPaths.map(async (componentPath) => {
+        const relativeCmpDir = componentPath.replace((0, path_1.join)(sourceRoot, '/'), '');
+        (0, component_story_1.createComponentStories)(tree, {
+            project: projectName,
+            interactionTests,
+            js,
+        }, relativeCmpDir);
+    }));
+}
+exports.createAllStories = createAllStories;
+async function storiesGenerator(host, schema) {
+    const projects = (0, devkit_1.getProjects)(host);
+    const projectConfiguration = projects.get(schema.project);
+    schema.interactionTests = schema.interactionTests ?? true;
+    await createAllStories(host, schema.project, schema.interactionTests, schema.js, projectConfiguration, schema.ignorePaths);
+    const tasks = [];
+    if (schema.interactionTests) {
+        const { interactionTestsDependencies, addInteractionsInAddons } = (0, devkit_1.ensurePackage)('@nx/storybook', versions_1.nxVersion);
+        tasks.push((0, devkit_1.addDependenciesToPackageJson)(host, {}, interactionTestsDependencies()));
+        addInteractionsInAddons(host, projectConfiguration);
+    }
+    if (!schema.skipFormat) {
+        await (0, devkit_1.formatFiles)(host);
+    }
+    return (0, devkit_1.runTasksInSerial)(...tasks);
+}
+exports.storiesGenerator = storiesGenerator;
+exports.default = storiesGenerator;

package/src/generators/storybook-configuration/configuration.d.ts

@@ -0,0 +1,4 @@
+import { StorybookConfigureSchema } from './schema';
+import { Tree } from '@nx/devkit';
+export declare function storybookConfigurationGenerator(host: Tree, schema: StorybookConfigureSchema): Promise<import("@nx/devkit").GeneratorCallback>;
+export default storybookConfigurationGenerator;

package/src/generators/storybook-configuration/configuration.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.storybookConfigurationGenerator = void 0;
+const stories_1 = require("../stories/stories");
+const devkit_1 = require("@nx/devkit");
+const versions_1 = require("../../utils/versions");
+async function generateStories(host, schema) {
+    await (0, stories_1.default)(host, {
+        project: schema.name,
+        js: schema.js,
+        ignorePaths: schema.ignorePaths,
+        skipFormat: true,
+        interactionTests: schema.interactionTests ?? true,
+    });
+}
+async function storybookConfigurationGenerator(host, schema) {
+    const { configurationGenerator } = (0, devkit_1.ensurePackage)('@nx/storybook', versions_1.nxVersion);
+    const installTask = await configurationGenerator(host, {
+        name: schema.name,
+        js: schema.js,
+        linter: schema.linter,
+        tsConfiguration: schema.tsConfiguration ?? true,
+        interactionTests: schema.interactionTests ?? true,
+        configureStaticServe: schema.configureStaticServe,
+        uiFramework: '@storybook/vue3-vite',
+        skipFormat: true,
+    });
+    if (schema.generateStories) {
+        await generateStories(host, schema);
+    }
+    await (0, devkit_1.formatFiles)(host);
+    return installTask;
+}
+exports.storybookConfigurationGenerator = storybookConfigurationGenerator;
+exports.default = storybookConfigurationGenerator;

package/src/generators/storybook-configuration/schema.d.ts

@@ -0,0 +1,12 @@
+import { Linter } from '@nx/linter';
+
+export interface StorybookConfigureSchema {
+  name: string;
+  interactionTests?: boolean;
+  generateStories?: boolean;
+  js?: boolean;
+  tsConfiguration?: boolean;
+  linter?: Linter;
+  ignorePaths?: string[];
+  configureStaticServe?: boolean;
+}

package/src/generators/storybook-configuration/schema.json

@@ -0,0 +1,77 @@
+{
+  "$schema": "http://json-schema.org/schema",
+  "cli": "nx",
+  "$id": "NxVueStorybookConfigure",
+  "title": "Vue Storybook Configure",
+  "description": "Set up Storybook for a Vue project.",
+  "type": "object",
+  "properties": {
+    "name": {
+      "type": "string",
+      "aliases": ["project", "projectName"],
+      "description": "Project for which to generate Storybook configuration.",
+      "$default": {
+        "$source": "argv",
+        "index": 0
+      },
+      "x-prompt": "For which project do you want to generate Storybook configuration?",
+      "x-dropdown": "projects",
+      "x-priority": "important"
+    },
+    "interactionTests": {
+      "type": "boolean",
+      "description": "Set up Storybook interaction tests.",
+      "x-prompt": "Do you want to set up Storybook interaction tests?",
+      "x-priority": "important",
+      "alias": ["configureTestRunner"],
+      "default": true
+    },
+    "generateStories": {
+      "type": "boolean",
+      "description": "Automatically generate `*.stories.ts` files for components declared in this project?",
+      "x-prompt": "Automatically generate *.stories.ts files for components declared in this project?",
+      "default": true,
+      "x-priority": "important"
+    },
+    "configureStaticServe": {
+      "type": "boolean",
+      "description": "Specifies whether to configure a static file server target for serving storybook. Helpful for speeding up CI build/test times.",
+      "x-prompt": "Configure a static file server for the storybook instance?",
+      "default": true,
+      "x-priority": "important"
+    },
+    "js": {
+      "type": "boolean",
+      "description": "Generate JavaScript story files rather than TypeScript story files.",
+      "default": false
+    },
+    "tsConfiguration": {
+      "type": "boolean",
+      "description": "Configure your project with TypeScript. Generate main.ts and preview.ts files, instead of main.js and preview.js.",
+      "default": true
+    },
+    "linter": {
+      "description": "The tool to use for running lint checks.",
+      "type": "string",
+      "enum": ["eslint"],
+      "default": "eslint"
+    },
+    "ignorePaths": {
+      "type": "array",
+      "description": "Paths to ignore when looking for components.",
+      "items": {
+        "type": "string",
+        "description": "Path to ignore."
+      },
+      "examples": [
+        "apps/my-app/src/not-stories/**",
+        "**/**/src/**/not-stories/**",
+        "libs/my-lib/**/*.something.ts",
+        "**/**/src/**/*.other.*",
+        "libs/my-lib/src/not-stories/**,**/**/src/**/*.other.*,apps/my-app/**/*.something.ts"
+      ]
+    }
+  },
+  "required": ["name"],
+  "examplesFile": "../../../docs/storybook-configuration-examples.md"
+}

package/src/tailwind.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Generates a set of glob patterns based off the source root of the app and its dependencies
+ * @param dirPath workspace relative directory path that will be used to infer the parent project and dependencies
+ * @param fileGlobPattern pass a custom glob pattern to be used
+ */
+export declare function createGlobPatternsForDependencies(dirPath: string, fileGlobPattern?: string): string[];

package/src/tailwind.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGlobPatternsForDependencies = void 0;
+const generate_globs_1 = require("@nx/js/src/utils/generate-globs");
+/**
+ * Generates a set of glob patterns based off the source root of the app and its dependencies
+ * @param dirPath workspace relative directory path that will be used to infer the parent project and dependencies
+ * @param fileGlobPattern pass a custom glob pattern to be used
+ */
+function createGlobPatternsForDependencies(dirPath, fileGlobPattern = '/**/*!(*.stories|*.spec).{vue,tsx,ts,jsx,js}') {
+    try {
+        return (0, generate_globs_1.createGlobPatternsForDependencies)(dirPath, fileGlobPattern);
+    }
+    catch (e) {
+        /**
+         * It should not be possible to reach this point when the utility is invoked as part of the normal
+         * lifecycle of Nx executors. However, other tooling, such as the VSCode Tailwind IntelliSense plugin
+         * or JetBrains editors such as WebStorm, may execute the tailwind.config.js file in order to provide
+         * autocomplete features, for example.
+         *
+         * In order to best support that use-case, we therefore do not hard error when the ProjectGraph is
+         * fundamentally unavailable in this tailwind-specific context.
+         */
+        console.warn('\nWARNING: There was an error creating glob patterns, returning an empty array\n' +
+            `${e.message}\n`);
+        return [];
+    }
+}
+exports.createGlobPatternsForDependencies = createGlobPatternsForDependencies;

package/src/utils/add-linting.d.ts

@@ -0,0 +1,12 @@
+import { Tree } from 'nx/src/generators/tree';
+import { Linter } from '@nx/linter';
+export declare function addLinting(host: Tree, options: {
+    linter: Linter;
+    name: string;
+    projectRoot: string;
+    unitTestRunner?: 'jest' | 'vitest' | 'none';
+    setParserOptionsProject?: boolean;
+    skipPackageJson?: boolean;
+    rootProject?: boolean;
+}, projectType: 'lib' | 'app'): Promise<import("@nx/devkit").GeneratorCallback>;
+export declare function editEslintConfigFiles(tree: Tree, projectRoot: string, rootProject?: boolean): void;

package/src/utils/add-linting.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.editEslintConfigFiles = exports.addLinting = void 0;
+const linter_1 = require("@nx/linter");
+const path_1 = require("nx/src/utils/path");
+const devkit_1 = require("@nx/devkit");
+const lint_1 = require("./lint");
+const eslint_file_1 = require("@nx/linter/src/generators/utils/eslint-file");
+const lint_project_1 = require("@nx/linter/src/generators/lint-project/lint-project");
+async function addLinting(host, options, projectType) {
+    if (options.linter === linter_1.Linter.EsLint) {
+        const lintTask = await (0, linter_1.lintProjectGenerator)(host, {
+            linter: options.linter,
+            project: options.name,
+            tsConfigPaths: [
+                (0, path_1.joinPathFragments)(options.projectRoot, `tsconfig.${projectType}.json`),
+            ],
+            unitTestRunner: options.unitTestRunner,
+            eslintFilePatterns: [
+                (0, lint_project_1.mapLintPattern)(options.projectRoot, '{ts,tsx,js,jsx,vue}', options.rootProject),
+            ],
+            skipFormat: true,
+            setParserOptionsProject: options.setParserOptionsProject,
+            rootProject: options.rootProject,
+        });
+        if ((0, eslint_file_1.isEslintConfigSupported)(host)) {
+            (0, eslint_file_1.addExtendsToLintConfig)(host, options.projectRoot, [
+                'plugin:vue/vue3-essential',
+                'eslint:recommended',
+                '@vue/eslint-config-typescript',
+                '@vue/eslint-config-prettier/skip-formatting',
+            ]);
+        }
+        editEslintConfigFiles(host, options.projectRoot, options.rootProject);
+        let installTask = () => { };
+        if (!options.skipPackageJson) {
+            installTask = (0, devkit_1.addDependenciesToPackageJson)(host, lint_1.extraEslintDependencies.dependencies, lint_1.extraEslintDependencies.devDependencies);
+        }
+        return (0, devkit_1.runTasksInSerial)(lintTask, installTask);
+    }
+    else {
+        return () => { };
+    }
+}
+exports.addLinting = addLinting;
+function editEslintConfigFiles(tree, projectRoot, rootProject) {
+    if (tree.exists((0, path_1.joinPathFragments)(projectRoot, 'eslint.config.js'))) {
+        const fileName = (0, path_1.joinPathFragments)(projectRoot, 'eslint.config.js');
+        (0, devkit_1.updateJson)(tree, fileName, (json) => {
+            let updated = false;
+            for (let override of json.overrides) {
+                if (override.parserOptions) {
+                    if (!override.files.includes('*.vue')) {
+                        override.files.push('*.vue');
+                    }
+                    updated = true;
+                }
+            }
+            if (!updated) {
+                json.overrides = [
+                    {
+                        files: ['*.ts', '*.tsx', '*.js', '*.jsx', '*.vue'],
+                        rules: {},
+                    },
+                ];
+            }
+            return json;
+        });
+    }
+    else {
+        const fileName = (0, path_1.joinPathFragments)(projectRoot, '.eslintrc.json');
+        (0, devkit_1.updateJson)(tree, fileName, (json) => {
+            let updated = false;
+            for (let override of json.overrides) {
+                if (override.parserOptions) {
+                    if (!override.files.includes('*.vue')) {
+                        override.files.push('*.vue');
+                    }
+                    updated = true;
+                }
+            }
+            if (!updated) {
+                json.overrides = [
+                    {
+                        files: ['*.ts', '*.tsx', '*.js', '*.jsx', '*.vue'],
+                        rules: {},
+                    },
+                ];
+            }
+            return json;
+        });
+    }
+    // Edit root config too
+    if (tree.exists('.eslintrc.base.json')) {
+        (0, devkit_1.updateJson)(tree, '.eslintrc.base.json', (json) => {
+            for (let override of json.overrides) {
+                if (override.rules &&
+                    '@nx/enforce-module-boundaries' in override.rules) {
+                    if (!override.files.includes('*.vue')) {
+                        override.files.push('*.vue');
+                    }
+                }
+            }
+            return json;
+        });
+    }
+    else if (tree.exists('.eslintrc.json') && !rootProject) {
+        (0, devkit_1.updateJson)(tree, '.eslintrc.json', (json) => {
+            for (let override of json.overrides) {
+                if (override.rules &&
+                    '@nx/enforce-module-boundaries' in override.rules) {
+                    if (!override.files.includes('*.vue')) {
+                        override.files.push('*.vue');
+                    }
+                }
+            }
+            return json;
+        });
+    }
+}
+exports.editEslintConfigFiles = editEslintConfigFiles;

package/src/utils/ast-utils.d.ts

@@ -0,0 +1,3 @@
+import type * as ts from 'typescript';
+import { StringChange } from '@nx/devkit';
+export declare function addImport(source: ts.SourceFile, statement: string): StringChange[];

package/src/utils/ast-utils.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addImport = void 0;
+const js_1 = require("@nx/js");
+const devkit_1 = require("@nx/devkit");
+const ensure_typescript_1 = require("@nx/js/src/utils/typescript/ensure-typescript");
+let tsModule;
+function addImport(source, statement) {
+    if (!tsModule) {
+        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+    }
+    const allImports = (0, js_1.findNodes)(source, tsModule.SyntaxKind.ImportDeclaration);
+    if (allImports.length > 0) {
+        const lastImport = allImports[allImports.length - 1];
+        return [
+            {
+                type: devkit_1.ChangeType.Insert,
+                index: lastImport.end + 1,
+                text: `\n${statement}\n`,
+            },
+        ];
+    }
+    else {
+        return [
+            {
+                type: devkit_1.ChangeType.Insert,
+                index: 0,
+                text: `\n${statement}\n`,
+            },
+        ];
+    }
+}
+exports.addImport = addImport;

package/src/utils/create-ts-config.d.ts

@@ -0,0 +1,9 @@
+import { Tree } from '@nx/devkit';
+export declare function createTsConfig(host: Tree, projectRoot: string, type: 'app' | 'lib', options: {
+    strict?: boolean;
+    style?: string;
+    bundler?: string;
+    rootProject?: boolean;
+    unitTestRunner?: string;
+}, relativePathToRootTsConfig: string): void;
+export declare function extractTsConfigBase(host: Tree): void;

package/src/utils/create-ts-config.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractTsConfigBase = exports.createTsConfig = void 0;
+const devkit_1 = require("@nx/devkit");
+const shared = require("@nx/js/src/utils/typescript/create-ts-config");
+function createTsConfig(host, projectRoot, type, options, relativePathToRootTsConfig) {
+    const json = {
+        compilerOptions: {
+            allowJs: true,
+            esModuleInterop: false,
+            allowSyntheticDefaultImports: true,
+            strict: options.strict,
+            jsx: 'preserve',
+            jsxImportSource: 'vue',
+            moduleResolution: 'bundler',
+            resolveJsonModule: true,
+            verbatimModuleSyntax: options.unitTestRunner !== 'jest',
+        },
+        files: [],
+        include: [],
+        references: [
+            {
+                path: type === 'app' ? './tsconfig.app.json' : './tsconfig.lib.json',
+            },
+        ],
+    };
+    if (options.unitTestRunner === 'vitest') {
+        json.references.push({
+            path: './tsconfig.spec.json',
+        });
+    }
+    // inline tsconfig.base.json into the project
+    if (options.rootProject) {
+        json.compileOnSave = false;
+        json.compilerOptions = {
+            ...shared.tsConfigBaseOptions,
+            ...json.compilerOptions,
+        };
+        json.exclude = ['node_modules', 'tmp'];
+    }
+    else {
+        json.extends = relativePathToRootTsConfig;
+    }
+    (0, devkit_1.writeJson)(host, `${projectRoot}/tsconfig.json`, json);
+    const tsconfigProjectPath = `${projectRoot}/tsconfig.${type}.json`;
+    if (options.bundler === 'vite' && host.exists(tsconfigProjectPath)) {
+        (0, devkit_1.updateJson)(host, tsconfigProjectPath, (json) => {
+            json.compilerOptions ??= {};
+            const types = new Set(json.compilerOptions.types ?? []);
+            types.add('vite/client');
+            json.compilerOptions.types = Array.from(types);
+            return json;
+        });
+    }
+    else {
+    }
+}
+exports.createTsConfig = createTsConfig;
+function extractTsConfigBase(host) {
+    shared.extractTsConfigBase(host);
+    if (host.exists('vite.config.ts')) {
+        const vite = host.read('vite.config.ts').toString();
+        host.write('vite.config.ts', vite.replace(`projects: []`, `projects: ['tsconfig.base.json']`));
+    }
+}
+exports.extractTsConfigBase = extractTsConfigBase;

package/src/utils/lint.d.ts

@@ -0,0 +1,9 @@
+export declare const extraEslintDependencies: {
+    dependencies: {};
+    devDependencies: {
+        '@vue/eslint-config-prettier': string;
+        '@vue/eslint-config-typescript': string;
+        'eslint-plugin-vue': string;
+    };
+};
+export declare const extendVueEslintJson: (json: any) => any;

package/src/utils/lint.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extendVueEslintJson = exports.extraEslintDependencies = void 0;
+const versions_1 = require("./versions");
+exports.extraEslintDependencies = {
+    dependencies: {},
+    devDependencies: {
+        '@vue/eslint-config-prettier': versions_1.vueEslintConfigPrettierVersion,
+        '@vue/eslint-config-typescript': versions_1.vueEslintConfigTypescriptVersion,
+        'eslint-plugin-vue': versions_1.eslintPluginVueVersion,
+    },
+};
+const extendVueEslintJson = (json) => {
+    const { extends: pluginExtends, ...config } = json;
+    return {
+        extends: [
+            'plugin:vue/vue3-essential',
+            'eslint:recommended',
+            '@vue/eslint-config-typescript',
+            '@vue/eslint-config-prettier/skip-formatting',
+            ...(pluginExtends || []),
+        ],
+        ...config,
+    };
+};
+exports.extendVueEslintJson = extendVueEslintJson;

package/src/utils/setup-jest.d.ts

@@ -0,0 +1,4 @@
+import { Tree } from '@nx/devkit';
+export declare function setupJestProject(tree: Tree, projectRoot: string): void;
+export declare function writeBabelRcFile(tree: Tree, projectRoot: string): void;
+export declare function updateJestConfigTsFile(tree: Tree, projectRoot: string): void;

package/src/utils/setup-jest.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateJestConfigTsFile = exports.writeBabelRcFile = exports.setupJestProject = void 0;
+const devkit_1 = require("@nx/devkit");
+function setupJestProject(tree, projectRoot) {
+    updateJestConfigTsFile(tree, projectRoot);
+    writeBabelRcFile(tree, projectRoot);
+}
+exports.setupJestProject = setupJestProject;
+function writeBabelRcFile(tree, projectRoot) {
+    (0, devkit_1.writeJson)(tree, (0, devkit_1.joinPathFragments)(projectRoot, '.babelrc'), {
+        presets: ['@nx/js/babel'],
+    });
+}
+exports.writeBabelRcFile = writeBabelRcFile;
+function updateJestConfigTsFile(tree, projectRoot) {
+    const jestConfigTs = (0, devkit_1.joinPathFragments)(projectRoot, 'jest.config.ts');
+    if (tree.exists(jestConfigTs)) {
+        const { tsquery } = require('@phenomnomnominal/tsquery');
+        let fileContent = tree.read(jestConfigTs, 'utf-8');
+        const sourceFile = tsquery.ast(fileContent);
+        const settingsObject = tsquery.query(sourceFile, 'ObjectLiteralExpression')?.[0];
+        if (settingsObject) {
+            const moduleFileExtensions = tsquery.query(sourceFile, `PropertyAssignment:has(Identifier:has([name="moduleFileExtensions"]))`)?.[0];
+            if (moduleFileExtensions) {
+                fileContent = (0, devkit_1.applyChangesToString)(fileContent, [
+                    {
+                        type: devkit_1.ChangeType.Delete,
+                        start: moduleFileExtensions.getStart(),
+                        length: moduleFileExtensions.getEnd() -
+                            moduleFileExtensions.getStart() +
+                            1,
+                    },
+                ]);
+            }
+            const transformProperty = tsquery.query(sourceFile, `PropertyAssignment:has(Identifier:has([name="transform"]))`)?.[0];
+            if (transformProperty) {
+                fileContent = (0, devkit_1.applyChangesToString)(fileContent, [
+                    {
+                        type: devkit_1.ChangeType.Delete,
+                        start: transformProperty.getStart(),
+                        length: transformProperty.getEnd() - transformProperty.getStart() + 1,
+                    },
+                ]);
+            }
+            const settingsObjectUpdated = tsquery.query(fileContent, 'ObjectLiteralExpression')?.[0];
+            fileContent = (0, devkit_1.applyChangesToString)(fileContent, [
+                {
+                    type: devkit_1.ChangeType.Insert,
+                    index: settingsObjectUpdated.getEnd() - 1,
+                    text: `,
+            moduleFileExtensions: ['js', 'ts', 'json', 'vue'],
+            transform: {
+              '^.+\\.[tj]sx?$': ['babel-jest'],
+              '^.+\\.vue$': [
+                '@vue/vue3-jest',
+                {
+                  tsConfig: './tsconfig.spec.json',
+                },
+              ],
+            },
+            testEnvironment: 'jsdom',
+            testMatch: ['**/*.spec.ts?(x)', '**/__tests__/*.ts?(x)'],
+            `,
+                },
+            ]);
+            tree.write(jestConfigTs, fileContent);
+        }
+        else {
+            writeNewJestConfig(tree, projectRoot);
+        }
+    }
+    else {
+        writeNewJestConfig(tree, projectRoot);
+    }
+}
+exports.updateJestConfigTsFile = updateJestConfigTsFile;
+function writeNewJestConfig(tree, projectRoot) {
+    tree.write((0, devkit_1.joinPathFragments)(projectRoot, 'jest.config.js'), `
+          module.exports = {
+              preset: '${devkit_1.offsetFromRoot}/jest.preset.js',
+              moduleFileExtensions: ['js', 'ts', 'json', 'vue'],
+              transform: {
+                '^.+\\.[tj]sx?$': ['babel-jest'],
+                '^.+\\.vue$': [
+                  '@vue/vue3-jest',
+                  {
+                    tsConfig: './tsconfig.spec.json',
+                  },
+                ],
+              },
+              testEnvironment: 'jsdom',
+              testMatch: ['**/*.spec.ts?(x)', '**/__tests__/*.ts?(x)'],
+            };
+          `);
+}

package/src/utils/test-utils.d.ts

@@ -0,0 +1,3 @@
+import { Tree } from '@nx/devkit';
+export declare function createApp(tree: Tree, appName: string): Promise<any>;
+export declare function createLib(tree: Tree, libName: string): Promise<any>;

package/src/utils/test-utils.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLib = exports.createApp = void 0;
+const devkit_1 = require("@nx/devkit");
+const linter_1 = require("@nx/linter");
+const application_1 = require("../generators/application/application");
+async function createApp(tree, appName) {
+    await (0, application_1.default)(tree, {
+        e2eTestRunner: 'none',
+        linter: linter_1.Linter.EsLint,
+        skipFormat: true,
+        style: 'css',
+        unitTestRunner: 'none',
+        name: appName,
+        projectNameAndRootFormat: 'as-provided',
+    });
+}
+exports.createApp = createApp;
+async function createLib(tree, libName) {
+    const { fileName } = (0, devkit_1.names)(libName);
+    tree.write(`/${fileName}/src/index.ts`, ``);
+    (0, devkit_1.addProjectConfiguration)(tree, fileName, {
+        tags: [],
+        root: `${fileName}`,
+        projectType: 'library',
+        sourceRoot: `${fileName}/src`,
+        targets: {},
+    });
+}
+exports.createLib = createLib;