@lwc/engine-core 6.1.1 → 6.2.1

package/dist/framework/api.d.ts

@@ -12,6 +12,7 @@ declare function c(sel: string, Ctor: LightningElementConstructor, data: VElemen
 declare function i(iterable: Iterable<any>, factory: (value: any, index: number, first: boolean, last: boolean) => VNodes | VNode): VNodes;
 /**
  * [f]lattening
+ * @param items
  */
 declare function f(items: Readonly<Array<Readonly<Array<VNodes>> | VNodes>>): VNodes;
 declare function t(text: string): VText;
@@ -25,15 +26,23 @@ declare function fid(url: string | undefined | null): string | null | undefined;
  * [ddc] - create a (deprecated) dynamic component via `<x-foo lwc:dynamic={Ctor}>`
  *
  * TODO [#3331]: remove usage of lwc:dynamic in 246
+ * @param sel
+ * @param Ctor
+ * @param data
+ * @param children
  */
 declare function ddc(sel: string, Ctor: LightningElementConstructor | null | undefined, data: VElementData, children?: VNodes): VCustomElement | null;
 /**
  * [dc] - create a dynamic component via `<lwc:component lwc:is={Ctor}>`
+ * @param Ctor
+ * @param data
+ * @param children
  */
 declare function dc(Ctor: LightningElementConstructor | null | undefined, data: VElementData, children?: VNodes): VCustomElement | null;
 export type SanitizeHtmlContentHook = (content: unknown) => string;
 /**
  * Sets the sanitizeHtmlContentHook.
+ * @param newHookImpl
  */
 export declare function setSanitizeHtmlContentHook(newHookImpl: SanitizeHtmlContentHook): void;
 declare function shc(content: unknown): string;

package/dist/framework/base-lightning-element.d.ts

@@ -21,7 +21,9 @@ export interface LightningElementConstructor {
     shadowSupportMode?: ShadowSupportMode;
     stylesheets: TemplateStylesheetFactories;
 }
-type HTMLElementTheGoodParts = Pick<Object, 'toString'> & Pick<HTMLElement, 'accessKey' | 'addEventListener' | 'attachInternals' | 'children' | 'childNodes' | 'classList' | 'dir' | 'dispatchEvent' | 'draggable' | 'firstChild' | 'firstElementChild' | 'getAttribute' | 'getAttributeNS' | 'getBoundingClientRect' | 'getElementsByClassName' | 'getElementsByTagName' | 'hasAttribute' | 'hasAttributeNS' | 'hidden' | 'id' | 'isConnected' | 'lang' | 'lastChild' | 'lastElementChild' | 'ownerDocument' | 'querySelector' | 'querySelectorAll' | 'removeAttribute' | 'removeAttributeNS' | 'removeEventListener' | 'setAttribute' | 'setAttributeNS' | 'spellcheck' | 'tabIndex' | 'tagName' | 'title'>;
+type HTMLElementTheGoodParts = {
+    toString: () => string;
+} & Pick<HTMLElement, 'accessKey' | 'addEventListener' | 'attachInternals' | 'children' | 'childNodes' | 'classList' | 'dir' | 'dispatchEvent' | 'draggable' | 'firstChild' | 'firstElementChild' | 'getAttribute' | 'getAttributeNS' | 'getBoundingClientRect' | 'getElementsByClassName' | 'getElementsByTagName' | 'hasAttribute' | 'hasAttributeNS' | 'hidden' | 'id' | 'isConnected' | 'lang' | 'lastChild' | 'lastElementChild' | 'ownerDocument' | 'querySelector' | 'querySelectorAll' | 'removeAttribute' | 'removeAttributeNS' | 'removeEventListener' | 'setAttribute' | 'setAttributeNS' | 'spellcheck' | 'tabIndex' | 'tagName' | 'title'>;
 type RefNodes = {
     [name: string]: Element;
 };
@@ -41,7 +43,7 @@ export interface LightningElement extends HTMLElementTheGoodParts, AccessibleEle
 /**
  * This class is the base class for any LWC element.
  * Some elements directly extends this class, others implement it via inheritance.
- **/
+ */
 export declare const LightningElement: LightningElementConstructor;
 export declare const lightningBasedDescriptors: PropertyDescriptorMap;
 export {};

package/dist/framework/check-version-mismatch.d.ts

@@ -5,6 +5,8 @@ import { LightningElementConstructor } from './base-lightning-element';
  * Validate a template, stylesheet, or component to make sure that its compiled version matches
  * the version used by the LWC engine at runtime. Note that this only works in dev mode because
  * it relies on code comments, which are stripped in production due to minification.
+ * @param func
+ * @param type
  */
 export declare function checkVersionMismatch(func: Template, type: 'template'): void;
 export declare function checkVersionMismatch(func: StylesheetFactory, type: 'stylesheet'): void;

package/dist/framework/component.d.ts

@@ -12,12 +12,15 @@ type ComponentConstructorMetadata = {
 /**
  * INTERNAL: This function can only be invoked by compiled code. The compiler
  * will prevent this function from being imported by userland code.
+ * @param Ctor
+ * @param metadata
  */
 export declare function registerComponent(Ctor: any, metadata: ComponentConstructorMetadata): any;
 export declare function getComponentRegisteredTemplate(Ctor: LightningElementConstructor): Template | undefined;
 export declare function getComponentRegisteredName(Ctor: LightningElementConstructor): string | undefined;
 export declare function getComponentAPIVersion(Ctor: LightningElementConstructor): APIVersion;
 export declare function getTemplateReactiveObserver(vm: VM): ReactiveObserver;
+export declare function resetTemplateObserverAndUnsubscribe(vm: VM): void;
 export declare function renderComponent(vm: VM): VNodes;
 export declare function markComponentAsDirty(vm: VM): void;
 export declare function getWrappedComponentsListener(vm: VM, listener: EventListener): EventListener;

package/dist/framework/decorators/api.d.ts

@@ -1,7 +1,10 @@
 /**
- * @api decorator to mark public fields and public methods in
+ * The @api decorator marks public fields and public methods in
  * LWC Components. This function implements the internals of this
  * decorator.
+ * @param target
+ * @param propertyKey
+ * @param descriptor
  */
 export default function api(target: any, propertyKey: string, descriptor: PropertyDescriptor): void;
 export declare function createPublicPropertyDescriptor(key: string): PropertyDescriptor;

package/dist/framework/decorators/register.d.ts

@@ -30,6 +30,8 @@ interface RegisterDecoratorMeta {
 /**
  * INTERNAL: This function can only be invoked by compiled code. The compiler
  * will prevent this function from being imported by user-land code.
+ * @param Ctor
+ * @param meta
  */
 export declare function registerDecorators(Ctor: LightningElementConstructor, meta: RegisterDecoratorMeta): LightningElementConstructor;
 interface DecoratorMeta {

package/dist/framework/decorators/track.d.ts

@@ -1,7 +1,10 @@
 /**
- * @track decorator function to mark field value as reactive in
+ * The @track decorator function marks field values as reactive in
  * LWC Components. This function can also be invoked directly
  * with any value to obtain the trackable version of the value.
+ * @param target
+ * @param propertyKey
+ * @param descriptor
  */
 export default function track(target: any, propertyKey: string, descriptor: PropertyDescriptor): any;
 export declare function internalTrackDecorator(key: string): PropertyDescriptor;

package/dist/framework/decorators/wire.d.ts

@@ -1,8 +1,10 @@
 import { WireAdapterConstructor } from '../wiring';
 /**
- * @wire decorator to wire fields and methods to a wire adapter in
+ * The @wire decorator wires fields and methods to a wire adapter in
  * LWC Components. This function implements the internals of this
  * decorator.
+ * @param _adapter
+ * @param _config
  */
 export default function wire(_adapter: WireAdapterConstructor, _config?: Record<string, any>): PropertyDecorator | MethodDecorator;
 export declare function internalWireFieldDecorator(key: string): PropertyDescriptor;

package/dist/framework/def.d.ts

@@ -36,6 +36,7 @@ export interface ComponentDef {
 /**
  * EXPERIMENTAL: This function allows for the identification of LWC constructors. This API is
  * subject to change or being removed.
+ * @param ctor
  */
 export declare function isComponentConstructor(ctor: unknown): ctor is LightningElementConstructor;
 export declare function getComponentInternalDef(Ctor: unknown): ComponentDef;
@@ -58,6 +59,7 @@ interface PublicComponentDef {
 /**
  * EXPERIMENTAL: This function allows for the collection of internal component metadata. This API is
  * subject to change or being removed.
+ * @param Ctor
  */
 export declare function getComponentDef(Ctor: any): PublicComponentDef;
 export {};

package/dist/framework/get-component-constructor.d.ts

@@ -2,5 +2,6 @@ import { LightningElement } from './base-lightning-element';
 /**
  * EXPERIMENTAL: This function provides access to the component constructor, given an HTMLElement.
  * This API is subject to change or being removed.
+ * @param elm
  */
 export declare function getComponentConstructor(elm: HTMLElement): typeof LightningElement | null;

package/dist/framework/membrane.d.ts

@@ -2,6 +2,7 @@
  * EXPERIMENTAL: This function implements an unwrap mechanism that
  * works for observable membrane objects. This API is subject to
  * change or being removed.
+ * @param value
  */
 export declare function unwrap(value: any): any;
 export declare function getReadOnlyProxy(value: any): any;

package/dist/framework/modules/static-parts.d.ts

@@ -2,10 +2,14 @@ import { VStatic } from '../vnodes';
 import { RendererAPI } from '../renderer';
 /**
  * Given an array of static parts, do all the mounting required for these parts.
- *
- * @param root - the root element
- * @param vnode - the parent VStatic
- * @param renderer - the renderer to use
- * @param mount - true this is a first (mount) render as opposed to a subsequent (patch) render
+ * @param root the root element
+ * @param vnode the parent VStatic
+ * @param renderer the renderer to use
  */
-export declare function applyStaticParts(root: Element, vnode: VStatic, renderer: RendererAPI, mount: boolean): void;
+export declare function mountStaticParts(root: Element, vnode: VStatic, renderer: RendererAPI): void;
+/**
+ * Mounts elements to the newly generated VStatic node
+ * @param n1 the previous VStatic vnode
+ * @param n2 the current VStatic vnode
+ */
+export declare function patchStaticParts(n1: VStatic, n2: VStatic): void;

package/dist/framework/mutation-tracker.d.ts

@@ -1,6 +1,7 @@
 import { CallbackFunction, ReactiveObserver } from '../libs/mutation-tracker';
 import { VM } from './vm';
 export declare function componentValueMutated(vm: VM, key: PropertyKey): void;
-export declare function componentValueObserved(vm: VM, key: PropertyKey): void;
+export declare function componentValueObserved(vm: VM, key: PropertyKey, target?: any): void;
 export declare function createReactiveObserver(callback: CallbackFunction): ReactiveObserver;
 export * from '../libs/mutation-tracker';
+export * from '../libs/signal-tracker';

package/dist/framework/readonly.d.ts

@@ -2,5 +2,6 @@
  * EXPERIMENTAL: This function allows you to create a reactive readonly
  * membrane around any object value. This API is subject to change or
  * being removed.
+ * @param obj
  */
 export declare function readonly(obj: any): any;

package/dist/framework/reporting.d.ts

@@ -1,4 +1,4 @@
-import { ShadowMode } from './vm';
+import { ShadowMode, ShadowSupportMode } from './vm';
 export declare const enum ReportingEventId {
     CrossRootAriaInSyntheticShadow = "CrossRootAriaInSyntheticShadow",
     CompilerRuntimeVersionMismatch = "CompilerRuntimeVersionMismatch",
@@ -6,7 +6,8 @@ export declare const enum ReportingEventId {
     TemplateMutation = "TemplateMutation",
     StylesheetMutation = "StylesheetMutation",
     ConnectedCallbackWhileDisconnected = "ConnectedCallbackWhileDisconnected",
-    ShadowModeUsage = "ShadowModeUsage"
+    ShadowModeUsage = "ShadowModeUsage",
+    ShadowSupportModeUsage = "ShadowSupportModeUsage"
 }
 export interface BasePayload {
     tagName?: string;
@@ -34,6 +35,9 @@ export interface ConnectedCallbackWhileDisconnectedPayload extends BasePayload {
 export interface ShadowModeUsagePayload extends BasePayload {
     mode: ShadowMode;
 }
+export interface ShadowSupportModeUsagePayload extends BasePayload {
+    mode: ShadowSupportMode;
+}
 export type ReportingPayloadMapping = {
     [ReportingEventId.CrossRootAriaInSyntheticShadow]: CrossRootAriaInSyntheticShadowPayload;
     [ReportingEventId.CompilerRuntimeVersionMismatch]: CompilerRuntimeVersionMismatchPayload;
@@ -42,15 +46,15 @@ export type ReportingPayloadMapping = {
     [ReportingEventId.StylesheetMutation]: StylesheetMutationPayload;
     [ReportingEventId.ConnectedCallbackWhileDisconnected]: ConnectedCallbackWhileDisconnectedPayload;
     [ReportingEventId.ShadowModeUsage]: ShadowModeUsagePayload;
+    [ReportingEventId.ShadowSupportModeUsage]: ShadowSupportModeUsagePayload;
 };
 export type ReportingDispatcher<T extends ReportingEventId = ReportingEventId> = (reportingEventId: T, payload: ReportingPayloadMapping[T]) => void;
-/** Callbacks to invoke when reporting is enabled **/
+/** Callbacks to invoke when reporting is enabled */
 type OnReportingEnabledCallback = () => void;
 export declare const reportingControl: {
     /**
      * Attach a new reporting control (aka dispatcher).
-     *
-     * @param dispatcher - reporting control
+     * @param dispatcher reporting control
      */
     attachDispatcher(dispatcher: ReportingDispatcher): void;
     /**
@@ -67,7 +71,7 @@ export declare function onReportingEnabled(callback: OnReportingEnabledCallback)
 /**
  * Report to the current dispatcher, if there is one.
  * @param reportingEventId
- * @param payload - data to report
+ * @param payload data to report
  */
 export declare function report<T extends ReportingEventId>(reportingEventId: T, payload: ReportingPayloadMapping[T]): void;
 /**

package/dist/framework/secure-template.d.ts

@@ -4,10 +4,15 @@ export declare function isTemplateRegistered(tpl: Template): boolean;
 /**
  * INTERNAL: This function can only be invoked by compiled code. The compiler
  * will prevent this function from being imported by userland code.
+ * @param tpl
  */
 export declare function registerTemplate(tpl: Template): Template;
 /**
  * EXPERIMENTAL: This function acts like a hook for Lightning Locker Service and other similar
  * libraries to sanitize vulnerable attributes.
+ * @param tagName
+ * @param namespaceUri
+ * @param attrName
+ * @param attrValue
  */
 export declare function sanitizeAttribute(tagName: string, namespaceUri: string, attrName: string, attrValue: any): string;

package/dist/framework/stylesheet.d.ts

@@ -8,8 +8,8 @@ import { VCustomElement, VNode } from './vnodes';
 export type StylesheetFactory = (stylesheetToken: string | undefined, useActualHostSelector: boolean, useNativeDirPseudoclass: boolean) => string;
 /**
  * The list of stylesheets associated with a template. Each entry is either a StylesheetFactory or a
- * TemplateStylesheetFactory a given stylesheet depends on other external stylesheets (via the
- * @import CSS declaration).
+ * TemplateStylesheetFactory a given stylesheet depends on other external stylesheets (via
+ * the @import CSS declaration).
  */
 export type TemplateStylesheetFactories = Array<StylesheetFactory | TemplateStylesheetFactories>;
 export declare function updateStylesheetToken(vm: VM, template: Template, legacy: boolean): void;
@@ -18,6 +18,8 @@ export declare function getStylesheetsContent(vm: VM, template: Template): strin
  * If the component that is currently being rendered uses scoped styles,
  * this returns the unique token for that scoped stylesheet. Otherwise
  * it returns null.
+ * @param owner
+ * @param legacy
  */
 export declare function getScopeTokenClass(owner: VM, legacy: boolean): string | null;
 /**
@@ -25,6 +27,7 @@ export declare function getScopeTokenClass(owner: VM, legacy: boolean): string |
  * exists. Otherwise it returns null.
  *
  * A host style token is applied to the component if scoped styles are used.
+ * @param vnode
  */
 export declare function getStylesheetTokenHost(vnode: VCustomElement): string | null;
 export declare function createStylesheet(vm: VM, stylesheets: string[]): VNode[] | null;

package/dist/framework/vm.d.ts

@@ -54,8 +54,10 @@ export interface Context {
     hasScopedStyles: boolean | undefined;
     /** The VNodes injected in all the shadow trees to apply the associated component stylesheets. */
     styleVNodes: VNode[] | null;
-    /** Object used by the template function to store information that can be reused between
-     *  different render cycle of the same template. */
+    /**
+     * Object used by the template function to store information that can be reused between
+     * different render cycle of the same template.
+     */
     tplCache: TemplateCache;
     /** List of wire hooks that are invoked when the component gets connected. */
     wiredConnecting: Array<() => void>;
@@ -94,16 +96,20 @@ export interface VM<N = HostNode, E = HostElement> {
     children: VNodes;
     /** The list of adopted children VNodes. */
     aChildren: VNodes;
-    /** The list of custom elements VNodes currently rendered in the shadow tree. We keep track of
+    /**
+     * The list of custom elements VNodes currently rendered in the shadow tree. We keep track of
      * those elements to efficiently unmount them when the parent component is disconnected without
-     * having to traverse the VNode tree. */
+     * having to traverse the VNode tree.
+     */
     velements: VCustomElement[];
     /** The component public properties. */
     cmpProps: {
         [name: string]: any;
     };
-    /** Contains information about the mapping between the slot names and the slotted VNodes, and
-     *  the owner of the slot content. */
+    /**
+     * Contains information about the mapping between the slot names and the slotted VNodes, and
+     * the owner of the slot content.
+     */
     cmpSlots: SlotSet;
     /** The component internal reactive properties. */
     cmpFields: {
@@ -121,28 +127,39 @@ export interface VM<N = HostNode, E = HostElement> {
     component: LightningElement;
     /** The custom element shadow root. */
     shadowRoot: ShadowRoot | null;
-    /** The component render root. If the component is a shadow DOM component, it is its shadow
-     * root. If the component is a light DOM component it the element itself. */
+    /**
+     * The component render root. If the component is a shadow DOM component, it is its shadow
+     * root. If the component is a light DOM component it the element itself.
+     */
     renderRoot: ShadowRoot | HostElement;
     /** The template reactive observer. */
     tro: ReactiveObserver;
-    /** Hook invoked whenever a property is accessed on the host element. This hook is used by
-     *  Locker only. */
+    /**
+     * Hook invoked whenever a property is accessed on the host element. This hook is used by
+     * Locker only.
+     */
     setHook: (cmp: LightningElement, prop: PropertyKey, newValue: any) => void;
-    /** Hook invoked whenever a property is set on the host element. This hook is used by Locker
-     *  only. */
+    /**
+     * Hook invoked whenever a property is set on the host element. This hook is used by Locker
+     * only.
+     */
     getHook: (cmp: LightningElement, prop: PropertyKey) => any;
-    /** Hook invoked whenever a method is called on the component (life-cycle hooks, public
-     *  properties and event handlers). This hook is used by Locker. */
+    /**
+     * Hook invoked whenever a method is called on the component (life-cycle hooks, public
+     * properties and event handlers). This hook is used by Locker.
+     */
     callHook: (cmp: LightningElement | undefined, fn: (...args: any[]) => any, args?: any[]) => any;
     /**
-     * Renderer API */
+     * Renderer API
+     */
     renderer: RendererAPI;
     /**
-     * Debug info bag. Stores useful debug information about the component. */
+     * Debug info bag. Stores useful debug information about the component.
+     */
     debugInfo?: Record<string, any>;
     /**
-     * Any stylesheets associated with the component */
+     * Any stylesheets associated with the component
+     */
     stylesheets: TemplateStylesheetFactories | null;
     /**
      * API version associated with this VM