feat: Convert src/runtime/internal/await_block.ts to JavaScript

src/runtime/internal/await_block.ts

@@ -2,126 +2,114 @@ import { is_promise } from './utils';
 import { check_outros, group_outros, transition_in, transition_out } from './transitions';
 import { flush } from './scheduler';
 import { get_current_component, set_current_component } from './lifecycle';
-import { Fragment, FragmentFactory } from './types';
+/** @param {Promise<T>} promise
-
+ * @param {PromiseInfo<T>} info
-interface PromiseInfo<T> {
+ * @returns {boolean}
-	ctx: null | any;
+ */
-	// unique object instance as a key to compare different promises
+export function handle_promise(promise, info) {
-	token: {};
+    const token = (info.token = {});
-	hasCatch: boolean;
+    /** @param {FragmentFactory} type
-	pending: FragmentFactory;
+     * @param {0 | 1 | 2} index
-	then: FragmentFactory;
+     * @param {number} key
-	catch: FragmentFactory;
+     * @returns {void}
-	// ctx index for resolved value and rejected error
+     */
-	value: number;
+    function update(type, index, key, value) {
-	error: number;
+        if (info.token !== token)
-	// resolved value or rejected error
+            return;
-	resolved?: T;
+        info.resolved = value;
-	// the current factory function for creating the fragment
+        let child_ctx = info.ctx;
-	current: FragmentFactory | null;
+        if (key !== undefined) {
-	// the current fragment
+            child_ctx = child_ctx.slice();
-	block: Fragment | null;
+            child_ctx[key] = value;
-	// tuple of the pending, then, catch fragment
+        }
-	blocks: [null | Fragment, null | Fragment, null | Fragment];
+        const block = type && (info.current = type)(child_ctx);
-	// DOM elements to mount and anchor on for the {#await} block
+        let needs_flush = false;
-	mount: () => HTMLElement;
+        if (info.block) {
-	anchor: HTMLElement;
+            if (info.blocks) {
+                info.blocks.forEach((block, i) => {
+                    if (i !== index && block) {
+                        group_outros();
+                        transition_out(block, 1, 1, () => {
+                            if (info.blocks[i] === block) {
+                                info.blocks[i] = null;
+                            }
+                        });
+                        check_outros();
+                    }
+                });
+            }
+            else {
+                info.block.d(1);
+            }
+            block.c();
+            transition_in(block, 1);
+            block.m(info.mount(), info.anchor);
+            needs_flush = true;
+        }
+        info.block = block;
+        if (info.blocks)
+            info.blocks[index] = block;
+        if (needs_flush) {
+            flush();
+        }
+    }
+    if (is_promise(promise)) {
+        const current_component = get_current_component();
+        promise.then((value) => {
+            set_current_component(current_component);
+            update(info.then, 1, info.value, value);
+            set_current_component(null);
+        }, (error) => {
+            set_current_component(current_component);
+            update(info.catch, 2, info.error, error);
+            set_current_component(null);
+            if (!info.hasCatch) {
+                throw error;
+            }
+        });
+        // if we previously had a then/catch block, destroy it
+        if (info.current !== info.pending) {
+            update(info.pending, 0);
+            return true;
+        }
+    }
+    else {
+        if (info.current !== info.then) {
+            update(info.then, 1, info.value, promise);
+            return true;
+        }
+        info.resolved = promise;
+    }
 }
-
+/** @returns {void} */
-export function handle_promise<T>(promise: Promise<T>, info: PromiseInfo<T>) {
+export function update_await_block_branch(info, ctx, dirty) {
-	const token = (info.token = {});
+    const child_ctx = ctx.slice();
-
+    const { resolved } = info;
-	function update(type: FragmentFactory, index: 0 | 1 | 2, key?: number, value?) {
+    if (info.current === info.then) {
-		if (info.token !== token) return;
+        child_ctx[info.value] = resolved;
-
+    }
-		info.resolved = value;
+    if (info.current === info.catch) {
-
+        child_ctx[info.error] = resolved;
-		let child_ctx = info.ctx;
+    }
-
+    info.block.p(child_ctx, dirty);
-		if (key !== undefined) {
-			child_ctx = child_ctx.slice();
-			child_ctx[key] = value;
-		}
-
-		const block = type && (info.current = type)(child_ctx);
-
-		let needs_flush = false;
-
-		if (info.block) {
-			if (info.blocks) {
-				info.blocks.forEach((block, i) => {
-					if (i !== index && block) {
-						group_outros();
-						transition_out(block, 1, 1, () => {
-							if (info.blocks[i] === block) {
-								info.blocks[i] = null;
-							}
-						});
-						check_outros();
-					}
-				});
-			} else {
-				info.block.d(1);
-			}
-
-			block.c();
-			transition_in(block, 1);
-			block.m(info.mount(), info.anchor);
-
-			needs_flush = true;
-		}
-
-		info.block = block;
-		if (info.blocks) info.blocks[index] = block;
-
-		if (needs_flush) {
-			flush();
-		}
-	}
-
-	if (is_promise(promise)) {
-		const current_component = get_current_component();
-		promise.then(
-			(value) => {
-				set_current_component(current_component);
-				update(info.then, 1, info.value, value);
-				set_current_component(null);
-			},
-			(error) => {
-				set_current_component(current_component);
-				update(info.catch, 2, info.error, error);
-				set_current_component(null);
-				if (!info.hasCatch) {
-					throw error;
-				}
-			}
-		);
-
-		// if we previously had a then/catch block, destroy it
-		if (info.current !== info.pending) {
-			update(info.pending, 0);
-			return true;
-		}
-	} else {
-		if (info.current !== info.then) {
-			update(info.then, 1, info.value, promise);
-			return true;
-		}
-
-		info.resolved = promise;
-	}
 }
 
-export function update_await_block_branch(info, ctx, dirty) {
-	const child_ctx = ctx.slice();
-	const { resolved } = info;
 
-	if (info.current === info.then) {
-		child_ctx[info.value] = resolved;
-	}
-	if (info.current === info.catch) {
-		child_ctx[info.error] = resolved;
-	}
 
-	info.block.p(child_ctx, dirty);
+
-}
+/** @typedef {Object} PromiseInfo
+ * @property {null|any} ctx
+ * @property {{}} token
+ * @property {boolean} hasCatch
+ * @property {FragmentFactory} pending
+ * @property {FragmentFactory} then
+ * @property {FragmentFactory} catch
+ * @property {number} value
+ * @property {number} error
+ * @property {T} [resolved]
+ * @property {FragmentFactory|null} current
+ * @property {Fragment|null} block
+ * @property {[null|Fragment,null|Fragment,null|Fragment]} blocks
+ * @property {()=>HTMLElement} mount
+ * @property {HTMLElement} anchor 
+ */