@lwc/template-compiler 2.7.1 → 2.7.2

package/dist/types/parser/constants.d.ts

@@ -11,10 +11,16 @@ export declare const LWC_DIRECTIVES: {
     INNER_HTML: string;
 };
 export declare const LWC_DIRECTIVE_SET: Set<string>;
+export declare const FOR_DIRECTIVES: {
+    FOR_EACH: string;
+    FOR_ITEM: string;
+    FOR_INDEX: string;
+};
 export declare const ROOT_TEMPLATE_DIRECTIVES: {
     PRESERVE_COMMENTS: string;
     RENDER_MODE: string;
 };
+export declare const ROOT_TEMPLATE_DIRECTIVES_SET: Set<string>;
 export declare const ID_REFERENCING_ATTRIBUTES_SET: Set<string>;
 export declare const DATA_RE: RegExp;
 export declare const SUPPORTED_SVG_TAGS: Set<string>;

package/dist/types/parser/expression.d.ts

@@ -1,8 +1,9 @@
+import { Location } from 'parse5';
+import { TemplateExpression, TemplateIdentifier } from '../shared/types';
 import ParserCtx from './parser';
-import { Expression, Identifier, SourceLocation } from '../shared/types';
 export declare const EXPRESSION_SYMBOL_START = "{";
 export declare const EXPRESSION_SYMBOL_END = "}";
 export declare function isExpression(source: string): boolean;
 export declare function isPotentialExpression(source: string): boolean;
-export declare function parseExpression(ctx: ParserCtx, source: string, location: SourceLocation): Expression;
-export declare function parseIdentifier(ctx: ParserCtx, source: string, location: SourceLocation): Identifier;
+export declare function parseExpression(ctx: ParserCtx, source: string, location: Location): TemplateExpression;
+export declare function parseIdentifier(ctx: ParserCtx, source: string, location: Location): TemplateIdentifier;

package/dist/types/parser/parser.d.ts

@@ -1,59 +1,28 @@
+import * as parse5 from 'parse5';
 import { CompilerDiagnostic, LWCErrorInfo } from '@lwc/errors';
+import { IRElement, LWCDirectiveRenderMode, IRBaseAttribute, IRNode } from '../shared/types';
 import { ResolvedConfig } from '../config';
