@tsrx/core 0.1.46 → 0.1.48

package/package.json

@@ -3,7 +3,7 @@
   "description": "Core compiler infrastructure for TSRX syntax",
   "license": "MIT",
   "author": "Dominic Gannaway",
-  "version": "0.1.46",
+  "version": "0.1.48",
   "type": "module",
   "repository": {
     "type": "git",

package/src/index.js

@@ -89,6 +89,7 @@ export {
 	is_function_node as isFunctionNode,
 	is_function_or_class_node as isFunctionOrClassNode,
 	is_function_or_component_node as isFunctionOrComponentNode,
+	has_location,
 	is_inside_component as isInsideComponent,
 	is_template_directive as isTemplateDirective,
 	is_tsrx_render_output_node as isTsrxRenderOutputNode,
@@ -148,6 +149,7 @@ export { normalize_css_property_name as normalizeCssPropertyName } from './utils
 export { escape, escape_script as escapeScript } from './utils/escaping.js';
 
 // Transform
+export { with_deferred_imports as withDeferredImports } from './transform/imports.js';
 export {
 	add_jsx_setup_declaration as addJsxSetupDeclaration,
 	clone_switch_helper_invocation as cloneSwitchHelperInvocation,
@@ -167,7 +169,6 @@ export {
 	plan_switch_lift as planSwitchLift,
 	return_value_body_to_expression as returnValueBodyToExpression,
 	rewrite_loop_continues_to_bare_returns as rewriteLoopContinuesToBareReturns,
-	to_jsx_attribute as toJsxAttribute,
 	validate_at_most_one_ref_attribute as validateAtMostOneRefAttribute,
 	wrap_edge_whitespace as wrapEdgeWhitespace,
 } from './transform/jsx/index.js';
@@ -189,7 +190,7 @@ export {
 } from './transform/style-ref.js';
 export {
 	add_extra_source_mappings_from_matching_expression,
-	clone_expression_node,
+	clone_ast_node,
 	clone_identifier,
 	clone_jsx_name,
 	contains_component_jsx,

package/src/parse/index.js

@@ -8,6 +8,7 @@
 import * as acorn from 'acorn';
 import { tsPlugin } from '@sveltejs/acorn-typescript';
 import { walk } from 'zimmerframe';
+import { has_location } from '../utils/ast.js';
 
 /**
  * @typedef {(BaseParser: typeof acorn.Parser) => typeof acorn.Parser} AcornPlugin
@@ -607,8 +608,8 @@ export function get_comment_handlers(source, comments, index = 0) {
 						}
 
 						const ancestorElements = path
-							.filter((ancestor) => isNativeTemplateNode(ancestor) && ancestor.loc)
-							.map((ancestor) => /** @type {AST.NodeWithLocation} */ (ancestor))
+							.filter(has_location)
+							.filter(isNativeTemplateNode)
 							.sort((a, b) => a.loc.start.line - b.loc.start.line);
 
 						const targetAncestor = ancestorElements.find(

package/src/plugin.js

@@ -4688,6 +4688,67 @@ export function TSRXPlugin(config) {
 				this.parseTemplateBody(body);
 			}
 
+			/**
+			 * Parse the argument list of a deferred dynamic import,
+			 * `import.defer(specifier, options?)`, starting at the opening paren.
+			 *
+			 * This mirrors Acorn's ES2025 `import(...)` grammar (optional `options`
+			 * argument, optional trailing comma), which neither inherited parser
+			 * produces here: acorn-typescript's `parseDynamicImport` emits legacy
+			 * `arguments`, and Acorn's own only enables the `options` shape at
+			 * `ecmaVersion >= 16` while TSRX parses at 13.
+			 *
+			 * @param {AST.ImportExpression} node
+			 * @returns {AST.ImportExpression}
+			 */
+			parseDeferredDynamicImport(node) {
+				this.next(); // `(`
+				node.source = this.parseMaybeAssign();
+				node.options = null;
+
+				if (!this.eat(tt.parenR)) {
+					this.expect(tt.comma);
+					if (!this.afterTrailingComma(tt.parenR)) {
+						node.options = this.parseMaybeAssign();
+						if (!this.eat(tt.parenR)) {
+							this.expect(tt.comma);
+							if (!this.afterTrailingComma(tt.parenR)) this.unexpected();
+						}
+					}
+				}
+
+				return this.finishNode(node, 'ImportExpression');
+			}
+
+			/**
+			 * Recognize the deferred dynamic-import form
+			 * `import.defer(specifier, options?)` before Acorn parses `import.<name>`
+			 * as an `import.meta` member access. Ordinary `import()` and `import.meta`
+			 * fall through to Acorn unchanged, so the proposal never alters their
+			 * existing AST shape.
+			 * @type {Parse.Parser['parseExprImport']}
+			 */
+			parseExprImport(forNew) {
+				if (
+					!forNew &&
+					this.lookahead().type === tt.dot &&
+					this.isContextualWithState('defer', this.lookahead(2))
+				) {
+					const node = /** @type {AST.ImportExpression} */ (this.startNode());
+					if (this.containsEsc) {
+						this.raiseRecoverable(this.start, 'Escape sequence in keyword import');
+					}
+					this.next(); // `import`
+					this.next(); // `.`
+					this.next(); // `defer`
+					node.phase = 'defer';
+					if (this.type !== tt.parenL) this.unexpected();
+					return this.parseDeferredDynamicImport(node);
+				}
+
+				return super.parseExprImport(forNew);
+			}
+
 			/**
 			 * Parse proposal-style imports from an inline module declaration:
 			 * `import { foo } from server;`
@@ -4698,54 +4759,77 @@ export function TSRXPlugin(config) {
 			 * @type {Parse.Parser['parseImport']}
 			 */
 			parseImport(node) {
-				const tokenIsIdentifier = /** @type {any} */ (Parser.acornTypeScript).tokenIsIdentifier;
-				const parser = /** @type {any} */ (this);
-				const import_node = /** @type {any} */ (node);
-				let enterHead = parser.lookahead();
-				import_node.importKind = 'value';
-				parser.importOrExportOuterKind = 'value';
+				const tokenIsIdentifier = Parser.acornTypeScript.tokenIsIdentifier;
+				let enterHead = this.lookahead();
+				let deferred = false;
+				let defer_start = -1;
+				node.importKind = 'value';
+				this.importOrExportOuterKind = 'value';
 				if (tokenIsIdentifier(enterHead.type) || this.match(tt.star) || this.match(tt.braceL)) {
-					let ahead = parser.lookahead(2);
-					if (
+					let ahead = this.lookahead(2);
+					// `defer` and `type` are only phase/kind modifiers when the following
+					// token cannot continue a default import (`, `/`from`) or an
+					// import-equals declaration (`=`); otherwise they are ordinary bindings.
+					const head_modifies =
 						ahead.type !== tt.comma &&
-						!parser.isContextualWithState('from', ahead) &&
-						ahead.type !== tt.eq &&
-						parser.ts_eatContextualWithState('type', 1, enterHead)
-					) {
-						parser.importOrExportOuterKind = 'type';
-						import_node.importKind = 'type';
-						enterHead = parser.lookahead();
-						ahead = parser.lookahead(2);
+						!this.isContextualWithState('from', ahead) &&
+						ahead.type !== tt.eq;
+					// The namespace-only restriction is checked after parsing the clause,
+					// which also gives invalid named/default deferred imports a focused
+					// diagnostic.
+					if (head_modifies && this.isContextualWithState('defer', enterHead)) {
+						deferred = true;
+						defer_start = enterHead.start;
+						node.phase = 'defer';
+						this.ts_eatContextualWithState('defer', 1, enterHead);
+						enterHead = this.lookahead();
+						ahead = this.lookahead(2);
+					} else if (head_modifies && this.ts_eatContextualWithState('type', 1, enterHead)) {
+						this.importOrExportOuterKind = 'type';
+						node.importKind = 'type';
+						enterHead = this.lookahead();
+						ahead = this.lookahead(2);
 					}
 					if (tokenIsIdentifier(enterHead.type) && ahead.type === tt.eq) {
 						this.next();
-						const importNode = parser.tsParseImportEqualsDeclaration(node);
-						parser.importOrExportOuterKind = 'value';
+						const importNode = this.tsParseImportEqualsDeclaration(node);
+						this.importOrExportOuterKind = 'value';
 						return importNode;
 					}
 				}
 				this.next();
 				if (this.type === tt.string) {
-					import_node.specifiers = [];
-					import_node.source = this.parseExprAtom();
+					node.specifiers = [];
+					node.source = /** @type {AST.Literal} */ (this.parseExprAtom());
 				} else {
-					import_node.specifiers = this.parseImportSpecifiers();
+					node.specifiers = this.parseImportSpecifiers();
 					this.expectContextual('from');
 					if (this.type === tt.string) {
-						import_node.source = this.parseExprAtom();
+						node.source = /** @type {AST.Literal} */ (this.parseExprAtom());
 					} else if (tokenIsIdentifier(this.type)) {
 						const source = this.parseIdent(false);
 						source.metadata ??= { path: [] };
-						import_node.source = source;
+						node.source = source;
 					} else {
 						this.unexpected();
 					}
 				}
-				parser.parseMaybeImportAttributes(node);
+				if (
+					deferred &&
+					(node.specifiers.length !== 1 ||
+						node.specifiers[0].type !== 'ImportNamespaceSpecifier' ||
+						node.source.type !== 'Literal')
+				) {
+					this.raise(
+						defer_start,
+						'`import defer` only supports a namespace import from a string literal.',
+					);
+				}
+				this.parseMaybeImportAttributes(node);
 				this.semicolon();
 				this.finishNode(node, 'ImportDeclaration');
-				parser.importOrExportOuterKind = 'value';
-				return import_node;
+				this.importOrExportOuterKind = 'value';
+				return node;
 			}
 
 			/**

package/src/transform/imports.js

@@ -0,0 +1,96 @@
+/** @import * as AST from 'estree' */
+
+/**
+ * Add TSRX import-phase support to an esrap TS/TSX visitor set. esrap 2.3
+ * understands the rest of ImportDeclaration but does not print its Stage 3
+ * `phase` field yet, so delegating would silently turn a deferred import into
+ * an eager one.
+ *
+ * @template {Record<string, any>} T
+ * @param {T} visitors
+ * @returns {T}
+ */
+export function with_deferred_imports(visitors) {
+	const print_import_declaration = visitors.ImportDeclaration;
+	const print_import_expression = visitors.ImportExpression;
+	if (
+		typeof print_import_declaration !== 'function' ||
+		typeof print_import_expression !== 'function'
+	) {
+		throw new TypeError('Deferred imports require a complete esrap TS or TSX visitor set.');
+	}
+
+	return /** @type {T} */ ({
+		...visitors,
+		/**
+		 * @param {AST.ImportDeclaration} node
+		 * @param {import('esrap').Context} context
+		 */
+		ImportDeclaration(node, context) {
+			const import_node = /** @type {AST.ImportDeclaration & { phase?: 'defer' | null }} */ (node);
+			if (import_node.phase !== 'defer') {
+				print_import_declaration(node, context);
+				return;
+			}
+
+			const [specifier] = node.specifiers;
+			if (node.specifiers.length !== 1 || specifier.type !== 'ImportNamespaceSpecifier') {
+				throw new Error('`import defer` only supports a namespace import.');
+			}
+
+			if (node.loc) context.location(node.loc.start.line, node.loc.start.column);
+			context.write('import defer ');
+			if (specifier.loc) {
+				context.location(specifier.loc.start.line, specifier.loc.start.column);
+			}
+			context.write('* as ');
+			context.visit(specifier.local);
+			context.write(' from ');
+			context.visit(node.source);
+
+			const attributes =
+				/** @type {Array<{ key: AST.Identifier | AST.Literal, value: AST.Literal }>} */ (
+					/** @type {any} */ (node).attributes ?? /** @type {any} */ (node).assertions ?? []
+				);
+			if (attributes.length > 0) {
+				context.write(' with { ');
+				for (let index = 0; index < attributes.length; index++) {
+					context.visit(attributes[index].key);
+					context.write(': ');
+					context.visit(attributes[index].value);
+					if (index + 1 !== attributes.length) context.write(', ');
+				}
+				context.write(' }');
+			}
+
+			context.write(';');
+			if (node.loc) context.location(node.loc.end.line, node.loc.end.column);
+		},
+		/**
+		 * @param {AST.ImportExpression} node
+		 * @param {import('esrap').Context} context
+		 */
+		ImportExpression(node, context) {
+			const import_node = /** @type {AST.ImportExpression & { phase?: 'defer' | null }} */ (node);
+			if (import_node.phase !== 'defer') {
+				print_import_expression(node, context);
+				return;
+			}
+
+			if (node.loc) context.location(node.loc.start.line, node.loc.start.column);
+			context.write('import.defer(');
+			context.visit(node.source);
+
+			const options =
+				node.options ??
+				/** @type {AST.Expression | undefined} */ (/** @type {any} */ (node).arguments?.[0]);
+			if (options) {
+				context.write(', ');
+				context.visit(options);
+			}
+
+			context.write(')');
+			if (node.loc) context.location(node.loc.end.line, node.loc.end.column);
+		},
+	});
+}