@lwc/engine-core 7.3.0-alpha.0 → 7.3.0-alpha.2

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

@@ -1,8 +1,9 @@
+import { LightningElement } from '../base-lightning-element';
 /**
  * The `@api` decorator marks public fields and public methods in
  * LWC Components. This function implements the internals of this
  * decorator.
  */
-export default function api(value: unknown, context: ClassMemberDecoratorContext | string | symbol): void;
+export default function api<Class extends LightningElement>(value: unknown, context: ClassFieldDecoratorContext<Class, unknown> | ClassMethodDecoratorContext<Class, (this: Class, ...args: any) => any> | ClassGetterDecoratorContext<Class, unknown> | ClassSetterDecoratorContext<Class, unknown>): void;
 export declare function createPublicPropertyDescriptor(key: string): PropertyDescriptor;
 export declare function createPublicAccessorDescriptor(key: PropertyKey, descriptor: PropertyDescriptor): PropertyDescriptor;

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

@@ -1,7 +1,9 @@
+import { LightningElement } from '../base-lightning-element';
 /**
  * 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.
  */
-export default function track(value: unknown, context: ClassMemberDecoratorContext | string | symbol): void;
+export default function track<Class extends LightningElement>(target: undefined, context: ClassFieldDecoratorContext<Class>): void;
+export default function track<T>(target: T, context?: never): T;
 export declare function internalTrackDecorator(key: string): PropertyDescriptor;

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

@@ -1,4 +1,5 @@
-import type { ConfigValue, ContextValue, ReplaceReactiveValues, WireAdapterConstructor, WireDecorator } from '../wiring';
+import type { LightningElement } from '../base-lightning-element';
+import type { ConfigValue, ContextValue, DataCallback, ReplaceReactiveValues, WireAdapterConstructor } from '../wiring';
 /**
  * Decorator factory to wire a property or method to a wire adapter data source.
  * @param adapter the adapter used to provision data
@@ -10,5 +11,5 @@ import type { ConfigValue, ContextValue, ReplaceReactiveValues, WireAdapterConst
  *   \@wire(getBook, { id: '$bookId'}) book;
  * }
  */
-export default function wire<ReactiveConfig extends ConfigValue = ConfigValue, Value = any, Context extends ContextValue = ContextValue>(adapter: WireAdapterConstructor<ReplaceReactiveValues<ReactiveConfig>, Value, Context>, config?: ReactiveConfig): WireDecorator<Value>;
+export default function wire<ReactiveConfig extends ConfigValue = ConfigValue, Value = any, Context extends ContextValue = ContextValue, Class extends LightningElement = LightningElement>(adapter: WireAdapterConstructor<ReplaceReactiveValues<ReactiveConfig, Class>, Value, Context>, config?: ReactiveConfig): (target: unknown, context: ClassFieldDecoratorContext<Class, Value | undefined> | ClassMethodDecoratorContext<Class, DataCallback<Value>>) => void;
 export declare function internalWireFieldDecorator(key: string): PropertyDescriptor;

package/dist/framework/stylesheet.d.ts

@@ -12,7 +12,7 @@ export type Stylesheet = (stylesheetToken: string | undefined, useActualHostSele
  */
 export type Stylesheets = Array<Stylesheet | Stylesheets>;
 export declare function updateStylesheetToken(vm: VM, template: Template, legacy: boolean): void;
-export declare function getStylesheetsContent(vm: VM, template: Template): string[];
+export declare function getStylesheetsContent(vm: VM, template: Template): ReadonlyArray<string>;
 /**
  * If the component that is currently being rendered uses scoped styles,
  * this returns the unique token for that scoped stylesheet. Otherwise
@@ -29,5 +29,5 @@ export declare function getScopeTokenClass(owner: VM, legacy: boolean): string |
  * @param vnode
  */
 export declare function getStylesheetTokenHost(vnode: VCustomElement): string | null;
-export declare function createStylesheet(vm: VM, stylesheets: string[]): VNode[] | null;
+export declare function createStylesheet(vm: VM, stylesheets: ReadonlyArray<string>): VNode[] | null;
 export declare function unrenderStylesheet(stylesheet: Stylesheet): void;

package/dist/framework/wiring/index.d.ts

@@ -1,3 +1,3 @@
 export { createContextProviderWithRegister, createContextWatcher } from './context';
-export { ConfigCallback, ConfigValue, ContextConsumer, ContextProvider, ContextValue, DataCallback, ReplaceReactiveValues, WireAdapter, WireAdapterConstructor, WireAdapterSchemaValue, WireContextSubscriptionPayload, WireContextSubscriptionCallback, WireDecorator, } from './types';
+export { ConfigCallback, ConfigValue, ContextConsumer, ContextProvider, ContextValue, DataCallback, ReplaceReactiveValues, WireAdapter, WireAdapterConstructor, WireAdapterSchemaValue, WireContextSubscriptionPayload, WireContextSubscriptionCallback, } from './types';
 export { connectWireAdapters, disconnectWireAdapters, installWireAdapters, storeWiredFieldMeta, storeWiredMethodMeta, } from './wiring';

package/dist/framework/wiring/types.d.ts

@@ -16,26 +16,6 @@ export interface WireAdapterConstructor<Config extends ConfigValue = ConfigValue
     configSchema?: Record<keyof Config, WireAdapterSchemaValue>;
     contextSchema?: Record<keyof Context, WireAdapterSchemaValue>;
 }