-import { Root, SourceLocation, ParentNode, BaseNode, LWCDirectiveRenderMode } from '../shared/types';
-interface ParentWrapper {
-    parent: ParentNode | null;
-    current: ParentNode;
-}
 export default class ParserCtx {
     private readonly source;
     readonly config: ResolvedConfig;
     readonly warnings: CompilerDiagnostic[];
     readonly seenIds: Set<string>;
     readonly seenSlots: Set<string>;
-    /**
-     * Scopes keep track of the hierarchy of ParentNodes as the parser traverses the parse5 AST.
-     * Each scope is represented by an array where each node in the array correspond to either
-     * a ForEach, ForOf, If, Element, Component, or Slot.
-     *
-     * Currently, each scope has a hierarchy of ForBlock > IfBlock > Element | Component | Slot.
-     * Note: Not all scopes will have all three, but when they do, they will appear in this order.
-     * We do not keep track of template nodes.
-     *
-     * Each scope corresponds to the original parse5.Element node.
-     */
-    private readonly scopes;
-    renderMode: LWCDirectiveRenderMode;
-    preserveComments: boolean;
+    readonly parentStack: IRElement[];
     constructor(source: String, config: ResolvedConfig);
     getSource(start: number, end: number): string;
-    setRootDirective(root: Root): void;
-    /**
-     * This method flattens the scopes into a single array for traversal.
-     */
-    ancestors(element?: ParentNode): IterableIterator<ParentWrapper>;
-    /**
-     * This method returns an iterator over ancestor nodes, starting at the parent and ending at the root node.
-     *
-     * Note: There are instances when we want to terminate the traversal early, such as searching for a ForBlock parent.
-     *
-     * @param {ParentNode} startNode - Starting node to begin search, defaults to the tail of the current scope.
-     * @param {function} predicate - This callback is called once for each ancestor until it finds one where predicate returns true.
-     * @param {function} traversalCond - This callback is called after predicate and will terminate the traversal if it returns false.
-     * traversalCond is ignored if no value is provided.
-     */
-    findAncestor<A extends ParentNode>(predicate: (node: ParentNode) => node is A, traversalCond?: (nodes: ParentWrapper) => unknown, startNode?: ParentNode): A | null;
-    /**
-     * This method searchs the current scope and returns the value that satisfies the predicate.
-     *
-     * @param {function} predicate - This callback is called once for each sibling in the current scope
-     * until it finds one where predicate returns true.
-     */
-    findSibling<A extends ParentNode>(predicate: (node: ParentNode) => node is A): A | null;
-    beginScope(): void;
-    endScope(): void;
-    addNodeCurrentScope(node: ParentNode): void;
-    private currentScope;
+    ancestors(element?: IRElement): Generator<{
+        current: IRElement;
+        index: number;
+    }, void, unknown>;
+    findAncestor(args: {
+        element?: IRElement;
+        predicate: (elm: IRElement) => unknown;
+        traversalCond?: (nodes: {
+            current: IRElement;
+            parent: IRElement | null;
+        }) => unknown;
+    }): IRElement | null;
     /**
      * This method recovers from diagnostic errors that are encountered when fn is invoked.
      * All other errors are considered compiler errors and can not be recovered from.
@@ -61,32 +30,34 @@ export default class ParserCtx {
      * @param fn - method to be invoked.
      */
     withErrorRecovery<T>(fn: () => T): T | undefined;
-    withErrorWrapping<T>(fn: () => T, errorInfo: LWCErrorInfo, location: SourceLocation, msgFormatter?: (error: any) => string): T;
-    throwOnError(errorInfo: LWCErrorInfo, error: any, location?: SourceLocation): never;
+    withErrorWrapping<T>(fn: () => T, errorInfo: LWCErrorInfo, location: parse5.Location, msgFormatter?: (error: any) => string): T;
+    throwOnError(errorInfo: LWCErrorInfo, error: any, location?: parse5.Location): never;
     /**
-     * This method throws a diagnostic error with the node's location.
+     * This method throws a diagnostic error with the IRNode's location.
      */
-    throwOnNode(errorInfo: LWCErrorInfo, node: BaseNode, messageArgs?: any[]): never;
+    throwOnIRNode(errorInfo: LWCErrorInfo, irNode: IRNode | IRBaseAttribute, messageArgs?: any[]): never;
     /**
      * This method throws a diagnostic error with location information.
      */
-    throwAtLocation(errorInfo: LWCErrorInfo, location: SourceLocation, messageArgs?: any[]): never;
+    throwAtLocation(errorInfo: LWCErrorInfo, location: parse5.Location, messageArgs?: any[]): never;
     /**
      * This method throws a diagnostic error and will immediately exit the current routine.
      */
-    throw(errorInfo: LWCErrorInfo, messageArgs?: any[], location?: SourceLocation): never;
+    throw(errorInfo: LWCErrorInfo, messageArgs?: any[], location?: parse5.Location): never;
     /**
-     * This method logs a diagnostic warning with the node's location.
+     * This method logs a diagnostic warning with the IRNode's location.
      */
-    warnOnNode(errorInfo: LWCErrorInfo, node: BaseNode, messageArgs?: any[]): void;
+    warnOnIRNode(errorInfo: LWCErrorInfo, irNode: IRNode | IRBaseAttribute, messageArgs?: any[]): void;
     /**
      * This method logs a diagnostic warning with location information.
      */
-    warnAtLocation(errorInfo: LWCErrorInfo, location: SourceLocation, messageArgs?: any[]): void;
+    warnAtLocation(errorInfo: LWCErrorInfo, location: parse5.Location, messageArgs?: any[]): void;
     /**
      * This method logs a diagnostic warning and will continue execution of the current routine.
      */
-    warn(errorInfo: LWCErrorInfo, messageArgs?: any[], location?: SourceLocation): void;
+    warn(errorInfo: LWCErrorInfo, messageArgs?: any[], location?: parse5.Location): void;
     private addDiagnostic;
+    getRoot(element: IRElement): IRElement;
+    getRenderMode(element: IRElement): LWCDirectiveRenderMode;
+    getPreserveComments(element: IRElement): boolean;
 }
