ttsc 0.0.1

package/CHANGELOG.md

@@ -0,0 +1,2 @@
+# Change Log
+

package/README.md

@@ -0,0 +1,395 @@
+# ttsc
+
+[![GitHub license](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/solar-religion/ttsc/blob/main/LICENSE)
+[![npm version](https://img.shields.io/npm/v/ttsc.svg)](https://www.npmjs.com/package/ttsc)
+[![Downloads](https://img.shields.io/npm/dm/ttsc.svg)](https://www.npmjs.com/package/ttsc)
+This repository was created due to a perceived lack of management of ttypescript.
+
+Also, we don't currently support ts-node and cache systems, as they weren't supported in the original, and we need time to figure out a way around that.
+
+And it supports TS5.
+
+[![npm version](https://badge.fury.io/js/ttypescript.svg)](https://badge.fury.io/js/ttypescript) [![Build Status](https://travis-ci.org/cevek/ttypescript.svg?branch=master)](https://travis-ci.org/cevek/ttypescript)
+
+# ttypescript
+
+## Existing contributors
+
+-   @cevek
+-   @zerkalica
+-   @SalvatorePreviti
+-   @timocov
+-   @SlurpTheo
+-   @samchon
+-   @henriquehbr
+-   @JiangWeixian
+-   @mdmitry01
+-   @jirutka
+-   @alexgorbatchev
+-   @oscard0m
+-   @sveyret
+-   @Jack-Works
+-   @MicahZoltu
+-   @Igorbek
+-   @gfx
+-   @danielpza
+-   @mikeyhew
+-   @huafu
+-   @dsherret
+-   @SupernaviX
+-   @HitkoDev
+
+## What it is
+
+Currently TypeScript doesn't support custom transformers in the tsconfig.json, but supports it programmatically.
+
+And there is no way to compile your files using custom transformers using `tsc` command.
+
+TTypescript (Transformer TypeScript) solves this problem by patching on the fly the compile module to use transformers from `tsconfig.json`.
+
+<!---
+TTypescript is a drop-in replacement for all typescript modules, located in ``` node_modules/typescript/lib ``` directory:
+
+```ts
+import * as ts from 'ttypescript'
+import * as tsServer from 'ttypescript/lib/tsserver'
+import * as watchGuard from 'ttypescript/lib/watchGuard'
+```
+--->
+
+Instead of tsc and tsserver, use ttsc and ttsserver wrappers. This wrappers try to use locally installed typescript first.
+
+No version lock-ins - typescript used as peer dependency.
+
+## How to install
+
+```
+npm i ttypescript -D
+```
+
+ttypescript uses your installed `typescript` in your `node_modules`
+
+## How to use
+
+### tsconfig.json
+
+Set a transformer path to the `tsconfig.json` in `compilerOptions` section `plugin` array:
+
+```
+{
+    "compilerOptions": {
+        "plugins": [
+            { "transform": "transformer-module" },
+        ]
+    }
+}
+```
+
+plugin entries described in `PluginConfig`:
+
+```ts
+export interface PluginConfig {
+    /**
+     * Path to transformer or transformer module name
+     */
+    transform?: string;
+
+    /**
+     * The optional name of the exported transform plugin in the transform module.
+     */
+    import?: string;
+
+    /**
+     * Plugin entry point format type, default is program
+     */
+    type?: 'program' | 'config' | 'checker' | 'raw' | 'compilerOptions';
+
+    /**
+     * Should transformer applied after all ones
+     */
+    after?: boolean;
+
+    /**
+     * Should transformer applied for d.ts files, supports from TS2.9
+     */
+    afterDeclarations?: boolean;
+    /**
+     * any other properties provided to the transformer as config argument
+     * */
+    [options: string]: any;
+}
+```
+
+You just need to add the `transform` block with optional `import`, `type`, `after`, `afterDeclarations` and plugin-related options.
+
+`transform` can accept npm module or local file path (.ts or .js) related to `tsconfig.json`
+
+### PluginConfig.type
+
+Because currently transformers can run only programmatically, most of them use factory wrapper with different signatures.
+For the possible to work with any of them you can specify `type` in the plugin config.
+
+By default will be used a `program` type.
+
+<!---
+
+Most of transformers exports ``` ts.TransformerFactory<ts.SourceFile> ```.
+But better to export TransformerBasePlugin, described below. In most cases it's a plugin responsibility to when run a transformer.
+
+```ts
+export interface TransformerBasePlugin {
+    before?: ts.TransformerFactory<ts.SourceFile>;
+    after?: ts.TransformerFactory<ts.SourceFile>;
+    afterDeclarations?: ts.TransformerFactory<ts.SourceFile>;
+}
+
+export type TransformerPlugin = TransformerBasePlugin | ts.TransformerFactory<ts.SourceFile>;
+```
+--->
+
+#### program
+
+If the transformer has a factory signature using `program` as first argument:
+
+```ts
+(program: ts.Program, config?: PluginConfig) => ts.TransformerFactory;
+where;
+ts.TransformerFactory = (context: ts.TransformationContext) => (sourceFile: ts.SourceFile) => ts.SourceFile;
+```
+
+Plugin config entry: `{ "transform": "transformer-module" }`.
+
+#### config
+
+For the signature with transformer's config:
+
+```ts
+(config: PluginConfig) => ts.TransformerFactory;
+```
+
+Plugin config entry: `{ "transform": "transformer-module", type: "config" }`.
+
+#### checker
+
+For the signature with ts.TypeChecker:
+
+```ts
+(checker: ts.TypeChecker, config?: PluginConfig) => ts.TransformerFactory;
+```
+
+Plugin config entry: `{ "transform": "transformer-module", type: "checker" }`.
+
+#### raw
+
+For the signature without factory wrapper:
+
+```ts
+ts.TransformerFactory;
+```
+
+Plugin config entry: `{ "transform": "transformer-module", type: "raw" }`.
+
+#### compilerOptions
+
+```ts
+(compilerOpts: ts.CompilerOptions, config?: PluginConfig) => ts.TransformerFactory;
+```
+
+Plugin config entry: `{ "transform": "transformer-module", type: "compilerOptions" }`.
+
+```json
+{
+    "compilerOptions": {
+        "plugins": [
+            { "transform": "transformer-module", "someOption1": 123, "someOption2": 321 },
+            { "transform": "./transformers/my-transformer.ts" },
+            { "transform": "transformer-module", "after": true },
+            { "transform": "transformer-module", "afterDeclarations": true },
+            { "transform": "transformer-module", "type": "ls" }
+        ]
+    }
+}
+```
+
+### Command line
+
+Like usual `tsc`, all arguments work the same way.
+
+```
+ttsc
+```
+
+### ts-node
+
+```
+ts-node --compiler ttypescript index.ts
+or
+ts-node -C ttypescript index.ts
+```
+
+### Parcel
+
+Just install a parcel plugin
+
+```
+npm i parcel-plugin-ttypescript
+```
+
+### Webpack
+
+```js
+    {
+        test: /\.(ts|tsx)$/,
+        loader: require.resolve('awesome-typescript-loader'),
+        // or
+        loader: require.resolve('ts-loader'),
+        options: {
+            compiler: 'ttypescript'
+        }
+    }
+```
+
+### Rollup
+
+```js
+// rollup.config.js
+import ttypescript from 'ttypescript';
+import tsPlugin from 'rollup-plugin-typescript2';
+
+export default {
+    // ...
+    plugins: [
+        // ...
+        tsPlugin({
+            typescript: ttypescript,
+        }),
+    ],
+};
+```
+
+### VS Code
+
+If you want to compile your project with VS Code task runner you need to overwrite the config `typescript.tsdk` to path of the installed `ttypescript`:
+
+```
+"typescript.tsdk": "/usr/local/lib/node_modules/ttypescript/lib",
+or
+"typescript.tsdk": "node_modules/ttypescript/lib",
+```
+
+### Jest, ts-jest
+
+```js
+module.exports = {
+    // [...]
+    globals: {
+        'ts-jest': {
+            compiler: 'ttypescript',
+        },
+    },
+};
+```
+
+or in `package.json`
+
+```json
+{
+    "jest": {
+        "globals": {
+            "ts-jest": {
+                "compiler": "ttypescript"
+            }
+        }
+    }
+}
+```
+
+## Transformers
+
+You can use transformers written in ts or js
+
+```ts
+// transformer1-module
+import * as ts from 'typescript';
+export default function (program: ts.Program, pluginOptions: {}) {
+    return (ctx: ts.TransformationContext) => {
+        return (sourceFile: ts.SourceFile) => {
+            function visitor(node: ts.Node): ts.Node {
+                // if (ts.isCallExpression(node)) {
+                //     return ts.createLiteral('call');
+                // }
+                return ts.visitEachChild(node, visitor, ctx);
+            }
+            return ts.visitEachChild(sourceFile, visitor, ctx);
+        };
+    };
+}
+```
+
+Examples of transformers:
+
+[`{ "transform": "ts-nameof", type: "raw"}`](https://github.com/dsherret/ts-nameof)
+
+[`{ "transform": "ts-optchain/transform" }`](https://github.com/rimeto/ts-optchain)
+
+[`{ "transform": "ts-transform-asset" }`](https://github.com/slune-org/ts-transform-asset)
+
+[`{ "transform": "ts-transform-auto-require" }`](https://github.com/slune-org/ts-transform-auto-require)
+
+[`{ "transform": "ts-transform-css-modules/dist/transform", type: "config" }`](https://github.com/longlho/ts-transform-css-modules)
+
+[`{ "transform": "ts-transform-graphql-tag/dist/transformer" }`](https://github.com/firede/ts-transform-graphql-tag)
+
+[`{ "transform": "ts-transform-img/dist/transform", type: "config" }`](https://github.com/longlho/ts-transform-img)
+
+[`{ "transform": "ts-transform-react-intl/dist/transform", import: "transform", type: "config" }`](https://github.com/longlho/ts-transform-react-intl)
+
+[`{ "transform": "ts-transformer-enumerate/transformer" }`](https://github.com/kimamula/ts-transformer-enumerate)
+
+[`{ "transform": "ts-transformer-keys/transformer" }`](https://github.com/kimamula/ts-transformer-keys)
+
+[`{ "transform": "ts-transformer-minify-privates" }`](https://github.com/timocov/ts-transformer-minify-privates)
+
+[`{ "transform": "typescript-is/lib/transform-inline/transformer" }`](https://github.com/woutervh-/typescript-is)
+
+[`{ "transform": "typescript-plugin-styled-components", type: "config" }`](https://github.com/Igorbek/typescript-plugin-styled-components#ttypescript-compiler)
+
+[`{ "transform": "typescript-transform-jsx" }`](https://github.com/LeDDGroup/typescript-transform-jsx)
+
+[`{ "transform": "typescript-transform-macros" }`](https://github.com/LeDDGroup/typescript-transform-macros)
+
+[`{ "transform": "typescript-transform-paths" }`](https://github.com/LeDDGroup/typescript-transform-paths)
+
+[`{ "transform": "@zerollup/ts-transform-paths" }`](https://github.com/zerkalica/zerollup/tree/master/packages/ts-transform-paths)
+
+[`{ "transform": "@zoltu/typescript-transformer-append-js-extension" }`](https://github.com/Zoltu/typescript-transformer-append-js-extension)
+
+[`{ "transform": "@magic-works/ttypescript-browser-like-import-transformer" }`](https://github.com/Jack-Works/ttypescript-browser-like-import-transformer)
+
+[`{ "transform": "typescript-transform-react-jsx-source" }`](https://github.com/alexgorbatchev/typescript-transform-react-jsx-source)
+
+[`{ "transform": "ts-transformer-remove-named-export" }`](https://github.com/dominguezcelada/ts-transformer-remove-named-export)
+
+[`{ "transform": "ts-transformer-export-default-name" }`](https://github.com/jirutka/ts-transformer-export-default-name)
+
+[`{ "transform": "ts-transformer-inline-file/transformer" }`](https://github.com/jirutka/ts-transformer-inline-file)
+
+[`{ "transform": "ts-transformer-strip-const-enums", "entrySourceFiles": ["./src/index.ts" }`](https://github.com/timocov/ts-transformer-strip-const-enums)
+
+[`{ "transform": "ts-transformer-properties-rename", "entrySourceFiles": ["./src/index.ts"] }`](https://github.com/timocov/ts-transformer-properties-rename)
+
+[`{ "transform": "tsc-progress", "name": "TSC", "color": "green" }`](https://github.com/JiangWeixian/tsc-progress)
+
+[Tutorial how to write a typescript transformer](https://dev.doctorevidence.com/how-to-write-a-typescript-transform-plugin-fc5308fdd943)
+
+-   [Tutorial how to write a typescript transformer](https://dev.doctorevidence.com/how-to-write-a-typescript-transform-plugin-fc5308fdd943)
+-   [Transformer framework](https://github.com/slune-org/simple-ts-transform)
+-   [Unit testing transformer compiler](https://github.com/slune-org/ts-transform-test-compiler)
+
+## Example
+
+An example project is in the [example](./packages/ttypescript-examples) directory
+
+## License
+
+MIT License

package/bin/tsc

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+require('../lib/tsc.js')

package/bin/tsserver

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+require('../lib/tsserver.js')

package/lib/PluginCreator.d.ts

@@ -0,0 +1,67 @@
+import * as ts from 'typescript';
+export interface PluginConfig {
+    /**
+     * Language Server TypeScript Plugin name
+     */
+    name?: string;
+    /**
+     * Path to transformer or transformer module name
+     */
+    transform?: string;
+    /**
+     * The optional name of the exported transform plugin in the transform module.
+     */
+    import?: string;
+    /**
+     * Plugin entry point format type, default is program
+     */
+    type?: 'ls' | 'program' | 'config' | 'checker' | 'raw' | 'compilerOptions';
+    /**
+     * Should transformer applied after all ones
+     */
+    after?: boolean;
+    /**
+     * Should transformer applied for d.ts files, supports from TS2.9
+     */
+    afterDeclarations?: boolean;
+}
+export interface TransformerBasePlugin {
+    before?: ts.TransformerFactory<ts.SourceFile>;
+    after?: ts.TransformerFactory<ts.SourceFile>;
+    afterDeclarations?: ts.TransformerFactory<ts.SourceFile | ts.Bundle>;
+}
+export type TransformerList = Required<ts.CustomTransformers>;
+export type TransformerPlugin = TransformerBasePlugin | ts.TransformerFactory<ts.SourceFile>;
+export type LSPattern = (ls: ts.LanguageService, config: {}) => TransformerPlugin;
+export type ProgramPattern = (program: ts.Program, config: {}, helpers?: {
+    ts: typeof ts;
+    addDiagnostic: (diag: ts.Diagnostic) => void;
+}) => TransformerPlugin;
+export type CompilerOptionsPattern = (compilerOpts: ts.CompilerOptions, config: {}) => TransformerPlugin;
+export type ConfigPattern = (config: {}) => TransformerPlugin;
+export type TypeCheckerPattern = (checker: ts.TypeChecker, config: {}) => TransformerPlugin;
+export type RawPattern = (context: ts.TransformationContext, program: ts.Program, config: {}) => ts.Transformer<ts.SourceFile>;
+export type PluginFactory = LSPattern | ProgramPattern | ConfigPattern | CompilerOptionsPattern | TypeCheckerPattern | RawPattern;
+/**
+ * @example
+ *
+ * new PluginCreator([
+ *   {transform: '@zerollup/ts-transform-paths', someOption: '123'},
+ *   {transform: '@zerollup/ts-transform-paths', type: 'ls', someOption: '123'},
+ *   {transform: '@zerollup/ts-transform-paths', type: 'ls', after: true, someOption: '123'}
+ * ]).createTransformers({ program })
+ */
+export declare class PluginCreator {
+    private typescript;
+    private configs;
+    private resolveBaseDir;
+    constructor(typescript: typeof ts, configs: PluginConfig[], resolveBaseDir?: string);
+    mergeTransformers(into: TransformerList, source: ts.CustomTransformers | TransformerBasePlugin): this;
+    createTransformers(params: {
+        program: ts.Program;
+    } | {
+        ls: ts.LanguageService;
+    }, customTransformers?: ts.CustomTransformers): Required<ts.CustomTransformers>;
+    private resolveFactory;
+    private validateConfigs;
+}

package/lib/PluginCreator.js

@@ -0,0 +1,190 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginCreator = void 0;
+var resolve = require("resolve");
+var util_1 = require("util");
+var patchCreateProgram_1 = require("./patchCreateProgram");
+function createTransformerFromPattern(_a) {
+    var typescript = _a.typescript, factory = _a.factory, config = _a.config, program = _a.program, ls = _a.ls;
+    var transform = config.transform, after = config.after, afterDeclarations = config.afterDeclarations, name = config.name, type = config.type, cleanConfig = __rest(config, ["transform", "after", "afterDeclarations", "name", "type"]);
+    if (!transform)
+        throw new Error('Not a valid config entry: "transform" key not found');
+    var ret;
+    switch (config.type) {
+        case 'ls':
+            if (!ls)
+                throw new Error("Plugin ".concat(transform, " need a LanguageService"));
+            ret = factory(ls, cleanConfig);
+            break;
+        case 'config':
+            ret = factory(cleanConfig);
+            break;
+        case 'compilerOptions':
+            ret = factory(program.getCompilerOptions(), cleanConfig);
+            break;
+        case 'checker':
+            ret = factory(program.getTypeChecker(), cleanConfig);
+            break;
+        case undefined:
+        case 'program':
+            ret = factory(program, cleanConfig, {
+                ts: typescript,
+                addDiagnostic: (0, patchCreateProgram_1.addDiagnosticFactory)(program),
+            });
+            break;
+        case 'raw':
+            ret = function (ctx) { return factory(ctx, program, cleanConfig); };
+            break;
+        default:
+            return never(config.type);
+    }
+    if (typeof ret === 'function') {
+        if (after)
+            return { after: ret };
+        else if (afterDeclarations) {
+            return { afterDeclarations: ret };
+        }
+        else
+            return { before: ret };
+    }
+    return ret;
+}
+function never(n) {
+    throw new Error('Unexpected type: ' + n);
+}
+var tsNodeIncluded = false;
+// to fix recursion bug, see usage below
+var requireStack = [];
+/**
+ * @example
+ *
+ * new PluginCreator([
+ *   {transform: '@zerollup/ts-transform-paths', someOption: '123'},
+ *   {transform: '@zerollup/ts-transform-paths', type: 'ls', someOption: '123'},
+ *   {transform: '@zerollup/ts-transform-paths', type: 'ls', after: true, someOption: '123'}
+ * ]).createTransformers({ program })
+ */
+var PluginCreator = /** @class */ (function () {
+    function PluginCreator(typescript, configs, resolveBaseDir) {
+        if (resolveBaseDir === void 0) { resolveBaseDir = process.cwd(); }
+        this.typescript = typescript;
+        this.configs = configs;
+        this.resolveBaseDir = resolveBaseDir;
+        this.validateConfigs(configs);
+    }
+    PluginCreator.prototype.mergeTransformers = function (into, source) {
+        var _a, _b, _c;
+        var slice = function (input) { return (Array.isArray(input) ? input.slice() : [input]); };
+        if (source.before) {
+            (_a = into.before).push.apply(_a, slice(source.before));
+        }
+        if (source.after) {
+            (_b = into.after).push.apply(_b, slice(source.after));
+        }
+        if (source.afterDeclarations) {
+            (_c = into.afterDeclarations).push.apply(_c, slice(source.afterDeclarations));
+        }
+        return this;
+    };
+    PluginCreator.prototype.createTransformers = function (params, customTransformers) {
+        var chain = {
+            before: [],
+            after: [],
+            afterDeclarations: [],
+        };
+        var ls;
+        var program;
+        if ('ls' in params) {
+            ls = params.ls;
+            program = ls.getProgram();
+        }
+        else {
+            program = params.program;
+        }
+        for (var _i = 0, _a = this.configs; _i < _a.length; _i++) {
+            var config = _a[_i];
+            if (!config.transform) {
+                continue;
+            }
+            var factory = this.resolveFactory(config.transform, config.import);
+            // if recursion
+            if (factory === undefined)
+                continue;
+            var transformer = createTransformerFromPattern({
+                typescript: this.typescript,
+                factory: factory,
+                config: config,
+                program: program,
+                ls: ls,
+            });
+            this.mergeTransformers(chain, transformer);
+        }
+        // if we're given some custom transformers, they must be chained at the end
+        if (customTransformers) {
+            this.mergeTransformers(chain, customTransformers);
+        }
+        return chain;
+    };
+    PluginCreator.prototype.resolveFactory = function (transform, importKey) {
+        if (importKey === void 0) { importKey = 'default'; }
+        if (!tsNodeIncluded &&
+            transform.match(/\.tsx?$/) &&
+            (module.parent.parent === null ||
+                module.parent.parent.parent === null ||
+                module.parent.parent.parent.id.split(/[\/\\]/).indexOf('ts-node') === -1)) {
+            require('ts-node').register({
+                transpileOnly: true,
+                skipProject: true,
+                compilerOptions: {
+                    target: 'ES2018',
+                    jsx: 'react',
+                    esModuleInterop: true,
+                    module: 'commonjs',
+                },
+            });
+            tsNodeIncluded = true;
+        }
+        var modulePath = resolve.sync(transform, { basedir: this.resolveBaseDir });
+        // in ts-node occurs error cause recursion:
+        //   ts-node file.ts -> createTransformers -> require transformer.ts
+        //        -> createTransformers -> require transformer.ts -> ...
+        //   this happens cause ts-node uses to compile transformers the same config included this transformer
+        //   so this stack checks that if we already required this file we are in the reqursion
+        if (requireStack.indexOf(modulePath) > -1)
+            return;
+        requireStack.push(modulePath);
+        var commonjsModule = require(modulePath);
+        requireStack.pop();
+        var factoryModule = typeof commonjsModule === 'function' ? { default: commonjsModule } : commonjsModule;
+        var factory = factoryModule[importKey];
+        if (!factory) {
+            throw new Error("tsconfig.json > plugins: \"".concat(transform, "\" does not have an export \"").concat(importKey, "\": ") +
+                (0, util_1.inspect)(factoryModule));
+        }
+        if (typeof factory !== 'function') {
+            throw new Error("tsconfig.json > plugins: \"".concat(transform, "\" export \"").concat(importKey, "\" is not a plugin: \"").concat((0, util_1.inspect)(factory), "\""));
+        }
+        return factory;
+    };
+    PluginCreator.prototype.validateConfigs = function (configs) {
+        for (var _i = 0, configs_1 = configs; _i < configs_1.length; _i++) {
+            var config = configs_1[_i];
+            if (!config.name && !config.transform) {
+                throw new Error('tsconfig.json plugins error: transform must be present');
+            }
+        }
+    };
+    return PluginCreator;
+}());
+exports.PluginCreator = PluginCreator;

package/lib/cancelationToken.js

@@ -0,0 +1,2 @@
+"use strict";
+module.exports = require('typescript/lib/cancellationToken');

package/lib/loadTypescript.d.ts

@@ -0,0 +1,7 @@
+import * as TS from 'typescript';
+type ts = typeof TS;
+export declare function loadTypeScript(filename: string, { folder, forceConfigLoad }?: {
+    folder?: string;
+    forceConfigLoad?: boolean;
+}): ts;
+export {};

package/lib/loadTypescript.js

@@ -0,0 +1,56 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadTypeScript = void 0;
+var fs_1 = require("fs");
+var resolve_1 = require("resolve");
+var patchCreateProgram_1 = require("./patchCreateProgram");
+var path_1 = require("path");
+var vm_1 = require("vm");
+var Module = require("module");
+function loadTypeScript(filename, _a) {
+    var _b;
+    var _c = _a === void 0 ? {} : _a, _d = _c.folder, folder = _d === void 0 ? __dirname : _d, _e = _c.forceConfigLoad, forceConfigLoad = _e === void 0 ? false : _e;
+    var libFilename = (0, resolve_1.sync)('typescript/lib/' + filename, { basedir: folder });
+    if (!require.cache[libFilename]) {
+        var temp = TSModuleFactory(libFilename);
+        require.cache = __assign(__assign({}, require.cache), (_b = {}, _b[libFilename] = temp, _b));
+    }
+    var ts = TSModuleFactory(libFilename).exports;
+    var _f = ts.versionMajorMinor.split('.'), major = _f[0], minor = _f[1];
+    if (+major < 3 && +minor < 7) {
+        throw new Error('ttypescript supports typescript from 2.7 version');
+    }
+    var result = (0, patchCreateProgram_1.patchCreateProgram)(ts, forceConfigLoad);
+    if (+major >= 5 && result.args) {
+        result.args.this = result.args.exports;
+    }
+    return result;
+}
+exports.loadTypeScript = loadTypeScript;
+var typeScriptFactoryCache = new Map();
+function TSModuleFactory(filename) {
+    var factory = typeScriptFactoryCache.get(filename);
+    if (!factory) {
+        var code = (0, fs_1.readFileSync)(filename, 'utf8');
+        factory = (0, vm_1.runInThisContext)("(function (exports, require, module, __filename, __dirname) {".concat(code, "\n});"), {
+            filename: filename,
+            lineOffset: 0,
+            displayErrors: true,
+        });
+        typeScriptFactoryCache.set(filename, factory);
+    }
+    var newModule = new Module(filename, module);
+    factory.call(newModule, newModule.exports, require, newModule, filename, (0, path_1.dirname)(filename));
+    return newModule;
+}

package/lib/patchCreateProgram.d.ts

@@ -0,0 +1,21 @@
+import * as ts from 'typescript';
+import { Diagnostic } from 'typescript/lib/tsserverlibrary';
+declare module 'typescript' {
+    interface CreateProgramOptions {
+        rootNames: ReadonlyArray<string>;
+        options: ts.CompilerOptions;
+        projectReferences?: ReadonlyArray<ts.ProjectReference>;
+        host?: ts.CompilerHost;
+        oldProgram?: ts.Program;
+        configFileParsingDiagnostics?: ReadonlyArray<ts.Diagnostic>;
+    }
+    interface ProjectReference {
+        path: string;
+        originalPath?: string;
+        prepend?: boolean;
+        circular?: boolean;
+    }
+}
+export declare const transformerErrors: WeakMap<ts.Program, Diagnostic[]>;
+export declare function addDiagnosticFactory(program: ts.Program): (diag: ts.Diagnostic) => void;
+export declare function patchCreateProgram(tsm: typeof ts, forceReadConfig?: boolean, projectDir?: string): typeof ts;

package/lib/patchCreateProgram.js

@@ -0,0 +1,175 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.patchCreateProgram = exports.addDiagnosticFactory = exports.transformerErrors = void 0;
+var path_1 = require("path");
+var PluginCreator_1 = require("./PluginCreator");
+exports.transformerErrors = new WeakMap();
+function addDiagnosticFactory(program) {
+    return function (diag) {
+        var arr = exports.transformerErrors.get(program) || [];
+        arr.push(diag);
+        exports.transformerErrors.set(program, arr);
+    };
+}
+exports.addDiagnosticFactory = addDiagnosticFactory;
+function patchCreateProgram(tsm, forceReadConfig, projectDir) {
+    if (forceReadConfig === void 0) { forceReadConfig = false; }
+    if (projectDir === void 0) { projectDir = process.cwd(); }
+    var originCreateProgram = tsm.createProgram;
+    var _ = tsm.createProgram, rest1 = __rest(tsm, ["createProgram"]);
+    function hackCreateProgram(rootNamesOrOptions, options, host, oldProgram, configFileParsingDiagnostics) {
+        var rootNames;
+        var createOpts;
+        if (!Array.isArray(rootNamesOrOptions)) {
+            createOpts = rootNamesOrOptions;
+        }
+        if (createOpts) {
+            rootNames = createOpts.rootNames;
+            options = createOpts.options;
+            host = createOpts.host;
+            oldProgram = createOpts.oldProgram;
+            configFileParsingDiagnostics = createOpts.configFileParsingDiagnostics;
+        }
+        else {
+            options = options;
+            rootNames = rootNamesOrOptions;
+        }
+        if (forceReadConfig) {
+            var info = getConfig(tsm, options, rootNames, projectDir);
+            options = info.compilerOptions;
+            if (createOpts) {
+                createOpts.options = options;
+            }
+            projectDir = info.projectDir;
+        }
+        var program = createOpts
+            ? originCreateProgram(createOpts)
+            : originCreateProgram(rootNames, options, host, oldProgram, configFileParsingDiagnostics);
+        var plugins = preparePluginsFromCompilerOptions(options.plugins);
+        var pluginCreator = new PluginCreator_1.PluginCreator(tsm, plugins, projectDir);
+        var originEmit = program.emit;
+        /**
+         * The emit method has the following declaration:
+         * https://github.com/microsoft/TypeScript/blob/bfc55b5762443c37ecdef08a3b5a4e057b4d1e85/src/compiler/builderPublic.ts#L101
+         * The declaration specifies 5 arguments, but it's not true. Sometimes the emit method takes 6 arguments.
+         */
+        program.emit = function newEmit(targetSourceFile, writeFile, cancellationToken, emitOnlyDtsFiles, customTransformers, arg) {
+            var mergedTransformers = pluginCreator.createTransformers({ program: program }, customTransformers);
+            var result = originEmit(targetSourceFile, writeFile, cancellationToken, emitOnlyDtsFiles, mergedTransformers, arg);
+            // todo: doesn't work with 3.7
+            // result.diagnostics = [...result.diagnostics, ...transformerErrors.get(program)!];
+            return result;
+        };
+        return program;
+    }
+    rest1.createProgram = hackCreateProgram;
+    return injectionShadowedValues(rest1);
+}
+exports.patchCreateProgram = patchCreateProgram;
+function getConfig(tsm, compilerOptions, rootFileNames, defaultDir) {
+    if (compilerOptions.configFilePath === undefined) {
+        var dir = rootFileNames.length > 0 ? (0, path_1.dirname)(rootFileNames[0]) : defaultDir;
+        var tsconfigPath = tsm.findConfigFile(dir, tsm.sys.fileExists);
+        if (tsconfigPath) {
+            var projectDir = (0, path_1.dirname)(tsconfigPath);
+            var config = readConfig(tsm, tsconfigPath, (0, path_1.dirname)(tsconfigPath));
+            compilerOptions = __assign(__assign({}, config.options), compilerOptions);
+            return {
+                projectDir: projectDir,
+                compilerOptions: compilerOptions,
+            };
+        }
+    }
+    return {
+        projectDir: (0, path_1.dirname)(compilerOptions.configFilePath),
+        compilerOptions: compilerOptions,
+    };
+}
+function readConfig(tsm, configFileNamePath, projectDir) {
+    var result = tsm.readConfigFile(configFileNamePath, tsm.sys.readFile);
+    if (result.error) {
+        throw new Error('tsconfig.json error: ' + result.error.messageText);
+    }
+    return tsm.parseJsonConfigFileContent(result.config, tsm.sys, projectDir, undefined, configFileNamePath);
+}
+function preparePluginsFromCompilerOptions(plugins) {
+    if (!plugins)
+        return [];
+    // old transformers system
+    if (plugins.length === 1 && plugins[0].customTransformers) {
+        var _a = plugins[0].customTransformers, _b = _a.before, before = _b === void 0 ? [] : _b, _c = _a.after, after = _c === void 0 ? [] : _c;
+        return __spreadArray(__spreadArray([], before.map(function (item) { return ({ transform: item }); }), true), after.map(function (item) { return ({ transform: item, after: true }); }), true);
+    }
+    return plugins;
+}
+function injectionShadowedValues(target) {
+    target.getDefaultCompilerOptions2 = function getDefaultCompilerOptions2() {
+        return {
+            target: 1 /* ES5 */,
+            jsx: 1 /* Preserve */,
+        };
+    };
+    function fail(message, stackCrawlMark) {
+        debugger;
+        var e = new Error(message ? "Debug Failure. ".concat(message) : 'Debug Failure.');
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(e, stackCrawlMark || fail);
+        }
+        throw e;
+    }
+    function assertEqual(a, b, msg, msg2, stackCrawlMark) {
+        if (a !== b) {
+            var message = msg ? (msg2 ? "".concat(msg, " ").concat(msg2) : msg) : '';
+            fail("Expected ".concat(a, " === ").concat(b, ". ").concat(message), stackCrawlMark || assertEqual);
+        }
+    }
+    target.assertEqual = assertEqual;
+    function fileExtensionIs(path, extension) {
+        return path.length > extension.length && path.endsWith(extension);
+    }
+    try {
+        var originTranspileModule = target.transpileModule
+            .toString()
+            .replace(/(?<!function)\s([a-z][A-Za-z0-9]+)\(/g, ' target.$1(')
+            .replace('hasProperty', 'target.hasProperty')
+            .replace(/Debug\./g, 'target.')
+            .replace('transpileOptionValueCompilerOptions', 'target.transpileOptionValueCompilerOptions');
+        var __ = target.transpileModule, _target = __rest(target, ["transpileModule"]);
+        _target.transpileModule = eval('(' + originTranspileModule + ')');
+        return _target;
+    }
+    catch (e) {
+        return target;
+    }
+}

package/lib/tsc.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/tsc.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var fs = require("fs");
+var resolve = require("resolve");
+var loadTypescript_1 = require("./loadTypescript");
+var path_1 = require("path");
+var vm_1 = require("vm");
+var ts = (0, loadTypescript_1.loadTypeScript)('typescript', { folder: process.cwd(), forceConfigLoad: true });
+var tscFileName = resolve.sync('typescript/lib/tsc', { basedir: process.cwd() });
+var _a = ts.version.split('.').map(function (str) { return Number(str); }), major = _a[0], minor = _a[1];
+var commandLineTsCode = fs
+    .readFileSync(tscFileName, 'utf8')
+    .replace(major >= 4 && minor >= 9
+    ? /^[\s\S]+(\(function \(ts\) {\s+var StatisticType;[\s\S]+)$/
+    : /^[\s\S]+(\(function \(ts\) \{\s+function countLines[\s\S]+)$/, '$1');
+if (major >= 5) {
+    commandLineTsCode = commandLineTsCode.replace(/\= createProgram\(/g, '= ts.createProgram(');
+}
+var globalCode = (fs.readFileSync(tscFileName, 'utf8').match(/^([\s\S]*?)var ts;/) || ['', ''])[1];
+(0, vm_1.runInThisContext)("(function (exports, require, module, __filename, __dirname, ts) {".concat(globalCode).concat(commandLineTsCode, "\n});"), {
+    filename: tscFileName,
+    lineOffset: 0,
+    displayErrors: true,
+}).call(ts, ts, require, { exports: ts }, tscFileName, (0, path_1.dirname)(tscFileName), ts);

package/lib/tsserver.js

@@ -0,0 +1,2 @@
+"use strict";
+module.exports = require('typescript/lib/tsserver');

package/lib/tsserverlibrary.d.ts

@@ -0,0 +1,3 @@
+import * as TSSL from 'typescript/lib/tsserverlibrary';
+declare const ts: typeof TSSL;
+export = ts;

package/lib/tsserverlibrary.js

@@ -0,0 +1,4 @@
+"use strict";
+var loadTypescript_1 = require("./loadTypescript");
+var ts = (0, loadTypescript_1.loadTypeScript)('tsserverlibrary');
+module.exports = ts;

package/lib/typescript.d.ts

@@ -0,0 +1,3 @@
+import * as TS from 'typescript';
+declare const ts: typeof TS;
+export = ts;

package/lib/typescript.js

@@ -0,0 +1,4 @@
+"use strict";
+var loadTypescript_1 = require("./loadTypescript");
+var ts = (0, loadTypescript_1.loadTypeScript)('typescript');
+module.exports = ts;

package/lib/typescriptServices.d.ts

@@ -0,0 +1,3 @@
+import * as TS from 'typescript';
+declare const ts: typeof TS;
+export = ts;

package/lib/typescriptServices.js

@@ -0,0 +1,4 @@
+"use strict";
+var loadTypescript_1 = require("./loadTypescript");
+var ts = (0, loadTypescript_1.loadTypeScript)('typescriptServices');
+module.exports = ts;

package/lib/typingsInstaller.js

@@ -0,0 +1,2 @@
+"use strict";
+module.exports = require('typescript/lib/typingsInstaller');

package/lib/watchGuard.js

@@ -0,0 +1,2 @@
+"use strict";
+module.exports = require('typescript/lib/watchGuard');

package/package.json

@@ -0,0 +1,42 @@
+{
+    "name": "ttsc",
+    "bin": {
+        "ttsc": "./bin/tsc",
+        "ttsserver": "./bin/tsserver"
+    },
+    "version": "0.0.1",
+    "description": "Over TypeScript tool to use custom transformers in the tsconfig.json",
+    "main": "lib/typescript.js",
+    "files": [
+        "*.md",
+        "bin",
+        "lib",
+        "ts-node-config"
+    ],
+    "author": "cevek",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/solar-religion/ttsc.git"
+    },
+    "homepage": "https://github.com/solar-religion/ttsc/tree/main/packages/ttypescript",
+    "keywords": [
+        "typescript",
+        "wrapper",
+        "transform",
+        "transformer",
+        "plugin",
+        "config"
+    ],
+    "license": "MIT",
+    "dependencies": {
+        "resolve": ">=1.9.0"
+    },
+    "devDependencies": {
+        "ts-node": ">=8.0.2",
+        "typescript": ">=3.2.2"
+    },
+    "peerDependencies": {
+        "ts-node": ">=8.0.2",
+        "typescript": ">=3.2.2"
+    }
+}