@lwc/ssr-compiler 8.12.0 → 8.12.1

package/dist/compile-js/index.d.ts

@@ -1,4 +1,5 @@
+import type { ComponentTransformOptions } from '../shared';
 import type { CompilationMode } from '@lwc/shared';
-export default function compileJS(src: string, filename: string, tagName: string, compilationMode: CompilationMode): {
+export default function compileJS(src: string, filename: string, tagName: string, options: ComponentTransformOptions, compilationMode: CompilationMode): {
     code: string;
 };

package/dist/compile-js/types.d.ts

@@ -1,3 +1,5 @@
+import type { ImportManager } from '../imports';
+import type { ComponentTransformOptions } from '../shared';
 import type { traverse } from 'estree-toolkit';
 import type { Identifier, MemberExpression, MethodDefinition, Node, ObjectExpression, PropertyDefinition } from 'estree';
 export type Visitors = Parameters<typeof traverse<Node, ComponentMetaState>>[1];
@@ -22,4 +24,6 @@ export interface ComponentMetaState {
     publicFields: Array<string>;
     privateFields: Array<string>;
     wireAdapters: WireAdapter[];
+    experimentalDynamicComponent: ComponentTransformOptions['experimentalDynamicComponent'];
+    importManager: ImportManager;
 }

package/dist/compile-template/shared.d.ts

@@ -1,6 +1,7 @@
 import type { TransformerContext } from './types';
 import type { Attribute as IrAttribute, Node as IrNode, Property as IrProperty } from '@lwc/template-compiler';
 import type { Expression as EsExpression, ObjectExpression as EsObjectExpression, Statement as EsStatement } from 'estree';
+import type { ComplexExpression as IrComplexExpression, Expression as IrExpression, Literal as IrLiteral } from '@lwc/template-compiler';
 export declare function optimizeAdjacentYieldStmts(statements: EsStatement[]): EsStatement[];
 export declare function bAttributeValue(node: IrNode, attrName: string): EsExpression;
 /**
@@ -14,3 +15,8 @@ export declare function bAttributeValue(node: IrNode, attrName: string): EsExpre
 export declare function getScopedExpression(expression: EsExpression, cxt: TransformerContext): EsExpression;
 export declare function normalizeClassAttributeValue(value: string): string;
 export declare function getChildAttrsOrProps(attrs: (IrAttribute | IrProperty)[], cxt: TransformerContext): EsObjectExpression;
+/**
+ * Determine if the provided node is of type Literal
+ * @param node
+ */
+export declare function isLiteral(node: IrLiteral | IrExpression | IrComplexExpression): node is IrLiteral;

package/dist/compile-template/types.d.ts

@@ -8,6 +8,7 @@ export interface TransformerContext {
     templateOptions: TemplateOpts;
     prevSibling?: IrNode;
     nextSibling?: IrNode;
+    isSlotted?: boolean;
     import: (imports: string | string[] | Record<string, string | undefined>, source?: string) => void;
 }
 export interface TemplateOpts {

package/dist/imports.d.ts

@@ -0,0 +1,8 @@
+import type { ImportDeclaration } from 'estree';
+export declare class ImportManager {
+    #private;
+    /** Add an import to a collection of imports, probably for adding to the AST later. */
+    add(imports: string | string[] | Record<string, string | undefined>, source?: string): void;
+    /** Get the collection of imports for adding to the AST, probably soon! */
+    getImportDeclarations(): ImportDeclaration[];
+}

package/dist/index.cjs.js

@@ -165,6 +165,116 @@ function transmogrify(compiledComponentAst, mode = 'sync') {
     return immer.produce(compiledComponentAst, (astDraft) => estreeToolkit.traverse(astDraft, visitors$2, state));
 }
 
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+function __classPrivateFieldGet(receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+/*
+ * Copyright (c) 2024, salesforce.com, inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: MIT
+ * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
+ */
+/**
+ * Creates an import statement, e.g. `import { foo, bar as $bar$ } from "pkg"`
+ * @param imports names to be imported; values can be a string (plain import) or object (aliased)
+ * @param source source location to import from; defaults to @lwc/ssr-runtime
+ */
+const bImportDeclaration = (imports, source = '@lwc/ssr-runtime') => {
+    let parsed;
+    if (typeof imports === 'string') {
+        parsed = [[imports, undefined]];
+    }
+    else if (Array.isArray(imports)) {
+        parsed = imports.map((imp) => [imp, undefined]);
+    }
+    else {
+        parsed = Object.entries(imports);
+    }
+    const specifiers = parsed.map(([imported, local]) => {
+        if (imported === 'default') {
+            return estreeToolkit.builders.importDefaultSpecifier(estreeToolkit.builders.identifier(local));
+        }
+        else if (imported === '*') {
+            return estreeToolkit.builders.importNamespaceSpecifier(estreeToolkit.builders.identifier(local));
+        }
+        else if (local) {
+            return estreeToolkit.builders.importSpecifier(estreeToolkit.builders.identifier(imported), estreeToolkit.builders.identifier(local));
+        }
+        else {
+            return estreeToolkit.builders.importSpecifier(estreeToolkit.builders.identifier(imported));
+        }
+    });
+    return estreeToolkit.builders.importDeclaration(specifiers, estreeToolkit.builders.literal(source));
+};
+
+/*
+ * Copyright (c) 2024, Salesforce, Inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: MIT
+ * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
+ */
+var _ImportManager_map;
+class ImportManager {
+    constructor() {
+        _ImportManager_map.set(this, new Map());
+    }
+    /** Add an import to a collection of imports, probably for adding to the AST later. */
+    add(imports, source = '@lwc/ssr-runtime') {
+        let specifiers;
+        if (typeof imports === 'string') {
+            specifiers = [[imports, undefined]];
+        }
+        else if (Array.isArray(imports)) {
+            specifiers = imports.map((name) => [name, undefined]);
+        }
+        else {
+            specifiers = Object.entries(imports);
+        }
+        let specifierMap = __classPrivateFieldGet(this, _ImportManager_map, "f").get(source);
+        if (specifierMap) {
+            for (const [imported, local] of specifiers) {
+                specifierMap.set(imported, local);
+            }
+        }
+        else {
+            specifierMap = new Map(specifiers);
+            __classPrivateFieldGet(this, _ImportManager_map, "f").set(source, specifierMap);
+        }
+    }
+    /** Get the collection of imports for adding to the AST, probably soon! */
+    getImportDeclarations() {
+        return Array.from(__classPrivateFieldGet(this, _ImportManager_map, "f"), ([source, specifierMap]) => {
+            return bImportDeclaration(Object.fromEntries(specifierMap), source);
+        });
+    }
+}
+_ImportManager_map = new WeakMap();
+
 /*
  * Copyright (c) 2024, salesforce.com, inc.
  * All rights reserved.
@@ -440,45 +550,6 @@ if (process.env.NODE_ENV !== 'production') {
     }
 }
 
-/*
- * Copyright (c) 2024, salesforce.com, inc.
- * All rights reserved.
- * SPDX-License-Identifier: MIT
- * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
- */
-/**
- * Creates an import statement, e.g. `import { foo, bar as $bar$ } from "pkg"`
- * @param imports names to be imported; values can be a string (plain import) or object (aliased)
- * @param source source location to import from; defaults to @lwc/ssr-runtime
- */
-const bImportDeclaration = (imports, source = '@lwc/ssr-runtime') => {
-    let parsed;
-    if (typeof imports === 'string') {
-        parsed = [[imports, undefined]];
-    }
-    else if (Array.isArray(imports)) {
-        parsed = imports.map((imp) => [imp, undefined]);
-    }
-    else {
-        parsed = Object.entries(imports);
-    }
-    const specifiers = parsed.map(([imported, local]) => {
-        if (imported === 'default') {
-            return estreeToolkit.builders.importDefaultSpecifier(estreeToolkit.builders.identifier(local));
-        }
-        else if (imported === '*') {
-            return estreeToolkit.builders.importNamespaceSpecifier(estreeToolkit.builders.identifier(local));
-        }
-        else if (local) {
-            return estreeToolkit.builders.importSpecifier(estreeToolkit.builders.identifier(imported), estreeToolkit.builders.identifier(local));
-        }
-        else {
-            return estreeToolkit.builders.importSpecifier(estreeToolkit.builders.identifier(imported));
-        }
-    });
-    return estreeToolkit.builders.importDeclaration(specifiers, estreeToolkit.builders.literal(source));
-};
-
 /*
  * Copyright (c) 2024, salesforce.com, inc.
  * All rights reserved.
@@ -496,19 +567,23 @@ function bMemberExpressionChain(props) {
 function getWireParams(node) {
     const { decorators } = node;
     if (decorators.length > 1) {
+        // TODO [#5032]: Harmonize errors thrown in `@lwc/ssr-compiler`
         throw new Error('todo - multiple decorators at once');
     }
     // validate the parameters
     const wireDecorator = decorators[0].expression;
     if (!estreeToolkit.is.callExpression(wireDecorator)) {
+        // TODO [#5032]: Harmonize errors thrown in `@lwc/ssr-compiler`
         throw new Error('todo - invalid usage');
     }
     const args = wireDecorator.arguments;
     if (args.length === 0 || args.length > 2) {
+        // TODO [#5032]: Harmonize errors thrown in `@lwc/ssr-compiler`
         throw new Error('todo - wrong number of args');
     }
     const [id, config] = args;
     if (estreeToolkit.is.spreadElement(id) || estreeToolkit.is.spreadElement(config)) {
+        // TODO [#5032]: Harmonize errors thrown in `@lwc/ssr-compiler`
         throw new Error('todo - spread in params');
     }
     return [id, config];
@@ -518,14 +593,17 @@ function validateWireId(id, path) {
     let wireAdapterVar;
     if (estreeToolkit.is.memberExpression(id)) {
         if (id.computed) {
+            // TODO [#5032]: Harmonize errors thrown in `@lwc/ssr-compiler`
             throw new Error('todo - FUNCTION_IDENTIFIER_CANNOT_HAVE_COMPUTED_PROPS');
         }
         if (!estreeToolkit.is.identifier(id.object)) {
+            // TODO [#5032]: Harmonize errors thrown in `@lwc/ssr-compiler`
             throw new Error('todo - FUNCTION_IDENTIFIER_CANNOT_HAVE_NESTED_MEMBER_EXRESSIONS');
         }
         wireAdapterVar = id.object.name;
     }
     else if (!estreeToolkit.is.identifier(id)) {
+        // TODO [#5032]: Harmonize errors thrown in `@lwc/ssr-compiler`
         throw new Error('todo - invalid adapter name');
     }
     else {
@@ -533,11 +611,13 @@ function validateWireId(id, path) {
     }
     // This is not the exact same validation done in @lwc/babel-plugin-component but it accomplishes the same thing
     if (path.scope?.getBinding(wireAdapterVar)?.kind !== 'module') {
+        // TODO [#5032]: Harmonize errors thrown in `@lwc/ssr-compiler`
         throw new Error('todo - WIRE_ADAPTER_SHOULD_BE_IMPORTED');
     }
 }
 function validateWireConfig(config, path) {
     if (!estreeToolkit.is.objectExpression(config)) {
+        // TODO [#5032]: Harmonize errors thrown in `@lwc/ssr-compiler`
         throw new Error('todo - CONFIG_OBJECT_SHOULD_BE_SECOND_PARAMETER');
     }
     for (const property of config.properties) {
@@ -560,6 +640,7 @@ function validateWireConfig(config, path) {
             if (estreeToolkit.is.templateLiteral(key)) {
                 // A template literal is not guaranteed to always result in the same value
                 // (e.g. `${Math.random()}`), so we disallow them entirely.
+                // TODO [#5032]: Harmonize errors thrown in `@lwc/ssr-compiler`
                 throw new Error('todo - COMPUTED_PROPERTY_CANNOT_BE_TEMPLATE_LITERAL');
             }
             else if (!('regex' in key)) {
@@ -567,6 +648,7 @@ function validateWireConfig(config, path) {
                 continue;
             }
         }
+        // TODO [#5032]: Harmonize errors thrown in `@lwc/ssr-compiler`
         throw new Error('todo - COMPUTED_PROPERTY_MUST_BE_CONSTANT_OR_LITERAL');
     }
 }
@@ -788,8 +870,28 @@ const visitors = {
         catalogAndReplaceStyleImports(path, state);
         removeDecoratorImport(path);
     },
-    ImportExpression(path) {
-        return path.replaceWith(estreeToolkit.builders.callExpression(estreeToolkit.builders.memberExpression(estreeToolkit.builders.identifier('Promise'), estreeToolkit.builders.identifier('resolve')), []));
+    ImportExpression(path, state) {
+        const { experimentalDynamicComponent, importManager } = state;
+        if (!experimentalDynamicComponent) {
+            // if no `experimentalDynamicComponent` config, then leave dynamic `import()`s as-is
+            return;
+        }
+        if (experimentalDynamicComponent.strictSpecifier) {
+            if (!estreeToolkit.is.literal(path.node?.source) || typeof path.node.source.value !== 'string') {
+                // TODO [#5032]: Harmonize errors thrown in `@lwc/ssr-compiler`
+                throw new Error('todo - LWCClassErrors.INVALID_DYNAMIC_IMPORT_SOURCE_STRICT');
+            }
+        }
+        const loader = experimentalDynamicComponent.loader;
+        if (!loader) {
+            // if no `loader` defined, then leave dynamic `import()`s as-is
+            return;
+        }
+        const source = path.node.source;
+        // 1. insert `import { load as __load } from '${loader}'` at top of program
+        importManager.add({ load: '__load' }, loader);
+        // 2. replace this import with `__load(${source})`
+        path.replaceWith(estreeToolkit.builders.callExpression(estreeToolkit.builders.identifier('__load'), [structuredClone(source)]));
     },
     ClassDeclaration(path, state) {
         const { node } = path;
@@ -902,8 +1004,17 @@ const visitors = {
             path.parentPath.node.arguments = [estreeToolkit.builders.identifier('propsAvailableAtConstruction')];
         }
     },
+    Program: {
+        leave(path, state) {
+            // After parsing the whole tree, insert needed imports
+            const importDeclarations = state.importManager.getImportDeclarations();
+            if (importDeclarations.length > 0) {
+                path.node?.body.unshift(...importDeclarations);
+            }
+        },
+    },
 };
-function compileJS(src, filename, tagName, compilationMode) {
+function compileJS(src, filename, tagName, options, compilationMode) {
     let ast = meriyah.parseModule(src, {
         module: true,
         next: true,
@@ -924,6 +1035,8 @@ function compileJS(src, filename, tagName, compilationMode) {
         publicFields: [],
         privateFields: [],
         wireAdapters: [],
+        experimentalDynamicComponent: options.experimentalDynamicComponent,
+        importManager: new ImportManager(),
     };
     estreeToolkit.traverse(ast, visitors, state);
     if (!state.isLWC) {
@@ -1138,6 +1251,13 @@ function getChildAttrsOrProps(attrs, cxt) {
         .filter(Boolean);
     return estreeToolkit.builders.objectExpression(objectAttrsOrProps);
 }
+/**
+ * Determine if the provided node is of type Literal
+ * @param node
+ */
+function isLiteral(node) {
+    return node.type === 'Literal';
+}
 
 /*
  * Copyright (c) 2024, Salesforce, Inc.
@@ -1327,6 +1447,8 @@ function getLightSlottedContent(rootNodes, cxt) {
     return results;
 }
 function getSlottedContent(node, cxt) {
+    const { isSlotted } = cxt;
+    cxt.isSlotted = true;
     // Anything inside the slotted content is a normal slotted content except for `<template lwc:slot-data>` which is a scoped slot.
     const slottableChildren = node.children.filter((child) => child.type !== 'ScopedSlotFragment');
     const scopedSlottableChildren = node.children.filter((child) => child.type === 'ScopedSlotFragment');
@@ -1336,13 +1458,17 @@ function getSlottedContent(node, cxt) {
         const boundVariableName = child.slotData.value.name;
         const boundVariable = estreeToolkit.builders.identifier(boundVariableName);
         cxt.pushLocalVars([boundVariableName]);
+        const slotName = isLiteral(child.slotName)
+            ? estreeToolkit.builders.literal(child.slotName.value)
+            : expressionIrToEs(child.slotName, cxt);
         // TODO [#4768]: what if the bound variable is `generateMarkup` or some framework-specific identifier?
-        const addLightContentExpr = estreeToolkit.builders.expressionStatement(bAddLightContent(child.slotName, boundVariable, irChildrenToEs(child.children, cxt)));
+        const addLightContentExpr = estreeToolkit.builders.expressionStatement(bAddLightContent(slotName, boundVariable, irChildrenToEs(child.children, cxt)));
         cxt.popLocalVars();
         return addLightContentExpr;
     });
     const hasShadowSlottedContent = estreeToolkit.builders.literal(shadowSlotContent.length > 0);
     const hasLightSlottedContent = estreeToolkit.builders.literal(lightSlotContent.length > 0 || scopedSlotContent.length > 0);
+    cxt.isSlotted = isSlotted;
     return bGenerateSlottedContent(hasShadowSlottedContent, shadowSlotContent, hasLightSlottedContent, lightSlotContent, scopedSlotContent);
 }
 
@@ -1615,9 +1741,6 @@ const Element = function Element(node, cxt) {
         }
         return result;
     });
-    if (shared.isVoidElement(node.name, shared.HTML_NAMESPACE)) {
-        return [bYield(estreeToolkit.builders.literal(`<${node.name}`)), ...yieldAttrsAndProps, bYield(estreeToolkit.builders.literal(`>`))];
-    }
     let childContent;
     // An element can have children or lwc:inner-html, but not both
     // If it has both, the template compiler will throw an error before reaching here
@@ -1633,14 +1756,15 @@ const Element = function Element(node, cxt) {
     else {
         childContent = [];
     }
+    const isForeignSelfClosingElement = node.namespace !== shared.HTML_NAMESPACE && childContent.length === 0;
+    const isSelfClosingElement = shared.isVoidElement(node.name, shared.HTML_NAMESPACE) || isForeignSelfClosingElement;
     return [
         bYield(estreeToolkit.builders.literal(`<${node.name}`)),
         // If we haven't already prefixed the scope token to an existing class, add an explicit class here
         ...(hasClassAttribute ? [] : [bConditionallyYieldScopeTokenClass()]),
         ...yieldAttrsAndProps,
-        bYield(estreeToolkit.builders.literal(`>`)),
-        ...childContent,
-        bYield(estreeToolkit.builders.literal(`</${node.name}>`)),
+        bYield(estreeToolkit.builders.literal(isForeignSelfClosingElement ? `/>` : `>`)),
+        ...(isSelfClosingElement ? [] : [...childContent, bYield(estreeToolkit.builders.literal(`</${node.name}>`))]),
     ].filter(Boolean);
 };
 
@@ -1736,7 +1860,7 @@ function bIfStatement(ifElseIfNode, cxt) {
             elseBlock = bIfStatement(elseNode, cxt);
         }
     }
-    return estreeToolkit.builders.ifStatement(expressionIrToEs(condition, cxt), bBlockStatement(children, cxt, true), elseBlock);
+    return estreeToolkit.builders.ifStatement(expressionIrToEs(condition, cxt), bBlockStatement(children, cxt, !cxt.isSlotted), elseBlock);
 }
 const IfBlock = function IfBlock(node, cxt) {
     return [bIfStatement(node, cxt)];
@@ -1751,12 +1875,15 @@ const IfBlock = function IfBlock(node, cxt) {
 const bConditionalSlot = (esTemplateWithYield `
     if (isLightDom) {
         const isScopedSlot = ${ /* isScopedSlot */estreeToolkit.is.literal};
+        const isSlotted = ${ /* isSlotted */estreeToolkit.is.literal};
         // start bookend HTML comment for light DOM slot vfragment
-        yield '<!---->';
-
-        // scoped slot factory has its own vfragment hence its own bookend
-        if (isScopedSlot) {
+        if (!isSlotted) {
             yield '<!---->';
+
+            // scoped slot factory has its own vfragment hence its own bookend
+            if (isScopedSlot) {
+                yield '<!---->';
+            }
         }
 
         const generators = lightSlottedContent?.[${ /* slotName */estreeToolkit.is.expression} ?? ""];
@@ -1772,14 +1899,16 @@ const bConditionalSlot = (esTemplateWithYield `
             // TODO: default/fallback slot content
             ${ /* slot fallback content */estreeToolkit.is.statement}
         }
-        
-        // scoped slot factory has its own vfragment hence its own bookend
-        if (isScopedSlot) {
-            yield '<!---->';
-        }
 
         // end bookend HTML comment for light DOM slot vfragment
-        yield '<!---->';
+        if (!isSlotted) {
+            yield '<!---->';
+
+            // scoped slot factory has its own vfragment hence its own bookend
+            if (isScopedSlot) {
+                yield '<!---->';
+            }
+        }
     } else {
         ${ /* slot element AST */estreeToolkit.is.statement}
     }
@@ -1794,7 +1923,8 @@ const Slot = function Slot(node, ctx) {
     const slotAst = Element(node, ctx);
     const slotChildren = irChildrenToEs(node.children, ctx);
     const isScopedSlot = estreeToolkit.builders.literal(Boolean(slotBound));
-    return [bConditionalSlot(isScopedSlot, slotName, slotBound, slotChildren, slotAst)];
+    const isSlotted = estreeToolkit.builders.literal(Boolean(ctx.isSlotted));
+    return [bConditionalSlot(isScopedSlot, isSlotted, slotName, slotBound, slotChildren, slotAst)];
 };
 
 /*
@@ -1807,9 +1937,6 @@ const bBufferTextContent = (esTemplateWithYield `
     didBufferTextContent = true;
     textContentBuffer += massageTextContent(${ /* string value */estreeToolkit.is.expression});
 `);
-function isLiteral(node) {
-    return node.type === 'Literal';
-}
 const Text = function Text(node, cxt) {
     cxt.import(['htmlEscape', 'massageTextContent']);
     const isLastInSeries = isLastConcatenatedNode(cxt);
@@ -1826,39 +1953,7 @@ const Text = function Text(node, cxt) {
  * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
  */
 function createNewContext(templateOptions) {
-    /** Map of source to imported name to local name. */
-    const importMap = new Map();
-    /**
-     * Hoist an import declaration to the top of the file. If source is not specified, defaults to
-     * `@lwc/ssr-runtime`.
-     */
-    const _import = (imports, source = '@lwc/ssr-runtime') => {
-        let specifiers;
-        if (typeof imports === 'string') {
-            specifiers = [[imports, undefined]];
-        }
-        else if (Array.isArray(imports)) {
-            specifiers = imports.map((name) => [name, undefined]);
-        }
-        else {
-            specifiers = Object.entries(imports);
-        }
-        let specifierMap = importMap.get(source);
-        if (specifierMap) {
-            for (const [imported, local] of specifiers) {
-                specifierMap.set(imported, local);
-            }
-        }
-        else {
-            specifierMap = new Map(specifiers);
-            importMap.set(source, specifierMap);
-        }
-    };
-    const getImports = () => {
-        return Array.from(importMap, ([source, specifierMap]) => {
-            return bImportDeclaration(Object.fromEntries(specifierMap), source);
-        });
-    };
+    const importManager = new ImportManager();
     const localVarStack = [];
     const pushLocalVars = (vars) => {
         localVarStack.push(new Set(vars));
@@ -1878,13 +1973,13 @@ function createNewContext(templateOptions) {
         return false;
     };
     return {
-        getImports,
+        getImports: () => importManager.getImportDeclarations(),
         cxt: {
             pushLocalVars,
             popLocalVars,
             isLocalVar,
             templateOptions,
-            import: _import,
+            import: importManager.add.bind(importManager),
         },
     };
 }
@@ -2068,7 +2163,7 @@ function compileTemplate(src, filename, options, compilationMode) {
  */
 function compileComponentForSSR(src, filename, options, mode = shared.DEFAULT_SSR_MODE) {
     const tagName = shared.generateCustomElementTagName(options.namespace, options.name);
-    const { code } = compileJS(src, filename, tagName, mode);
+    const { code } = compileJS(src, filename, tagName, options, mode);
     return { code, map: undefined };
 }
 function compileTemplateForSSR(src, filename, options, mode = shared.DEFAULT_SSR_MODE) {
@@ -2078,5 +2173,5 @@ function compileTemplateForSSR(src, filename, options, mode = shared.DEFAULT_SSR
 
 exports.compileComponentForSSR = compileComponentForSSR;
 exports.compileTemplateForSSR = compileTemplateForSSR;
-/** version: 8.12.0 */
+/** version: 8.12.1 */
 //# sourceMappingURL=index.cjs.js.map