@lwc/ssr-compiler 8.12.0 → 8.12.2

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

@@ -0,0 +1,4 @@
+import { type LWCErrorInfo } from '@lwc/errors';
+type ExtractArguments<T extends string, Numbers extends number = never, Args extends string[] = []> = T extends `${string}{${infer N extends number}}${infer R}` ? N extends Numbers ? ExtractArguments<R, Numbers, Args> : ExtractArguments<R, N | Numbers, [string, ...Args]> : Args;
+export declare function generateError<const T extends LWCErrorInfo>(error: T, ...args: ExtractArguments<T['message']>): Error;
+export {};

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/lwc-import.d.ts

@@ -1,4 +1,4 @@
-import type { ImportDeclaration } from 'estree';
+import type { ImportDeclaration, ExportNamedDeclaration, ExportAllDeclaration } from 'estree';
 import type { NodePath } from 'estree-toolkit';
 import type { ComponentMetaState } from './types';
 /**
@@ -8,3 +8,11 @@ import type { ComponentMetaState } from './types';
  *  2. it makes note of the local var name associated with the `LightningElement` import
  */
 export declare function replaceLwcImport(path: NodePath<ImportDeclaration>, state: ComponentMetaState): void;
+/**
+ * This handles lwc barrel exports by replacing "lwc" with "@lwc/ssr-runtime"
+ */
+export declare function replaceNamedLwcExport(path: NodePath<ExportNamedDeclaration>): void;
+/**
+ * This handles all lwc barrel exports by replacing "lwc" with "@lwc/ssr-runtime"
+ */
+export declare function replaceAllLwcExport(path: NodePath<ExportAllDeclaration>): void;

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];
@@ -10,7 +12,6 @@ export interface ComponentMetaState {
     isLWC: boolean;
     hasConstructor: boolean;
     hasConnectedCallback: boolean;
-    hasRenderMethod: boolean;
     hadRenderedCallback: boolean;
     hadDisconnectedCallback: boolean;
     hadErrorCallback: boolean;
@@ -22,4 +23,6 @@ export interface ComponentMetaState {
     publicFields: Array<string>;
     privateFields: Array<string>;
     wireAdapters: WireAdapter[];
+    experimentalDynamicComponent: ComponentTransformOptions['experimentalDynamicComponent'];
+    importManager: ImportManager;
 }

package/dist/compile-template/ir-to-es.d.ts

@@ -1,7 +1,7 @@
 import type { ChildNode as IrChildNode, Node as IrNode } from '@lwc/template-compiler';
 import type { Statement as EsStatement } from 'estree';
 import type { TemplateOpts, TransformerContext } from './types';
-export declare function irChildrenToEs(children: IrChildNode[], cxt: TransformerContext): EsStatement[];
+export declare function irChildrenToEs(children: IrChildNode[], cxt: TransformerContext, cb?: (child: IrChildNode) => (() => void) | void): EsStatement[];
 export declare function irToEs<T extends IrNode>(node: T, cxt: TransformerContext): EsStatement[];
 export declare function templateIrToEsTree(node: IrNode, contextOpts: TemplateOpts): {
     addImport: (imports: string | string[] | Record<string, string | undefined>, source?: string | undefined) => void;

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/transformers/legacyIf.d.ts

@@ -0,0 +1,3 @@
+import type { If as IrIf } from '@lwc/template-compiler';
+import type { Transformer } from '../types';
+export declare const LegacyIf: Transformer<IrIf>;

package/dist/compile-template/transformers/lwcIf.d.ts

@@ -0,0 +1,3 @@
+import type { ElseifBlock as IrElseifBlock, IfBlock as IrIfBlock } from '@lwc/template-compiler';
+import type { Transformer } from '../types';
+export declare const IfBlock: Transformer<IrIfBlock | IrElseifBlock>;

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/estree/validators.d.ts

@@ -1,23 +1,5 @@
-import type { CallExpression, Identifier, MemberExpression } from 'estree';
 import type { Checker } from 'estree-toolkit/dist/generated/is-type';
 import type { Node } from 'estree-toolkit/dist/helpers';
-/** Node representing an identifier named "render". */
-type RenderIdentifier = Identifier & {
-    name: 'render';
-};
-/** Node representing a member expression `<something>.render`. */
-type RenderMemberExpression = MemberExpression & {
-    property: RenderIdentifier;
-};
-/** Node representing a method call `<something>.render()`. */
-type RenderCall = CallExpression & {
-    callee: RenderMemberExpression;
-};
-/** Returns `true` if the node is an identifier or `<something>.render()`. */
-export declare const isIdentOrRenderCall: {
-    (node: Node | null | undefined): node is Identifier | RenderCall;
-    __debugName: string;
-};
 /** A validator that returns `true` if the node is `null`. */
 type NullableChecker<T extends Node> = (node: Node | null | undefined) => node is T | null;
 /** Extends a validator to return `true` if the node is `null`. */

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[];
+}