@umbraco-cms/backoffice 17.0.2 → 17.1.0

package/dist-cms/external/dompurify/package.json

@@ -6,6 +6,6 @@
         "build": "vite build"
     },
     "dependencies": {
-        "dompurify": "^3.2.7"
+        "dompurify": "^3.3.0"
     }
 }

package/dist-cms/external/lit/index.d.ts

@@ -1,12 +1,24 @@
 export * from 'lit';
 export * from 'lit/decorators.js';
 export { directive, AsyncDirective, type PartInfo } from 'lit/async-directive.js';
+export * from 'lit/directives/async-append.js';
+export * from 'lit/directives/async-replace.js';
+export * from 'lit/directives/cache.js';
+export * from 'lit/directives/choose.js';
 export * from 'lit/directives/class-map.js';
+export * from 'lit/directives/guard.js';
 export * from 'lit/directives/if-defined.js';
+export * from 'lit/directives/join.js';
+export * from 'lit/directives/keyed.js';
+export * from 'lit/directives/live.js';
 export * from 'lit/directives/map.js';
+export * from 'lit/directives/range.js';
 export * from 'lit/directives/ref.js';
 export * from 'lit/directives/repeat.js';
 export * from 'lit/directives/style-map.js';
+export * from 'lit/directives/template-content.js';
 export * from 'lit/directives/unsafe-html.js';
+export * from 'lit/directives/unsafe-mathml.js';
+export * from 'lit/directives/unsafe-svg.js';
 export * from 'lit/directives/until.js';
 export * from 'lit/directives/when.js';

package/dist-cms/external/lit/index.js

@@ -1,12 +1,24 @@
 export * from 'lit';
 export * from 'lit/decorators.js';
 export { directive, AsyncDirective } from 'lit/async-directive.js';
+export * from 'lit/directives/async-append.js';
+export * from 'lit/directives/async-replace.js';
+export * from 'lit/directives/cache.js';
+export * from 'lit/directives/choose.js';
 export * from 'lit/directives/class-map.js';
+export * from 'lit/directives/guard.js';
 export * from 'lit/directives/if-defined.js';
+export * from 'lit/directives/join.js';
+export * from 'lit/directives/keyed.js';
+export * from 'lit/directives/live.js';
 export * from 'lit/directives/map.js';
+export * from 'lit/directives/range.js';
 export * from 'lit/directives/ref.js';
 export * from 'lit/directives/repeat.js';
 export * from 'lit/directives/style-map.js';
+export * from 'lit/directives/template-content.js';
 export * from 'lit/directives/unsafe-html.js';
+export * from 'lit/directives/unsafe-mathml.js';
+export * from 'lit/directives/unsafe-svg.js';
 export * from 'lit/directives/until.js';
 export * from 'lit/directives/when.js';

package/dist-cms/external/monaco-editor/package.json

@@ -6,6 +6,6 @@
         "build": "vite build"
     },
     "dependencies": {
-        "monaco-editor": "^0.54.0"
+        "monaco-editor": "^0.55.1"
     }
 }

package/dist-cms/libs/context-api/consume/context-consume.decorator.d.ts

