Top 10 Examples of "tsconfig in functional component" in JavaScript

import { createMatchPath } from "../../src";
import * as Tsconfig from "tsconfig";
import * as path from "path";

// Load tsconfig
const loadResult = Tsconfig.loadSync(process.cwd(), undefined);

// Create function that will match paths
const matchPath = createMatchPath(
  path.join(
    path.dirname(loadResult.path),
    loadResult.config.compilerOptions.baseUrl
  ),
  loadResult.config.compilerOptions.paths
);

// Match a path and log result
const result = matchPath("foo/mylib");
console.log(result);

import { createMatchPath } from "../../src";
import * as Tsconfig from "tsconfig";
import * as path from "path";

// Load tsconfig
const loadResult = Tsconfig.loadSync(process.cwd());

// Create function that will match paths
const matchPath = createMatchPath(
  path.join(
    path.dirname(loadResult.path),
    loadResult.config.compilerOptions.baseUrl
  ),
  loadResult.config.compilerOptions.paths
);

const iterations = 100000;

console.time(`Matching path ${iterations} times`);
for (let i = 0; i < iterations; i++) {
  const result = matchPath("foo/mylib", undefined, undefined, [
    ".ts",

"dist/"
  ],
  "scripts": {
    "build": "npx stencil build --docs",
    "start": "npx stencil build",
    "test": "npx stencil test --spec --e2e",
    "test.watch": "npx stencil test --spec --e2e --watchAll"
  },
  "dependencies": {},
  "devDependencies": {
    "@stencil/core": "~0.15.2"
  },
  "license": "MIT"
}`;
    // add extra files
    files['tsconfig.json'] = `\
{
  "compilerOptions": {
    "allowSyntheticDefaultImports": true,
    "allowUnreachableCode": false,
    "declaration": false,
    "experimentalDecorators": true,
    "lib": [
      "dom",
      "es2017"
    ],
    "moduleResolution": "node",
    "module": "esnext",
    "target": "es2017",
    "noUnusedLocals": true,
    "noUnusedParameters": true,
    "jsx": "react",

function readConfig (filename: string, loader: WebPackLoader, TS: typeof ts) {
  const config = filename ? tsconfig.readFileSync(filename) : {
    files: [],
    compilerOptions: {}
  }

  // Merge all possible compiler options together.
  config.compilerOptions = extend({
    target: 'es5',
    module: 'commonjs'
  }, config.compilerOptions, {
    sourceMap: loader.sourceMap,
    inlineSourceMap: false,
    inlineSources: false,
    declaration: false
  })

  return TS.parseConfigFile(config, TS.sys, filename)

import commonjs from 'rollup-plugin-commonjs';
import license from 'rollup-plugin-license';
import visualizer from 'rollup-plugin-visualizer';
import typescript from 'rollup-plugin-typescript2';
import vueTemplateCompiler from 'rollup-plugin-vue-template-compiler';
import replace from 'rollup-plugin-replace';
import json from 'rollup-plugin-json';

import { isString } from 'util';
import moment from 'moment';
import _ from 'lodash';
import { readFileSync } from 'tsconfig';

// eslint-disable-next-line no-undef
const pkg = require( './package.json' );
const tsconfig = readFileSync( './tsconfig.json' );

const env = process.env.BUILD || 'development';
// The module name
const pkgName = pkg.name;
const globalName = 'VuejsDatatable';
const allContributors = [ pkg.author ].concat( pkg.contributors );
const userToString = p => {
	if ( isString( p ) ){
		return p;
	}
	return p.name + ( p.email ? `<${  p.email  }>` : '' ) + ( p.url ? ` (${  p.url  })` : '' );
};
const allContributorsString = allContributors.map( userToString ).join( ', ' );
// Plugins used for build
export const getPlugins = (iife, environment) => {
	const tsconfigOverride = {

log('Using inline tsconfig');
			config = JSON.parse(JSON.stringify(opts.project));
			config.compilerOptions = config.compilerOptions || {};
			extend(config.compilerOptions, opts);
		} else {
			if (fileExists(opts.project)) {
				configFile = opts.project;
			} else {
				configFile = ts.findConfigFile(
					ts.normalizeSlashes(opts.project || bopts.basedir || currentDirectory),
					fileExists
				);
			}
			if (configFile) {
				log('Using tsconfig file at %s', configFile);
				config = tsconfig.readFileSync(configFile);
				config.compilerOptions = config.compilerOptions || {};
				extend(config.compilerOptions, opts);
			} else {
				config = {
					files: [],
					compilerOptions: opts
				};
			}
		}

		// Note that subarg parses command line arrays in its own peculiar way:
		// https://github.com/substack/subarg

		if (opts.exclude) {
			config.exclude = opts.exclude._ || opts.exclude;
		}

function createInstance (loader: WebPackLoader, options: Options): LoaderInstance {
  const context = loader.context
  const rootFile = loader.resourcePath
  const files: FilesMap = {}
  const ignoreWarnings = arrify(options.ignoreWarnings).map(Number)

  // Allow custom TypeScript compilers to be used.
  const TS: typeof ts = require(options.compiler || 'typescript')

  // Allow `configFile` option to override `tsconfig.json` lookup.
  const configFile = options.configFile ?
    resolve(context, options.configFile) :
    tsconfig.resolveSync(context)

  const config = readConfig(configFile, loader, TS)

  // Emit configuration errors.
  config.errors.forEach((error: ts.Diagnostic) => {
    loader.emitError(formatDiagnostic(error, TS))
  })

  const serviceHost: ts.LanguageServiceHost = {
    getScriptFileNames (): string[] {
      // Return an array of all file names. We can't return just the default
      // files because webpack may have traversed through a regular JS file
      // back to a TypeScript file and if we don't have that file in the array,
      // TypeScript will give us a file not found compilation error.
      return config.fileNames.concat(Object.keys(files))
    },

return tslib_1.__generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    if (!utils_1.endsWith(tsConfigFilePath, ".json")) {
                        tsConfigFilePath = path.join(tsConfigFilePath, utils_1.CONFIG_FILENAME);
                    }
                    return [4 /*yield*/, tsconfig.readFile(tsConfigFilePath)];
                case 1:
                    config = _a.sent();
                    utils_1.validateTsConfig(config);
                    outDir = path.resolve(path.dirname(tsConfigFilePath), config.compilerOptions.outDir);
                    jsFiles = utils_1.getJSFiles(outDir);
                    if (!jsFiles.length) {
                        throw new Error("No .js files found");
                    }
                    modules = Object.keys(config.compilerOptions.paths);
                    return [4 /*yield*/, Promise.all(jsFiles.map(function (filePath) {
                            var tsModules = [];
                            for (var _i = 0, modules_2 = modules; _i < modules_2.length; _i++) {
                                var moduleName = modules_2[_i];
                                var modulePath = utils_1.rtrim(config.compilerOptions.paths[moduleName][0], "*"); // Remove trailing *s
                                tsModules.push({ name: moduleName, path: modulePath });
                            }

export async function resolve(tsConfigFilePath: string) {
    if (!endsWith(tsConfigFilePath, ".json")) {
        tsConfigFilePath = path.join(tsConfigFilePath, CONFIG_FILENAME);
    }

    const config: any = await tsconfig.readFile(tsConfigFilePath);
    validateTsConfig(config);

    const outDir = path.resolve(path.dirname(tsConfigFilePath), config.compilerOptions.outDir);

    const jsFiles: string[] = getJSFiles(outDir);
    if (!jsFiles.length) {
        throw new Error("No .js files found");
    }
    const modules = Object.keys(config.compilerOptions.paths);
    await Promise.all(
        jsFiles.map((filePath: string) => {
            const tsModules: ITypescriptModule[] = [];
            for (const moduleName of modules) {
                const modulePath = rtrim(config.compilerOptions.paths[moduleName][0], "*"); // Remove trailing *s
                tsModules.push({ name: moduleName, path: modulePath });
            }

test('tsconfig.json should be valid json', async () => {
  const { files } = await generateWithPlugin([
    {
      id: 'ts',
      apply: require('../generator'),
      options: {}
    }
  ])
  expect(() => {
    JSON.parse(files['tsconfig.json'])
  }).not.toThrow()
  expect(files['tsconfig.json']).not.toMatch('"  ')
})