Convert src/compiler/compile/nodes/shared/TemplateScope.ts to JavaScript

src/compiler/compile/nodes/shared/Tag.js

@@ -13,10 +13,10 @@ export default class Tag extends Node {
 	should_cache;
 
 	/**
-	 * @param {any} component  *
+	 * @param {any} component
-	 * @param {any} parent  *
+	 * @param {any} parent
-	 * @param {any} scope  *
+	 * @param {any} scope
-	 * @param {any} info  undefined
+	 * @param {any} info
 	 */
 	constructor(component, parent, scope, info) {
 		super(component, parent, scope, info);

src/compiler/compile/nodes/shared/TemplateScope.ts

@@ -1,69 +1,83 @@
-import EachBlock from '../EachBlock';
+export default class TemplateScope {
-import ThenBlock from '../ThenBlock';
-import CatchBlock from '../CatchBlock';
-import InlineComponent from '../InlineComponent';
-import Element from '../Element';
-import SlotTemplate from '../SlotTemplate';
-import ConstTag from '../ConstTag';
 
-type NodeWithScope =
+    /** @type {Set<string>} */
-	| EachBlock
+    names;
-	| ThenBlock
-	| CatchBlock
-	| InlineComponent
-	| Element
-	| SlotTemplate
-	| ConstTag;
 
-export default class TemplateScope {
+    /** @type {Map<string, Set<string>>} */
-	names: Set<string>;
+    dependencies_for_name;
-	dependencies_for_name: Map<string, Set<string>>;
+
-	owners: Map<string, NodeWithScope> = new Map();
+    /** @type {Map<string, NodeWithScope>} */
-	parent?: TemplateScope;
+    owners = new Map();
+
+    /** @type {TemplateScope} */
+    parent;
 
-	constructor(parent?: TemplateScope) {
+    /** @param {TemplateScope} [parent]  undefined */
+    constructor(parent) {
         this.parent = parent;
         this.names = new Set(parent ? parent.names : []);
         this.dependencies_for_name = new Map(parent ? parent.dependencies_for_name : []);
     }
 
-	add(name, dependencies: Set<string>, owner) {
+ /**
+  * @param {any} name
+     * @param {Set<string>} dependencies
+     * @param {any} owner
+     */
+    add(name, dependencies, owner) {
         this.names.add(name);
         this.dependencies_for_name.set(name, dependencies);
         this.owners.set(name, owner);
         return this;
     }
-
     child() {
         const child = new TemplateScope(this);
         return child;
     }
 
-	is_top_level(name: string) {
+    /** @param {string} name */
+    is_top_level(name) {
         return !this.parent || (!this.names.has(name) && this.parent.is_top_level(name));
     }
 
-	get_owner(name: string): NodeWithScope {
+ /**
+  * @param {string} name
+     * @returns {any}
+     */
+    get_owner(name) {
         return this.owners.get(name) || (this.parent && this.parent.get_owner(name));
     }
 
-	is_let(name: string) {
+    /** @param {string} name */
+    is_let(name) {
         const owner = this.get_owner(name);
-		return (
+        return (owner &&
-			owner &&
             (owner.type === 'Element' ||
                 owner.type === 'InlineComponent' ||
-				owner.type === 'SlotTemplate')
+                owner.type === 'SlotTemplate'));
-		);
     }
 
-	is_await(name: string) {
+    /** @param {string} name */
+    is_await(name) {
         const owner = this.get_owner(name);
         return owner && (owner.type === 'ThenBlock' || owner.type === 'CatchBlock');
     }
 
-	is_const(name: string) {
+    /** @param {string} name */
+    is_const(name) {
         const owner = this.get_owner(name);
         return owner && owner.type === 'ConstTag';
     }
 }
+
+
+/**
+ * @typedef {| EachBlock
+ * 	| ThenBlock
+ * 	| CatchBlock
+ * 	| InlineComponent
+ * 	| Element
+ * 	| SlotTemplate
+ * 	| ConstTag} NodeWithScope
+ */
+