@@ -0,0 +1,85 @@
+import type { UmbContextToken } from '../token/index.js';
+import type { UmbContextMinimal } from '../types.js';
+import type { UmbContextCallback } from './context-request.event.js';
+export interface UmbConsumeOptions<BaseType extends UmbContextMinimal = UmbContextMinimal, ResultType extends BaseType = BaseType> {
+    /**
+     * The context to consume, either as a string alias or an UmbContextToken.
+     */
+    context: string | UmbContextToken<BaseType, ResultType>;
+    /**
+     * An optional callback that is invoked when the context value is set or changes.
+     * Note, the class instance is probably not fully constructed when this is first invoked.
+     * If you need to ensure the class is fully constructed, consider using a setter on the property instead.
+     */
+    callback?: UmbContextCallback<ResultType>;
+    /**
+     * If true, the context consumer will stay active and invoke the callback on context changes.
+     * If false, the context consumer will use asPromise() to get the value once and then clean up.
+     * @default true
+     */
+    subscribe?: boolean;
+}
+/**
+ * A property decorator that adds an UmbContextConsumerController to the component
+ * which will try and retrieve a value for the property via the Umbraco Context API.
+ *
+ * This decorator supports both modern "standard" decorators (Stage 3 TC39 proposal) and
+ * legacy TypeScript experimental decorators for backward compatibility.
+ * @param {UmbConsumeOptions} options Configuration object containing context, callback, and subscribe options
+ * @example
+ * ```ts
+ * import {consumeContext} from '../index.js';
+ * import {UMB_WORKSPACE_CONTEXT} from './workspace.context-token.js';
+ *
+ * class MyElement extends UmbLitElement {
+ *   // Standard decorators (with 'accessor' keyword) - Modern approach
+ *   @consumeContext({context: UMB_WORKSPACE_CONTEXT})
+ *   accessor workspaceContext?: UmbWorkspaceContext;
+ *
+ *   // Legacy decorators (without 'accessor') - Works with @state/@property
+ *   @consumeContext({context: UMB_USER_CONTEXT, subscribe: false})
+ *   @state()
+ *   currentUser?: UmbUserContext;
+ * }
+ * ```
+ * @returns {ConsumeDecorator<ResultType>} A property decorator function
+ */
+export declare function consumeContext<BaseType extends UmbContextMinimal = UmbContextMinimal, ResultType extends BaseType = BaseType>(options: UmbConsumeOptions<BaseType, ResultType>): ConsumeDecorator<ResultType>;
+/**
+ * Generates a public interface type that removes private and protected fields.
+ * This allows accepting otherwise incompatible versions of the type (e.g. from
+ * multiple copies of the same package in `node_modules`).
+ */
+type Interface<T> = {
+    [K in keyof T]: T[K];
+};
+declare class ReactiveElement {
+    static addInitializer?: (initializer: (instance: any) => void) => void;
+}
+declare class ReactiveController {
+    hostConnected?: () => void;
+}
+/**
+ * A type representing the base class of which the decorator should work
+ * requiring either addInitializer (UmbLitElement) or hostConnected (UmbController).
+ */
+type ReactiveEntity = ReactiveElement | ReactiveController;
+type ConsumeDecorator<ValueType> = {
+    <K extends PropertyKey, Proto extends Interface<ReactiveEntity>>(protoOrDescriptor: Proto, name?: K): FieldMustMatchProvidedType<Proto, K, ValueType>;
+    <C extends Interface<ReactiveEntity>, V extends ValueType>(value: ClassAccessorDecoratorTarget<C, V>, context: ClassAccessorDecoratorContext<C, V>): void;
+};
+type DecoratorReturn = void | any;
+type FieldMustMatchProvidedType<Obj, Key extends PropertyKey, ProvidedType> = Obj extends Record<Key, infer ConsumingType> ? [
+    ProvidedType
+] extends [ConsumingType] ? DecoratorReturn : {
+    message: 'provided type not assignable to consuming field';
+    provided: ProvidedType;
+    consuming: ConsumingType;
+} : Obj extends Partial<Record<Key, infer ConsumingType>> ? [
+    ProvidedType
+] extends [ConsumingType | undefined] ? DecoratorReturn : {
+    message: 'provided type not assignable to consuming field';
+    provided: ProvidedType;
+    consuming: ConsumingType | undefined;
+} : DecoratorReturn;
+export {};

package/dist-cms/libs/context-api/consume/context-consume.decorator.js

