@lwc/ssr-compiler 8.2.0 → 8.3.0

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

@@ -1,4 +1,4 @@
-import type { TransformOptions } from '../shared';
-export default function compileTemplate(src: string, filename: string, options: TransformOptions): {
+import { type Config as TemplateCompilerConfig } from '@lwc/template-compiler';
+export default function compileTemplate(src: string, filename: string, options: TemplateCompilerConfig): {
     code: string;
 };

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

@@ -1,5 +1,5 @@
 import type { ImportDeclaration as EsImportDeclaration, Statement as EsStatement } from 'estree';
-export declare const bImportHtmlEscape: (...replacementNodes: (import("estree").Node | import("estree").Node[] | null)[]) => EsImportDeclaration;
+export declare const bImportHtmlEscape: () => EsImportDeclaration;
 export declare const importHtmlEscapeKey = "import:htmlEscape";
 export declare const isValidIdentifier: (str: string) => boolean;
 export declare function optimizeAdjacentYieldStmts(statements: EsStatement[]): EsStatement[];

package/dist/compile-template/{comment.d.ts → transformers/comment.d.ts}

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

package/dist/compile-template/{component.d.ts → transformers/component.d.ts}

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

package/dist/compile-template/{element.d.ts → transformers/element.d.ts}

@@ -1,3 +1,3 @@
-import { type Element as IrElement, ExternalComponent as IrExternalComponent } from '@lwc/template-compiler';
-import type { Transformer } from './types';
-export declare const Element: Transformer<IrElement | IrExternalComponent>;
+import { type Element as IrElement, ExternalComponent as IrExternalComponent, Slot as IrSlot } from '@lwc/template-compiler';
+import type { Transformer } from '../types';
+export declare const Element: Transformer<IrElement | IrExternalComponent | IrSlot>;

package/dist/compile-template/{for-each.d.ts → transformers/for-each.d.ts}

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

package/dist/compile-template/{for-of.d.ts → transformers/for-of.d.ts}

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

package/dist/compile-template/{if.d.ts → transformers/if.d.ts}

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

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

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

package/dist/compile-template/{text.d.ts → transformers/text.d.ts}

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

package/dist/estemplate.d.ts

@@ -1,8 +1,43 @@
 import type { Node as EsNode } from 'estree';
-export declare const placeholder = false;
-type ReplacementNode = EsNode | EsNode[] | null;
-type ReturnsBool = (node: EsNode | null) => boolean;
-export type Validator = ReturnsBool | typeof placeholder;
-export declare function esTemplate<RetType = EsNode, ArgTypes extends ReplacementNode[] = ReplacementNode[]>(javascriptSegments: TemplateStringsArray, ...validatorFns: Validator[]): (...replacementNodes: ArgTypes) => RetType;
-export declare function esTemplateWithYield<RetType = EsNode, ArgTypes extends ReplacementNode[] = ReplacementNode[]>(javascriptSegments: TemplateStringsArray, ...validatorFns: Validator[]): (...replacementNodes: ArgTypes) => RetType;
+import type { Checker } from 'estree-toolkit/dist/generated/is-type';
+/** Placeholder value to use to opt out of validation. */
+declare const NO_VALIDATION = false;
+/** A function that accepts a node and checks that it is a particular type of node. */
+type Validator<T extends EsNode | null = EsNode | null> = (node: EsNode | null | undefined) => node is T;
+/**
+ * A pointer to a previous value in the template literal, indicating that the value should be re-used.
+ * @see {@linkcode esTemplate}
+ */
+type ValidatorReference = number;
+/** A validator, validation opt-out, or reference to previously-used validator. */
+type ValidatorPlaceholder<T extends EsNode | null> = Validator<T> | ValidatorReference | typeof NO_VALIDATION;
+/** Extracts the type being validated from the validator function. */
+type ValidatedType<T> = T extends Validator<infer V> ? T extends Checker<infer C> ? // estree validator
+C | C[] : // custom validator
+V | Array<NonNullable<V>> : T extends typeof NO_VALIDATION ? // no validation = broadest type possible
+EsNode | EsNode[] | null : never;
+/**
+ * Converts the validators and refs used in the template to the list of parameters required by the
+ * created template function. Removes back references to previous slots from the list.
+ */
+type ToReplacementParameters<Arr extends unknown[]> = Arr extends [infer Head, ...infer Rest] ? Head extends number ? ToReplacementParameters<Rest> : [
+    ValidatedType<Head>,
+    ...ToReplacementParameters<Rest>
+] : [];
+/**
+ * Template literal tag that generates a builder function. Like estree's `builders`, but for more
+ * complex structures. The template values should be estree `is` validators or a back reference to
+ * a previous slot (to re-use the referenced value).
+ *
+ * To have the generated function return a particular node type, the generic comes _after_ the
+ * template literal. Kinda weird, but it's necessary to infer the types of the template values.
+ * (If it were at the start, we'd need to explicitly provide _all_ type params. Tedious!)
+ * @example
+ * const bSum = esTemplate`(${is.identifier}, ${is.identifier}) => ${0} + ${1}`<EsArrowFunctionExpression>
+ * const sumFuncNode = bSum(b.identifier('a'), b.identifier('b'))
+ * // `sumFuncNode` is an AST node representing `(a, b) => a + b`
+ */
+export declare function esTemplate<Validators extends ValidatorPlaceholder<EsNode | null>[]>(javascriptSegments: TemplateStringsArray, ...Validators: Validators): <RetType>(...replacementNodes: ToReplacementParameters<Validators>) => RetType;
+/** Similar to {@linkcode esTemplate}, but supports `yield` expressions. */
+export declare function esTemplateWithYield<Validators extends ValidatorPlaceholder<EsNode | null>[]>(javascriptSegments: TemplateStringsArray, ...validators: Validators): <RetType>(...replacementNodes: ToReplacementParameters<Validators>) => RetType;
 export {};

package/dist/estree/builders.d.ts

@@ -1,2 +1,6 @@
 import type { ImportDeclaration } from 'estree';
-export declare const bImportDeclaration: (...replacementNodes: (import("estree").Node | import("estree").Node[] | null)[]) => ImportDeclaration;
+export declare const bImportDeclaration: (replacementNodes_0: import("estree").Identifier | import("estree").Identifier[], replacementNodes_1: (import("estree").SimpleLiteral & {
+    value: string;
+}) | NonNullable<import("estree").SimpleLiteral & {
+    value: string;
+}>[]) => ImportDeclaration;

package/dist/estree/validators.d.ts

@@ -1,5 +1,27 @@
-import type { Node } from 'estree';
-import type { Validator } from '../estemplate';
-export declare const isStringLiteral: (node: Node | null) => boolean;
-export declare const isIdentOrRenderCall: (node: Node | null) => boolean;
-export declare function isNullableOf(validator: Validator): (node: Node | null) => boolean;
+import type { CallExpression, Identifier, MemberExpression, SimpleLiteral } from 'estree';
+import type { Checker } from 'estree-toolkit/dist/generated/is-type';
+import type { Node } from 'estree-toolkit/dist/helpers';
+/** Node representing a string literal. */
+type StringLiteral = SimpleLiteral & {
+    value: string;
+};
+export declare const isStringLiteral: (node: Node | null | undefined) => node is StringLiteral;
+/** 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;
+/** 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`. */
+export declare function isNullableOf<T extends Node>(validator: Checker<T>): NullableChecker<T>;
+export {};