KaneAI - World’s First E2E Software Testing Agent.Signup for Private Beta Join TestMu Conference

How to use tsConfig method in storybook-root

Best JavaScript code snippet using storybook-root

compile-references.js

Source:compile-references.js

1// @ts-check2'use-strict';3/********************************************************************************4 * Copyright (C) 2020 Ericsson and others.5 *6 * This program and the accompanying materials are made available under the7 * terms of the Eclipse Public License v. 2.0 which is available at8 * http://www.eclipse.org/legal/epl-2.0.9 *10 * This Source Code may also be made available under the following Secondary11 * Licenses when the conditions for such availability set forth in the Eclipse12 * Public License v. 2.0 are satisfied: GNU General Public License, version 213 * with the GNU Classpath Exception which is available at14 * https://www.gnu.org/software/classpath/license.html.15 *16 * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.017 ********************************************************************************/18/**19 * This script generates tsconfig references between our workspaces, it also20 * configures our .eslintrc file to use such references.21 *22 * `tsc` build mode relies on these references to build out of date dependencies23 * only when required, but it cannot infer workspaces by itself, it has to be24 * explicitly defined [1].25 *26 * You can do a dry run using the cli flag `--dry-run`, the script will exit27 * with a code different from zero if something needed to be updated.28 *29 * [1]: https://www.typescriptlang.org/docs/handbook/project-references.html30 */31const cp = require('child_process');32const path = require('path').posix;33const fs = require('fs');34const ROOT = path.join(__dirname, '..');35const DRY_RUN = popFlag(process.argv, '--dry-run');36const FORCE_REWRITE = popFlag(process.argv, '--force-rewrite') && !DRY_RUN;37/** @type {{ [packageName: string]: YarnWorkspace }} */38const YARN_WORKSPACES = JSON.parse(cp.execSync('yarn --silent workspaces info').toString());39// Add the package name inside each package object.40for (const [packageName, yarnWorkspace] of Object.entries(YARN_WORKSPACES)) {41    yarnWorkspace.name = packageName;42}43/** @type {YarnWorkspace} */44const THEIA_MONOREPO = {45    name: '@theia/monorepo',46    workspaceDependencies: Object.keys(YARN_WORKSPACES),47    location: ROOT,48};49try {50    let rewriteRequired = false;51    let result = false;52    // Configure all `compile.tsconfig.json` files of this monorepo53    for (const packageName of Object.keys(YARN_WORKSPACES)) {54        const workspacePackage = YARN_WORKSPACES[packageName];55        const tsconfigCompilePath = path.join(ROOT, workspacePackage.location, 'compile.tsconfig.json');56        const references = getTypescriptReferences(workspacePackage);57        result = configureTypeScriptCompilation(workspacePackage, tsconfigCompilePath, references);58        rewriteRequired = rewriteRequired || result;59    }60    // Configure our root compilation configuration, living inside `configs/root-compilation.tsconfig.json`.61    const configsFolder = path.join(ROOT, 'configs');62    const tsconfigCompilePath = path.join(configsFolder, 'root-compilation.tsconfig.json');63    const references = getTypescriptReferences(THEIA_MONOREPO, configsFolder);64    result = configureTypeScriptCompilation(THEIA_MONOREPO, tsconfigCompilePath, references);65    rewriteRequired = rewriteRequired || result;66    // Configure the root `tsconfig.json` for code navigation using `tsserver`.67    const tsconfigNavPath = path.join(ROOT, 'tsconfig.json');68    result = configureTypeScriptNavigation(THEIA_MONOREPO, tsconfigNavPath);69    rewriteRequired = rewriteRequired || result;70    // CI will be able to tell if references got changed by looking at the exit code.71    if (rewriteRequired) {72        if (DRY_RUN) {73            // Running a dry run usually only happens when a developer or CI runs the tests, so we only print the help then.74            console.error('TypeScript references seem to be out of sync, run "yarn prepare:references" to fix.');75            process.exitCode = 1;76        } else {77            console.warn('TypeScript references were out of sync and got updated.');78        }79    }80} catch (error) {81    console.error(error);82    process.exitCode = 1;83}84/**85 * @param {YarnWorkspace} requestedPackage86 * @param {string} [overrideLocation] affects how relative paths are computed.87 * @returns {string[]} project references for `requestedPackage`.88 */89function getTypescriptReferences(requestedPackage, overrideLocation) {90    const references = [];91    for (const dependency of requestedPackage.workspaceDependencies || []) {92        const depWorkspace = YARN_WORKSPACES[dependency];93        const depConfig = path.join(depWorkspace.location, 'compile.tsconfig.json');94        if (!fs.existsSync(depConfig)) {95            continue;96        }97        const relativePath = path.relative(overrideLocation || requestedPackage.location, depWorkspace.location);98        references.push(relativePath);99    }100    return references;101}102/**103 * Wires a given compilation tsconfig file according to the provided references.104 * This allows TypeScript to operate in build mode.105 *106 * @param {YarnWorkspace} targetPackage for debug purpose.107 * @param {string} tsconfigPath path to the tsconfig file to edit.108 * @param {string[]} references list of paths to the related project roots.109 * @returns {boolean} rewrite was needed.110 */111function configureTypeScriptCompilation(targetPackage, tsconfigPath, references) {112    if (!fs.existsSync(tsconfigPath)) {113        return false;114    }115    const tsconfigJson = readJsonFile(tsconfigPath);116    let needRewrite = FORCE_REWRITE;117    if (!tsconfigJson.compilerOptions) {118        // Somehow no `compilerOptions` literal is defined.119        tsconfigJson.compilerOptions = {120            composite: true,121            rootDir: 'src',122            outDir: 'lib',123        };124        needRewrite = true;125    } else if (!tsconfigJson.compilerOptions.composite) {126        // `compilerOptions` is missing the `composite` literal.127        tsconfigJson.compilerOptions = {128            composite: true,129            ...tsconfigJson.compilerOptions,130        };131        needRewrite = true;132    }133    /** @type {string[]} */134    const tsconfigReferences = references135        .map(reference => path.join(reference, 'compile.tsconfig.json'));136    /** @type {string[]} */137    const currentReferences = (tsconfigJson['references'] || [])138        // We will work on a set of paths, easier to handle than objects.139        .map(reference => reference.path)140        // Remove any invalid reference (maybe outdated).141        .filter((referenceRelativePath, index, self) => {142            if (!tsconfigReferences.includes(referenceRelativePath)) {143                // Found a reference that wasn't automatically computed, will remove.144                console.warn(`error: ${targetPackage.name} untracked reference: ${referenceRelativePath}`);145                needRewrite = true;146                return false; // remove147            }148            if (self.indexOf(referenceRelativePath) !== index) {149                // Remove duplicates.150                console.error(`error: ${targetPackage.name} duplicate reference: ${referenceRelativePath}`);151                needRewrite = true;152                return false; // remove153            }154            const referencePath = path.join(path.dirname(tsconfigPath), referenceRelativePath);155            try {156                const referenceStat = fs.statSync(referencePath);157                if (referenceStat.isDirectory() && fs.statSync(path.join(referencePath, 'tsconfig.json')).isFile()) {158                    return true; // keep159                } else if (referenceStat.isFile()) { // still could be something else than a tsconfig, but good enough.160                    return true; // keep161                }162            } catch {163                // passthrough164            }165            console.error(`error: ${targetPackage.name} invalid reference: ${referenceRelativePath}`);166            needRewrite = true;167            return false; // remove168        });169    for (const tsconfigReference of tsconfigReferences) {170        if (!currentReferences.includes(tsconfigReference)) {171            console.error(`error: ${targetPackage.name} missing reference: ${tsconfigReference}`);172            currentReferences.push(tsconfigReference);173            needRewrite = true;174        }175    }176    if (!DRY_RUN && needRewrite) {177        tsconfigJson.references = currentReferences.map(path => ({ path }));178        const content = JSON.stringify(tsconfigJson, undefined, 2);179        fs.writeFileSync(tsconfigPath, content + '\n');180        console.warn(`info: ${tsconfigPath} updated.`);181    }182    return needRewrite;183}184/**185 * Wire the root `tsconfig.json` to map scoped import to real location in the monorepo.186 * This setup is a shim for the TypeScript language server to provide cross-package navigation.187 * Compilation is done via `compile.tsconfig.json` files.188 *189 * @param {YarnWorkspace} targetPackage for debug purpose.190 * @param {string} tsconfigPath191 * @returns {boolean} rewrite was needed.192 */193function configureTypeScriptNavigation(targetPackage, tsconfigPath) {194    const tsconfigJson = readJsonFile(tsconfigPath);195    let needRewrite = FORCE_REWRITE;196    if (typeof tsconfigJson.compilerOptions === 'undefined') {197        // Somehow no `compilerOptions` literal is defined.198        tsconfigJson.compilerOptions = {199            baseUrl: '.',200            paths: {},201        };202        needRewrite = true;203    } else if (typeof tsconfigJson.compilerOptions.paths === 'undefined') {204        // `compilerOptions` is missing the `paths` literal.205        tsconfigJson.compilerOptions = {206            ...tsconfigJson.compilerOptions,207            paths: {},208        };209        needRewrite = true;210    }211    /** @type {{ [prefix: string]: string[] }} */212    const currentPaths = tsconfigJson.compilerOptions.paths;213    for (const packageName of THEIA_MONOREPO.workspaceDependencies) {214        const depWorkspace = YARN_WORKSPACES[packageName];215        /** @type {string} */216        let originalImportPath;217        /** @type {string} */218        let mappedFsPath;219        const depSrcPath = path.join(depWorkspace.location, 'src');220        const depConfigPath = path.join(depWorkspace.location, 'compile.tsconfig.json');221        if (fs.existsSync(depConfigPath) && fs.existsSync(depSrcPath)) {222            // If it is a TypeScript dependency, map `lib` imports to our local sources in `src`.223            const depConfigJson = readJsonFile(depConfigPath);224            originalImportPath = `${packageName}/${depConfigJson.compilerOptions.outDir}/*`;225            mappedFsPath = path.relative(THEIA_MONOREPO.location, path.join(depSrcPath, '*'));226        } else {227            // I don't really know what to do here, simply point to our local package root.228            originalImportPath = `${packageName}/*`;229            mappedFsPath = path.relative(THEIA_MONOREPO.location, path.join(depWorkspace.location, '*'));230        }231        /** @type {string[] | undefined} */232        const currentFsPaths = currentPaths[originalImportPath];233        if (typeof currentFsPaths === 'undefined' || currentFsPaths.length !== 1 || currentFsPaths[0] !== mappedFsPath) {234            console.error(`error: ${targetPackage.name} invalid mapped path: ${JSON.stringify({ [originalImportPath]: currentFsPaths })}`);235            currentPaths[originalImportPath] = [mappedFsPath];236            needRewrite = true;237        }238    }239    if (!DRY_RUN && needRewrite) {240        const content = JSON.stringify(tsconfigJson, undefined, 2);241        fs.writeFileSync(tsconfigPath, content + '\n');242        console.warn(`info: ${tsconfigPath} updated.`);243    }244    return needRewrite;245}246/**247 *248 * @param {string[]} argv249 * @param {string} flag250 * @returns {boolean}251 */252function popFlag(argv, flag) {253    const flagIndex = argv.indexOf(flag)254    if (flagIndex !== -1) {255        argv.splice(flagIndex, 1);256        return true;257    } else {258        return false;259    }260}261/**262 * @param {string} filePath263 * @returns {any}264 */265function readJsonFile(filePath) {266    try {267        return JSON.parse(fs.readFileSync(filePath).toString());268    } catch (error) {269        console.error('ParseError in file:', filePath);270        throw error;271    }272}273/**274 * @typedef YarnWorkspace275 * @property {string} name276 * @property {string} location277 * @property {string[]} workspaceDependencies...

