@lwc/template-compiler 6.1.1 → 6.2.1

package/dist/codegen/codegen.d.ts

@@ -69,10 +69,15 @@ export default class CodeGen {
     genScopedFragId(id: string | t.Expression): t.CallExpression;
     /**
      * Generates childs vnodes when slot content is static.
+     * @param slotName
+     * @param data
+     * @param children
      */
     getSlot(slotName: string, data: t.ObjectExpression, children: t.Expression): import("estree").CallExpression;
     /**
      * Generates a factory function that inturn generates child vnodes for scoped slot content.
+     * @param callback
+     * @param slotName
      */
     getScopedSlotFactory(callback: t.FunctionExpression, slotName: t.Expression | t.SimpleLiteral): import("estree").CallExpression;
     genTabIndex(children: [t.Expression]): import("estree").CallExpression;
@@ -84,9 +89,8 @@ export default class CodeGen {
      * This routine generates an expression that avoids
      * computing the sanitized html of a raw html if it does not change
      * between renders.
-     *
      * @param expr
-     * @returns sanitizedHtmlExpr
+     * @returns The generated expression
      */
     genSanitizedHtmlExpr(expr: t.Expression): import("estree").ConditionalExpression | import("estree").LogicalExpression;
     private _renderApiCall;
@@ -96,12 +100,14 @@ export default class CodeGen {
     declareIdentifier(identifier: t.Identifier): void;
     /**
      * Searches the scopes to find an identifier with a matching name.
+     * @param identifier
      */
     isLocalIdentifier(identifier: t.Identifier): boolean;
     /**
      * Bind the passed expression to the component instance. It applies the following transformation to the expression:
      * - {value} --> {$cmp.value}
      * - {value[index]} --> {$cmp.value[$cmp.index]}
+     * @param expression
      */
     bindExpression(expression: Expression | Literal | ComplexExpression): t.Expression;
     genStaticElement(element: StaticElement, slotParentName?: string): t.Expression;

package/dist/codegen/expression.d.ts

@@ -4,20 +4,22 @@ import type CodeGen from './codegen';
 /**
  * Bind the passed expression to the component instance. It applies the following
  * transformation to the expression:
- *    {value} --> {$cmp.value}
- *    {value[index]} --> {$cmp.value[$cmp.index]}
- *    {foo ?? bar} --> {$cmp.foo ?? $cmp.bar}
- *    {foo?.bar} --> {$cmp.foo?.bar}
+ * - `{value}` --> `{$cmp.value}`
+ * - `{value[index]}` --> `{$cmp.value[$cmp.index]}`
+ * - `{foo ?? bar}` --> `{$cmp.foo ?? $cmp.bar}`
+ * - `{foo?.bar}` --> `{$cmp.foo?.bar}`
  *
  * However, parameter variables are not be transformed in this way. For example,
  * the following transformations do not happen:
- *    {(foo) => foo && bar} -> {(foo) => $cmp.foo && $cmp.bar}
- *    {(foo) => foo && bar} -> {($cmp.foo) => foo && $cmp.bar}
- *    {(foo) => foo && bar} -> {($cmp.foo) => $cmp.foo && $cmp.bar}
+ * - `{(foo) => foo && bar}` --> `{(foo) => $cmp.foo && $cmp.bar}`
+ * - `{(foo) => foo && bar}` --> `{($cmp.foo) => foo && $cmp.bar}`
+ * - `{(foo) => foo && bar}` --> `{($cmp.foo) => $cmp.foo && $cmp.bar}`
  *
  * Instead, the scopes are respected:
- *    {(foo) => foo && $cmp.bar}
+ * - `{(foo) => foo && $cmp.bar}`
  *
  * Similar checks occur for local identifiers introduced via for:each or similar.
+ * @param expression
+ * @param codeGen
  */
 export declare function bindComplexExpression(expression: ComplexExpression, codeGen: CodeGen): t.Expression;

package/dist/codegen/formatters/module.d.ts

@@ -4,7 +4,8 @@ import CodeGen from '../codegen';
  * Generate an ES module AST from a template ESTree AST. The generated module imports the dependent
  * LWC components via import statements and expose the template function via a default export
  * statement.
- *
+ * @param templateFn
+ * @param codeGen
  * @example
  * ```js
  * import { registerTemplate } from 'lwc';

package/dist/codegen/helpers.d.ts

@@ -10,10 +10,13 @@ export declare function objectToAST(obj: object, valueMapper: (key: string) => t
  *
  * This function searches through the children to determine if flattening needs to occur in the runtime.
  * Children should be flattened if they contain an iterator, a dynamic directive or a slot inside a light dom element.
+ * @param codeGen
+ * @param children
  */
 export declare function shouldFlatten(codeGen: CodeGen, children: ChildNode[]): boolean;
 /**
  * Returns true if the AST element or any of its descendants use an id attribute.
+ * @param node
  */
 export declare function hasIdAttribute(node: Node): boolean;
 export declare function memorizeHandler(codeGen: CodeGen, componentHandler: t.Expression, handler: t.Expression): t.Expression;

package/dist/codegen/optimize.d.ts

@@ -29,5 +29,6 @@ import * as t from '../shared/estree';
  *   };
  * }
  * ```
+ * @param templateFn
  */
 export declare function optimizeStaticExpressions(templateFn: t.FunctionDeclaration): Array<t.FunctionDeclaration | t.VariableDeclaration>;

package/dist/config.d.ts

@@ -6,23 +6,24 @@ export interface Config {
      */
     customRendererConfig?: CustomRendererConfig;
     /**
-     * Enable computed member expression in the template. eg:
-     *    <template>
-     *        {list[0].name}
-     *    </template>
+     * Enable computed member expression in the template.
+     * @example
+     * <template>
+     *     {list[0].name}
+     * </template>
      */
     experimentalComputedMemberExpression?: boolean;
     /**
      * Enable use of (a subset of) JavaScript expressions in place of template bindings.
-     *
-     *    <template>
-     *        <input
-     *            attr={complex ?? expressions()}
-     *            onchange={({ target }) => componentMethod(target.value)}
-     *        >
-     *            Hey there {inAustralia ? 'mate' : 'friend'}
-     *        </input>
-     *    </template>
+     * @example
+     * <template>
+     *     <input
+     *         attr={complex ?? expressions()}
+     *         onchange={({ target }) => componentMethod(target.value)}
+     *     >
+     *         Hey there {inAustralia ? 'mate' : 'friend'}
+     *     </input>
+     * </template>
      */
     experimentalComplexExpressions?: boolean;
     /**