@lwc/engine-core 2.7.1 → 2.7.2

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@lwc/engine-core",
-    "version": "2.7.1",
+    "version": "2.7.2",
     "description": "Core LWC engine APIs.",
     "homepage": "https://lwc.dev/",
     "repository": {
@@ -24,8 +24,8 @@
         "types/"
     ],
     "dependencies": {
-        "@lwc/features": "2.7.1",
-        "@lwc/shared": "2.7.1"
+        "@lwc/features": "2.7.2",
+        "@lwc/shared": "2.7.2"
     },
     "devDependencies": {
         "observable-membrane": "2.0.0"
@@ -33,5 +33,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "1b2e246e03c6bfbc80bea3def43b7d0281a1de21"
+    "gitHead": "f668a3ad36bbebbaa33a5863408a45bf4185d218"
 }

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

@@ -0,0 +1,2 @@
+export declare const HTMLElementConstructor: typeof HTMLElement;
+export declare const HTMLElementPrototype: HTMLElement;

package/types/framework/main.d.ts

@@ -18,5 +18,5 @@ export { profilerControl as __unstable__ProfilerControl } from './profiler';
 export { getUpgradableConstructor } from './upgradable-element';
 export { swapTemplate, swapComponent, swapStyle } from './hot-swaps';
 export { setHooks } from './overridable-hooks';
-export type { Renderer } from './renderer';
 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, setInsertGlobalStylesheet, setInsertStylesheet, setIsConnected, setIsHydrating, setIsNativeShadowDefined, setIsSyntheticShadowDefined, setNextSibling, setQuerySelector, setQuerySelectorAll, setRemove, setRemoveAttribute, setRemoveEventListener, setSetAttribute, setSetCSSStyleProperty, setSetProperty, setSetText, setSsr, setAddEventListener, } from '../renderer';

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

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

package/types/framework/vm.d.ts

@@ -1,9 +1,9 @@
+import type { HostNode, HostElement } from '../renderer';
 import { Template } from './template';
 import { ComponentDef } from './def';
 import { LightningElement } from './base-lightning-element';
 import { ReactiveObserver } from './mutation-tracker';
 import { AccessorReactiveObserver } from './decorators/api';
-import { Renderer, HostNode, HostElement } from './renderer';
 import { VNodes, VCustomElement, VNode } from '../3rdparty/snabbdom/types';
 declare type ShadowRootMode = 'open' | 'closed';
 export interface TemplateCache {
@@ -60,7 +60,6 @@ export interface VM<N = HostNode, E = HostElement> {
     /** The owner VM or null for root elements. */
     readonly owner: VM<N, E> | null;
     /** Rendering operations associated with the VM */
-    readonly renderer: Renderer<N, E>;
     renderMode: RenderMode;
     shadowMode: ShadowMode;
     /** The component creation index. */
@@ -127,7 +126,6 @@ export declare function createVM<HostNode, HostElement>(elm: HostElement, def: C
     mode: ShadowRootMode;
     owner: VM<HostNode, HostElement> | null;
     tagName: string;
-    renderer: Renderer;
 }): VM;
 export declare function associateVM(obj: VMAssociable, vm: VM): void;
 export declare function getAssociatedVM(obj: VMAssociable): VM;

package/types/renderer.d.ts

@@ -0,0 +1,122 @@
+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 insertGlobalStylesheetFunc = (content: string) => void;
+export declare let insertGlobalStylesheet: insertGlobalStylesheetFunc;
+export declare function setInsertGlobalStylesheet(insertGlobalStylesheetImpl: insertGlobalStylesheetFunc): void;
+declare type insertStylesheetFunc = (content: string, target: N) => 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;

package/types/framework/renderer.d.ts

@@ -1,46 +0,0 @@
-export declare type HostNode = any;
-export declare type HostElement = any;
-export interface Renderer<N = HostNode, E = HostElement> {
-    ssr: boolean;
-    isHydrating(): boolean;
-    isNativeShadowDefined: boolean;
-    isSyntheticShadowDefined: 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: E, type: string, callback: (event: Event) => any, options?: AddEventListenerOptions | boolean): void;
-    removeEventListener(target: E, 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;
-    insertGlobalStylesheet(content: string): void;
-    insertStylesheet(content: string, target: N): void;
-    assertInstanceOfHTMLElement?(elm: any, msg: string): void;
-    defineCustomElement(name: string, constructor: CustomElementConstructor, options?: ElementDefinitionOptions): void;
-    getCustomElement(name: string): CustomElementConstructor | undefined;
-    HTMLElement: typeof HTMLElement;
-}
-export declare const HTMLElementConstructor: typeof HTMLElement;
-export declare const HTMLElementPrototype: HTMLElement;