Currently it is very selective and does not include this.

Hey, thanks for making this tool 👍

But I wondering, what's difference between strict and strictMode? If I used the code below

const swcConfig = convertTsConfig({
  module: 'commonjs',
  target: 'es2015'
})

It generates config below

{
  "sourceMaps": "inline",
  "module": {
    "type": "commonjs",
    "strict": false,
    "strictMode": true,
    "noInterop": true
  },
  "jsc": {
    "externalHelpers": false,
    "target": "es2015",
    "parser": {
      "syntax": "typescript",
      "tsx": true,
      "decorators": false,
      "dynamicImport": true
    },
    "transform": {
      "legacyDecorator": true,
      "decoratorMetadata": false,
      "react": {
        "throwIfNamespace": false,
        "development": false,
        "useBuiltins": false,
        "pragma": "React.createElement",
        "pragmaFrag": "React.Fragment",
        "importSource": "react"
      }
    },
    "keepClassNames": false
  }
}

Why strict: false and strictMode: true? I can't find any documentation about this option... 🤕

Thanks,

npm version is 1.1.0: https://www.npmjs.com/package/tsconfig-to-swcconfig

github version is 1.2.0:

Hey, thanks for the library.

I might implement this at some point, but it would be great if this library supported the extends property, and followed the compiler rules up the config tree.

https://github.com/privatenumber/get-tsconfig

Hi there,

Many thanks for this library. We are attempting to use it to enable our adoption of swc and it has saved us a lot of time so far!

In convertTsConfig, we assign swc config from the tsconfig, setting properties where they don't exist.

The problem occurs when we merge the two configs together here. tsc's definition of strict is not the same as swc's definition, but we merge them as if they are the same.

I think a simple solution would be to remove the copying of the strict setting from the tsconfig, and only set it if passed in via the manually overridden config. Would you accept a PR that did this?

When using TypeScript 5+ and configuring the tsconfig property "extends" as an array in the tsconfig.json file, the following error is thrown in the utils.js file:

/node_modules/tsconfig-to-swcconfig/dist/utils.js:35
if (!_extends.endsWith('.json')) {
              ^

TypeError: _extends.endsWith is not a function

This error occurs because the code expects "extends" to be a string. In TypeScript 5+, the extends property in the tsconfig.json file can now be a string or an array.

You can see the update here: microsoft/TypeScript#29118

Steps to reproduce:

1. Use TypeScript 5+
2. Set the extends property in the tsconfig.json file as an array.
3. Run the project.

Expected behavior:

The project should run without any errors.

Actual behavior:

The error mentioned above is thrown in the utils.js file.

Possible solution:

This solution is dependent on the desired direction for the package:

1. Manual approach

To address the issue, you can manually check if the extends property is an array or string in the tsconfig.json file. If it is a string, maintain the current behavior. If it is an array, you can do the following:

1. Iterate through each element in the extends array and attempt to load the corresponding tsconfig.json file.
2. Merge the tsconfigs deeply, ensuring that the order of the tsconfigs is respected. This means that the first tsconfig is overwritten by subsequent tsconfigs, and the last tsconfig is the one the user provided.
3. This should resolve the error and produce the expected output.

2. Use typescript

The previous solution may not be future-proof, as it tries to mimic the expected behavior of typescript rather than relying on TypeScript to compile the tsconfig and using the output to generate the swcconfig.

You can rely on TypeScript's inner workings to generate the complete tsconfig without worrying about compiling it, as follows:

import * as ts from 'typescript';

const configFileName = 'tsconfig.json';
const { config, error } = ts.readConfigFile(configFileName, ts.sys.readFile);
if (error) {
    console.error(error);
    process.exit(1);
}

const parsedConfig = ts.parseJsonConfigFileContent(config, ts.sys, './');
const compilerOptions = ts.convertCompilerOptionsFromJson(parsedConfig.options, './', configFileName);

console.log(compilerOptions.options);

This code generates the complete tsconfig as expected, without compiling it manually. You can leverage the inner workings of TypeScript to resolve the tsconfig and then use it to map the swcconfig.

Affected Package:
tsconfig-to-swcconfig

Version:
2.2.0

Platform:

• Node 18.14
• Typescript 5.0.4