angular-demo/node_modules/ts-node/dist/transpilers/swc.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.createSwcOptions = exports.targetMapping = exports.create = void 0;
const ts_internals_1 = require("../ts-internals");
function create(createOptions) {
    const { swc, service: { config, projectLocalResolveHelper }, transpilerConfigLocalResolveHelper, nodeModuleEmitKind, } = createOptions;
    // Load swc compiler
    let swcInstance;
    // Used later in diagnostics; merely needs to be human-readable.
    let swcDepName = 'swc';
    if (typeof swc === 'string') {
        swcDepName = swc;
        swcInstance = require(transpilerConfigLocalResolveHelper(swc, true));
    }
    else if (swc == null) {
        let swcResolved;
        try {
            swcDepName = '@swc/core';
            swcResolved = transpilerConfigLocalResolveHelper(swcDepName, true);
        }
        catch (e) {
            try {
                swcDepName = '@swc/wasm';
                swcResolved = transpilerConfigLocalResolveHelper(swcDepName, true);
            }
            catch (e) {
                throw new Error('swc compiler requires either @swc/core or @swc/wasm to be installed as a dependency.  See https://typestrong.org/ts-node/docs/transpilers');
            }
        }
        swcInstance = require(swcResolved);
    }
    else {
        swcInstance = swc;
    }
    // Prepare SWC options derived from typescript compiler options
    const { nonTsxOptions, tsxOptions } = createSwcOptions(config.options, nodeModuleEmitKind, swcInstance, swcDepName);
    const transpile = (input, transpileOptions) => {
        const { fileName } = transpileOptions;
        const swcOptions = fileName.endsWith('.tsx') || fileName.endsWith('.jsx') ? tsxOptions : nonTsxOptions;
        const { code, map } = swcInstance.transformSync(input, {
            ...swcOptions,
            filename: fileName,
        });
        return { outputText: code, sourceMapText: map };
    };
    return {
        transpile,
    };
}
exports.create = create;
/** @internal */
exports.targetMapping = new Map();
exports.targetMapping.set(/* ts.ScriptTarget.ES3 */ 0, 'es3');
exports.targetMapping.set(/* ts.ScriptTarget.ES5 */ 1, 'es5');
exports.targetMapping.set(/* ts.ScriptTarget.ES2015 */ 2, 'es2015');
exports.targetMapping.set(/* ts.ScriptTarget.ES2016 */ 3, 'es2016');
exports.targetMapping.set(/* ts.ScriptTarget.ES2017 */ 4, 'es2017');
exports.targetMapping.set(/* ts.ScriptTarget.ES2018 */ 5, 'es2018');
exports.targetMapping.set(/* ts.ScriptTarget.ES2019 */ 6, 'es2019');
exports.targetMapping.set(/* ts.ScriptTarget.ES2020 */ 7, 'es2020');
exports.targetMapping.set(/* ts.ScriptTarget.ES2021 */ 8, 'es2021');
exports.targetMapping.set(/* ts.ScriptTarget.ES2022 */ 9, 'es2022');
exports.targetMapping.set(/* ts.ScriptTarget.ESNext */ 99, 'esnext');
/**
 * @internal
 * We use this list to downgrade to a prior target when we probe swc to detect if it supports a particular target
 */
const swcTargets = [
    'es3',
    'es5',
    'es2015',
    'es2016',
    'es2017',
    'es2018',
    'es2019',
    'es2020',
    'es2021',
    'es2022',
    'esnext',
];
const ModuleKind = {
    None: 0,
    CommonJS: 1,
    AMD: 2,
    UMD: 3,
    System: 4,
    ES2015: 5,
    ES2020: 6,
    ESNext: 99,
    Node16: 100,
    NodeNext: 199,
};
const JsxEmit = {
    ReactJSX: /* ts.JsxEmit.ReactJSX */ 4,
    ReactJSXDev: /* ts.JsxEmit.ReactJSXDev */ 5,
};
/**
 * Prepare SWC options derived from typescript compiler options.
 * @internal exported for testing
 */