@@ -0,0 +1,171 @@
+/*
+ * Portions of this code are adapted from @lit/context
+ * Copyright 2017 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Original source: https://github.com/lit/lit/tree/main/packages/context
+ *
+ * @license BSD-3-Clause
+ */
+import { UmbContextConsumerController } from './context-consumer.controller.js';
+/**
+ * A property decorator that adds an UmbContextConsumerController to the component
+ * which will try and retrieve a value for the property via the Umbraco Context API.
+ *
+ * This decorator supports both modern "standard" decorators (Stage 3 TC39 proposal) and
+ * legacy TypeScript experimental decorators for backward compatibility.
+ * @param {UmbConsumeOptions} options Configuration object containing context, callback, and subscribe options
+ * @example
+ * ```ts
+ * import {consumeContext} from '../index.js';
+ * import {UMB_WORKSPACE_CONTEXT} from './workspace.context-token.js';
+ *
+ * class MyElement extends UmbLitElement {
+ *   // Standard decorators (with 'accessor' keyword) - Modern approach
+ *   @consumeContext({context: UMB_WORKSPACE_CONTEXT})
+ *   accessor workspaceContext?: UmbWorkspaceContext;
+ *
+ *   // Legacy decorators (without 'accessor') - Works with @state/@property
+ *   @consumeContext({context: UMB_USER_CONTEXT, subscribe: false})
+ *   @state()
+ *   currentUser?: UmbUserContext;
+ * }
+ * ```
+ * @returns {ConsumeDecorator<ResultType>} A property decorator function
+ */
+export function consumeContext(options) {
+    const { context, callback, subscribe = true } = options;
+    return ((protoOrTarget, nameOrContext) => {
+        if (typeof nameOrContext === 'object') {
+            setupStandardDecorator(protoOrTarget, nameOrContext, context, callback, subscribe);
+            return;
+        }
+        setupLegacyDecorator(protoOrTarget, nameOrContext, context, callback, subscribe);
+    });
+}
+/**
+ * Sets up a standard decorator (Stage 3 TC39 proposal) for auto-accessors.
+ * This branch is used when decorating with the 'accessor' keyword.
+ * Example: @consumeContext({context: TOKEN}) accessor myProp?: Type;
+ *
+ * The decorator receives a ClassAccessorDecoratorContext object which provides
+ * addInitializer() to run code during class construction.
+ *
+ * This is the modern, standardized decorator API that will be the standard
+ * when Lit 4.x is released.
+ *
+ * Note: Standard decorators currently don't work with @state()/@property()
+ * decorators, which is why we still need the legacy branch.
+ * @param protoOrTarget
+ * @param decoratorContext
+ * @param context
+ * @param callback
+ * @param subscribe
+ */
+function setupStandardDecorator(protoOrTarget, decoratorContext, context, callback, subscribe) {
+    if (!('addInitializer' in decoratorContext)) {
+        console.warn('@consumeContext decorator: Standard decorator context does not support addInitializer. ' +
+            'This should not happen with modern decorators.');
+        return;
+    }
+    decoratorContext.addInitializer(function () {
+        queueMicrotask(() => {
+            if (subscribe) {
+                // Continuous subscription - stays active and updates property on context changes
+                new UmbContextConsumerController(this, context, (value) => {
+                    protoOrTarget.set.call(this, value);
+                    callback?.(value);
+                });
+            }
+            else {
+                // One-time consumption - uses asPromise() to get the value once and then cleans up
+                const controller = new UmbContextConsumerController(this, context, callback);
+                controller.asPromise().then((value) => {
+                    protoOrTarget.set.call(this, value);
+                });
+            }
+        });
+    });
+}
+/**
+ * Sets up a legacy decorator (TypeScript experimental) for regular properties.
+ * This branch is used when decorating without the 'accessor' keyword.
+ * Example: @consumeContext({context: TOKEN}) @state() myProp?: Type;
+ *
+ * The decorator receives:
+ * - protoOrTarget: The class prototype
+ * - propertyKey: The property name (string)
+ *
+ * This is the older TypeScript experimental decorator API, still widely used
+ * in Umbraco because it works with @state() and @property() decorators.
+ * The 'accessor' keyword is not compatible with these decorators yet.
+ *
+ * We support three initialization strategies:
+ * 1. addInitializer (if available, e.g., on LitElement classes)
+ * 2. hostConnected wrapper (for UmbController classes)
+ * 3. Warning (if neither is available)
+ * @param protoOrTarget
+ * @param propertyKey
+ * @param context
+ * @param callback
+ * @param subscribe
+ */
+function setupLegacyDecorator(protoOrTarget, propertyKey, context, callback, subscribe) {
+    const constructor = protoOrTarget.constructor;
+    // Strategy 1: Use addInitializer if available (LitElement classes)
+    if (constructor.addInitializer) {
+        constructor.addInitializer((element) => {
+            queueMicrotask(() => {
+                if (subscribe) {
+                    // Continuous subscription
+                    new UmbContextConsumerController(element, context, (value) => {
+                        element[propertyKey] = value;
+                        callback?.(value);
+                    });
+                }
+                else {
+                    // One-time consumption using asPromise()
+                    const controller = new UmbContextConsumerController(element, context, callback);
+                    controller.asPromise().then((value) => {
+                        element[propertyKey] = value;
+                    });
+                }
+            });
+        });
+        return;
+    }
+    // Strategy 2: Wrap hostConnected for UmbController classes without addInitializer
+    if ('hostConnected' in protoOrTarget && typeof protoOrTarget.hostConnected === 'function') {
+        const originalHostConnected = protoOrTarget.hostConnected;
+        protoOrTarget.hostConnected = function () {
+            // Set up consumer once, using a flag to prevent multiple setups
+            if (!this.__consumeControllers) {
+                this.__consumeControllers = new Map();
+            }
+            if (!this.__consumeControllers.has(propertyKey)) {
+                if (subscribe) {
+                    // Continuous subscription
+                    const controller = new UmbContextConsumerController(this, context, (value) => {
+                        this[propertyKey] = value;
+                        callback?.(value);
+                    });
+                    this.__consumeControllers.set(propertyKey, controller);
+                }
+                else {
+                    // One-time consumption using asPromise()
+                    const controller = new UmbContextConsumerController(this, context, callback);
+                    controller.asPromise().then((value) => {
+                        this[propertyKey] = value;
+                    });
+                    // Don't store in map since it cleans itself up
+                }
+            }
+            // Call original hostConnected if it exists
+            originalHostConnected?.call(this);
+        };
+        return;
+    }
+    // Strategy 3: No supported initialization method available
+    console.warn(`@consumeContext applied to ${constructor.name}.${propertyKey} but neither addInitializer nor hostConnected is available. ` +
+        `Make sure the class extends UmbLitElement, UmbControllerBase, or implements UmbController with hostConnected.`);
+}