-export {};

package/dist/types/shared/estree.d.ts

@@ -52,6 +52,8 @@ export declare type BlockStatement = t.BlockStatement;
 export declare type ReturnStatement = t.ReturnStatement;
 export declare type VariableDeclarator = t.VariableDeclarator;
 export declare type VariableDeclaration = t.VariableDeclaration;
+export declare type TemplateLiteral = t.TemplateLiteral;
+export declare type TemplateElement = t.TemplateElement;
 export declare type ImportDeclaration = t.ImportDeclaration;
 export declare type ImportDefaultSpecifier = t.ImportDefaultSpecifier;
 export declare type ImportSpecifier = t.ImportSpecifier;

package/dist/types/shared/ir.d.ts

@@ -0,0 +1,15 @@
+import * as parse5 from 'parse5';
+import { TemplateIdentifier, TemplateExpression, IRNode, IRText, IRElement, IRComment, IRAttribute, IRExpressionAttribute, IRStringAttribute, IRBooleanAttribute } from './types';
+export declare function createElement(original: parse5.Element, location: parse5.ElementLocation): IRElement;
+export declare function createText(value: string | TemplateExpression, location: parse5.Location): IRText;
+export declare function createComment(value: string, location: parse5.Location): IRComment;
+export declare function isElement(node: IRNode): node is IRElement;
+export declare function isTextNode(node: IRNode): node is IRText;
+export declare function isCommentNode(node: IRNode): node is IRComment;
+export declare function isCustomElement(node: IRNode): boolean;
+export declare function isTemplate(element: IRElement): boolean;
+export declare function isSlot(element: IRElement): boolean;
+export declare function isIRExpressionAttribute(attribute: IRAttribute): attribute is IRExpressionAttribute;
+export declare function isIRStringAttribute(attribute: IRAttribute): attribute is IRStringAttribute;
+export declare function isIRBooleanAttribute(attribute: IRAttribute): attribute is IRBooleanAttribute;
+export declare function isComponentProp(identifier: TemplateIdentifier, root: IRNode, parentStack: IRNode[]): boolean;

package/dist/types/shared/parse5.d.ts

@@ -3,3 +3,4 @@ export declare function isElementNode(node: parse5.Node): node is parse5.Element
 export declare function isCommentNode(node: parse5.Node): node is parse5.CommentNode;
 export declare function isTextNode(node: parse5.Node): node is parse5.TextNode;
 export declare function getTemplateContent(templateElement: parse5.Element): parse5.DocumentFragment | undefined;
+export declare function createEmptyElementLocation(): parse5.ElementLocation;

package/dist/types/shared/types.d.ts

@@ -1,12 +1,36 @@
+import * as parse5 from 'parse5';
 import { CompilerDiagnostic } from '@lwc/errors';
+export declare type TemplateIdentifier = {
+    type: 'Identifier';
+    name: string;
+};
+export declare type TemplateExpression = {
+    type: 'MemberExpression';
+    object: TemplateExpression;
+    property: TemplateExpression;
+    computed: boolean;
+    optional: boolean;
+} | {
+    type: 'Literal';
+    value: string | number | boolean | null;
+} | TemplateIdentifier;
 export declare type TemplateCompileResult = {
     code: string;
     warnings: CompilerDiagnostic[];
 };
 export declare type TemplateParseResult = {
-    root?: Root;
+    root?: IRElement | undefined;
     warnings: CompilerDiagnostic[];
 };
