@umbraco-cms/backoffice 18.3.0-rc2 → 19.0.0-beta1

package/dist-cms/assets/lang/vi.js

@@ -264,6 +264,7 @@ export default {
         noVariantsToProcess: 'Không có biến thể nào có sẵn',
         releaseDate: 'Xuất bản vào',
         unpublishDate: 'Hủy xuất bản vào',
+        scheduleForAllLanguages: 'Lên lịch cho tất cả ngôn ngữ đã chọn',
         removeDate: 'Xóa ngày',
         setDate: 'Đặt ngày',
         sortDone: 'Thứ tự sắp xếp đã được cập nhật',
@@ -621,34 +622,6 @@ export default {
         changeKeyError: "Khóa '%0%' đã tồn tại.",
         overviewTitle: 'Tổng quan từ điển',
     },
-    examineManagement: {
-        configuredSearchers: 'Các tìm kiếm đã cấu hình',
-        configuredSearchersDescription: 'Hiển thị các thuộc tính và công cụ cho bất kỳ tìm kiếm nào đã cấu hình (ví dụ: như một tìm kiếm đa chỉ mục)',
-        fieldValues: 'Giá trị trường',
-        healthStatus: 'Trạng thái sức khỏe',
-        healthStatusDescription: 'Trạng thái sức khỏe của chỉ mục và nếu nó có thể được đọc',
-        indexers: 'Bộ lập chỉ mục',
-        indexInfo: 'Thông tin chỉ mục',
-        contentInIndex: 'Nội dung trong chỉ mục',
-        indexInfoDescription: 'Liệt kê các thuộc tính của chỉ mục',
-        manageIndexes: 'Quản lý các chỉ mục Examine',
-        manageIndexesDescription: 'Cho phép bạn xem chi tiết của từng chỉ mục và cung cấp một số công cụ để quản lý các chỉ mục',
-        rebuildIndex: 'Xây dựng lại chỉ mục',
-        rebuildIndexWarning: 'Điều này sẽ khiến chỉ mục được xây dựng lại.<br />Tùy thuộc vào lượng nội dung trên trang web của bạn, quá trình này có thể mất một thời gian.<br />Không khuyến nghị xây dựng lại chỉ mục trong thời gian lưu lượng truy cập cao hoặc khi các biên tập viên đang chỉnh sửa nội dung.',
-        searchers: 'Bộ tìm kiếm',
-        searchDescription: 'Tìm kiếm trong chỉ mục và xem kết quả',
-        tools: 'Công cụ',
-        toolsDescription: 'Công cụ quản lý chỉ mục',
-        fields: 'trường',
-        indexCannotRead: 'Không thể đọc chỉ mục và cần được xây dựng lại',
-        processIsTakingLonger: 'Quá trình mất nhiều thời gian hơn dự kiến, hãy kiểm tra nhật ký Umbraco để xem có lỗi nào trong quá trình này không',
-        indexCannotRebuild: 'Chỉ mục này không thể được xây dựng lại vì không có IIndexPopulator được gán',
-        iIndexPopulator: 'IIndexPopulator',
-        noResults: 'Không tìm thấy kết quả nào',
-        searchResultsFound: 'Hiển thị %0% - %1% của %2% kết quả - Trang %3% trên %4%',
-        corruptStatus: 'Phát hiện chỉ mục có khả năng bị hỏng',
-        corruptErrorDescription: 'Lỗi nhận được khi đánh giá chỉ mục:',
-    },
     placeholders: {
         username: 'Nhập tên người dùng...',
         password: 'Nhập mật khẩu...',
@@ -2205,7 +2178,6 @@ export default {
         contentRedirectManager: 'Quản lý URL chuyển hướng',
         mediaFolderBrowser: 'Nội dung',
         settingsWelcome: 'Chào mừng',
-        settingsExamine: 'Quản lý Examine',
         settingsPublishedStatus: 'Trạng thái đã xuất bản',
         settingsModelsBuilder: 'Models Builder',
         settingsHealthCheck: 'Health Check',

package/dist-cms/assets/lang/zh.js

@@ -382,6 +382,7 @@ export default {
         createdBlueprintMessage: "已从 '%0%' 创建文档蓝图",
         duplicateBlueprintMessage: '已存在同名的文档蓝图',
         blueprintDescription: '文档蓝图是预定义的内容，编辑者可选择将其作为创建新内容的基础',
+        noAccessToBlueprints: '您没有管理文档蓝图的权限。请联系管理员为您授予访问权限。',
     },
     entityDetail: {
         notFoundTitle: (entityType) => `${entityType ?? '项目'}未找到`,
@@ -2172,6 +2173,7 @@ export default {
         languageHelp: '设置你在菜单和对话框中看到的语言',
         allowAccessToAllDocuments: '允许访问所有文档',
         allowAccessToAllElements: '允许访问所有元素',
+        allowAccessToAllDocumentBlueprints: '允许访问所有文档蓝图',
         allowAccessToAllMedia: '允许访问所有媒体',
         startnodes: '内容起始节点',
         startnodehelp: '将内容树限制为特定的起始节点',
@@ -2181,6 +2183,8 @@ export default {
         mediastartnodeshelp: '将媒体库限制为特定的起始节点',
         selectElementStartNode: '选择元素起始节点',
         selectElementStartNodeDescription: '将元素库限制为特定的起始节点',
+        selectDocumentBlueprintStartNode: '选择文档蓝图起始节点',
+        selectDocumentBlueprintStartNodeDescription: '将用户可管理的文档蓝图限制为特定的起始节点',
         noStartNode: '未选择起始节点',
         noStartNodes: '未选择起始节点',
         selectUserGroup: (multiple) => (multiple ? '选择用户组' : '选择用户组'),

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

@@ -1,39 +1,2 @@
 import '@umbraco-ui/uui';
-import { UUITimer } from '@umbraco-ui/uui';
-import type { UUIActiveMixinInterface, UUILabelMixinInterface, UUIPopoverTargetMixinInterface, UUISelectableMixinInterface, UUISelectOnlyMixinInterface } from '@umbraco-ui/uui';
 export * from '@umbraco-ui/uui';
-declare global {
-    interface Option {
-        name: string;
-        value: string;
-        group?: string;
-        selected?: boolean;
-        disabled?: boolean;
-    }
-}
-/**
- * @deprecated
- * For v.17 we need to keep this function around for backwards compatibility with the legacy UUI 1.x custom elements.
- * TODO: To be removed in v.18.
- * Fire a warning if the custom element with the provided name isn't available.
- * @func demandCustomElement
- * @param {HTMLElement} requester - Reference to the element requiring this custom element..
- * @param {string} elementName - Tag name of the required custom element.
- * @param {string} message - Optional message describing the consequences of it not begin available.
- */
-export declare const demandCustomElement: (requester: HTMLElement, elementName: string, message?: string) => void;
-/** @deprecated Use UUITimer instead */
-export declare const Timer: typeof UUITimer;
-/** @deprecated Use UUIActiveMixinInterface instead */
-export type ActiveMixinInterface = UUIActiveMixinInterface;
-/** @deprecated Use UUILabelMixinInterface instead */
-export type LabelMixinInterface = UUILabelMixinInterface;
-/** @deprecated Use UUIPopoverTargetMixinInterface instead */
-export type PopoverTargetMixinInterface = UUIPopoverTargetMixinInterface;
-/** @deprecated Use UUISelectOnlyMixinInterface instead */
-export type SelectOnlyMixinInterface = UUISelectOnlyMixinInterface;
-/** @deprecated Use UUISelectableMixinInterface instead */
-export type SelectableMixinInterface = UUISelectableMixinInterface;
-export * from './uui-popover.element.js';
-export * from './UUIPopoverEvent.js';
-export * from './uui-caret.element.js';

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

@@ -1,27 +1,2 @@
 import '@umbraco-ui/uui';
-import { UUITimer } from '@umbraco-ui/uui';
 export * from '@umbraco-ui/uui';
-/**
- * @deprecated
- * For v.17 we need to keep this function around for backwards compatibility with the legacy UUI 1.x custom elements.
- * TODO: To be removed in v.18.
- * Fire a warning if the custom element with the provided name isn't available.
- * @func demandCustomElement
- * @param {HTMLElement} requester - Reference to the element requiring this custom element..
- * @param {string} elementName - Tag name of the required custom element.
- * @param {string} message - Optional message describing the consequences of it not begin available.
- */
-export const demandCustomElement = (requester, elementName, message = `This element has to be present for ${requester.nodeName} to work appropriate.`) => {
-    if (!customElements.get(elementName)) {
-        console.warn(`%c ${requester.nodeName} requires ${elementName} element to be registered!`, 'font-weight: bold;', message, requester);
-    }
-};
-/** @deprecated Use UUITimer instead */
-// TODO: Remove in v.18
-export const Timer = UUITimer;
-// TODO: Remove in v.18
-export * from './uui-popover.element.js';
-// TODO: Remove in v.18
-export * from './UUIPopoverEvent.js';
-// TODO: Remove in v.18
-export * from './uui-caret.element.js';

package/dist-cms/libs/extension-api/condition/extension-condition.interface.d.ts

@@ -1,6 +1,9 @@
 import type { UmbConditionConfigBase } from '../types/index.js';
 import type { UmbController } from '../../controller-api/index.js';
 export interface UmbExtensionCondition extends UmbController {
-    readonly permitted: boolean;
+    /**
+     * Whether the condition permits the extension. Undefined until the condition has given its first answer.
+     */
+    readonly permitted?: boolean;
     readonly config: UmbConditionConfigBase;
 }

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

@@ -20,6 +20,12 @@ export declare abstract class UmbBaseExtensionInitializer<ManifestType extends M
     constructor(host: UmbControllerHost, extensionRegistry: UmbExtensionRegistry<ManifestCondition>, controllerTypeName: string, alias: string, onPermissionChanged?: (isPermitted: boolean, controller: SubClassType) => void);
     protected _init(): void;
     asPromise(): Promise<void>;
+    /**
+     * Resolves once this extension has had its first permission answer: either permitted once all its conditions
+     * have answered, or any of its conditions has answered that it is not permitted. Later changes to the permission do not affect it.
+     * @returns {Promise<void>} A promise that resolves when the first answer is known.
+     */
+    asSettledPromise(): Promise<void>;
     protected abstract _conditionsAreGood(signal: AbortSignal): Promise<boolean>;
     protected abstract _conditionsAreBad(): Promise<void>;
     equal(otherClass: UmbBaseExtensionInitializer | undefined): boolean;

package/dist-cms/libs/extension-api/controller/base-extension-initializer.controller.js

@@ -12,6 +12,8 @@ const observeExtensionsCtrlAlias = Symbol();
 export class UmbBaseExtensionInitializer extends UmbControllerBase {
     //
     #promiseResolvers;
+    #settledResolvers;
+    #isSettled;
     #manifestObserver;
     #extensionRegistry;
     #alias;
@@ -39,6 +41,8 @@ export class UmbBaseExtensionInitializer extends UmbControllerBase {
         super(host, controllerTypeName + '_' + alias);
         //
         this.#promiseResolvers = [];
+        this.#settledResolvers = [];
+        this.#isSettled = false;
         this.#overwrites = [];
         this.#conditionControllers = [];
         this.hasConditions = async () => {
@@ -92,6 +96,10 @@ export class UmbBaseExtensionInitializer extends UmbControllerBase {
             const isPositive = this.#checkConditionsAreGood();
             if (this._isConditionsPositive === isPositive) {
                 // No change in the conditions, so we don't need to do anything, this is an optimization to prevent multiple calls to the callback when there is no change. [NL]
+                // A positive answer is settled by the pass that is making the extension permitted.
+                if (isPositive === false && this.#isPermitted !== undefined && this.#hasConditionAnswerSettlingPermission()) {
+                    this.#settle();
+                }
                 return;
             }
             // We will collect old value here, but we need to re-collect it after a async method have been called, as it could have changed in the mean time. [NL]
@@ -152,6 +160,10 @@ export class UmbBaseExtensionInitializer extends UmbControllerBase {
                 }
                 this.#onPermissionChanged?.(this.#isPermitted, this);
             }
+            // Settles once every condition has answered, or as soon as one answers false, which rules the extension out without waiting for the others.
+            if (this.#isPermitted !== undefined && this.#hasConditionAnswerSettlingPermission()) {
+                this.#settle();
+            }
         };
         this.#extensionRegistry = extensionRegistry;
         this.#alias = alias;
@@ -176,6 +188,7 @@ export class UmbBaseExtensionInitializer extends UmbControllerBase {
                 this.#clearPermittedState();
                 this.#overwrites = [];
                 this.#cleanConditions();
+                this.#settle();
             }
         }, observeExtensionsCtrlAlias);
     }
@@ -189,6 +202,26 @@ export class UmbBaseExtensionInitializer extends UmbControllerBase {
             }
         });
     }
+    /**
+     * Resolves once this extension has had its first permission answer: either permitted once all its conditions
+     * have answered, or any of its conditions has answered that it is not permitted. Later changes to the permission do not affect it.
+     * @returns {Promise<void>} A promise that resolves when the first answer is known.
+     */
+    asSettledPromise() {
+        return new Promise((resolve) => {
+            if (this.#isSettled) {
+                resolve();
+            }
+            else {
+                this.#settledResolvers.push(resolve);
+            }
+        });
+    }
+    #settle() {
+        this.#isSettled = true;
+        this.#settledResolvers.forEach((x) => x());
+        this.#settledResolvers = [];
+    }
     #cleanConditions() {
         if (this.#conditionControllers === undefined || this.#conditionControllers.length === 0)
             return;
@@ -267,7 +300,7 @@ export class UmbBaseExtensionInitializer extends UmbControllerBase {
         }
         return undefined;
     }
-    #checkConditionsAreGood() {
+    #hasAllConditionControllers() {
         // Not good if we don't have a manifest.
         if (this.#manifest === undefined)
             return false;
@@ -276,11 +309,22 @@ export class UmbBaseExtensionInitializer extends UmbControllerBase {
         if (hasAllConditions === false)
             return false;
         // Compare all manifest conditions with the condition controllers configs to be sure we have the right ones, as we might end up in a state where we have the same amount of controllers as conditions, but they are not the right ones. [NL]
-        const allConditionsHaveControllers = (this.#manifest.conditions ?? []).every((condition) => this.#conditionControllers.some((controller) => controller.config === condition));
-        if (allConditionsHaveControllers === false)
+        return (this.#manifest.conditions ?? []).every((condition) => this.#conditionControllers.some((controller) => controller.config === condition));
+    }
+    #hasAllConditionsAnswered() {
+        return (this.#hasAllConditionControllers() &&
+            this.#conditionControllers.every((controller) => controller.permitted !== undefined));
+    }
+    #hasConditionAnswerSettlingPermission() {
+        return this.#isPermitted === true
+            ? this.#hasAllConditionsAnswered()
+            : this.#conditionControllers.some((controller) => controller.permitted === false);
+    }
+    #checkConditionsAreGood() {
+        if (this.#hasAllConditionControllers() === false)
             return false;
         // Only good if all the conditions are permitted:
-        return this.#conditionControllers.some((condition) => condition.permitted === false) === false;
+        return this.#conditionControllers.every((condition) => condition.permitted === true);
     }
     // The currently-pending `_conditionsAreGood()` promise and manifest, to detect if we can reuse it.
     #pendingGoodCall;
@@ -324,6 +368,7 @@ export class UmbBaseExtensionInitializer extends UmbControllerBase {
             return;
         this.#manifest = undefined;
         this.#promiseResolvers = [];
+        this.#settle();
         // Abort any pending good-call so its subclass run refuses to commit (sees
         // `signal.aborted`) instead of trying to assign into a destroyed initializer. [NL]
         this.#abortPendingGoodCall();

package/dist-cms/libs/extension-api/controller/base-extensions-initializer.controller.d.ts

@@ -22,6 +22,18 @@ export declare abstract class UmbBaseExtensionsInitializer<ManifestTypes extends
     #private;
     protected _extensions: Array<ControllerType>;
     asPromise(): Promise<void>;
+    /**
+     * Resolves once the manifests have been received and each of the matching extensions has had its first
+     * permission answer: either permitted (and ready to use) or not permitted by its conditions.
+     * Resolves right away when no extension matches. Later changes to the extensions do not affect it.
+     * @returns {Promise<void>} A promise that resolves when the first answers are known.
+     */
+    asSettledPromise(): Promise<void>;
+    /**
+     * The aliases of the extensions that {@link asSettledPromise} is still waiting for.
+     * @returns {Array<string>} The aliases of the extensions without a first answer.
+     */
+    getUnsettledAliases(): Array<string>;
     constructor(host: UmbControllerHost, extensionRegistry: UmbExtensionRegistry<ManifestTypes>, type: ManifestTypeName | Array<ManifestTypeName>, filter: undefined | null | ((manifest: ManifestType) => boolean), onChange?: (permittedManifests: Array<MyPermittedControllerType>) => void, controllerAlias?: string, args?: UmbBaseExtensionsInitializerArgs);
     protected _init(): void;
     protected abstract _createController(manifest: ManifestType): ControllerType;

package/dist-cms/libs/extension-api/controller/base-extensions-initializer.controller.js

@@ -7,6 +7,9 @@ import { UmbControllerBase } from '../../class-api/index.js';
  */
 export class UmbBaseExtensionsInitializer extends UmbControllerBase {
     #promiseResolvers;
+    #unsettledAliases;
+    #manifestsReceivedResolver;
+    #manifestsReceived;
     #extensionRegistry;
     #type;
     #filter;
@@ -25,9 +28,33 @@ export class UmbBaseExtensionsInitializer extends UmbControllerBase {
             }
         });
     }
+    /**
+     * Resolves once the manifests have been received and each of the matching extensions has had its first
+     * permission answer: either permitted (and ready to use) or not permitted by its conditions.
+     * Resolves right away when no extension matches. Later changes to the extensions do not affect it.
+     * @returns {Promise<void>} A promise that resolves when the first answers are known.
+     */
+    async asSettledPromise() {
+        await this.#manifestsReceived;
+        await Promise.all(this._extensions.map((extension) => {
+            this.#unsettledAliases.add(extension.alias);
+            return extension.asSettledPromise().then(() => this.#unsettledAliases.delete(extension.alias));
+        }));
+    }
+    /**
+     * The aliases of the extensions that {@link asSettledPromise} is still waiting for.
+     * @returns {Array<string>} The aliases of the extensions without a first answer.
+     */
+    getUnsettledAliases() {
+        return [...this.#unsettledAliases];
+    }
     constructor(host, extensionRegistry, type, filter, onChange, controllerAlias, args = {}) {
         super(host, controllerAlias ?? 'extensionsInitializer_' + (Array.isArray(type) ? type.join('_') : type));
         this.#promiseResolvers = [];
+        this.#unsettledAliases = new Set();
+        this.#manifestsReceived = new Promise((resolve) => {
+            this.#manifestsReceivedResolver = resolve;
+        });
         this.#single = false;
         this._extensions = [];
         this.#permittedExts = [];
@@ -40,6 +67,7 @@ export class UmbBaseExtensionsInitializer extends UmbControllerBase {
                 this._extensions.length = 0;
                 // _permittedExts should have been cleared via the destroy callbacks.
                 this.#permittedExts.length = 0;
+                this.#manifestsReceivedResolver();
                 return;
             }
             // If we get no manifests and we have not exposed any extensions yet, then we should notify to let the listener know that we have our first response. [NL]
@@ -62,6 +90,7 @@ export class UmbBaseExtensionsInitializer extends UmbControllerBase {
                     this._extensions.push(this._createController(manifest));
                 }
             });
+            this.#manifestsReceivedResolver();
         };
         this._extensionChanged = (isPermitted, controller) => {
             let hasChanged = false;
@@ -182,6 +211,7 @@ export class UmbBaseExtensionsInitializer extends UmbControllerBase {
             this.#onChange?.([]);
         }
         this.#promiseResolvers.length = 0;
+        this.#manifestsReceivedResolver();
         this.#filter = undefined;
         this.#onChange = undefined;
         this.#extensionRegistry = undefined;

package/dist-cms/libs/extension-api/functions/has-init-export.function.d.ts

@@ -4,4 +4,4 @@ import type { UmbEntryPointModule } from '../models/entry-point.interface.js';
  * @param {unknown} obj The object to check.
  * @returns {boolean} True if the object has an 'onInit' function.
  */
-export declare function hasInitExport(obj: unknown): obj is Pick<UmbEntryPointModule, 'onInit'>;
+export declare function hasInitExport(obj: unknown): obj is Required<Pick<UmbEntryPointModule, 'onInit'>>;

package/dist-cms/libs/extension-api/functions/has-init-export.function.js

@@ -4,5 +4,5 @@
  * @returns {boolean} True if the object has an 'onInit' function.
  */
 export function hasInitExport(obj) {
-    return obj !== null && typeof obj === 'object' && 'onInit' in obj;
+    return obj !== null && typeof obj === 'object' && typeof obj.onInit === 'function';
 }

package/dist-cms/libs/extension-api/functions/has-on-unload-export.function.d.ts

@@ -4,4 +4,4 @@ import type { UmbEntryPointModule } from '../models/entry-point.interface.js';
  * @param {unknown} obj The object to check.
  * @returns {boolean} True if the object has an 'onUnload' function.
  */
-export declare function hasOnUnloadExport(obj: unknown): obj is Pick<UmbEntryPointModule, 'onUnload'>;
+export declare function hasOnUnloadExport(obj: unknown): obj is Required<Pick<UmbEntryPointModule, 'onUnload'>>;

package/dist-cms/libs/extension-api/functions/has-on-unload-export.function.js

@@ -4,5 +4,5 @@
  * @returns {boolean} True if the object has an 'onUnload' function.
  */
 export function hasOnUnloadExport(obj) {
-    return obj !== null && typeof obj === 'object' && 'onUnload' in obj;
+    return obj !== null && typeof obj === 'object' && typeof obj.onUnload === 'function';
 }

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

@@ -9,7 +9,6 @@ export type UmbEntryPointOnUnload = (host: UmbElement, extensionRegistry: UmbExt
 export interface UmbEntryPointModule {
     /**
      * Function that will be called when the host element is initialized and/or the extension is loaded for the first time.
-     * @optional
      */
     onInit: UmbEntryPointOnInit;
     /**
@@ -17,5 +16,5 @@ export interface UmbEntryPointModule {
      * @remarks This does not mean the host element is destroyed, only that the extension is no longer available. You should listen to the host element's `destroy` event if you need to clean up after the host element.
      * @optional
      */
-    onUnload: UmbEntryPointOnUnload;
+    onUnload?: UmbEntryPointOnUnload;
 }

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

@@ -0,0 +1,3 @@
+export * from './parallel-hook.controller.js';
+export * from './sequential-hook.controller.js';
+export type * from './types.js';

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

@@ -0,0 +1,2 @@
+export * from './parallel-hook.controller.js';
+export * from './sequential-hook.controller.js';

package/dist-cms/{external/openid → libs/hook-api}/package.json

@@ -1,5 +1,5 @@
 {
-    "name": "@umbraco-backoffice/openid",
+    "name": "@umbraco-backoffice-lib/hook-api",
     "private": true,
     "type": "module",
     "scripts": {

package/dist-cms/libs/hook-api/parallel-hook.controller.d.ts

@@ -0,0 +1,29 @@
+import type { UmbParallelHookMethod } from './types.js';
+import { UmbControllerBase } from '../class-api/index.js';
+/**
+ * A hook whose methods all run at the same time when executed. Use it when the methods are independent of
+ * each other and only the point where they have all finished matters.
+ * @template MetaType - The type of the meta passed to every method.
+ */
+export declare class UmbParallelHookController<MetaType> extends UmbControllerBase {
+    #private;
+    /**
+     * Adds a method to the hook. All methods run at the same time when the hook is executed.
+     * A method added while the hook is executing is started right away, and is awaited by that execution.
+     * @param {UmbParallelHookMethod} method - The method to run.
+     */
+    add(method: UmbParallelHookMethod<MetaType>): void;
+    /**
+     * Removes a method from the hook. Executions that are already running are not affected.
+     * @param {UmbParallelHookMethod} method - The method to remove.
+     */
+    remove(method: UmbParallelHookMethod<MetaType>): void;
+    /**
+     * Runs all methods at once, and resolves when they have all finished, including methods added meanwhile.
+     * If any method fails, the first failure is thrown once all of them have finished.
+     * @param {MetaType} meta - Passed to every method.
+     * @returns {Promise<void>} A promise that resolves when all methods have finished.
+     */
+    execute(meta: MetaType): Promise<void>;
+    destroy(): void;
+}

package/dist-cms/libs/hook-api/parallel-hook.controller.js

@@ -0,0 +1,66 @@
+import { UmbControllerBase } from '../class-api/index.js';
+/**
+ * A hook whose methods all run at the same time when executed. Use it when the methods are independent of
+ * each other and only the point where they have all finished matters.
+ * @template MetaType - The type of the meta passed to every method.
+ */
+export class UmbParallelHookController extends UmbControllerBase {
+    #methods = [];
+    // Starts a method in an execution that is running, one for each execution.
+    #executions = new Set();
+    /**
+     * Adds a method to the hook. All methods run at the same time when the hook is executed.
+     * A method added while the hook is executing is started right away, and is awaited by that execution.
+     * @param {UmbParallelHookMethod} method - The method to run.
+     */
+    add(method) {
+        this.#methods.push(method);
+        this.#executions.forEach((start) => start(method));
+    }
+    /**
+     * Removes a method from the hook. Executions that are already running are not affected.
+     * @param {UmbParallelHookMethod} method - The method to remove.
+     */
+    remove(method) {
+        const index = this.#methods.indexOf(method);
+        if (index !== -1) {
+            this.#methods.splice(index, 1);
+        }
+    }
+    /**
+     * Runs all methods at once, and resolves when they have all finished, including methods added meanwhile.
+     * If any method fails, the first failure is thrown once all of them have finished.
+     * @param {MetaType} meta - Passed to every method.
+     * @returns {Promise<void>} A promise that resolves when all methods have finished.
+     */
+    async execute(meta) {
+        const pending = new Set();
+        const failures = [];
+        const start = (method) => {
+            const run = (async () => method(meta))()
+                .catch((error) => {
+                failures.push(error);
+            })
+                .finally(() => pending.delete(run));
+            pending.add(run);
+        };
+        this.#executions.add(start);
+        try {
+            [...this.#methods].forEach(start);
+            // Waiting for the running methods can leave new methods running, so wait until none are left.
+            while (pending.size > 0) {
+                await Promise.all(pending);
+            }
+        }
+        finally {
+            this.#executions.delete(start);
+        }
+        if (failures.length > 0)
+            throw failures[0];
+    }
+    destroy() {
+        super.destroy();
+        this.#methods = [];
+        this.#executions.clear();
+    }
+}

package/dist-cms/libs/hook-api/sequential-hook.controller.d.ts

@@ -0,0 +1,32 @@
+import type { UmbSequentialHookMethod } from './types.js';
+import { UmbControllerBase } from '../class-api/index.js';
+/**
+ * A hook whose methods run one after the other, each receiving the value returned by the previous one.
+ * Use it when the methods transform a value and the order matters.
+ * @template ValueType - The type of the value passed through the methods.
+ * @template MetaType - The type of the meta passed to every method.
+ */
+export declare class UmbSequentialHookController<ValueType, MetaType extends Record<string, unknown> = Record<string, unknown>> extends UmbControllerBase {
+    #private;
+    /**
+     * Adds a method to the hook. Methods run in order of weight, highest first.
+     * A method can also be added while the hook is executing, it then runs if it comes after the method that is
+     * currently running, and is skipped by that execution if it comes before.
+     * @param {UmbSequentialHookMethod} method - The method to run.
+     * @param {number} [weight] - Without a weight the method comes after all methods added so far.
+     */
+    add(method: UmbSequentialHookMethod<ValueType, MetaType>, weight?: number): void;
+    /**
+     * Removes a method from the hook. Executions that are already running skip it if it has not run yet.
+     * @param {UmbSequentialHookMethod} method - The method to remove.
+     */
+    remove(method: UmbSequentialHookMethod<ValueType, MetaType>): void;
+    /**
+     * Passes the value through all methods in order of weight, highest first.
+     * @param {ValueType | Promise<ValueType>} data - The initial value.
+     * @param {MetaType} meta - Passed to every method.
+     * @returns {Promise<ValueType>} The value returned by the last method, or the initial value when there are no methods.
+     */
+    execute(data: ValueType | Promise<ValueType>, meta: MetaType): Promise<ValueType>;
+    destroy(): void;
+}

package/dist-cms/libs/hook-api/sequential-hook.controller.js

@@ -0,0 +1,59 @@
+import { UmbControllerBase } from '../class-api/index.js';
+/**
+ * A hook whose methods run one after the other, each receiving the value returned by the previous one.
+ * Use it when the methods transform a value and the order matters.
+ * @template ValueType - The type of the value passed through the methods.
+ * @template MetaType - The type of the meta passed to every method.
+ */
+export class UmbSequentialHookController extends UmbControllerBase {
+    // Always sorted: highest weight first, and in the order of adding for the same weight.
+    #entries = [];
+    #nextOrder = 0;
+    /**
+     * Adds a method to the hook. Methods run in order of weight, highest first.
+     * A method can also be added while the hook is executing, it then runs if it comes after the method that is
+     * currently running, and is skipped by that execution if it comes before.
+     * @param {UmbSequentialHookMethod} method - The method to run.
+     * @param {number} [weight] - Without a weight the method comes after all methods added so far.
+     */
+    add(method, weight) {
+        const lowestWeight = this.#entries[this.#entries.length - 1]?.weight;
+        const resolvedWeight = weight ?? (lowestWeight === undefined ? 0 : lowestWeight - 1);
+        const entry = { method, weight: resolvedWeight, order: this.#nextOrder++ };
+        const index = this.#entries.findIndex((existing) => existing.weight < resolvedWeight);
+        this.#entries.splice(index === -1 ? this.#entries.length : index, 0, entry);
+    }
+    /**
+     * Removes a method from the hook. Executions that are already running skip it if it has not run yet.
+     * @param {UmbSequentialHookMethod} method - The method to remove.
+     */
+    remove(method) {
+        const index = this.#entries.findIndex((entry) => entry.method === method);
+        if (index !== -1) {
+            this.#entries.splice(index, 1);
+        }
+    }
+    /**
+     * Passes the value through all methods in order of weight, highest first.
+     * @param {ValueType | Promise<ValueType>} data - The initial value.
+     * @param {MetaType} meta - Passed to every method.
+     * @returns {Promise<ValueType>} The value returned by the last method, or the initial value when there are no methods.
+     */
+    async execute(data, meta) {
+        let result = await data;
+        let previous;
+        // Each step takes the entry that follows the one that just ran, from the current list, so methods added meanwhile are included.
+        while (true) {
+            const last = previous;
+            const next = this.#entries.find((entry) => !last || entry.weight < last.weight || (entry.weight === last.weight && entry.order > last.order));
+            if (!next)
+                return result;
+            previous = next;
+            result = await next.method(result, meta);
+        }
+    }
+    destroy() {
+        super.destroy();
+        this.#entries = [];
+    }
+}

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

@@ -0,0 +1,18 @@
+/**
+ * A method of a sequential hook. Receives the value returned by the previous method and returns the value for the next.
+ */
+export type UmbSequentialHookMethod<ValueType, MetaType> = (data: ValueType, meta: MetaType) => Promise<ValueType> | ValueType;
+/**
+ * A method registered on a sequential hook, with the weight deciding its place in the order.
+ */
+export interface UmbSequentialHookEntry<ValueType, MetaType> {
+    method: UmbSequentialHookMethod<ValueType, MetaType>;
+    /**
+     * Methods with a higher weight run first.
+     */
+    weight: number;
+}
+/**
+ * A method of a parallel hook. Runs at the same time as the other methods of the hook.
+ */
+export type UmbParallelHookMethod<MetaType> = (meta: MetaType) => Promise<void> | void;