package/dist-cms/libs/context-api/consume/context-consumer.js

@@ -169,8 +169,14 @@ export class UmbContextConsumer {
         if (this.#raf !== undefined) {
             cancelAnimationFrame(this.#raf);
         }
+        const hostElement = this._retrieveHost();
+        // Add connection check to prevent requesting on disconnected elements
+        if (hostElement && !hostElement.isConnected) {
+            console.warn('UmbContextConsumer: Attempting to request context on disconnected element', hostElement);
+            return;
+        }
         const event = new UmbContextRequestEventImplementation(this.#contextAlias, this.#apiAlias, this._onResponse, this.#stopAtContextMatch);
-        (this.#skipHost ? this._retrieveHost()?.parentNode : this._retrieveHost())?.dispatchEvent(event);
+        (this.#skipHost ? hostElement?.parentNode : hostElement)?.dispatchEvent(event);
         if (this.#promiseResolver && this.#promiseOptions?.preventTimeout !== true) {
             this.#raf = requestAnimationFrame(() => {
                 // For unproviding, then setInstance to undefined here. [NL]

package/dist-cms/libs/context-api/consume/index.d.ts

@@ -1,3 +1,4 @@
+export * from './context-consume.decorator.js';
 export * from './context-consumer.controller.js';
 export * from './context-consumer.js';
 export * from './context-request.event.js';

package/dist-cms/libs/context-api/consume/index.js

@@ -1,3 +1,4 @@
+export * from './context-consume.decorator.js';
 export * from './context-consumer.controller.js';
 export * from './context-consumer.js';
 export * from './context-request.event.js';

package/dist-cms/libs/context-api/provide/context-provide.decorator.d.ts

@@ -0,0 +1,89 @@
+import type { UmbContextToken } from '../token/index.js';
+import type { UmbContextMinimal } from '../types.js';
+export interface UmbProvideOptions<BaseType extends UmbContextMinimal, ResultType extends BaseType> {
+    context: string | UmbContextToken<BaseType, ResultType>;
+}
+/**
+ * A property decorator that creates an UmbContextProviderController to provide
+ * a context value to child elements via the Umbraco Context API.
+ *
+ * This decorator supports both modern "standard" decorators (Stage 3 TC39 proposal) and
+ * legacy TypeScript experimental decorators for backward compatibility.
+ *
+ * The provider is created once during initialization with the property's initial value.
+ * To update the provided value dynamically, keep a state inside the provided context instance
+ * and update that state as needed. The context instance itself should remain the same.
+ * You can use any of the Umb{*}State classes.
+ * @param {UmbProvideOptions} options Configuration object containing the context token
+ * @example
+ * ```ts
+ * import {provideContext} from '../index.js';
+ * import {UMB_WORKSPACE_CONTEXT} from './workspace.context-token.js';
+ *
+ * class MyWorkspaceElement extends UmbLitElement {
+ *   // Standard decorators - requires 'accessor' keyword
+ *   @provideContext({context: UMB_WORKSPACE_CONTEXT})
+ *   accessor workspaceContext = new UmbWorkspaceContext(this);
+ *
+ *   // Legacy decorators - works without 'accessor'
+ *   @provideContext({context: UMB_WORKSPACE_CONTEXT})
+ *   workspaceContext = new UmbWorkspaceContext(this);
+ * }
+ * ```
+ * @example
+ * ```ts
+ * // For dynamic updates, store the state inside the context instance
+ * class MyContext extends UmbControllerBase {
+ *   someProperty = new UmbStringState('initial value');
+ * }
+ *
+ * class MyElement extends UmbLitElement {
+ *   @provideContext({context: MY_CONTEXT})
+ *   private _myContext = new MyContext(this);
+ *
+ *   updateValue(newValue: string) {
+ *     this._myContext.someProperty.setValue(newValue);
+ *   }
+ * }
+ * ```
+ * @returns {ProvideDecorator<InstanceType>} A property decorator function
+ */
+export declare function provideContext<BaseType extends UmbContextMinimal = UmbContextMinimal, ResultType extends BaseType = BaseType, InstanceType extends ResultType = ResultType>(options: UmbProvideOptions<BaseType, ResultType>): ProvideDecorator<InstanceType>;
+/**
+ * Generates a public interface type that removes private and protected fields.
+ * This allows accepting otherwise compatible versions of the type (e.g. from
+ * multiple copies of the same package in `node_modules`).
+ */
+type Interface<T> = {
+    [K in keyof T]: T[K];
+};
+declare class ReactiveElement {
+    static addInitializer?: (initializer: (instance: any) => void) => void;
+}
+declare class ReactiveController {
+    hostConnected?: () => void;
+}
+/**
+ * A type representing the base class of which the decorator should work
+ * requiring either addInitializer (UmbLitElement) or hostConnected (UmbController).
+ */
+type ReactiveEntity = ReactiveElement | ReactiveController;
+type ProvideDecorator<ContextType> = {
+    <K extends PropertyKey, Proto extends Interface<ReactiveEntity>>(protoOrDescriptor: Proto, name?: K): FieldMustMatchContextType<Proto, K, ContextType>;
+    <C extends Interface<ReactiveEntity>, V extends ContextType>(value: ClassAccessorDecoratorTarget<C, V>, context: ClassAccessorDecoratorContext<C, V>): void;
+};
+type DecoratorReturn = void | any;
+type FieldMustMatchContextType<Obj, Key extends PropertyKey, ContextType> = Obj extends Record<Key, infer ProvidingType> ? [
+    ProvidingType
+] extends [ContextType] ? DecoratorReturn : {
+    message: 'providing field not assignable to context';
+    context: ContextType;
+    provided: ProvidingType;
+} : Obj extends Partial<Record<Key, infer Providing>> ? [
+    Providing | undefined
+] extends [ContextType] ? DecoratorReturn : {
+    message: 'providing field not assignable to context';
+    context: ContextType;
+    consuming: Providing | undefined;
+} : DecoratorReturn;
+export {};

package/dist-cms/libs/context-api/provide/context-provide.decorator.js

@@ -0,0 +1,154 @@
+/*
+ * Portions of this code are adapted from @lit/context
+ * Copyright 2017 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Original source: https://github.com/lit/lit/tree/main/packages/context
+ *
+ * @license BSD-3-Clause
+ */
+import { UmbContextProviderController } from './context-provider.controller.js';
+/**
+ * A property decorator that creates an UmbContextProviderController to provide
+ * a context value to child elements via the Umbraco Context API.
+ *
+ * This decorator supports both modern "standard" decorators (Stage 3 TC39 proposal) and
+ * legacy TypeScript experimental decorators for backward compatibility.
+ *
+ * The provider is created once during initialization with the property's initial value.
+ * To update the provided value dynamically, keep a state inside the provided context instance
+ * and update that state as needed. The context instance itself should remain the same.
+ * You can use any of the Umb{*}State classes.
+ * @param {UmbProvideOptions} options Configuration object containing the context token
+ * @example
+ * ```ts
+ * import {provideContext} from '../index.js';
+ * import {UMB_WORKSPACE_CONTEXT} from './workspace.context-token.js';
+ *
+ * class MyWorkspaceElement extends UmbLitElement {
+ *   // Standard decorators - requires 'accessor' keyword
+ *   @provideContext({context: UMB_WORKSPACE_CONTEXT})
+ *   accessor workspaceContext = new UmbWorkspaceContext(this);
+ *
+ *   // Legacy decorators - works without 'accessor'
+ *   @provideContext({context: UMB_WORKSPACE_CONTEXT})
+ *   workspaceContext = new UmbWorkspaceContext(this);
+ * }
+ * ```
+ * @example
+ * ```ts
+ * // For dynamic updates, store the state inside the context instance
+ * class MyContext extends UmbControllerBase {
+ *   someProperty = new UmbStringState('initial value');
+ * }
+ *
+ * class MyElement extends UmbLitElement {
+ *   @provideContext({context: MY_CONTEXT})
+ *   private _myContext = new MyContext(this);
+ *
+ *   updateValue(newValue: string) {
+ *     this._myContext.someProperty.setValue(newValue);
+ *   }
+ * }
+ * ```
+ * @returns {ProvideDecorator<InstanceType>} A property decorator function
+ */
+export function provideContext(options) {
+    const { context } = options;
+    return ((protoOrTarget, nameOrContext) => {
+        if (typeof nameOrContext === 'object') {
+            return setupStandardDecorator(protoOrTarget, context);
+        }
+        setupLegacyDecorator(protoOrTarget, nameOrContext, context);
+    });
+}
+/**
+ * Sets up a standard decorator (Stage 3 TC39 proposal) for auto-accessors.
+ * This branch is used when decorating with the 'accessor' keyword.
+ * Example: @provideContext({context: TOKEN}) accessor myProp = new MyContext();
+ *
+ * The decorator receives a ClassAccessorDecoratorContext object and returns
+ * an accessor descriptor that intercepts the property initialization.
+ *
+ * This is the modern, standardized decorator API that will be the standard
+ * when Lit 4.x is released.
+ *
+ * Note: Standard decorators currently don't work with @state()/@property()
+ * decorators, which is why we still need the legacy branch.
+ * @param protoOrTarget
+ * @param context
+ */
+function setupStandardDecorator(protoOrTarget, context) {
+    return {
+        get() {
+            return protoOrTarget.get.call(this);
+        },
+        set(value) {
+            return protoOrTarget.set.call(this, value);
+        },
+        init(value) {
+            // Defer controller creation to avoid timing issues with private fields
+            queueMicrotask(() => {
+                new UmbContextProviderController(this, context, value);
+            });
+            return value;
+        },
+    };
+}
+/**
+ * Sets up a legacy decorator (TypeScript experimental) for regular properties.
+ * This branch is used when decorating without the 'accessor' keyword.
+ * Example: @provideContext({context: TOKEN}) myProp = new MyContext();
+ *
+ * The decorator receives:
+ * - protoOrTarget: The class prototype
+ * - propertyKey: The property name (string)
+ *
+ * This is the older TypeScript experimental decorator API, still widely used
+ * in Umbraco because it works with @state() and @property() decorators.
+ * The 'accessor' keyword is not compatible with these decorators yet.
+ *
+ * We support three initialization strategies:
+ * 1. addInitializer (if available, e.g., on LitElement classes)
+ * 2. hostConnected wrapper (for UmbController classes)
+ * 3. Warning (if neither is available)
+ * @param protoOrTarget
+ * @param propertyKey
+ * @param context
+ */
+function setupLegacyDecorator(protoOrTarget, propertyKey, context) {
+    const constructor = protoOrTarget.constructor;
+    // Strategy 1: Use addInitializer if available (LitElement classes)
+    if (constructor.addInitializer) {
+        constructor.addInitializer((element) => {
+            // Defer controller creation to avoid timing issues with private fields
+            queueMicrotask(() => {
+                const initialValue = element[propertyKey];
+                new UmbContextProviderController(element, context, initialValue);
+            });
+        });
+        return;
+    }
+    // Strategy 2: Wrap hostConnected for UmbController classes without addInitializer
+    if ('hostConnected' in protoOrTarget && typeof protoOrTarget.hostConnected === 'function') {
+        const originalHostConnected = protoOrTarget.hostConnected;
+        protoOrTarget.hostConnected = function () {
+            // Set up provider once, using a flag to prevent multiple setups
+            if (!this.__provideControllers) {
+                this.__provideControllers = new Map();
+            }
+            if (!this.__provideControllers.has(propertyKey)) {
+                const initialValue = this[propertyKey];
+                new UmbContextProviderController(this, context, initialValue);
+                // Mark as set up to prevent duplicate providers
+                this.__provideControllers.set(propertyKey, true);
+            }
+            // Call original hostConnected if it exists
+            originalHostConnected?.call(this);
+        };
+        return;
+    }
+    // Strategy 3: No supported initialization method available
+    console.warn(`@provideContext applied to ${constructor.name}.${propertyKey} but neither addInitializer nor hostConnected is available. ` +
+        `Make sure the class extends UmbLitElement, UmbControllerBase, or implements UmbController with hostConnected.`);
+}

package/dist-cms/libs/context-api/provide/index.d.ts

@@ -1,3 +1,4 @@
+export * from './context-provide.decorator.js';
 export * from './context-boundary.js';
 export * from './context-boundary.controller.js';
 export * from './context-provide.event.js';

package/dist-cms/libs/context-api/provide/index.js

@@ -1,3 +1,4 @@
+export * from './context-provide.decorator.js';
 export * from './context-boundary.js';
 export * from './context-boundary.controller.js';
 export * from './context-provide.event.js';

package/dist-cms/libs/localization-api/localization.controller.d.ts

@@ -41,7 +41,7 @@ export declare class UmbLocalizationController<LocalizationSetType extends UmbLo
     /**
      * Outputs a translated term.
      * @param {string} key - the localization key, the indicator of what localization entry you want to retrieve.
-     * @param {...any} args - the arguments to parse for this localization entry.
+     * @param {unknown[]} args - the arguments to parse for this localization entry.
      * @returns {string} - the translated term as a string.
      * @example
      * Retrieving a term without any arguments:
@@ -54,6 +54,29 @@ export declare class UmbLocalizationController<LocalizationSetType extends UmbLo
      * ```
      */
     term<K extends keyof LocalizationSetType>(key: K, ...args: FunctionParams<LocalizationSetType[K]>): string;
+    /**
+     * Returns the localized term for the given key, or the default value if not found.
+     * This method follows the same resolution order as term() (primary → secondary → fallback),
+     * but returns the provided defaultValue instead of the key when no translation is found.
+     * @param {string} key - the localization key, the indicator of what localization entry you want to retrieve.
+     * @param {string | null} defaultValue - the value to return if the key is not found in any localization set.
+     * @param {unknown[]} args - the arguments to parse for this localization entry.
+     * @returns {string | null} - the translated term or the default value.
+     * @example
+     * Retrieving a term with fallback:
+     * ```ts
+     * this.localize.termOrDefault('general_close', 'X');
+     * ```
+     * Retrieving a term with fallback and arguments:
+     * ```ts
+     * this.localize.termOrDefault('general_greeting', 'Hello!', userName);
+     * ```
+     * Retrieving a term with null as fallback:
+     * ```ts
+     * this.localize.termOrDefault('general_close', null);
+     * ```
+     */
+    termOrDefault<K extends keyof LocalizationSetType, D extends string | null>(key: K, defaultValue: D, ...args: FunctionParams<LocalizationSetType[K]>): string | D;
     /**
      * Outputs a localized date in the specified format.
      * @param {Date} dateToFormat - the date to format.
@@ -99,8 +122,8 @@ export declare class UmbLocalizationController<LocalizationSetType extends UmbLo
      * If the term is found in the localization set, it will be replaced with the localized term.
      * If the term is not found, the original term will be returned.
      * @param {string | undefined} text The text to translate.
-     * @param {...any} args The arguments to parse for this localization entry.
+     * @param {unknown[]} args The arguments to parse for this localization entry.
      * @returns {string} The translated text.
      */
-    string(text: string | undefined, ...args: any): string;
+    string(text: string | undefined, ...args: unknown[]): string;
 }