-/**
- * The decorator returned by `@wire()`; not the `wire` factory function.
- *
- * If you're using `@wire(adapter) property` and getting an opaque type error, ensure that the
- * property is explicitly typed and the type matches the value used by the adapter. Note that one
- * of the following conditions must always be true:
- * - The adapter uses `undefined` as a possible value
- * - The property is marked as optional
- * - The property is assigned a default value (not provided by the adapter)
- */
-export interface WireDecorator<Value = any> {
-    /** Property decorator for `"experimentalDecorators": false`. */
-    <Class extends LightningElement>(target: undefined, ctx: ClassFieldDecoratorContext<Class, Value>): void;
-    /** Method decorator for `"experimentalDecorators": false`. */
-    <Class extends LightningElement>(target: DataCallback<Value>, ctx: ClassMethodDecoratorContext<Class, DataCallback<Value>>): void | DataCallback<Value>;
-    /** Property decorator for `"experimentalDecorators": true`. */
-    <K extends string | symbol>(target: Record<K, Value>, propertyKey: K): void;
-    /** Method decorator for `"experimentalDecorators": true`. */
-    <K extends string | symbol>(target: Record<K, DataCallback<Value>>, propertyKey: K, descriptor: TypedPropertyDescriptor<DataCallback<Value>>): void;
-}
 export interface WireDef {
     method?: (data: any) => void;
     adapter: WireAdapterConstructor;
@@ -69,11 +49,14 @@ export interface ContextProviderOptions {
 }
 export type ContextProvider = (elmOrComponent: EventTarget, options: ContextProviderOptions) => void;
 export type RegisterContextProviderFn = (element: HostElement, adapterContextToken: string, onContextSubscription: WireContextSubscriptionCallback) => void;
+/** Resolves a property chain to the corresponding value on the target type. */
+type ResolveReactiveValue<Target, Keys> = Keys extends keyof Target ? Target[Keys] : Keys extends `${infer K}.${infer Rest}` ? K extends keyof Target ? ResolveReactiveValue<Target[K], Rest> : undefined : undefined;
 /**
- * String values starting with "$" are reactive; they get replaced by values from the component.
- * We don't have access to the component, and we don't expect all reactive strings to be typed as
- * literals, so we just replace all strings with `any`.
+ * Detects if the `Value` type is a property chain starting with "$". If so, it resolves the
+ * properties to the corresponding value on the target type.
  */
-export type ReplaceReactiveValues<T> = {
-    [K in keyof T]: T[K] extends string ? any : T[K];
+type ResolveValueIfReactive<Value, Target> = Value extends string ? string extends Value ? any : Value extends `$${infer Keys}` ? ResolveReactiveValue<Target, Keys> : Value : Value;
+export type ReplaceReactiveValues<Config extends ConfigValue, Component extends LightningElement> = {
+    [K in keyof Config]: ResolveValueIfReactive<Config[K], Component>;
 };
+export {};

package/dist/index.cjs.js

@@ -2378,8 +2378,8 @@ function createPublicAccessorDescriptor(key, descriptor) {
  * SPDX-License-Identifier: MIT
  * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
  */
-function track(target) {
-    if (arguments.length === 1) {
+function track(target, context) {
+    if (shared.isUndefined(context)) {
         return getReactiveProxy(target);
     }
     if (process.env.NODE_ENV !== 'production') {
@@ -3133,15 +3133,22 @@ function evaluateStylesheetsContent(stylesheets, stylesheetToken, vm) {
 function getStylesheetsContent(vm, template) {
     const { stylesheets, stylesheetToken } = template;
     const { stylesheets: vmStylesheets } = vm;
-    let content = [];
-    if (hasStyles(stylesheets)) {
-        content = evaluateStylesheetsContent(stylesheets, stylesheetToken, vm);
+    const hasTemplateStyles = hasStyles(stylesheets);
+    const hasVmStyles = hasStyles(vmStylesheets);
+    if (hasTemplateStyles) {
+        const content = evaluateStylesheetsContent(stylesheets, stylesheetToken, vm);
+        if (hasVmStyles) {
+            // Slow path – merge the template styles and vm styles
+            shared.ArrayPush.apply(content, evaluateStylesheetsContent(vmStylesheets, stylesheetToken, vm));
+        }
+        return content;
     }
-    // VM (component) stylesheets apply after template stylesheets
-    if (hasStyles(vmStylesheets)) {
-        shared.ArrayPush.apply(content, evaluateStylesheetsContent(vmStylesheets, stylesheetToken, vm));
+    if (hasVmStyles) {
+        // No template styles, so return vm styles directly
+        return evaluateStylesheetsContent(vmStylesheets, stylesheetToken, vm);
     }
-    return content;
+    // Fastest path - no styles, so return an empty array
+    return EmptyArray;
 }
 // It might be worth caching this to avoid doing the lookup repeatedly, but
 // perf testing has not shown it to be a huge improvement yet:
@@ -6544,6 +6551,8 @@ function computeShadowMode(def, owner, renderer, hydrated) {
     // on, but components running in actual native shadow mode
     (process.env.NODE_ENV === 'test-karma-lwc' &&
         process.env.FORCE_NATIVE_SHADOW_MODE_FOR_TEST) ||
+        // If synthetic shadow is explicitly disabled, use pure-native
+        lwcRuntimeFlags.DISABLE_SYNTHETIC_SHADOW ||
         // hydration only supports native shadow
         shared.isTrue(hydrated)) {
         return 0 /* ShadowMode.Native */;
@@ -8083,5 +8092,5 @@ exports.swapTemplate = swapTemplate;
 exports.track = track;
 exports.unwrap = unwrap;
 exports.wire = wire;
-/** version: 7.2.0 */
+/** version: 7.3.0-alpha.2 */
 //# sourceMappingURL=index.cjs.js.map