Convert src/compiler/compile/render_dom/wrappers/DebugTag.ts to JavaScript

src/compiler/compile/render_dom/wrappers/DebugTag.ts

@@ -1,88 +1,90 @@
-import Renderer from '../Renderer';
-import Wrapper from './shared/Wrapper';
-import Block from '../Block';
-import DebugTag from '../../nodes/DebugTag';
-import add_to_set from '../../utils/add_to_set';
+import Wrapper from './shared/Wrapper.js';
+import add_to_set from '../../utils/add_to_set.js';
 import { b, p } from 'code-red';
-import { Identifier, DebuggerStatement } from 'estree';
 
+/** @extends Wrapper */
 export default class DebugTagWrapper extends Wrapper {
-	node: DebugTag;
 
-	constructor(
-		renderer: Renderer,
-		block: Block,
-		parent: Wrapper,
-		node: DebugTag,
-		_strip_whitespace: boolean,
-		_next_sibling: Wrapper
-	) {
+    /** @type {import('../../nodes/DebugTag.js').default} */
+    node;
+
+ /**
+  * @param {import('../Renderer.js').default} renderer
+     * @param {import('../Block.js').default} block
+     * @param {import('./shared/Wrapper.js').default} parent
+     * @param {import('../../nodes/DebugTag.js').default} node
+     * @param {boolean} _strip_whitespace
+     * @param {import('./shared/Wrapper.js').default} _next_sibling
+     */
+    constructor(renderer, block, parent, node, _strip_whitespace, _next_sibling) {
         super(renderer, block, parent, node);
     }
 
-	render(block: Block, _parent_node: Identifier, _parent_nodes: Identifier) {
+ /**
+  * @param {import('../Block.js').default} block
+     * @param {import('estree').Identifier} _parent_node
+     * @param {import('estree').Identifier} _parent_nodes
+     */
+    render(block, _parent_node, _parent_nodes) {
         const { renderer } = this;
         const { component } = renderer;
-
-		if (!renderer.options.dev) return;
-
+        if (!renderer.options.dev)
+            return;
         const { var_lookup } = component;
-
         const start = component.locate(this.node.start + 1);
         const end = { line: start.line, column: start.column + 6 };
-
         const loc = { start, end };
 
-		const debug: DebuggerStatement = {
+        /** @type {import('estree').DebuggerStatement} */
+        const debug = {
             type: 'DebuggerStatement',
             loc
         };
-
         if (this.node.expressions.length === 0) {
             // Debug all
             block.chunks.create.push(debug);
             block.chunks.update.push(debug);
-		} else {
-			const log: Identifier = {
+        }
+        else {
+
+            /** @type {import('estree').Identifier} */
+            const log = {
                 type: 'Identifier',
                 name: 'log',
                 loc
             };
 
-			const dependencies: Set<string> = new Set();
+            /** @type {Set<string>} */
+            const dependencies = new Set();
             this.node.expressions.forEach((expression) => {
                 add_to_set(dependencies, expression.dependencies);
             });
-
             const contextual_identifiers = this.node.expressions
                 .filter((e) => {
-					const variable = var_lookup.get((e.node as Identifier).name);
+                const variable = var_lookup.get(( /** @type {import('estree').Identifier} */(e.node)).name);
                 return !(variable && variable.hoistable);
             })
-				.map((e) => (e.node as Identifier).name);
-
-			const logged_identifiers = this.node.expressions.map(
-				(e) => p`${(e.node as Identifier).name}`
-			);
-
-			const debug_statements = b`
-				${contextual_identifiers.map((name) => b`const ${name} = ${renderer.reference(name)};`)}
+                .map((e) => ( /** @type {import('estree').Identifier} */(e.node)).name);
+            const logged_identifiers = this.node.expressions.map((e) => p `${( /** @type {import('estree').Identifier} */(e.node)).name}`);
+            const debug_statements = b `
+				${contextual_identifiers.map((name) => b `const ${name} = ${renderer.reference(name)};`)}
 				@_console.${log}({ ${logged_identifiers} });
 				debugger;`;
-
             if (dependencies.size) {
                 const condition = renderer.dirty(Array.from(dependencies));
-
-				block.chunks.update.push(b`
+                block.chunks.update.push(b `
 					if (${condition}) {
 						${debug_statements}
 					}
 				`);
             }
-
-			block.chunks.create.push(b`{
+            block.chunks.create.push(b `{
 				${debug_statements}
 			}`);
         }
     }
 }
+
+
+
+