@umbraco-cms/backoffice 14.0.0-8d2a75e2 → 14.0.0-8f7cbf82

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

@@ -0,0 +1 @@
+export { v4, validate } from 'uuid';

package/dist-cms/libs/class-api/class.interface.d.ts

@@ -8,5 +8,5 @@ export interface UmbClassMixinInterface extends UmbControllerHost, UmbController
         asObservable: () => Observable<T>;
     }, callback: (_value: T) => void, unique?: string): UmbObserverController<T>;
     provideContext<R = unknown>(alias: string | UmbContextToken<R>, instance: R): UmbContextProviderController<R>;
-    consumeContext<R = unknown>(alias: string | UmbContextToken<R>, callback: UmbContextCallback<R>): UmbContextConsumerController<R>;
+    consumeContext<BaseType = unknown, ResultType extends BaseType = BaseType>(alias: string | UmbContextToken<BaseType, ResultType>, callback: UmbContextCallback<ResultType>): UmbContextConsumerController<BaseType, ResultType>;
 }

package/dist-cms/libs/class-api/class.mixin.d.ts

@@ -10,8 +10,8 @@ declare class UmbClassMixinDeclaration implements UmbClassMixinInterface {
     observe<T>(source: Observable<T> | {
         asObservable: () => Observable<T>;
     }, callback: (_value: T) => void, controllerAlias?: UmbControllerAlias): UmbObserverController<T>;
-    provideContext<R = unknown>(alias: string | UmbContextToken<R>, instance: R): UmbContextProviderController<R>;
-    consumeContext<R = unknown>(alias: string | UmbContextToken<R>, callback: UmbContextCallback<R>): UmbContextConsumerController<R>;
+    provideContext<BaseType = unknown, ResultType extends BaseType = BaseType, InstanceType extends ResultType = ResultType>(alias: string | UmbContextToken<BaseType, ResultType>, instance: InstanceType): UmbContextProviderController<BaseType, ResultType, InstanceType>;
+    consumeContext<BaseType = unknown, ResultType extends BaseType = BaseType>(alias: string | UmbContextToken<BaseType, ResultType>, callback: UmbContextCallback<ResultType>): UmbContextConsumerController<BaseType, ResultType>;
     hasController(controller: UmbController): boolean;
     getControllers(filterMethod: (ctrl: UmbController) => boolean): UmbController[];
     addController(controller: UmbController): void;

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

@@ -2,9 +2,9 @@ import { UmbContextToken } from '../token/context-token.js';
 import { UmbContextConsumer } from './context-consumer.js';
 import { UmbContextCallback } from './context-request.event.js';
 import type { UmbControllerHost, UmbController } from '../../controller-api/index.js';
-export declare class UmbContextConsumerController<T = unknown> extends UmbContextConsumer<T> implements UmbController {
+export declare class UmbContextConsumerController<BaseType = unknown, ResultType extends BaseType = BaseType> extends UmbContextConsumer<BaseType, ResultType> implements UmbController {
     #private;
     get controllerAlias(): symbol;
-    constructor(host: UmbControllerHost, contextAlias: string | UmbContextToken<T>, callback: UmbContextCallback<T>);
+    constructor(host: UmbControllerHost, contextAlias: string | UmbContextToken<BaseType, ResultType>, callback: UmbContextCallback<ResultType>);
     destroy(): void;
 }

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

@@ -4,20 +4,21 @@ import { UmbContextCallback } from './context-request.event.js';
  * @export
  * @class UmbContextConsumer
  */
-export declare class UmbContextConsumer<T = unknown> {
+export declare class UmbContextConsumer<BaseType = unknown, ResultType extends BaseType = BaseType> {
     #private;
     protected hostElement: EventTarget;
-    get instance(): T | undefined;
+    get instance(): ResultType | undefined;
     /**
      * Creates an instance of UmbContextConsumer.
      * @param {EventTarget} hostElement
      * @param {string} contextAlias
-     * @param {UmbContextCallback} _callback
+     * @param {UmbContextCallback} callback
      * @memberof UmbContextConsumer
      */
-    constructor(hostElement: EventTarget, contextAlias: string | UmbContextToken<T>, callback?: UmbContextCallback<T>);
-    protected _onResponse: (instance: T) => void;
-    asPromise(): Promise<T>;
+    constructor(hostElement: EventTarget, contextAlias: string | UmbContextToken<BaseType, ResultType>, callback?: UmbContextCallback<ResultType>);
+    protected _onResponse: (instance: BaseType) => void;
+    protected setInstance(instance: ResultType): void;
+    asPromise(): Promise<ResultType>;
     /**
      * @memberof UmbContextConsumer
      */

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

@@ -17,25 +17,33 @@ export class UmbContextConsumer {
         return this.#instance;
     }
     #contextAlias;
+    #discriminator;
     /**
      * Creates an instance of UmbContextConsumer.
      * @param {EventTarget} hostElement
      * @param {string} contextAlias
-     * @param {UmbContextCallback} _callback
+     * @param {UmbContextCallback} callback
      * @memberof UmbContextConsumer
      */
     constructor(hostElement, contextAlias, callback) {
         this.hostElement = hostElement;
-        /* Idea: Niels: If we need to filter for specific contexts, we could make the response method return true/false. If false, the event should then then not be stopped. Alternatively parse the event it self on to the response-callback. This will enable the event to continue to bubble up finding a context that matches. The reason for such would be to have some who are more specific than others. For example, some might just need the current workspace-context, others might need the closest handling a certain entityType. As I'm writting this is not relevant, but I wanted to keep the idea as we have had some circumstance that might be solved with this approach.*/
+        /* Idea: Niels: If we need to filter for specific contexts, we could make the response method return true/false. If false, the event should then then not be stopped. Alternatively parse the event it self on to the response-callback.
+        This will enable the event to continue to bubble up finding a context that matches.
+        The reason for such would be to have some who are more specific than others. For example, some might just need the current workspace-context, others might need the closest handling a certain entityType.
+        As I'm writing this is not relevant, but I wanted to keep the idea as we have had some circumstance that might be solved with this approach.
+        */
         this._onResponse = (instance) => {
             if (this.#instance === instance) {
                 return;
             }
-            this.#instance = instance;
-            this.#callback?.(instance);
-            if (instance !== undefined) {
-                this.#promiseResolver?.(instance);
-                this.#promise = undefined;
+            if (this.#discriminator) {
+                // Notice if discriminator returns false, we do not want to setInstance.
+                if (this.#discriminator(instance)) {
+                    this.setInstance(instance);
+                }
+            }
+            else {
+                this.setInstance(instance);
             }
         };
         this.#handleNewProvider = (event) => {
@@ -48,6 +56,15 @@ export class UmbContextConsumer {
         };
         this.#contextAlias = contextAlias.toString();
         this.#callback = callback;
+        this.#discriminator = contextAlias.getDiscriminator?.();
+    }
+    setInstance(instance) {
+        this.#instance = instance;
+        this.#callback?.(instance);
+        if (instance !== undefined) {
+            this.#promiseResolver?.(instance);
+            this.#promise = undefined;
+        }
     }
     asPromise() {
         return (this.#promise ??

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

@@ -6,9 +6,9 @@ export type UmbContextCallback<T> = (instance: T) => void;
  * @export
  * @interface UmbContextRequestEvent
  */
-export interface UmbContextRequestEvent<T = unknown> extends Event {
-    readonly contextAlias: string | UmbContextToken<T>;
-    readonly callback: UmbContextCallback<T>;
+export interface UmbContextRequestEvent<ResultType = unknown> extends Event {
+    readonly contextAlias: string | UmbContextToken<unknown, ResultType>;
+    readonly callback: UmbContextCallback<ResultType>;
 }
 /**
  * @export
@@ -16,10 +16,10 @@ export interface UmbContextRequestEvent<T = unknown> extends Event {
  * @extends {Event}
  * @implements {UmbContextRequestEvent}
  */
-export declare class UmbContextRequestEventImplementation<T = unknown> extends Event implements UmbContextRequestEvent<T> {
-    readonly contextAlias: string | UmbContextToken<T>;
-    readonly callback: UmbContextCallback<T>;
-    constructor(contextAlias: string | UmbContextToken<T>, callback: UmbContextCallback<T>);
+export declare class UmbContextRequestEventImplementation<ResultType = unknown> extends Event implements UmbContextRequestEvent<ResultType> {
+    readonly contextAlias: string | UmbContextToken<any, ResultType>;
+    readonly callback: UmbContextCallback<ResultType>;
+    constructor(contextAlias: string | UmbContextToken<any, ResultType>, callback: UmbContextCallback<ResultType>);
 }
 export declare const isUmbContextRequestEvent: (event: Event) => event is UmbContextRequestEventImplementation<unknown>;
 export declare class UmbContextDebugRequest extends Event {

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

@@ -1,9 +1,9 @@
 import { UmbContextToken } from '../token/context-token.js';
 import { UmbContextProvider } from './context-provider.js';
 import type { UmbControllerHost, UmbController } from '../../controller-api/index.js';
-export declare class UmbContextProviderController<T = unknown> extends UmbContextProvider implements UmbController {
+export declare class UmbContextProviderController<BaseType = unknown, ResultType extends BaseType = BaseType, InstanceType extends ResultType = ResultType> extends UmbContextProvider<BaseType, ResultType> implements UmbController {
     #private;
     get controllerAlias(): string;
-    constructor(host: UmbControllerHost, contextAlias: string | UmbContextToken<T>, instance: T);
+    constructor(host: UmbControllerHost, contextAlias: string | UmbContextToken<BaseType, ResultType>, instance: InstanceType);
     destroy(): void;
 }

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

@@ -3,7 +3,7 @@ import { UmbContextToken } from '../token/context-token.js';
  * @export
  * @class UmbContextProvider
  */
-export declare class UmbContextProvider {
+export declare class UmbContextProvider<BaseType = unknown, ResultType extends BaseType = BaseType> {
     #private;
     protected hostElement: EventTarget;
     protected _contextAlias: string;
@@ -20,7 +20,7 @@ export declare class UmbContextProvider {
      * @param {*} instance
      * @memberof UmbContextProvider
      */
-    constructor(hostElement: EventTarget, contextAlias: string | UmbContextToken, instance: unknown);
+    constructor(hostElement: EventTarget, contextAlias: string | UmbContextToken<BaseType, ResultType>, instance: ResultType);
     /**
      * @memberof UmbContextProvider
      */

package/dist-cms/libs/context-api/token/context-token.d.ts

@@ -1,6 +1,7 @@
-export declare class UmbContextToken<T = unknown> {
+export type UmbContextDiscriminator<BaseType, DiscriminatorResult extends BaseType> = (instance: BaseType) => instance is DiscriminatorResult;
+export declare class UmbContextToken<BaseType = unknown, ResultType extends BaseType = BaseType> {
+    #private;
     protected alias: string;
-    protected _desc?: string | undefined;
     /**
      * Get the type of the token
      *
@@ -10,14 +11,12 @@ export declare class UmbContextToken<T = unknown> {
      * @example   `typeof MyToken.TYPE`
      * @returns   undefined
      */
-    readonly TYPE: T;
+    readonly TYPE: ResultType;
     /**
-     * @param alias   Unique identifier for the token,
-     * @param _desc   Description for the token,
-     *                used only for debugging purposes,
-     *                it should but does not need to be unique
+     * @param alias   Unique identifier for the token
      */
-    constructor(alias: string, _desc?: string | undefined);
+    constructor(alias: string, discriminator?: UmbContextDiscriminator<BaseType, ResultType>);
+    getDiscriminator(): UmbContextDiscriminator<BaseType, ResultType> | undefined;
     /**
      * This method must always return the unique alias of the token since that
      * will be used to look up the token in the injector.

package/dist-cms/libs/context-api/token/context-token.js

@@ -1,13 +1,10 @@
 export class UmbContextToken {
+    #discriminator;
     /**
-     * @param alias   Unique identifier for the token,
-     * @param _desc   Description for the token,
-     *                used only for debugging purposes,
-     *                it should but does not need to be unique
+     * @param alias   Unique identifier for the token
      */
-    constructor(alias, _desc) {
+    constructor(alias, discriminator) {
         this.alias = alias;
-        this._desc = _desc;
         /**
          * Get the type of the token
          *
@@ -18,6 +15,10 @@ export class UmbContextToken {
          * @returns   undefined
          */
         this.TYPE = undefined;
+        this.#discriminator = discriminator;
+    }
+    getDiscriminator() {
+        return this.#discriminator;
     }
     /**
      * This method must always return the unique alias of the token since that

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

@@ -5,8 +5,8 @@ declare const UmbBaseController_base: (new (host: UmbControllerHost, controllerA
     observe<T>(source: import("rxjs").Observable<T> | {
         asObservable: () => import("rxjs").Observable<T>;
     }, callback: (_value: T) => void, controllerAlias?: import("./controller-alias.type.js").UmbControllerAlias): import("../observable-api/observer.controller.js").UmbObserverController<T>;
-    provideContext<R = unknown>(alias: string | import("../context-api/index.js").UmbContextToken<R>, instance: R): import("../context-api/index.js").UmbContextProviderController<R>;
-    consumeContext<R_1 = unknown>(alias: string | import("../context-api/index.js").UmbContextToken<R_1>, callback: import("../context-api/index.js").UmbContextCallback<R_1>): import("../context-api/index.js").UmbContextConsumerController<R_1>;
+    provideContext<BaseType = unknown, ResultType extends BaseType = BaseType, InstanceType_1 extends ResultType = ResultType>(alias: string | import("../context-api/index.js").UmbContextToken<BaseType, ResultType>, instance: InstanceType_1): import("../context-api/index.js").UmbContextProviderController<BaseType, ResultType, InstanceType_1>;
+    consumeContext<BaseType_1 = unknown, ResultType_1 extends BaseType_1 = BaseType_1>(alias: string | import("../context-api/index.js").UmbContextToken<BaseType_1, ResultType_1>, callback: import("../context-api/index.js").UmbContextCallback<ResultType_1>): import("../context-api/index.js").UmbContextConsumerController<BaseType_1, ResultType_1>;
     hasController(controller: UmbController): boolean;
     getControllers(filterMethod: (ctrl: UmbController) => boolean): UmbController[];
     addController(controller: UmbController): void;
@@ -22,8 +22,8 @@ declare const UmbBaseController_base: (new (host: UmbControllerHost, controllerA
     observe<T>(source: import("rxjs").Observable<T> | {
         asObservable: () => import("rxjs").Observable<T>;
     }, callback: (_value: T) => void, controllerAlias?: import("./controller-alias.type.js").UmbControllerAlias): import("../observable-api/observer.controller.js").UmbObserverController<T>;
-    provideContext<R = unknown>(alias: string | import("../context-api/index.js").UmbContextToken<R>, instance: R): import("../context-api/index.js").UmbContextProviderController<R>;
-    consumeContext<R_1 = unknown>(alias: string | import("../context-api/index.js").UmbContextToken<R_1>, callback: import("../context-api/index.js").UmbContextCallback<R_1>): import("../context-api/index.js").UmbContextConsumerController<R_1>;
+    provideContext<BaseType = unknown, ResultType extends BaseType = BaseType, InstanceType_1 extends ResultType = ResultType>(alias: string | import("../context-api/index.js").UmbContextToken<BaseType, ResultType>, instance: InstanceType_1): import("../context-api/index.js").UmbContextProviderController<BaseType, ResultType, InstanceType_1>;
+    consumeContext<BaseType_1 = unknown, ResultType_1 extends BaseType_1 = BaseType_1>(alias: string | import("../context-api/index.js").UmbContextToken<BaseType_1, ResultType_1>, callback: import("../context-api/index.js").UmbContextCallback<ResultType_1>): import("../context-api/index.js").UmbContextConsumerController<BaseType_1, ResultType_1>;
     hasController(controller: UmbController): boolean;
     getControllers(filterMethod: (ctrl: UmbController) => boolean): UmbController[];
     addController(controller: UmbController): void;

package/dist-cms/libs/element-api/element.mixin.d.ts

@@ -14,7 +14,7 @@ export declare class UmbElement extends UmbControllerHostElement {
     observe<T>(source: Observable<T> | {
         asObservable: () => Observable<T>;
     }, callback: ObserverCallback<T>, unique?: string): UmbObserverController<T>;
-    provideContext<R = unknown>(alias: string | UmbContextToken<R>, instance: R): UmbContextProviderController<R>;
-    consumeContext<R = unknown>(alias: string | UmbContextToken<R>, callback: UmbContextCallback<R>): UmbContextConsumerController<R>;
+    provideContext<BaseType = unknown, ResultType extends BaseType = BaseType, InstanceType extends ResultType = ResultType>(alias: string | UmbContextToken<BaseType, ResultType>, instance: InstanceType): UmbContextProviderController<BaseType, ResultType, InstanceType>;
+    consumeContext<BaseType = unknown, ResultType extends BaseType = BaseType>(alias: string | UmbContextToken<BaseType, ResultType>, callback: UmbContextCallback<ResultType>): UmbContextConsumerController<BaseType, ResultType>;
 }
 export declare const UmbElementMixin: <T extends HTMLElementConstructor>(superClass: T) => HTMLElementConstructor<UmbElement> & T;

package/dist-cms/libs/extension-api/bundle-extension-initializer.d.ts

@@ -1,7 +1,7 @@
 import type { ManifestBundle } from './types.js';
 import { UmbExtensionRegistry } from './registry/extension.registry.js';
-import { UmbControllerHostElement } from '../controller-api/index.js';
-export declare class UmbBundleExtensionInitializer {
+import { UmbBaseController, UmbControllerHostElement } from '../controller-api/index.js';
+export declare class UmbBundleExtensionInitializer extends UmbBaseController {
     #private;
     constructor(host: UmbControllerHostElement, extensionRegistry: UmbExtensionRegistry<ManifestBundle>);
     instantiateBundle(manifest: ManifestBundle): Promise<void>;

package/dist-cms/libs/extension-api/bundle-extension-initializer.js

@@ -1,10 +1,12 @@
 import { loadExtension } from './load-extension.function.js';
-export class UmbBundleExtensionInitializer {
+import { UmbBaseController } from '../controller-api/index.js';
+export class UmbBundleExtensionInitializer extends UmbBaseController {
     #extensionRegistry;
     #bundleMap = new Map();
     constructor(host, extensionRegistry) {
+        super(host);
         this.#extensionRegistry = extensionRegistry;
-        extensionRegistry.extensionsOfType('bundle').subscribe((bundles) => {
+        this.observe(extensionRegistry.extensionsOfType('bundle'), (bundles) => {
             // Unregister removed bundles:
             this.#bundleMap.forEach((existingBundle) => {
                 if (!bundles.find((b) => b.alias === existingBundle.alias)) {

package/dist-cms/libs/extension-api/entry-point-extension-initializer.d.ts

@@ -1,7 +1,8 @@
+import { UmbBaseController } from '../controller-api/controller.class.js';
 import type { ManifestEntryPoint } from './types.js';
 import { UmbExtensionRegistry } from './registry/extension.registry.js';
 import { UmbElement } from '../element-api/index.js';
-export declare class UmbEntryPointExtensionInitializer {
+export declare class UmbEntryPointExtensionInitializer extends UmbBaseController {
     #private;
     constructor(host: UmbElement, extensionRegistry: UmbExtensionRegistry<ManifestEntryPoint>);
     instantiateEntryPoint(manifest: ManifestEntryPoint): Promise<void>;

package/dist-cms/libs/extension-api/entry-point-extension-initializer.js

@@ -1,13 +1,15 @@
+import { UmbBaseController } from '../controller-api/controller.class.js';
 import { hasInitExport } from './has-init-export.function.js';
 import { loadExtension } from './load-extension.function.js';
-export class UmbEntryPointExtensionInitializer {
+export class UmbEntryPointExtensionInitializer extends UmbBaseController {
     #host;
     #extensionRegistry;
     #entryPointMap = new Map();
     constructor(host, extensionRegistry) {
+        super(host);
         this.#host = host;
         this.#extensionRegistry = extensionRegistry;
-        extensionRegistry.extensionsOfType('entryPoint').subscribe((entryPoints) => {
+        this.observe(extensionRegistry.extensionsOfType('entryPoint'), (entryPoints) => {
             entryPoints.forEach((entryPoint) => {
                 if (this.#entryPointMap.has(entryPoint.alias))
                     return;

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

@@ -1,3 +1,3 @@
 export * from './localize.controller.js';
-export * from './types/translation.js';
+export * from './types/localization.js';
 export * from './manager.js';

package/dist-cms/libs/localization-api/index.js

@@ -1,3 +1,3 @@
 export * from './localize.controller.js';
-export * from './types/translation.js';
+export * from './types/localization.js';
 export * from './manager.js';

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

@@ -1,4 +1,4 @@
-import { DefaultTranslationSet, FunctionParams, TranslationSet } from './manager.js';
+import { DefaultLocalizationSet, FunctionParams, LocalizationSet } from './manager.js';
 import { UmbController, UmbControllerHost } from '../controller-api/index.js';
 /**
  * The UmbLocalizeController enables localization for your element.
@@ -18,7 +18,7 @@ import { UmbController, UmbControllerHost } from '../controller-api/index.js';
  * }
  * ```
  */
-export declare class UmbLocalizeController<TranslationType extends TranslationSet = DefaultTranslationSet> implements UmbController {
+export declare class UmbLocalizeController<LocalizationType extends LocalizationSet = DefaultLocalizationSet> implements UmbController {
     #private;
     controllerAlias: symbol;
     constructor(host: UmbControllerHost);
@@ -35,9 +35,9 @@ export declare class UmbLocalizeController<TranslationType extends TranslationSe
      * lowercase.
      */
     lang(): string;
-    private getTranslationData;
+    private getLocalizationData;
     /** Outputs a translated term. */
-    term<K extends keyof TranslationType>(key: K, ...args: FunctionParams<TranslationType[K]>): string;
+    term<K extends keyof LocalizationType>(key: K, ...args: FunctionParams<LocalizationType[K]>): string;
     /** Outputs a localized date in the specified format. */
     date(dateToFormat: Date | string, options?: Intl.DateTimeFormatOptions): string;
     /** Outputs a localized number in the specified format. */

package/dist-cms/libs/localization-api/localize.controller.js

@@ -11,7 +11,7 @@ The above copyright notice and this permission notice shall be included in all c
 
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
-import { connectedElements, documentDirection, documentLanguage, fallback, translations, } from './manager.js';
+import { connectedElements, documentDirection, documentLanguage, fallback, localizations, } from './manager.js';
 const LocalizeControllerAlias = Symbol();
 /**
  * The UmbLocalizeController enables localization for your element.
@@ -67,17 +67,17 @@ export class UmbLocalizeController {
     lang() {
         return `${this.#hostEl.lang || documentLanguage}`.toLowerCase();
     }
-    getTranslationData(lang) {
+    getLocalizationData(lang) {
         const locale = new Intl.Locale(lang);
         const language = locale?.language.toLowerCase();
         const region = locale?.region?.toLowerCase() ?? '';
-        const primary = translations.get(`${language}-${region}`);
-        const secondary = translations.get(language);
+        const primary = localizations.get(`${language}-${region}`);
+        const secondary = localizations.get(language);
         return { locale, language, region, primary, secondary };
     }
     /** Outputs a translated term. */
     term(key, ...args) {
-        const { primary, secondary } = this.getTranslationData(this.lang());
+        const { primary, secondary } = this.getLocalizationData(this.lang());
         let term;
         // Look for a matching term using regionCode, code, then the fallback
         if (primary && primary[key]) {

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

@@ -1,18 +1,18 @@
-import type { UmbTranslationEntry } from './types/translation.js';
+import type { UmbLocalizationEntry } from './types/localization.js';
 export type FunctionParams<T> = T extends (...args: infer U) => string ? U : [];
-export interface TranslationSet {
+export interface LocalizationSet {
     $code: string;
     $dir: 'ltr' | 'rtl';
 }
-export interface DefaultTranslationSet extends TranslationSet {
-    [key: string]: UmbTranslationEntry;
+export interface DefaultLocalizationSet extends LocalizationSet {
+    [key: string]: UmbLocalizationEntry;
 }
 export declare const connectedElements: Set<HTMLElement>;
-export declare const translations: Map<string, TranslationSet>;
+export declare const localizations: Map<string, LocalizationSet>;
 export declare let documentDirection: string;
 export declare let documentLanguage: string;
-export declare let fallback: TranslationSet;
+export declare let fallback: LocalizationSet;
 /** Registers one or more translations */
-export declare function registerTranslation(...translation: TranslationSet[]): void;
+export declare function registerLocalization(...translation: LocalizationSet[]): void;
 /** Updates all localized elements that are currently connected */
 export declare function update(): void;

package/dist-cms/libs/localization-api/manager.js

@@ -1,6 +1,6 @@
 export const connectedElements = new Set();
 const documentElementObserver = new MutationObserver(update);
-export const translations = new Map();
+export const localizations = new Map();
 export let documentDirection = document.documentElement.dir || 'ltr';
 export let documentLanguage = document.documentElement.lang || navigator.language;
 export let fallback;
@@ -10,15 +10,15 @@ documentElementObserver.observe(document.documentElement, {
     attributeFilter: ['dir', 'lang'],
 });
 /** Registers one or more translations */
-export function registerTranslation(...translation) {
+export function registerLocalization(...translation) {
     translation.map((t) => {
         const code = t.$code.toLowerCase();
-        if (translations.has(code)) {
+        if (localizations.has(code)) {
             // Merge translations that share the same language code
-            translations.set(code, { ...translations.get(code), ...t });
+            localizations.set(code, { ...localizations.get(code), ...t });
         }
         else {
-            translations.set(code, t);
+            localizations.set(code, t);
         }
         // The first translation that's registered is the fallback
         if (!fallback) {

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

@@ -0,0 +1,3 @@
+export type UmbLocalizationEntry = string | ((...args: any[]) => string);
+export type UmbLocalizationDictionary = Record<string, Record<string, UmbLocalizationEntry>>;
+export type UmbLocalizationFlatDictionary = Record<string, UmbLocalizationEntry>;

package/dist-cms/mocks/data/stylesheet.data.d.ts

@@ -1,14 +1,36 @@
-import { UmbEntityData } from './entity.data.js';
-import { FileSystemTreeItemPresentationModel, PagedFileSystemTreeItemPresentationModel } from '../../external/backend-api/index.js';
-type StylesheetDBItem = FileSystemTreeItemPresentationModel & {
-    content: string;
+import { UmbData } from './data.js';
+import { CreateTextFileViewModelBaseModel, ExtractRichTextStylesheetRulesRequestModel, ExtractRichTextStylesheetRulesResponseModel, FileSystemTreeItemPresentationModel, InterpolateRichTextStylesheetRequestModel, PagedFileSystemTreeItemPresentationModel, PagedStylesheetOverviewResponseModel, StylesheetResponseModel, UpdateStylesheetRequestModel } from '../../external/backend-api/index.js';
+type StylesheetDBItem = StylesheetResponseModel & FileSystemTreeItemPresentationModel & {
+    icon?: string;
 };
 export declare const data: Array<StylesheetDBItem>;
-declare class UmbStylesheetData extends UmbEntityData<StylesheetDBItem> {
+declare class UmbStylesheetData extends UmbData<StylesheetDBItem> {
     constructor();
     getTreeRoot(): PagedFileSystemTreeItemPresentationModel;
     getTreeItemChildren(parentPath: string): PagedFileSystemTreeItemPresentationModel;
     getTreeItem(paths: Array<string>): Array<FileSystemTreeItemPresentationModel>;
+    getStylesheetItem(path: string): StylesheetDBItem | undefined;
+    getStylesheet(path: string): StylesheetResponseModel | undefined;
+    getAllStylesheets(): PagedStylesheetOverviewResponseModel;
+    getFolder(path: string): StylesheetDBItem | undefined;
+    getRules(path: string): ExtractRichTextStylesheetRulesResponseModel;
+    extractRules({ requestBody }: {
+        requestBody?: ExtractRichTextStylesheetRulesRequestModel;
+    }): Promise<{
+        rules: ({
+            [key: string]: string;
+        } | undefined)[];
+    }>;
+    interpolateRules({ requestBody }: {
+        requestBody?: InterpolateRichTextStylesheetRequestModel;
+    }): {
+        content: string;
+    };
+    insertFolder(item: CreateTextFileViewModelBaseModel): StylesheetDBItem;
+    insertStyleSheet(item: CreateTextFileViewModelBaseModel): StylesheetDBItem;
+    insert(item: StylesheetDBItem): StylesheetDBItem;
+    updateData(updateItem: UpdateStylesheetRequestModel): void;
+    delete(paths: Array<string>): (string | undefined)[];
 }
 export declare const umbStylesheetData: UmbStylesheetData;
 export {};