configs.spec.ts

Source:configs.spec.ts

1import * as path from 'path';2import { assert } from 'chai';3import { copyFromTo } from '../src/utils';4import { createNGCConfig, parseConfigFile } from '../src/config-helpers';5describe('ConfigHelpers', () => {6  before((done: Function) => {7    copyFromTo({8      pattern: 'tsconfig*',9      rootDir: path.resolve(process.cwd(), 'integration/project4'),10      toDir: path.resolve(__dirname),11    }).then(() => done());12  });13  const defaultTSConfigPath = path.resolve(__dirname, './tsconfig.json');14  it('createNGCConfig', () => {15    const ngcConfigsPath = path.resolve(__dirname, 'tsconfig.ngc.json');16    let { configs: defaultTSConfig, error } = parseConfigFile(defaultTSConfigPath);17    defaultTSConfig.angularCompilerOptions = {18      annotateForClosureCompiler: false,19    };20    assert.isUndefined(error);21    assert.property(defaultTSConfig, 'compilerOptions');22    const moduleId = 'check-mod';23    const flatModuleId = '@scope/module';24    createNGCConfig(ngcConfigsPath, moduleId, defaultTSConfig, flatModuleId);25    ({ configs: defaultTSConfig, error  } = parseConfigFile(ngcConfigsPath));26    assert.isDefined(defaultTSConfig, 'files');27    assert.isArray(defaultTSConfig.files);28    assert.deepEqual(defaultTSConfig.files, ['./src/public_api.ts']);29    assert.isUndefined(error);30    assert.property(defaultTSConfig, 'compilerOptions');31    assert.propertyVal(defaultTSConfig.compilerOptions, 'outDir', './ngc-compiled');32    assert.propertyVal(defaultTSConfig.compilerOptions, 'module', 'es2015');33    assert.property(defaultTSConfig, 'angularCompilerOptions');34    assert.propertyVal(defaultTSConfig.angularCompilerOptions, 'flatModuleId', flatModuleId);35    assert.propertyVal(defaultTSConfig.angularCompilerOptions, 'annotateForClosureCompiler', false);36  });37  it('createNGCConfig: no flatModuleId', () => {38    const ngcConfigsPath = path.resolve(__dirname, 'tsconfig.ngc.json');39    let { configs: defaultTSConfig, error } = parseConfigFile(defaultTSConfigPath);40    defaultTSConfig.angularCompilerOptions = {41      annotateForClosureCompiler: false,42    };43    assert.isUndefined(error);44    assert.property(defaultTSConfig, 'compilerOptions');45    const moduleId = 'check-mod';46    createNGCConfig(ngcConfigsPath, moduleId, defaultTSConfig);47    ({ configs: defaultTSConfig, error  } = parseConfigFile(ngcConfigsPath));48    assert.isDefined(defaultTSConfig, 'files');49    assert.isArray(defaultTSConfig.files);50    assert.deepEqual(defaultTSConfig.files, ['./src/public_api.ts']);51    assert.isUndefined(error);52    assert.property(defaultTSConfig, 'compilerOptions');53    assert.propertyVal(defaultTSConfig.compilerOptions, 'outDir', './ngc-compiled');54    assert.propertyVal(defaultTSConfig.compilerOptions, 'module', 'es2015');55    assert.property(defaultTSConfig, 'angularCompilerOptions');56    assert.propertyVal(defaultTSConfig.angularCompilerOptions, 'flatModuleId', moduleId);57    assert.propertyVal(defaultTSConfig.angularCompilerOptions, 'annotateForClosureCompiler', false);58  });59  it('parseConfigFile (Extends configs)', () => {60    const loaded = parseConfigFile(defaultTSConfigPath);61    assert.isUndefined(loaded.error);62    assert.isDefined(loaded.configs);63    const { compilerOptions } = loaded.configs;64    assert.isDefined(compilerOptions);65    assert.property(compilerOptions, 'target', 'es5');66    assert.property(compilerOptions, 'module', 'es2015');67  });...

update-tsconfigs.ts

Source:update-tsconfigs.ts

1import * as FS from 'fs';2import * as Path from 'path';3import Glob from 'glob';4import {format} from 'prettier';5import stripJsonComments from 'strip-json-comments';6// tslint:disable-next-line: no-var-requires no-require-imports7const PRETTIER_CONFIG = require('../prettier.config');8const TSCONFIG_FILE_NAME = 'tsconfig.json';9const COMPOSITE_TSCONFIG_FILE_NAME = 'tsconfig.json';10const CONFIG_EXTENSION_TO_COMPILER_OPTIONS_DICT = {11  incremental: {12    noUnusedLocals: false,13    noUnusedParameters: false,14  },15};16interface TSConfig {17  extends?: string;18  compilerOptions?: object;19  references?: {path: string}[];20}21const tsConfigPaths = Glob.sync(`**/${TSCONFIG_FILE_NAME}`, {22  ignore: '**/node_modules/**',23});24for (let tsConfigPath of tsConfigPaths) {25  let dirName = Path.dirname(tsConfigPath);26  let compositeTSConfigPath = Path.join(dirName, COMPOSITE_TSCONFIG_FILE_NAME);27  let compositeTSConfigJSONC = FS.readFileSync(compositeTSConfigPath, 'utf8');28  let compositeTSConfig = JSON.parse(29    stripJsonComments(compositeTSConfigJSONC),30  ) as TSConfig;31  let {references = []} = compositeTSConfig;32  let beingReferencesConfig =33    !compositeTSConfig.extends && !compositeTSConfig.compilerOptions;34  for (let reference of references) {35    let path = Path.join(dirName, reference.path);36    let stats = FS.statSync(path);37    if (stats && stats.isDirectory()) {38      reference.path = Path.join(reference.path, TSCONFIG_FILE_NAME);39      path = Path.join(dirName, reference.path);40      stats = FS.statSync(path);41    }42    if (!stats || !stats.isFile()) {43      throw new Error(44        `Reference "${reference.path}" in "${compositeTSConfigPath}" does not exist`,45      );46    }47  }48  for (let [extension, compilerOptions] of Object.entries(49    CONFIG_EXTENSION_TO_COMPILER_OPTIONS_DICT,50  )) {51    let extendedTSConfigPath = Path.join(dirName, `tsconfig.${extension}.json`);52    if (!FS.existsSync(extendedTSConfigPath)) {53      continue;54    }55    let extendedTSConfigReferences = references56      .map(({path: relativePath, ...rest}) => {57        return {58          path: Path.join(59            relativePath,60            `../tsconfig.${extension}.json`,61          ).replace(/\\/g, '/'),62          ...rest,63        };64      })65      .filter(({path: relativePath}) =>66        FS.existsSync(Path.join(dirName, relativePath)),67      );68    let extendedTSConfig = beingReferencesConfig69      ? {70          references: extendedTSConfigReferences,71          files: [],72        }73      : {74          extends: `./${COMPOSITE_TSCONFIG_FILE_NAME}`,75          compilerOptions,76          references: extendedTSConfigReferences.length77            ? extendedTSConfigReferences78            : undefined,79        };80    updateTSConfigFile(extendedTSConfigPath, extendedTSConfig);81  }82}83function updateTSConfigFile(path: string, config: TSConfig): void {84  let json = format(JSON.stringify(config), {85    parser: 'json',86    ...PRETTIER_CONFIG,87  });88  let originalJSON = FS.existsSync(path)89    ? FS.readFileSync(path, 'utf8')90    : undefined;91  if (json !== originalJSON) {92    FS.writeFileSync(path, json);93    console.info(`Updated "${path}".`);94  }...

Using AI Code Generation

1module.exports = {2  stories: ['../src/**/*.stories.@(js|jsx|ts|tsx|mdx)'],3};4{5  "compilerOptions": {6    "paths": {7    }8  }9}10const path = require('path');11module.exports = {12  stories: ['../src/**/*.stories.@(js|jsx|ts|tsx|mdx)'],13  webpackFinal: async (config) => {14    config.resolve.alias = {15      '@': path.resolve(__dirname, '../src'),16      'components': path.resolve(__dirname, '../src/components'),17      'pages': path.resolve(__dirname, '../src/pages'),18      'utils': path.resolve(__dirname, '../src/utils'),19      'assets': path.resolve(__dirname, '../src/assets'),20      'styles': path.resolve(__dirname, '../src/styles'),21      'redux': path.resolve(__dirname, '../src/redux'),22      'storybook': path.resolve(__dirname, '../.storybook'),23    };24    return config;25  },26};27import { addDecorator } from '@storybook/react';28import { withRootAlias } from 'storybook-addon-root-alias';29addDecorator(withRootAlias({ '@': 'src' }));30{31  "compilerOptions": {32    "paths": {

Using AI Code Generation

1const root = require('storybook-root');2module.exports = {3  stories: ['../src/**/*.stories.@(js|jsx|ts|tsx)'],4  typescript: {5    reactDocgenTypescriptOptions: {6      tsconfigPath: root.resolve('tsconfig.json'),7    },8  },9};10{11  "compilerOptions": {12    "paths": {13    }14  },15}16{17  "compilerOptions": {18  },19}20const root = require('storybook-root');21const path = require('path');22const tsConfigPathsPlugin = require('tsconfig-paths-webpack-plugin');23module.exports = async ({ config, mode }) => {24    new tsConfigPathsPlugin({25      configFile: root.resolve('tsconfig.json'),26    }),27  ];28  config.resolve.extensions.push('.ts', '.tsx');29  config.module.rules.push({30    test: /\.(ts|tsx)$/,31    loader: require.resolve('babel-loader'),32    options: {33      presets: [['react-app', { flow: false, typescript: true }]],34    },35  });36  config.module.rules.push({37    include: path.resolve(__dirname, '../'),38  });39  return config;40};41{

Using AI Code Generation

1const tsConfig = require('tsconfig-paths');2const tsConfigPaths = tsConfig.loadConfig('./tsconfig.json');3tsConfig.register({4});5const { alias } = require('storybook-root-alias');6alias();7const { alias } = require('storybook-root-alias');8const tsConfig = require('tsconfig-paths-webpack-plugin');9const tsConfigPaths = tsConfig('./tsconfig.json');10alias({11});12const { alias } = require('storybook-root-alias');13const tsConfig = require('tsconfig-paths-webpack-plugin');14const tsConfigPaths = tsConfig('./tsconfig.json');15const { resolve } = require('webpack-alias-resolver');16const webpackConfig = {17  resolve: {18    alias: resolve(tsConfigPaths),19  },20};21alias({22});23const { alias } = require('storybook-root-alias');24const tsConfig = require('tsconfig-paths-webpack-plugin');25const tsConfigPaths = tsConfig('./tsconfig.json');26const { resolve } = require('webpack-alias-resolver');27const webpack = require('webpack');28const webpackConfig = {29  resolve: {30    alias: resolve(tsConfigPaths),31  },32};33const compiler = webpack(webpackConfig);34alias({35});36const { alias } = require('storybook-root-alias');37const tsConfig = require('tsconfig-paths-webpack-plugin');38const tsConfigPaths = tsConfig('./tsconfig.json');39const { resolve } = require('webpack-alias-resolver');40const webpack = require('webpack');41const webpackConfig = require('./webpack.config.js');42const compiler = webpack(webpackConfig);43alias({44});

Using AI Code Generation

1const { tsConfig } = require('storybook-root-config');2module.exports = {3  stories: ['../src/**/*.stories.@(ts|tsx|js|jsx|mdx)'],4  typescript: {5  },6  core: {7  },8  webpackFinal: async (config) => {9    return {10      module: {11          {12            test: /\.(ts|tsx)$/,13            loader: require.resolve('babel-loader'),14            options: {15              presets: [['react-app', { flow: false, typescript: true }]],16            },17          },18      },19      resolve: {20        alias: {21          ...tsConfig().compilerOptions.paths,22        },23      },24    };25  },26};27const { tsConfig } = require('storybook-root-config');28module.exports = {29  stories: ['../src/**/*.stories.@(ts|tsx|js|jsx|mdx)'],30  typescript: {31  },32  core: {33  },34  webpackFinal: async (config) => {35    return {36      module: {37          {38            test: /\.(ts|tsx)$/,39            loader: require.resolve('babel-loader'),40            options: {41              presets: [['react-app', { flow: false, typescript: true }]],42            },43          },44      },45      resolve: {

Using AI Code Generation

1const path = require('path');2const tsConfig = require('./tsconfig.json');3module.exports = {4  webpackFinal: async (config) => {5    config.module.rules.push({6      include: path.resolve(__dirname, '../'),7    });8    config.module.rules.push({9        {10          options: { configFile: 'tsconfig.json' },11        },12    });13    config.resolve.extensions.push('.ts');14    config.resolve.alias = {15    };16    return config;17  },18};19{20  "compilerOptions": {21    "paths": {22    }23  }24}25"scripts": {26  },

Using AI Code Generation

1const tsConfig = require("tsconfig-paths");2const { pathsToModuleNameMapper } = require("ts-jest/utils");3const { compilerOptions } = require("./tsconfig.json");4module.exports = {5  moduleNameMapper: pathsToModuleNameMapper(compilerOptions.paths, {6  })7};8{9  "compilerOptions": {10    "paths": {11    }12  }13}14const tsConfig = require("tsconfig-paths");15const { pathsToModuleNameMapper } = require("ts-jest/utils");16const { compilerOptions } = require("./tsconfig.json");17module.exports = {18  moduleNameMapper: pathsToModuleNameMapper(compilerOptions.paths, {19  })20};21{22  "compilerOptions": {23    "paths": {24    }25  }26}27const tsConfig = require("tsconfig-paths");28const { pathsToModuleNameMapper } = require("ts-jest/utils");29const { compilerOptions } = require("./tsconfig.json");30module.exports = {31  moduleNameMapper: pathsToModuleNameMapper(compilerOptions.paths, {32  })33};34{35  "compilerOptions": {36    "paths": {37    }38  }39}40const tsConfig = require("tsconfig-paths");41const { pathsToModuleNameMapper } = require("ts-jest/utils");42const { compilerOptions } = require("./tsconfig.json");43module.exports = {44  moduleNameMapper: pathsToModuleNameMapper(compilerOptions.paths, {

Using AI Code Generation

1module.exports = {2  stories: ['../src/**/*.stories.@(js|jsx|ts|tsx|mdx)'],3  webpackFinal: async (config) => {4    config.resolve.plugins.push(new TsconfigPathsPlugin({ configFile: 'tsconfig.json' }));5    config.module.rules.push({6      include: path.resolve(__dirname, '../'),7    });8    config.module.rules.push({9      include: path.resolve(__dirname, '../'),10    });11    return config;12  },13};14{15  "compilerOptions": {16  },17}18{19  "compilerOptions": {20    "paths": {

Using AI Code Generation

1const tsConfig = require('tsconfig-paths');2const tsConfigPaths = tsConfig.loadConfig("./tsconfig.json");3tsConfig.register(tsConfigPaths);4const tsConfig = require('tsconfig-paths');5const tsConfigPaths = tsConfig.loadConfig("./tsconfig.json");6tsConfig.register(tsConfigPaths);7const tsConfig = require('tsconfig-paths');8const tsConfigPaths = tsConfig.loadConfig("./tsconfig.json");9tsConfig.register(tsConfigPaths);10const tsConfig = require('tsconfig-paths');11const tsConfigPaths = tsConfig.loadConfig("./tsconfig.json");12tsConfig.register(tsConfigPaths);13const tsConfig = require('tsconfig-paths');14const tsConfigPaths = tsConfig.loadConfig("./tsconfig.json");15tsConfig.register(tsConfigPaths);16const tsConfig = require('tsconfig-paths');17const tsConfigPaths = tsConfig.loadConfig("./tsconfig.json");18tsConfig.register(tsConfigPaths);19const tsConfig = require('tsconfig-paths');20const tsConfigPaths = tsConfig.loadConfig("./tsconfig.json");21tsConfig.register(tsConfigPaths);22const tsConfig = require('tsconfig-paths');23const tsConfigPaths = tsConfig.loadConfig("./tsconfig.json");24tsConfig.register(tsConfigPaths);25const tsConfig = require('tsconfig-paths');26const tsConfigPaths = tsConfig.loadConfig("./tsconfig.json");27tsConfig.register(tsConfigPaths);28const tsConfig = require('tsconfig-paths');29const tsConfigPaths = tsConfig.loadConfig("./tsconfig.json");30tsConfig.register(tsConfigPaths);31const tsConfig = require('tsconfig-paths');32const tsConfigPaths = tsConfig.loadConfig("./tsconfig.json");33tsConfig.register(tsConfigPaths);

Using AI Code Generation

1import { tsConfig } from 'storybook-root-alias';2module.exports = tsConfig();3{4  "compilerOptions": {5    "paths": {6    }7  }8}9module.exports = {10  node: {11  },12};13module.exports = {14  node: {15  },16};17module.exports = (baseConfig, env, config) => {18  config.node = {19  };20  return config;21};22module.exports = (baseConfig, env, config) => {23  config.node = {24  };25  return config;26};27module.exports = {28  node: {29  },30};31module.exports = {32  node: {33  },34};

Using AI Code Generation

1import { tsConfig } from 'storybook-root-alias';2module.exports = {3  webpackFinal: async (config) => {4    const tsConfigPath = path.resolve(__dirname, '../tsconfig.json');5    const tsConfigOptions = {6    };7    const alias = tsConfig(tsConfigPath, tsConfigOptions);8    config.resolve.alias = {9    };10    return config;11  },12};13{14  "compilerOptions": {15    "paths": {16    }17  }18}19import Button from '@/components/Button';20import React from 'react';21import Modal from '@/components/Modal';22import React from 'react';23import ModalContent from '@/components/Modal/ModalContent';24import React from 'react';

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.