Convert src/compiler/compile/render_dom/wrappers/shared/get_slot_definition.ts to JavaScript

src/compiler/compile/render_dom/wrappers/shared/get_slot_definition.ts

@@ -1,12 +1,13 @@
-import Let from '../../../nodes/Let';
 import { x, p } from 'code-red';
-import Block from '../../Block';
-import TemplateScope from '../../../nodes/shared/TemplateScope';
-import { BinaryExpression, Identifier } from 'estree';
-
-export function get_slot_definition(block: Block, scope: TemplateScope, lets: Let[]) {
-	if (lets.length === 0) return { block, scope };
 
+/**
+ * @param {import('../../Block.js').default} block
+ * @param {import('../../../nodes/shared/TemplateScope.js').default} scope
+ * @param {import('../../../nodes/Let.js').default[]} lets
+ */
+export function get_slot_definition(block, scope, lets) {
+    if (lets.length === 0)
+        return { block, scope };
     const context_input = {
         type: 'ObjectPattern',
         properties: lets.map((l) => ({
@@ -16,18 +17,19 @@ export function get_slot_definition(block: Block, scope: TemplateScope, lets: Le
             value: l.value || l.name
         }))
     };
-
     const properties = [];
     const value_map = new Map();
-
     lets.forEach((l) => {
-		let value: Identifier;
+
+        /** @type {import('estree').Identifier} */
+        let value;
         if (l.names.length > 1) {
             // more than one, probably destructuring
             const unique_name = block.get_unique_name(l.names.join('_')).name;
             value_map.set(l.value, unique_name);
             value = { type: 'Identifier', name: unique_name };
-		} else {
+        }
+        else {
             value = l.value || l.name;
         }
         properties.push({
@@ -37,15 +39,16 @@ export function get_slot_definition(block: Block, scope: TemplateScope, lets: Le
             value
         });
     });
-
     const changes_input = {
         type: 'ObjectPattern',
         properties
     };
 
-	const names: Set<string> = new Set();
-	const names_lookup: Map<string, string> = new Map();
+    /** @type {Set<string>} */
+    const names = new Set();
 
+    /** @type {Map<string, string>} */
+    const names_lookup = new Map();
     lets.forEach((l) => {
         l.names.forEach((name) => {
             names.add(name);
@@ -54,16 +57,11 @@ export function get_slot_definition(block: Block, scope: TemplateScope, lets: Le
             }
         });
     });
-
     const context = {
         type: 'ObjectExpression',
-		properties: Array.from(names).map(
-			(name) => p`${block.renderer.context_lookup.get(name).index}: ${name}`
-		)
+        properties: Array.from(names).map((name) => p `${block.renderer.context_lookup.get(name).index}: ${name}`)
     };
-
     const { context_lookup } = block.renderer;
-
     // i am well aware that this code is gross
     // TODO: context-overflow make it less gross
     const changes = {
@@ -71,49 +69,44 @@ export function get_slot_definition(block: Block, scope: TemplateScope, lets: Le
         get expression() {
             if (block.renderer.context_overflow) {
                 const grouped = [];
-
                 Array.from(names).forEach((name) => {
-					const i = context_lookup.get(name).index.value as number;
+                    const i = /** @type {number} */ (context_lookup.get(name).index.value);
                     const g = Math.floor(i / 31);
-
                     const lookup_name = names_lookup.has(name) ? names_lookup.get(name) : name;
-
-					if (!grouped[g]) grouped[g] = [];
+                    if (!grouped[g])
+                        grouped[g] = [];
                     grouped[g].push({ name: lookup_name, n: i % 31 });
                 });
-
                 const elements = [];
-
                 for (let g = 0; g < grouped.length; g += 1) {
                     elements[g] = grouped[g]
                         ? grouped[g]
-								.map(({ name, n }) => x`${name} ? ${1 << n} : 0`)
-								.reduce(
-									(lhs: ReturnType<typeof x>, rhs: ReturnType<typeof x>) => x`${lhs} | ${rhs}`
-								)
-						: x`0`;
+                            .map(({ name, n }) => x `${name} ? ${1 << n} : 0`)
+                            .reduce((lhs, rhs) => x `${lhs} | ${rhs}`)
+                        : x `0`;
                 }
-
                 return {
                     type: 'ArrayExpression',
                     elements
                 };
             }
-
-			return Array.from(names)
+            return /** @type {import('estree').BinaryExpression} */ (Array.from(names)
                 .map((name) => {
                 const lookup_name = names_lookup.has(name) ? names_lookup.get(name) : name;
-					const i = context_lookup.get(name).index.value as number;
-					return x`${lookup_name} ? ${1 << i} : 0`;
+                const i = /** @type {number} */ (context_lookup.get(name).index.value);
+                return x `${lookup_name} ? ${1 << i} : 0`;
             })
-				.reduce((lhs, rhs) => x`${lhs} | ${rhs}`) as BinaryExpression;
+                .reduce((lhs, rhs) => x `${lhs} | ${rhs}`));
         }
     };
-
     return {
         block,
         scope,
-		get_context: x`${context_input} => ${context}`,
-		get_changes: x`${changes_input} => ${changes}`
+        get_context: x `${context_input} => ${context}`,
+        get_changes: x `${changes_input} => ${changes}`
     };
 }
+
+
+
+