+export interface ForEach {
+    expression: TemplateExpression;
+    item: TemplateIdentifier;
+    index?: TemplateIdentifier;
+}
+export interface ForIterator {
+    expression: TemplateExpression;
+    iterator: TemplateIdentifier;
+}
 export declare enum LWCDirectiveDomMode {
     manual = "manual"
 }
@@ -14,141 +38,74 @@ export declare enum LWCDirectiveRenderMode {
     shadow = "shadow",
     light = "light"
 }
-export interface BaseNode {
-    type: string;
-    location: SourceLocation;
-}
-export interface SourceLocation {
-    startLine: number;
-    startColumn: number;
-    endLine: number;
-    endColumn: number;
-    start: number;
-    end: number;
-}
-export interface ElementSourceLocation extends SourceLocation {
-    startTag: SourceLocation;
-    endTag?: SourceLocation;
-}
-export interface Literal<Value = string | boolean> {
-    type: 'Literal';
-    value: Value;
-}
-export interface Identifier extends BaseNode {
-    type: 'Identifier';
-    name: string;
-}
-export interface MemberExpression extends BaseNode {
-    type: 'MemberExpression';
-    object: Expression;
-    property: Identifier;
-}
-export declare type Expression = Identifier | MemberExpression;
-export interface Attribute extends BaseNode {
-    type: 'Attribute';
-    name: string;
-    value: Literal | Expression;
-}
-export interface Property extends BaseNode {
-    type: 'Property';
-    name: string;
-    attributeName: string;
-    value: Literal | Expression;
-}
-export interface EventListener extends BaseNode {
-    type: 'EventListener';
-    name: string;
-    handler: Expression;
-}
-export interface Directive extends BaseNode {
-    type: 'Directive';
-    name: string;
-    value: Expression | Literal;
-}
-export interface KeyDirective extends Directive {
-    name: 'Key';
-    value: Expression;
-}
-export interface DynamicDirective extends Directive {
-    name: 'Dynamic';
-    value: Expression;
-}
-export interface DomDirective extends Directive {
-    name: 'Dom';
-    value: Literal<'manual'>;
-}
-export interface InnerHTMLDirective extends Directive {
-    name: `InnerHTML`;
-    value: Expression | Literal<string>;
+export interface LWCDirectiveDynamic {
+    prop: string;
 }
-export interface RenderModeDirective extends Directive {
-    name: 'RenderMode';
-    value: Literal<LWCDirectiveRenderMode>;
+export interface LWCDirectives {
+    dom?: LWCDirectiveDomMode;
+    dynamic?: TemplateExpression;
+    renderMode?: LWCDirectiveRenderMode;
+    preserveComments?: IRBooleanAttribute;
+    innerHTML?: TemplateExpression | string;
 }
-export interface PreserveCommentsDirective extends Directive {
-    name: 'PreserveComments';
-    value: Literal<boolean>;
-}
-export declare type ElementDirective = KeyDirective | DynamicDirective | DomDirective | InnerHTMLDirective;
-export declare type RootDirective = RenderModeDirective | PreserveCommentsDirective;
-export interface Text extends BaseNode {
-    type: 'Text';
-    value: Literal | Expression;
-}
-export interface Comment extends BaseNode {
-    type: 'Comment';
+export interface IRBaseNode<N extends parse5.Node> {
+    type: string;
+    location: parse5.Location;
+    __original?: N;
+}
+export interface IRElement extends IRBaseNode<parse5.Element> {
+    type: 'element';
+    tag: string;
+    namespace: string;
+    children: IRNode[];
+    location: parse5.ElementLocation;
+    component?: string;
+    on?: {
+        [name: string]: TemplateExpression;
+    };
+    attrs?: {
+        [name: string]: IRAttribute;
+    };
+    props?: {
+        [name: string]: IRAttribute;
+    };
+    if?: TemplateExpression;
+    ifModifier?: string;
+    forEach?: ForEach;
+    forOf?: ForIterator;
+    forKey?: TemplateExpression;
+    lwc?: LWCDirectives;
+    slotName?: string;
+}
+export interface IRText extends IRBaseNode<parse5.TextNode> {
+    type: 'text';
+    value: string | TemplateExpression;
+}
+export interface IRComment extends IRBaseNode<parse5.CommentNode> {
+    type: 'comment';
     value: string;
 }
-export interface BaseParentNode extends BaseNode {
-    children: ChildNode[];
+export declare type IRNode = IRComment | IRElement | IRText;
+export declare enum IRAttributeType {
+    Expression = 0,
+    String = 1,
+    Boolean = 2
 }
-export interface AbstractBaseElement extends BaseParentNode {
+export interface IRBaseAttribute {
     name: string;
-    location: ElementSourceLocation;
-    properties: Property[];
-    attributes: Attribute[];
-    listeners: EventListener[];
-    directives: ElementDirective[];
-    namespace?: string;
-}
-export interface Element extends AbstractBaseElement {
-    type: 'Element';
-}
-export interface Component extends AbstractBaseElement {
-    type: 'Component';
+    location: parse5.Location;
+    type: IRAttributeType;
 }
-export interface Slot extends AbstractBaseElement {
-    type: 'Slot';
-    /** Specifies slot element name. An empty string value maps to the default slot.  */
-    slotName: string;
+export interface IRExpressionAttribute extends IRBaseAttribute {
+    type: IRAttributeType.Expression;
+    value: TemplateExpression;
 }
-export declare type BaseElement = Element | Component | Slot;
-export interface Root extends BaseParentNode {
-    type: 'Root';
-    location: ElementSourceLocation;
-    directives: RootDirective[];
-}
-interface DirectiveParentNode extends BaseParentNode {
-    directiveLocation: SourceLocation;
-}
-export interface If extends DirectiveParentNode {
-    type: 'If';
-    modifier: string;
-    condition: Expression;
-}
-export interface ForEach extends DirectiveParentNode {
-    type: 'ForEach';
-    expression: Expression;
-    item: Identifier;
-    index?: Identifier;
+export interface IRStringAttribute extends IRBaseAttribute {
+    type: IRAttributeType.String;
+    value: string;
 }
-export interface ForOf extends DirectiveParentNode {
-    type: 'ForOf';
-    expression: Expression;
-    iterator: Identifier;
+export interface IRBooleanAttribute extends IRBaseAttribute {
+    type: IRAttributeType.Boolean;
+    value: true;
 }
-export declare type ForBlock = ForEach | ForOf;
-export declare type ParentNode = Root | ForBlock | If | BaseElement;
-export declare type ChildNode = ForBlock | If | BaseElement | Comment | Text;
-export declare type Node = Root | ForBlock | If | BaseElement | Comment | Text;
-export {};
+export declare type IRAttribute = IRStringAttribute | IRExpressionAttribute | IRBooleanAttribute;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@lwc/template-compiler",
-    "version": "2.7.1",
+    "version": "2.7.2",
     "description": "Template compiler package",
     "homepage": "https://lwc.dev/",
     "repository": {
@@ -25,9 +25,9 @@
     },
     "//": "Currently can't upgrade estree-walker to v3.0.0 because it dropped CommonJS support: https://git.io/JXguS",
     "dependencies": {
-        "@lwc/errors": "2.7.1",
-        "@lwc/shared": "2.7.1",
-        "acorn": "~8.6.0",
+        "@lwc/errors": "2.7.2",
+        "@lwc/shared": "2.7.2",
+        "acorn": "~8.7.0",
         "astring": "~1.8.1",
         "estree-walker": "~2.0.2",
         "he": "~1.2.0",
@@ -39,5 +39,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "1b2e246e03c6bfbc80bea3def43b7d0281a1de21"
+    "gitHead": "f668a3ad36bbebbaa33a5863408a45bf4185d218"
 }