function createSwcOptions(compilerOptions, nodeModuleEmitKind, swcInstance, swcDepName) {
    var _a;
    const { esModuleInterop, sourceMap, importHelpers, experimentalDecorators, emitDecoratorMetadata, target, module, jsx, jsxFactory, jsxFragmentFactory, strict, alwaysStrict, noImplicitUseStrict, jsxImportSource, } = compilerOptions;
    let swcTarget = (_a = exports.targetMapping.get(target)) !== null && _a !== void 0 ? _a : 'es3';
    // Downgrade to lower target if swc does not support the selected target.
    // Perhaps project has an older version of swc.
    // TODO cache the results of this; slightly faster
    let swcTargetIndex = swcTargets.indexOf(swcTarget);
    for (; swcTargetIndex >= 0; swcTargetIndex--) {
        try {
            swcInstance.transformSync('', {
                jsc: { target: swcTargets[swcTargetIndex] },
            });
            break;
        }
        catch (e) { }
    }
    swcTarget = swcTargets[swcTargetIndex];
    const keepClassNames = target >= /* ts.ScriptTarget.ES2016 */ 3;
    const isNodeModuleKind = module === ModuleKind.Node16 || module === ModuleKind.NodeNext;
    // swc only supports these 4x module options [MUST_UPDATE_FOR_NEW_MODULEKIND]
    const moduleType = module === ModuleKind.CommonJS
        ? 'commonjs'
        : module === ModuleKind.AMD
            ? 'amd'
            : module === ModuleKind.UMD
                ? 'umd'
                : isNodeModuleKind && nodeModuleEmitKind === 'nodecjs'
                    ? 'commonjs'
                    : isNodeModuleKind && nodeModuleEmitKind === 'nodeesm'
                        ? 'es6'
                        : 'es6';
    // In swc:
    //   strictMode means `"use strict"` is *always* emitted for non-ES module, *never* for ES module where it is assumed it can be omitted.
    //   (this assumption is invalid, but that's the way swc behaves)
    // tsc is a bit more complex:
    //   alwaysStrict will force emitting it always unless `import`/`export` syntax is emitted which implies it per the JS spec.
    //   if not alwaysStrict, will emit implicitly whenever module target is non-ES *and* transformed module syntax is emitted.
    // For node, best option is to assume that all scripts are modules (commonjs or esm) and thus should get tsc's implicit strict behavior.
    // Always set strictMode, *unless* alwaysStrict is disabled and noImplicitUseStrict is enabled
    const strictMode = 
    // if `alwaysStrict` is disabled, remembering that `strict` defaults `alwaysStrict` to true
    (alwaysStrict === false || (alwaysStrict !== true && strict !== true)) &&
        // if noImplicitUseStrict is enabled
        noImplicitUseStrict === true
        ? false
        : true;
    const jsxRuntime = jsx === JsxEmit.ReactJSX || jsx === JsxEmit.ReactJSXDev ? 'automatic' : undefined;
    const jsxDevelopment = jsx === JsxEmit.ReactJSXDev ? true : undefined;
    const useDefineForClassFields = (0, ts_internals_1.getUseDefineForClassFields)(compilerOptions);
    const nonTsxOptions = createVariant(false);
    const tsxOptions = createVariant(true);
    return { nonTsxOptions, tsxOptions };
    function createVariant(isTsx) {
        const swcOptions = {
            sourceMaps: sourceMap,
            // isModule: true,
            module: moduleType
                ? {
                    type: moduleType,
                    ...(moduleType === 'amd' || moduleType === 'commonjs' || moduleType === 'umd'
                        ? {
                            noInterop: !esModuleInterop,
                            strictMode,
                            // For NodeNext and Node12, emit as CJS but do not transform dynamic imports
                            ignoreDynamic: nodeModuleEmitKind === 'nodecjs',
                        }
                        : {}),
                }
                : undefined,
            swcrc: false,
            jsc: {
                externalHelpers: importHelpers,
                parser: {
                    syntax: 'typescript',
                    tsx: isTsx,
                    decorators: experimentalDecorators,
                    dynamicImport: true,
                    importAssertions: true,
                },
                target: swcTarget,
                transform: {
                    decoratorMetadata: emitDecoratorMetadata,
                    legacyDecorator: true,
                    react: {
                        throwIfNamespace: false,
                        development: jsxDevelopment,
                        useBuiltins: false,
                        pragma: jsxFactory,
                        pragmaFrag: jsxFragmentFactory,
                        runtime: jsxRuntime,
                        importSource: jsxImportSource,
                    },
                    useDefineForClassFields,
                },
                keepClassNames,
                experimental: {
                    keepImportAttributes: true,
                    emitAssertForImportAttributes: true,
                },
            },
        };
        // Throw a helpful error if swc version is old, for example, if it rejects `ignoreDynamic`
        try {
            swcInstance.transformSync('', swcOptions);
        }
        catch (e) {
            throw new Error(`${swcDepName} threw an error when attempting to validate swc compiler options.\n` +
                'You may be using an old version of swc which does not support the options used by ts-node.\n' +
                'Try upgrading to the latest version of swc.\n' +
                'Error message from swc:\n' +
                (e === null || e === void 0 ? void 0 : e.message));
        }
        return swcOptions;
    }
}
exports.createSwcOptions = createSwcOptions;
//# sourceMappingURL=swc.js.map