@lwc/engine-core 2.14.1 → 2.14.2

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@lwc/engine-core",
-    "version": "2.14.1",
+    "version": "2.14.2",
     "description": "Core LWC engine APIs.",
     "homepage": "https://lwc.dev/",
     "repository": {
@@ -25,8 +25,8 @@
         "types/"
     ],
     "dependencies": {
-        "@lwc/features": "2.14.1",
-        "@lwc/shared": "2.14.1"
+        "@lwc/features": "2.14.2",
+        "@lwc/shared": "2.14.2"
     },
     "devDependencies": {
         "observable-membrane": "2.0.0"

package/types/framework/main.d.ts

@@ -22,4 +22,3 @@ export { setHooks } from './overridable-hooks';
 export { freezeTemplate } from './freeze-template';
 export { getComponentConstructor } from './get-component-constructor';
 export type { ConfigValue as WireConfigValue, ContextValue as WireContextValue, DataCallback, WireAdapter, WireAdapterConstructor, WireAdapterSchemaValue, } from './wiring';
-export { setAssertInstanceOfHTMLElement, setAttachShadow, setCreateComment, setCreateElement, setCreateText, setDefineCustomElement, setDispatchEvent, setGetAttribute, setGetBoundingClientRect, setGetChildNodes, setGetChildren, setGetClassList, setGetCustomElement, setGetElementsByClassName, setGetElementsByTagName, setGetFirstChild, setGetFirstElementChild, setGetLastChild, setGetLastElementChild, setGetProperty, setHTMLElement, setInsert, setIsConnected, setIsHydrating, setIsNativeShadowDefined, setIsSyntheticShadowDefined, setNextSibling, setQuerySelector, setQuerySelectorAll, setRemove, setRemoveAttribute, setRemoveEventListener, setSetAttribute, setSetCSSStyleProperty, setSetProperty, setSetText, setSsr, setAddEventListener, setInsertStylesheet, } from '../renderer';

package/types/framework/modules/attrs.d.ts

@@ -1,2 +1,3 @@
+import { RendererAPI } from '../renderer';
 import { VBaseElement } from '../vnodes';
-export declare function patchAttributes(oldVnode: VBaseElement | null, vnode: VBaseElement): void;
+export declare function patchAttributes(oldVnode: VBaseElement | null, vnode: VBaseElement, renderer: RendererAPI): void;

package/types/framework/modules/computed-class-attr.d.ts

@@ -1,2 +1,3 @@
+import { RendererAPI } from '../renderer';
 import { VBaseElement } from '../vnodes';
-export declare function patchClassAttribute(oldVnode: VBaseElement | null, vnode: VBaseElement): void;
+export declare function patchClassAttribute(oldVnode: VBaseElement | null, vnode: VBaseElement, renderer: RendererAPI): void;

package/types/framework/modules/computed-style-attr.d.ts

@@ -1,2 +1,3 @@
+import { RendererAPI } from '../renderer';
 import { VBaseElement } from '../vnodes';
-export declare function patchStyleAttribute(oldVnode: VBaseElement | null, vnode: VBaseElement): void;
+export declare function patchStyleAttribute(oldVnode: VBaseElement | null, vnode: VBaseElement, renderer: RendererAPI): void;

package/types/framework/modules/events.d.ts

@@ -1,2 +1,3 @@
+import { RendererAPI } from '../renderer';
 import { VBaseElement } from '../vnodes';
-export declare function applyEventListeners(vnode: VBaseElement): void;
+export declare function applyEventListeners(vnode: VBaseElement, renderer: RendererAPI): void;

package/types/framework/modules/props.d.ts

@@ -1,2 +1,3 @@
+import { RendererAPI } from '../renderer';
 import { VBaseElement } from '../vnodes';
-export declare function patchProps(oldVnode: VBaseElement | null, vnode: VBaseElement): void;
+export declare function patchProps(oldVnode: VBaseElement | null, vnode: VBaseElement, renderer: RendererAPI): void;

package/types/framework/modules/static-class-attr.d.ts

@@ -1,2 +1,3 @@
+import { RendererAPI } from '../renderer';
 import { VBaseElement } from '../vnodes';
-export declare function applyStaticClassAttribute(vnode: VBaseElement): void;
+export declare function applyStaticClassAttribute(vnode: VBaseElement, renderer: RendererAPI): void;

package/types/framework/modules/static-style-attr.d.ts

@@ -1,2 +1,3 @@
+import { RendererAPI } from '../renderer';
 import { VBaseElement } from '../vnodes';
-export declare function applyStaticStyleAttribute(vnode: VBaseElement): void;
+export declare function applyStaticStyleAttribute(vnode: VBaseElement, renderer: RendererAPI): void;

package/types/framework/renderer.d.ts

@@ -0,0 +1,46 @@
+export declare type HostNode = any;
+export declare type HostElement = any;
+declare type N = HostNode;
+declare type E = HostElement;
+export interface RendererAPI {
+    ssr: boolean;
+    isNativeShadowDefined: boolean;
+    isSyntheticShadowDefined: boolean;
+    HTMLElementExported: typeof HTMLElement;
+    isHydrating: () => boolean;
+    insert: (node: N, parent: E, anchor: N | null) => void;
+    remove: (node: N, parent: E) => void;
+    createElement: (tagName: string, namespace?: string) => E;
+    createText: (content: string) => N;
+    createComment: (content: string) => N;
+    nextSibling: (node: N) => N | null;
+    attachShadow: (element: E, options: ShadowRootInit) => N;
+    getProperty: (node: N, key: string) => any;
+    setProperty: (node: N, key: string, value: any) => void;
+    setText: (node: N, content: string) => void;
+    getAttribute: (element: E, name: string, namespace?: string | null) => string | null;
+    setAttribute: (element: E, name: string, value: string, namespace?: string | null) => void;
+    removeAttribute: (element: E, name: string, namespace?: string | null) => void;
+    addEventListener: (target: N, type: string, callback: (event: Event) => any, options?: AddEventListenerOptions | boolean) => void;
+    removeEventListener: (target: N, type: string, callback: (event: Event) => any, options?: EventListenerOptions | boolean) => void;
+    dispatchEvent: (target: N, event: Event) => boolean;
+    getClassList: (element: E) => DOMTokenList;
+    setCSSStyleProperty: (element: E, name: string, value: string, important: boolean) => void;
+    getBoundingClientRect: (element: E) => ClientRect;
+    querySelector: (element: E, selectors: string) => E | null;
+    querySelectorAll: (element: E, selectors: string) => NodeList;
+    getElementsByTagName: (element: E, tagNameOrWildCard: string) => HTMLCollection;
+    getElementsByClassName: (element: E, names: string) => HTMLCollection;
+    getChildren: (element: E) => HTMLCollection;
+    getChildNodes: (element: E) => NodeList;
+    getFirstChild: (element: E) => N | null;
+    getFirstElementChild: (element: E) => E | null;
+    getLastChild: (element: E) => N | null;
+    getLastElementChild: (element: E) => E | null;
+    isConnected: (node: N) => boolean;
+    insertStylesheet: (content: string, target?: ShadowRoot) => void;
+    assertInstanceOfHTMLElement: (elm: any, msg: string) => void;
+    defineCustomElement: (name: string, constructor: CustomElementConstructor, options?: ElementDefinitionOptions) => void;
+    getCustomElement: (name: string) => CustomElementConstructor | undefined;
+}
+export {};

package/types/framework/rendering.d.ts

@@ -1,7 +1,8 @@
+import { RendererAPI } from './renderer';
 import { VM } from './vm';
 import { VNode, VNodes, VCustomElement } from './vnodes';
-export declare function patchChildren(c1: VNodes, c2: VNodes, parent: ParentNode): void;
-export declare function mount(node: VNode, parent: ParentNode, anchor: Node | null): void;
-export declare function removeNode(node: Node, parent: ParentNode): void;
+export declare function patchChildren(c1: VNodes, c2: VNodes, parent: ParentNode, renderer: RendererAPI): void;
+export declare function mount(node: VNode, parent: ParentNode, renderer: RendererAPI, anchor: Node | null): void;
+export declare function removeNode(node: Node, parent: ParentNode, renderer: RendererAPI): void;
 export declare function allocateChildren(vnode: VCustomElement, vm: VM): void;
 export declare function markAsDynamicChildren(children: VNodes): void;

package/types/framework/upgradable-element.d.ts

@@ -1,6 +1,7 @@
+import type { RendererAPI } from './renderer';
 declare type UpgradeCallback = (elm: HTMLElement) => void;
 interface UpgradableCustomElementConstructor extends CustomElementConstructor {
     new (upgradeCallback?: UpgradeCallback): HTMLElement;
 }
-export declare function getUpgradableConstructor(tagName: string): CustomElementConstructor | UpgradableCustomElementConstructor;
+export declare function getUpgradableConstructor(tagName: string, renderer: RendererAPI): CustomElementConstructor | UpgradableCustomElementConstructor;
 export {};

package/types/framework/vm.d.ts

@@ -1,10 +1,10 @@
+import { HostNode, HostElement, RendererAPI } from './renderer';
 import { Template } from './template';
 import { ComponentDef } from './def';
 import { LightningElement, LightningElementConstructor } from './base-lightning-element';
 import { ReactiveObserver } from './mutation-tracker';
 import { AccessorReactiveObserver } from './decorators/api';
 import { VNodes, VCustomElement, VNode } from './vnodes';
-import type { HostNode, HostElement } from '../renderer';
 declare type ShadowRootMode = 'open' | 'closed';
 export interface TemplateCache {
     [key: string]: any;
@@ -121,6 +121,9 @@ export interface VM<N = HostNode, E = HostElement> {
     /** 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: RendererAPI;
 }
 declare type VMAssociable = HostNode | LightningElement;
 export declare function rerenderVM(vm: VM): void;
@@ -128,7 +131,7 @@ export declare function connectRootElement(elm: any): void;
 export declare function disconnectRootElement(elm: any): void;
 export declare function appendVM(vm: VM): void;
 export declare function removeVM(vm: VM): void;
-export declare function createVM<HostNode, HostElement>(elm: HostElement, ctor: LightningElementConstructor, options: {
+export declare function createVM<HostNode, HostElement>(elm: HostElement, ctor: LightningElementConstructor, renderer: RendererAPI, options: {
     mode: ShadowRootMode;
     owner: VM<HostNode, HostElement> | null;
     tagName: string;

package/types/framework/vnodes.d.ts

@@ -1,4 +1,5 @@
-import { VM } from './vm';
+import type { VM } from './vm';
+import type { RendererAPI } from './renderer';
 export declare type Key = string | number;
 export declare const enum VNodeType {
     Text = 0,
@@ -55,6 +56,7 @@ export interface VNodeData {
     readonly context?: Readonly<Record<string, Readonly<Record<string, any>>>>;
     readonly on?: Readonly<Record<string, (event: Event) => any>>;
     readonly svg?: boolean;
+    readonly renderer?: RendererAPI;
 }
 export interface VElementData extends VNodeData {
     readonly key: Key;

package/types/renderer.d.ts

@@ -1,119 +0,0 @@
-export declare type HostNode = any;
-export declare type HostElement = any;
-declare type N = HostNode;
-declare type E = HostElement;
-export declare let ssr: boolean;
-export declare function setSsr(ssrImpl: boolean): void;
-export declare let isNativeShadowDefined: boolean;
-export declare function setIsNativeShadowDefined(isNativeShadowDefinedImpl: boolean): void;
-export declare let isSyntheticShadowDefined: boolean;
-export declare function setIsSyntheticShadowDefined(isSyntheticShadowDefinedImpl: boolean): void;
-declare type HTMLElementType = typeof HTMLElement;
-declare let HTMLElementExported: HTMLElementType;
-export { HTMLElementExported as HTMLElement };
-export declare function setHTMLElement(HTMLElementImpl: HTMLElementType): void;
-declare type isHydratingFunc = () => boolean;
-export declare let isHydrating: isHydratingFunc;
-export declare function setIsHydrating(isHydratingImpl: isHydratingFunc): void;
-declare type insertFunc = (node: N, parent: E, anchor: N | null) => void;
-export declare let insert: insertFunc;
-export declare function setInsert(insertImpl: insertFunc): void;
-declare type removeFunc = (node: N, parent: E) => void;
-export declare let remove: removeFunc;
-export declare function setRemove(removeImpl: removeFunc): void;
-declare type createElementFunc = (tagName: string, namespace?: string) => E;
-export declare let createElement: createElementFunc;
-export declare function setCreateElement(createElementImpl: createElementFunc): void;
-declare type createTextFunc = (content: string) => N;
-export declare let createText: createTextFunc;
-export declare function setCreateText(createTextImpl: createTextFunc): void;
-declare type createCommentFunc = (content: string) => N;
-export declare let createComment: createCommentFunc;
-export declare function setCreateComment(createCommentImpl: createCommentFunc): void;
-declare type nextSiblingFunc = (node: N) => N | null;
-export declare let nextSibling: nextSiblingFunc;
-export declare function setNextSibling(nextSiblingImpl: nextSiblingFunc): void;
-declare type attachShadowFunc = (element: E, options: ShadowRootInit) => N;
-export declare let attachShadow: attachShadowFunc;
-export declare function setAttachShadow(attachShadowImpl: attachShadowFunc): void;
-declare type getPropertyFunc = (node: N, key: string) => any;
-export declare let getProperty: getPropertyFunc;
-export declare function setGetProperty(getPropertyImpl: getPropertyFunc): void;
-declare type setPropertyFunc = (node: N, key: string, value: any) => void;
-export declare let setProperty: setPropertyFunc;
-export declare function setSetProperty(setPropertyImpl: setPropertyFunc): void;
-declare type setTextFunc = (node: N, content: string) => void;
-export declare let setText: setTextFunc;
-export declare function setSetText(setTextImpl: setTextFunc): void;
-declare type getAttributeFunc = (element: E, name: string, namespace?: string | null) => string | null;
-export declare let getAttribute: getAttributeFunc;
-export declare function setGetAttribute(getAttributeImpl: getAttributeFunc): void;
-declare type setAttributeFunc = (element: E, name: string, value: string, namespace?: string | null) => void;
-export declare let setAttribute: setAttributeFunc;
-export declare function setSetAttribute(setAttributeImpl: setAttributeFunc): void;
-declare type removeAttributeFunc = (element: E, name: string, namespace?: string | null) => void;
-export declare let removeAttribute: removeAttributeFunc;
-export declare function setRemoveAttribute(removeAttributeImpl: removeAttributeFunc): void;
-declare type addEventListenerFunc = (target: N, type: string, callback: (event: Event) => any, options?: AddEventListenerOptions | boolean) => void;
-export declare let addEventListener: addEventListenerFunc;
-export declare function setAddEventListener(addEventListenerImpl: addEventListenerFunc): void;
-declare type removeEventListenerFunc = (target: N, type: string, callback: (event: Event) => any, options?: EventListenerOptions | boolean) => void;
-export declare let removeEventListener: removeEventListenerFunc;
-export declare function setRemoveEventListener(removeEventListenerImpl: removeEventListenerFunc): void;
-declare type dispatchEventFunc = (target: N, event: Event) => boolean;
-export declare let dispatchEvent: dispatchEventFunc;
-export declare function setDispatchEvent(dispatchEventImpl: dispatchEventFunc): void;
-declare type getClassListFunc = (element: E) => DOMTokenList;
-export declare let getClassList: getClassListFunc;
-export declare function setGetClassList(getClassListImpl: getClassListFunc): void;
-declare type setCSSStylePropertyFunc = (element: E, name: string, value: string, important: boolean) => void;
-export declare let setCSSStyleProperty: setCSSStylePropertyFunc;
-export declare function setSetCSSStyleProperty(setCSSStylePropertyImpl: setCSSStylePropertyFunc): void;
-declare type getBoundingClientRectFunc = (element: E) => ClientRect;
-export declare let getBoundingClientRect: getBoundingClientRectFunc;
-export declare function setGetBoundingClientRect(getBoundingClientRectImpl: getBoundingClientRectFunc): void;
-declare type querySelectorFunc = (element: E, selectors: string) => E | null;
-export declare let querySelector: querySelectorFunc;
-export declare function setQuerySelector(querySelectorImpl: querySelectorFunc): void;
-declare type querySelectorAllFunc = (element: E, selectors: string) => NodeList;
-export declare let querySelectorAll: querySelectorAllFunc;
-export declare function setQuerySelectorAll(querySelectorAllImpl: querySelectorAllFunc): void;
-declare type getElementsByTagNameFunc = (element: E, tagNameOrWildCard: string) => HTMLCollection;
-export declare let getElementsByTagName: getElementsByTagNameFunc;
-export declare function setGetElementsByTagName(getElementsByTagNameImpl: getElementsByTagNameFunc): void;
-declare type getElementsByClassNameFunc = (element: E, names: string) => HTMLCollection;
-export declare let getElementsByClassName: getElementsByClassNameFunc;
-export declare function setGetElementsByClassName(getElementsByClassNameImpl: getElementsByClassNameFunc): void;
-declare type getChildrenFunc = (element: E) => HTMLCollection;
-export declare let getChildren: getChildrenFunc;
-export declare function setGetChildren(getChildrenImpl: getChildrenFunc): void;
-declare type getChildNodesFunc = (element: E) => NodeList;
-export declare let getChildNodes: getChildNodesFunc;
-export declare function setGetChildNodes(getChildNodesImpl: getChildNodesFunc): void;
-declare type getFirstChildFunc = (element: E) => N | null;
-export declare let getFirstChild: getFirstChildFunc;
-export declare function setGetFirstChild(getFirstChildImpl: getFirstChildFunc): void;
-declare type getFirstElementChildFunc = (element: E) => E | null;
-export declare let getFirstElementChild: getFirstElementChildFunc;
-export declare function setGetFirstElementChild(getFirstElementChildImpl: getFirstElementChildFunc): void;
-declare type getLastChildFunc = (element: E) => N | null;
-export declare let getLastChild: getLastChildFunc;
-export declare function setGetLastChild(getLastChildImpl: getLastChildFunc): void;
-declare type getLastElementChildFunc = (element: E) => E | null;
-export declare let getLastElementChild: getLastElementChildFunc;
-export declare function setGetLastElementChild(getLastElementChildImpl: getLastElementChildFunc): void;
-declare type isConnectedFunc = (node: N) => boolean;
-export declare let isConnected: isConnectedFunc;
-export declare function setIsConnected(isConnectedImpl: isConnectedFunc): void;
-declare type insertStylesheetFunc = (content: string, target?: ShadowRoot) => void;
-export declare let insertStylesheet: insertStylesheetFunc;
-export declare function setInsertStylesheet(insertStylesheetImpl: insertStylesheetFunc): void;
-declare type assertInstanceOfHTMLElementFunc = (elm: any, msg: string) => void;
-export declare let assertInstanceOfHTMLElement: assertInstanceOfHTMLElementFunc;
-export declare function setAssertInstanceOfHTMLElement(assertInstanceOfHTMLElementImpl: assertInstanceOfHTMLElementFunc): void;
-declare type defineCustomElementFunc = (name: string, constructor: CustomElementConstructor, options?: ElementDefinitionOptions) => void;
-export declare let defineCustomElement: defineCustomElementFunc;
-export declare function setDefineCustomElement(defineCustomElementImpl: defineCustomElementFunc): void;
-declare type getCustomElementFunc = (name: string) => CustomElementConstructor | undefined;
-export declare let getCustomElement: getCustomElementFunc;
-export declare function setGetCustomElement(getCustomElementImpl: getCustomElementFunc): void;