Exemple #1
0
        /// <summary>
        /// Returns transpiled javascript according to the specified options.
        /// </summary>
        /// <param name="options">Transpile options</param>
        /// <returns>The output of the transpilation process</returns>
        public Task <TranspileOutput> Transpile(TranspileOptions options)
        {
            if (m_isDisposed)
            {
                throw new ObjectDisposedException(nameof(TypeScriptTranspiler));
            }

            if (options == null)
            {
                throw new ArgumentNullException(nameof(options));
            }

            return(Task.Factory.StartNew(new Func <object, TranspileOutput>((transpilerOptions) =>
            {
                return TranspileInternal(transpilerOptions as TranspileOptions);
            }),
                                         options,
                                         CancellationToken.None,
                                         TaskCreationOptions.DenyChildAttach,
                                         new ThreadPerTaskScheduler()));
        }
Exemple #2
0
        private TranspileOutput TranspileInternal(TranspileOptions options)
        {
            using (var rt = m_runtimeFactory.CreateRuntime(JavaScriptRuntimeAttributes.DisableBackgroundWork | JavaScriptRuntimeAttributes.DisableEval))
                using (var ctx = rt.CreateContext())
                    using (ctx.Scope())
                    {
                        var tsBuffer     = GetSerializedTypeScriptCompiler(ctx);
                        var fnTypeScript = ctx.ParseSerializedScript(tsBuffer, () => EmbeddedResourceHelper.LoadResource(ResourceName), "[typescript]");

                        //Create the compiler options object that specifies the compiler options.
                        var objCompilerOptions = ctx.CreateObject();
                        objCompilerOptions["target"] = ctx.CreateNumber((int)options.CompilerOptions.Target);
                        objCompilerOptions["module"] = ctx.CreateNumber((int)options.CompilerOptions.Module);
                        objCompilerOptions["jsx"]    = ctx.CreateNumber((int)options.CompilerOptions.Jsx);
                        if (options.CompilerOptions.ImportHelpers.HasValue)
                        {
                            objCompilerOptions["importHelpers"] = options.CompilerOptions.ImportHelpers.Value ? ctx.True : ctx.False;
                        }

                        //Create the transpile options object that specifies the transpilation options
                        var objTranspileOptions = ctx.CreateObject();
                        objTranspileOptions["compilerOptions"] = objCompilerOptions;
                        objTranspileOptions["fileName"]        = ctx.CreateString(options.FileName);

                        ////All systems go. Perform the transpilation.
                        var jsScriptToTranspile = ctx.CreateString(options.Script);

                        var jsTs = fnTypeScript.Call <JsObject>();
                        var fnTranspileModule = jsTs.GetProperty <JsFunction>("transpileModule");
                        var objTranspiled     = fnTranspileModule.Call <JsObject>(jsTs, jsScriptToTranspile, objTranspileOptions);

                        var output = new TranspileOutput
                        {
                            OutputText    = objTranspiled["outputText"].ToString(),
                            SourceMapText = objTranspiled["sourceMapText"].ToString()
                        };
                        return(output);
                    }
        }