Add markup text for JSX in Typescript, closes #878

Author: Sannis

src/languages/typescript.js

@@ -22,7 +22,7 @@ function(hljs) {
       'Float64Array Int16Array Int32Array Int8Array Uint16Array Uint32Array ' +
       'Uint8Array Uint8ClampedArray ArrayBuffer DataView JSON Intl arguments require ' +
       'module console window document any number boolean string void'
-  }
+  };
 
   return {
     aliases: ['ts'],

test/markup/typescript/jsx.expect.txt

@@ -0,0 +1,41 @@
+<span class="hljs-keyword">export</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">getModuleInstanceState</span>(<span class="hljs-params">node: Node</span>): <span class="hljs-title">ModuleInstanceState</span> </span>{
+    <span class="hljs-comment">// A module is uninstantiated if it contains only</span>
+    <span class="hljs-comment">// 1. interface declarations, type alias declarations</span>
+    <span class="hljs-keyword">if</span> (node.kind === SyntaxKind.InterfaceDeclaration || node.kind === SyntaxKind.TypeAliasDeclaration) {
+        <span class="hljs-keyword">return</span> ModuleInstanceState.NonInstantiated;
+    }
+    <span class="hljs-comment">// 2. const enum declarations</span>
+    <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> (isConstEnumDeclaration(node)) {
+        <span class="hljs-keyword">return</span> ModuleInstanceState.ConstEnumOnly;
+    }
+    <span class="hljs-comment">// 3. non-exported import declarations</span>
+    <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> ((node.kind === SyntaxKind.ImportDeclaration || node.kind === SyntaxKind.ImportEqualsDeclaration) &amp;&amp; !(node.flags &amp; NodeFlags.Export)) {
+        <span class="hljs-keyword">return</span> ModuleInstanceState.NonInstantiated;
+    }
+    <span class="hljs-comment">// 4. other uninstantiated module declarations.</span>
+    <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> (node.kind === SyntaxKind.ModuleBlock) {
+        <span class="hljs-keyword">let</span> state = ModuleInstanceState.NonInstantiated;
+        forEachChild(node, n =&gt; {
+            <span class="hljs-keyword">switch</span> (getModuleInstanceState(n)) {
+                <span class="hljs-keyword">case</span> ModuleInstanceState.NonInstantiated:
+                    <span class="hljs-comment">// child is non-instantiated - continue searching</span>
+                    <span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;
+                <span class="hljs-keyword">case</span> ModuleInstanceState.ConstEnumOnly:
+                    <span class="hljs-comment">// child is const enum only - record state and continue searching</span>
+                    state = ModuleInstanceState.ConstEnumOnly;
+                    <span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;
+                <span class="hljs-keyword">case</span> ModuleInstanceState.Instantiated:
+                    <span class="hljs-comment">// child is instantiated - record state and stop</span>
+                    state = ModuleInstanceState.Instantiated;
+                    <span class="hljs-keyword">return</span> <span class="hljs-literal">true</span>;
+            }
+        });
+        <span class="hljs-keyword">return</span> state;
+    }
+    <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> (node.kind === SyntaxKind.ModuleDeclaration) {
+        <span class="hljs-keyword">return</span> getModuleInstanceState((&lt;ModuleDeclaration&gt;node).body);
+    }
+    <span class="hljs-keyword">else</span> {
+        <span class="hljs-keyword">return</span> ModuleInstanceState.Instantiated;
+    }
+}

test/markup/typescript/jsx.txt

@@ -0,0 +1,41 @@
+export function getModuleInstanceState(node: Node): ModuleInstanceState {
+    // A module is uninstantiated if it contains only
+    // 1. interface declarations, type alias declarations
+    if (node.kind === SyntaxKind.InterfaceDeclaration || node.kind === SyntaxKind.TypeAliasDeclaration) {
+        return ModuleInstanceState.NonInstantiated;
+    }
+    // 2. const enum declarations
+    else if (isConstEnumDeclaration(node)) {
+        return ModuleInstanceState.ConstEnumOnly;
+    }
+    // 3. non-exported import declarations
+    else if ((node.kind === SyntaxKind.ImportDeclaration || node.kind === SyntaxKind.ImportEqualsDeclaration) && !(node.flags & NodeFlags.Export)) {
+        return ModuleInstanceState.NonInstantiated;
+    }
+    // 4. other uninstantiated module declarations.
+    else if (node.kind === SyntaxKind.ModuleBlock) {
+        let state = ModuleInstanceState.NonInstantiated;
+        forEachChild(node, n => {
+            switch (getModuleInstanceState(n)) {
+                case ModuleInstanceState.NonInstantiated:
+                    // child is non-instantiated - continue searching
+                    return false;
+                case ModuleInstanceState.ConstEnumOnly:
+                    // child is const enum only - record state and continue searching
+                    state = ModuleInstanceState.ConstEnumOnly;
+                    return false;
+                case ModuleInstanceState.Instantiated:
+                    // child is instantiated - record state and stop
+                    state = ModuleInstanceState.Instantiated;
+                    return true;
+            }
+        });
+        return state;
+    }
+    else if (node.kind === SyntaxKind.ModuleDeclaration) {
+        return getModuleInstanceState((<ModuleDeclaration>node).body);
+    }
+    else {
+        return ModuleInstanceState.Instantiated;
+    }
+}