@umbraco-cms/backoffice 18.2.1 → 18.3.0-rc

package/dist-cms/packages/core/property-editor/components/start-node-access/start-node-access-base.element.d.ts

@@ -0,0 +1,55 @@
+import type { UmbPropertyEditorConfigCollection } from '../../config/index.js';
+import type { UmbPropertyEditorUiElement } from '../../extensions/property-editor-ui-element.interface.js';
+import { UmbLitElement } from '../../../lit-element/index.js';
+import type { UmbReferenceByUnique } from '../../../models/index.js';
+/**
+ * The value of a start-node-access property editor: either unrestricted ("root") access, or access
+ * limited to the given set of start nodes.
+ */
+export type UmbStartNodeAccessValue = {
+    rootAccess: boolean;
+    startNodes: Array<UmbReferenceByUnique>;
+};
+/**
+ * Abstract base for a property editor UI that offers either unrestricted ("root") access or access
+ * limited to a set of picked start nodes, toggled by a single boolean.
+ *
+ * Subclasses only need to implement `renderPicker()`, rendering the entity-specific input bound to
+ * `_selection`/`_onPick` and forwarding `readonly`/`_min`/`_max`.
+ */
+export declare abstract class UmbStartNodeAccessPropertyEditorUiElementBase extends UmbLitElement implements UmbPropertyEditorUiElement {
+    #private;
+    /**
+     * Sets the input to readonly mode, meaning the value cannot be changed but the toggle and picker can still be read.
+     * @type {boolean}
+     * @attr
+     * @default false
+     */
+    readonly: boolean;
+    /**
+     * The current start-node-access value.
+     * @type {UmbStartNodeAccessValue}
+     */
+    set value(value: UmbStartNodeAccessValue | undefined);
+    get value(): UmbStartNodeAccessValue;
+    /**
+     * The property editor config. Reads the `rootAccessLabel` alias for the root-access toggle label, and the
+     * `validationLimit` alias (`{min, max}`) forwarded to the picker as selection limits.
+     * @type {UmbPropertyEditorConfigCollection}
+     */
+    set config(config: UmbPropertyEditorConfigCollection | undefined);
+    protected _rootAccess: boolean;
+    protected _startNodes: Array<UmbReferenceByUnique>;
+    private _rootAccessLabel;
+    protected _min: number;
+    protected _max: number;
+    protected get _selection(): Array<string>;
+    /**
+     * Renders the entity-specific picker, shown whenever root access is off. Implementations should
+     * bind their selection to `_selection`, forward `readonly`/`_min`/`_max`, and call `_onPick` on change.
+     */
+    protected abstract renderPicker(): unknown;
+    protected _onPick(selection: Array<string>): void;
+    render(): import("lit-html").TemplateResult<1>;
+    static readonly styles: import("lit").CSSResult[];
+}

package/dist-cms/packages/core/property-editor/components/start-node-access/start-node-access-base.element.js

@@ -0,0 +1,110 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { css, html, property, state, when } from '../../../../../external/lit/index.js';
+import { UmbChangeEvent } from '../../../event/index.js';
+import { UmbLitElement } from '../../../lit-element/index.js';
+/**
+ * Abstract base for a property editor UI that offers either unrestricted ("root") access or access
+ * limited to a set of picked start nodes, toggled by a single boolean.
+ *
+ * Subclasses only need to implement `renderPicker()`, rendering the entity-specific input bound to
+ * `_selection`/`_onPick` and forwarding `readonly`/`_min`/`_max`.
+ */
+export class UmbStartNodeAccessPropertyEditorUiElementBase extends UmbLitElement {
+    constructor() {
+        super(...arguments);
+        /**
+         * Sets the input to readonly mode, meaning the value cannot be changed but the toggle and picker can still be read.
+         * @type {boolean}
+         * @attr
+         * @default false
+         */
+        this.readonly = false;
+        this._rootAccess = false;
+        this._startNodes = [];
+        this._rootAccessLabel = '';
+        this._min = 0;
+        this._max = Infinity;
+    }
+    /**
+     * The current start-node-access value.
+     * @type {UmbStartNodeAccessValue}
+     */
+    set value(value) {
+        this._rootAccess = value?.rootAccess ?? false;
+        this._startNodes = value?.startNodes ?? [];
+    }
+    get value() {
+        return { rootAccess: this._rootAccess, startNodes: this._startNodes };
+    }
+    /**
+     * The property editor config. Reads the `rootAccessLabel` alias for the root-access toggle label, and the
+     * `validationLimit` alias (`{min, max}`) forwarded to the picker as selection limits.
+     * @type {UmbPropertyEditorConfigCollection}
+     */
+    set config(config) {
+        if (!config)
+            return;
+        this._rootAccessLabel = config.getValueByAlias('rootAccessLabel') ?? '';
+        const minMax = config.getValueByAlias('validationLimit');
+        this._min = minMax?.min ?? 0;
+        this._max = minMax?.max ?? Infinity;
+    }
+    get _selection() {
+        return this._startNodes.map((reference) => reference.unique);
+    }
+    _onPick(selection) {
+        this._rootAccess = false;
+        this._startNodes = selection.map((unique) => ({ unique }));
+        this.dispatchEvent(new UmbChangeEvent());
+    }
+    #onToggle(event) {
+        this._rootAccess = event.target.checked;
+        this._startNodes = [];
+        this.dispatchEvent(new UmbChangeEvent());
+    }
+    render() {
+        return html `
+			<uui-toggle
+				.checked=${this._rootAccess}
+				.label=${this._rootAccessLabel}
+				?readonly=${this.readonly}
+				@change=${this.#onToggle}></uui-toggle>
+			${when(this._rootAccess === false, () => this.renderPicker())}
+		`;
+    }
+    static { this.styles = [
+        css `
+			:host {
+				display: flex;
+				flex-direction: column;
+				gap: var(--uui-size-space-3);
+			}
+		`,
+    ]; }
+}
+__decorate([
+    property({ type: Boolean, reflect: true })
+], UmbStartNodeAccessPropertyEditorUiElementBase.prototype, "readonly", void 0);
+__decorate([
+    property({ attribute: false })
+], UmbStartNodeAccessPropertyEditorUiElementBase.prototype, "value", null);
+__decorate([
+    state()
+], UmbStartNodeAccessPropertyEditorUiElementBase.prototype, "_rootAccess", void 0);
+__decorate([
+    state()
+], UmbStartNodeAccessPropertyEditorUiElementBase.prototype, "_startNodes", void 0);
+__decorate([
+    state()
+], UmbStartNodeAccessPropertyEditorUiElementBase.prototype, "_rootAccessLabel", void 0);
+__decorate([
+    state()
+], UmbStartNodeAccessPropertyEditorUiElementBase.prototype, "_min", void 0);
+__decorate([
+    state()
+], UmbStartNodeAccessPropertyEditorUiElementBase.prototype, "_max", void 0);

package/dist-cms/packages/core/property-editor/extensions/property-editor-ui-element.interface.d.ts

@@ -1,5 +1,5 @@
 import type { UmbPropertyEditorConfigCollection } from '../config/index.js';
-import type { ManifestPropertyEditorUi } from './property-editor.extension.js';
+import type { ManifestPropertyEditorUi } from './property-editor-ui.extension.js';
 export interface UmbPropertyEditorUiElement extends HTMLElement {
     manifest?: ManifestPropertyEditorUi;
     alias?: string;

package/dist-cms/packages/core/property-editor/extensions/{property-editor.extension.d.ts → property-editor-ui.extension.d.ts}

@@ -47,6 +47,19 @@ export interface MetaPropertyEditorUi {
      * @example ["text", "input", "string"]
      */
     keywords?: string[];
+    /**
+     * @deprecated Will be removed in a future version, as this will be enforced on all Property Editor UIs from v.19.
+     * Declares that this Property Editor UI keeps itself up to date when the variant it is bound to changes —
+     * for example, an editor that observes its own value and configuration and updates in place rather than
+     * relying on being remounted.
+     *
+     * When not set to `true`, the property re-creates the Property Editor UI element whenever it detects a
+     * variant switch, so the element always initializes fresh for the variant it is currently bound to. A
+     * variant switch is detected via the data path the property is bound to changing, so this has no effect for
+     * a property that does not vary by culture or segment, since its data path never changes on a variant switch.
+     * @default false
+     */
+    supportsVariantChange?: boolean;
 }
 export interface ManifestPropertyEditorSchema extends ManifestBase {
     type: 'propertyEditorSchema';

package/dist-cms/packages/core/property-editor/extensions/types.d.ts

@@ -1,6 +1,6 @@
-export type * from './property-editor.extension.js';
+export type * from './property-editor-ui.extension.js';
 export type * from './property-editor-ui-element.interface.js';
-import type { ManifestPropertyEditorSchema, ManifestPropertyEditorUi } from './property-editor.extension.js';
+import type { ManifestPropertyEditorSchema, ManifestPropertyEditorUi } from './property-editor-ui.extension.js';
 type UmbPropertyEditorExtensions = ManifestPropertyEditorSchema | ManifestPropertyEditorUi;
 declare global {
     interface UmbExtensionManifestMap {

package/dist-cms/packages/core/property-editor-data-source/input/input-property-editor-data-source.element.js

@@ -147,12 +147,13 @@ let UmbInputPropertyEditorDataSourceElement = class UmbInputPropertyEditorDataSo
 				${repeat(this._statuses, (status) => status.unique, (status) => {
             const unique = status.unique;
             const item = this._items?.find((x) => x.unique === unique);
+            const isError = status.state.type === 'error';
             return html `<umb-entity-item-ref
 							id=${unique}
 							.item=${item}
-							?error=${status.state.type === 'error'}
+							?error=${isError}
 							.errorMessage=${status.state.error}
-							?readonly=${this.readonly}
+							?readonly=${this.readonly || isError}
 							?standalone=${this.max === 1}>
 							${when(!this.readonly, () => html `
 									<uui-action-bar slot="actions">

package/dist-cms/packages/core/recycle-bin/entity-action/trash/trash.action.js

@@ -53,16 +53,16 @@ export class UmbTrashEntityAction extends UmbEntityActionBase {
         const actionEventContext = await this.getContext(UMB_ACTION_EVENT_CONTEXT);
         if (!actionEventContext)
             throw new Error('Action event context is missing.');
-        const event = new UmbRequestReloadStructureForEntityEvent({
+        const trashedEvent = new UmbEntityTrashedEvent({
             unique: this.args.unique,
             entityType: this.args.entityType,
         });
-        actionEventContext.dispatchEvent(event);
-        const trashedEvent = new UmbEntityTrashedEvent({
+        actionEventContext.dispatchEvent(trashedEvent);
+        const event = new UmbRequestReloadStructureForEntityEvent({
             unique: this.args.unique,
             entityType: this.args.entityType,
         });
-        actionEventContext.dispatchEvent(trashedEvent);
+        actionEventContext.dispatchEvent(event);
     }
 }
 export { UmbTrashEntityAction as api };

package/dist-cms/packages/core/recycle-bin/index.d.ts

@@ -3,4 +3,6 @@ export * from './entity-action/index.js';
 export * from './entity-bulk-action/index.js';
 export { UmbRecycleBinRepositoryBase } from './recycle-bin-repository-base.js';
 export { UmbIsTrashedEntityContext } from './contexts/is-trashed/index.js';
+export { UmbTrashableEntityWorkspaceController, UMB_TRASHABLE_ENTITY_WORKSPACE_CONTEXT, } from './workspace-context/index.js';
 export type * from './types.js';
+export type * from './workspace-context/types.js';

package/dist-cms/packages/core/recycle-bin/index.js

@@ -3,3 +3,4 @@ export * from './entity-action/index.js';
 export * from './entity-bulk-action/index.js';
 export { UmbRecycleBinRepositoryBase } from './recycle-bin-repository-base.js';
 export { UmbIsTrashedEntityContext } from './contexts/is-trashed/index.js';
+export { UmbTrashableEntityWorkspaceController, UMB_TRASHABLE_ENTITY_WORKSPACE_CONTEXT, } from './workspace-context/index.js';

package/dist-cms/packages/core/recycle-bin/manifests.js

@@ -6,6 +6,7 @@ import { manifests as trashEntityActionManifests } from './entity-action/trash/m
 import { manifests as trashFolderEntityActionManifests } from './entity-action/trash-folder/manifests.js';
 import { manifests as trashEntityBulkActionManifests } from './entity-bulk-action/bulk-trash/manifests.js';
 import { manifests as treeManifests } from './tree/manifests.js';
+import { manifests as workspaceContextManifests } from './workspace-context/manifests.js';
 export const manifests = [
     ...collectionActionManifests,
     ...conditionManifests,
@@ -15,4 +16,5 @@ export const manifests = [
     ...trashFolderEntityActionManifests,
     ...trashEntityBulkActionManifests,
     ...treeManifests,
+    ...workspaceContextManifests,
 ];

package/dist-cms/packages/core/recycle-bin/workspace-context/index.d.ts

@@ -0,0 +1,3 @@
+export { UmbTrashableEntityWorkspaceController } from './trashable-entity-workspace.controller.js';
+export { UMB_TRASHABLE_ENTITY_WORKSPACE_CONTEXT } from './trashable-entity-workspace.context-token.js';
+export type * from './types.js';

package/dist-cms/packages/core/recycle-bin/workspace-context/index.js

@@ -0,0 +1,2 @@
+export { UmbTrashableEntityWorkspaceController } from './trashable-entity-workspace.controller.js';
+export { UMB_TRASHABLE_ENTITY_WORKSPACE_CONTEXT } from './trashable-entity-workspace.context-token.js';

package/dist-cms/packages/core/recycle-bin/workspace-context/manifests.d.ts

@@ -0,0 +1,2 @@
+import type { UmbExtensionManifestKind } from '../../extension-registry/index.js';
+export declare const manifests: Array<UmbExtensionManifestKind>;

package/dist-cms/packages/core/recycle-bin/workspace-context/manifests.js

@@ -0,0 +1,14 @@
+import { UmbTrashableEntityWorkspaceController } from './trashable-entity-workspace.controller.js';
+export const manifests = [
+    {
+        type: 'kind',
+        alias: 'Umb.Kind.WorkspaceContext.Trashable',
+        matchKind: 'trashable',
+        matchType: 'workspaceContext',
+        manifest: {
+            type: 'workspaceContext',
+            kind: 'trashable',
+            api: UmbTrashableEntityWorkspaceController,
+        },
+    },
+];

package/dist-cms/packages/core/recycle-bin/workspace-context/trashable-entity-workspace-context.test-utils.d.ts

@@ -0,0 +1,62 @@
+import type { UmbTrashableEntityWorkspaceContext } from './types.js';
+import type { UmbControllerHost } from '../../../../libs/controller-api/index.js';
+import type { UmbGuardRule, UmbReadOnlyGuardManager } from '../../utils/index.js';
+import type { UmbNameWriteGuardManager } from '../../workspace/index.js';
+declare const UmbTestRecycleBinControllerHostElement_base: import("../../../../libs/extension-api/index.js").HTMLElementConstructor<import("../../../../libs/controller-api/index.js").UmbControllerHostElement> & {
+    new (): HTMLElement;
+    prototype: HTMLElement;
+};
+export declare class UmbTestRecycleBinControllerHostElement extends UmbTestRecycleBinControllerHostElement_base {
+}
+export interface UmbTestGuardRuleCall {
+    action: 'add' | 'remove';
+    unique: string;
+    permitted?: boolean;
+}
+/**
+ * A minimal, hand-written `UmbTrashableEntityWorkspaceContext` — stands in for a real document/media workspace
+ * context in isolated tests, recording the calls the recycle-bin context makes against it.
+ */
+export declare class UmbTestTrashableEntityWorkspaceContext implements UmbTrashableEntityWorkspaceContext {
+    #private;
+    readonly workspaceAlias = "Umb.Test.Workspace";
+    readonly unique: import("rxjs").Observable<string | null>;
+    readonly isTrashed: import("rxjs").Observable<boolean | undefined>;
+    readonly isNew: import("rxjs").Observable<boolean | undefined>;
+    readonly navigationParentItemPath: import("rxjs").Observable<string | undefined>;
+    modalContext: unknown;
+    readonly readOnlyGuardRuleCalls: Array<UmbTestGuardRuleCall>;
+    readonly readOnlyGuard: UmbReadOnlyGuardManager<UmbGuardRule>;
+    readonly nameWriteGuardRuleCalls: Array<UmbTestGuardRuleCall>;
+    readonly nameWriteGuard: UmbNameWriteGuardManager;
+    reloadCallCount: number;
+    resetDataCallCount: number;
+    constructor(host: UmbControllerHost);
+    getHostElement(): Element;
+    getUnique(): string | null;
+    getEntityType(): string;
+    setUnique(unique: string | null): void;
+    setEntityType(entityType: string): void;
+    setIsTrashed(value: boolean | undefined): void;
+    setIsNew(value: boolean | undefined): void;
+    setNavigationParentItemPath(path: string | undefined): void;
+    resetData(): void;
+    reload(): Promise<void>;
+    destroy(): void;
+}
+/**
+ * Monkey-patches `window.history.pushState`/`replaceState` to record calls instead of navigating — this project
+ * does not use sinon, so history calls are asserted against plain recorded-call arrays. Call `restore()` in
+ * `afterEach`.
+ * @returns {object} The recorded call arrays, and a `restore()` function to undo the monkey-patch.
+ */
+export declare function stubHistory(): {
+    pushStateCalls: {
+        url: string;
+    }[];
+    replaceStateCalls: {
+        url: string;
+    }[];
+    restore: () => void;
+};
+export {};

package/dist-cms/packages/core/recycle-bin/workspace-context/trashable-entity-workspace-context.test-utils.js

@@ -0,0 +1,109 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { UmbControllerHostElementMixin } from '../../../../libs/controller-api/index.js';
+import { customElement } from '../../../../external/lit/index.js';
+import { UmbBooleanState, UmbObjectState } from '../../../../libs/observable-api/index.js';
+let UmbTestRecycleBinControllerHostElement = class UmbTestRecycleBinControllerHostElement extends UmbControllerHostElementMixin(HTMLElement) {
+};
+UmbTestRecycleBinControllerHostElement = __decorate([
+    customElement('umb-test-recycle-bin-controller-host')
+], UmbTestRecycleBinControllerHostElement);
+export { UmbTestRecycleBinControllerHostElement };
+/**
+ * A minimal, hand-written `UmbTrashableEntityWorkspaceContext` — stands in for a real document/media workspace
+ * context in isolated tests, recording the calls the recycle-bin context makes against it.
+ */
+export class UmbTestTrashableEntityWorkspaceContext {
+    #host;
+    #unique;
+    #entityType;
+    #isTrashed;
+    #isNew;
+    #navigationParentItemPath;
+    constructor(host) {
+        this.#unique = new UmbObjectState('test-unique');
+        this.#entityType = 'test-entity-type';
+        this.#isTrashed = new UmbBooleanState(undefined);
+        this.#isNew = new UmbBooleanState(undefined);
+        this.#navigationParentItemPath = new UmbObjectState(undefined);
+        this.workspaceAlias = 'Umb.Test.Workspace';
+        this.unique = this.#unique.asObservable();
+        this.isTrashed = this.#isTrashed.asObservable();
+        this.isNew = this.#isNew.asObservable();
+        this.navigationParentItemPath = this.#navigationParentItemPath.asObservable();
+        this.readOnlyGuardRuleCalls = [];
+        this.readOnlyGuard = {
+            addRule: (rule) => this.readOnlyGuardRuleCalls.push({ action: 'add', unique: rule.unique, permitted: rule.permitted }),
+            removeRule: (unique) => this.readOnlyGuardRuleCalls.push({ action: 'remove', unique }),
+        };
+        this.nameWriteGuardRuleCalls = [];
+        this.nameWriteGuard = {
+            addRule: (rule) => this.nameWriteGuardRuleCalls.push({ action: 'add', unique: rule.unique, permitted: rule.permitted }),
+            removeRule: (unique) => this.nameWriteGuardRuleCalls.push({ action: 'remove', unique }),
+        };
+        this.reloadCallCount = 0;
+        this.resetDataCallCount = 0;
+        this.#host = host;
+    }
+    getHostElement() {
+        return this.#host.getHostElement();
+    }
+    getUnique() {
+        return this.#unique.getValue();
+    }
+    getEntityType() {
+        return this.#entityType;
+    }
+    setUnique(unique) {
+        this.#unique.setValue(unique);
+    }
+    setEntityType(entityType) {
+        this.#entityType = entityType;
+    }
+    setIsTrashed(value) {
+        this.#isTrashed.setValue(value);
+    }
+    setIsNew(value) {
+        this.#isNew.setValue(value);
+    }
+    setNavigationParentItemPath(path) {
+        this.#navigationParentItemPath.setValue(path);
+    }
+    resetData() {
+        this.resetDataCallCount++;
+    }
+    async reload() {
+        this.reloadCallCount++;
+    }
+    destroy() { }
+}
+/**
+ * Monkey-patches `window.history.pushState`/`replaceState` to record calls instead of navigating — this project
+ * does not use sinon, so history calls are asserted against plain recorded-call arrays. Call `restore()` in
+ * `afterEach`.
+ * @returns {object} The recorded call arrays, and a `restore()` function to undo the monkey-patch.
+ */
+export function stubHistory() {
+    const originalPushState = window.history.pushState;
+    const originalReplaceState = window.history.replaceState;
+    const pushStateCalls = [];
+    const replaceStateCalls = [];
+    window.history.pushState = (_data, _unused, url) => {
+        pushStateCalls.push({ url: String(url) });
+    };
+    window.history.replaceState = (_data, _unused, url) => {
+        replaceStateCalls.push({ url: String(url) });
+    };
+    return {
+        pushStateCalls,
+        replaceStateCalls,
+        restore: () => {
+            window.history.pushState = originalPushState;
+            window.history.replaceState = originalReplaceState;
+        },
+    };
+}

package/dist-cms/packages/core/recycle-bin/workspace-context/trashable-entity-workspace.context-token.d.ts

@@ -0,0 +1,4 @@
+import type { UmbTrashableEntityWorkspaceContext } from './types.js';
+import { UmbContextToken } from '../../../../libs/context-api/index.js';
+import type { UmbWorkspaceContext } from '../../workspace/index.js';
+export declare const UMB_TRASHABLE_ENTITY_WORKSPACE_CONTEXT: UmbContextToken<UmbWorkspaceContext, UmbTrashableEntityWorkspaceContext>;

package/dist-cms/packages/core/recycle-bin/workspace-context/trashable-entity-workspace.context-token.js

@@ -0,0 +1,2 @@
+import { UmbContextToken } from '../../../../libs/context-api/index.js';
+export const UMB_TRASHABLE_ENTITY_WORKSPACE_CONTEXT = new UmbContextToken('UmbWorkspaceContext', undefined, (context) => 'reload' in context && 'isTrashed' in context && 'isNew' in context && 'navigationParentItemPath' in context);

package/dist-cms/packages/core/recycle-bin/workspace-context/trashable-entity-workspace.controller.d.ts

@@ -0,0 +1,16 @@
+import { UmbControllerBase } from '../../../../libs/class-api/index.js';
+import type { UmbControllerHost } from '../../../../libs/controller-api/index.js';
+/**
+ * Adds recycle-bin support (readonly-when-trashed, reload on trash/restore, redirect to parent when the current
+ * user trashes the open entity) to any workspace context satisfying {@link UmbTrashableEntityWorkspaceContext}.
+ * A plain controller, not a context — nothing needs to consume this from elsewhere. Registered directly as the
+ * default `api` of the `Umb.Kind.WorkspaceContext.Trashable` kind — entity types opt in via a `kind: 'trashable'`
+ * manifest instead of subclassing this.
+ * @class UmbTrashableEntityWorkspaceController
+ * @augments {UmbControllerBase}
+ */
+export declare class UmbTrashableEntityWorkspaceController extends UmbControllerBase {
+    #private;
+    constructor(host: UmbControllerHost);
+    destroy(): void;
+}

package/dist-cms/packages/core/recycle-bin/workspace-context/trashable-entity-workspace.controller.js

@@ -0,0 +1,111 @@
+import { UmbIsTrashedEntityContext } from '../contexts/is-trashed/is-trashed.entity-context.js';
+import { UmbEntityRestoredFromRecycleBinEvent, UmbEntityTrashedEvent } from '../entity-action/index.js';
+import { UMB_TRASHABLE_ENTITY_WORKSPACE_CONTEXT } from './trashable-entity-workspace.context-token.js';
+import { UMB_ACTION_EVENT_CONTEXT } from '../../action/index.js';
+import { UmbControllerBase } from '../../../../libs/class-api/index.js';
+/**
+ * Adds recycle-bin support (readonly-when-trashed, reload on trash/restore, redirect to parent when the current
+ * user trashes the open entity) to any workspace context satisfying {@link UmbTrashableEntityWorkspaceContext}.
+ * A plain controller, not a context — nothing needs to consume this from elsewhere. Registered directly as the
+ * default `api` of the `Umb.Kind.WorkspaceContext.Trashable` kind — entity types opt in via a `kind: 'trashable'`
+ * manifest instead of subclassing this.
+ * @class UmbTrashableEntityWorkspaceController
+ * @augments {UmbControllerBase}
+ */
+export class UmbTrashableEntityWorkspaceController extends UmbControllerBase {
+    #workspaceContext;
+    #actionEventContext;
+    #isTrashedContext = new UmbIsTrashedEntityContext(this);
+    #navigationParentItemPath;
+    constructor(host) {
+        super(host);
+        this.consumeContext(UMB_TRASHABLE_ENTITY_WORKSPACE_CONTEXT, (workspaceContext) => {
+            this.#workspaceContext = workspaceContext;
+            this.observe(this.#workspaceContext?.isTrashed, (isTrashed) => this.#onTrashStateChange(isTrashed), 'umbRecycleBinObserveIsTrashed');
+            this.observe(this.#workspaceContext?.isNew, (isNew) => {
+                if (isNew) {
+                    this.#isTrashedContext.setIsTrashed(false);
+                }
+            }, 'umbRecycleBinObserveIsNew');
+            this.observe(this.#workspaceContext?.navigationParentItemPath, (path) => (this.#navigationParentItemPath = path), 'umbRecycleBinObserveNavigationParentItemPath');
+        });
+        this.consumeContext(UMB_ACTION_EVENT_CONTEXT, (actionEventContext) => {
+            this.#removeEventListeners();
+            this.#actionEventContext = actionEventContext;
+            this.#addEventListeners();
+        });
+    }
+    #addEventListeners() {
+        this.#actionEventContext?.addEventListener(UmbEntityTrashedEvent.TYPE, this.#onTrashed);
+        this.#actionEventContext?.addEventListener(UmbEntityRestoredFromRecycleBinEvent.TYPE, this.#onRestored);
+    }
+    #removeEventListeners() {
+        this.#actionEventContext?.removeEventListener(UmbEntityTrashedEvent.TYPE, this.#onTrashed);
+        this.#actionEventContext?.removeEventListener(UmbEntityRestoredFromRecycleBinEvent.TYPE, this.#onRestored);
+    }
+    #isMatchingEvent(event) {
+        return (event.getUnique() === this.#workspaceContext?.getUnique() &&
+            event.getEntityType() === this.#workspaceContext?.getEntityType());
+    }
+    #onRestored = (event) => {
+        if (!this.#isMatchingEvent(event))
+            return;
+        this.#workspaceContext?.reload();
+    };
+    #onTrashed = (event) => {
+        if (!this.#isMatchingEvent(event))
+            return;
+        // Only reload when staying put (a modal), to refresh the visible trashed state — when redirecting away,
+        // the new data isn't needed here.
+        if (event.getUnique() && !this.#workspaceContext?.modalContext) {
+            // The entity is already trashed server-side by this point, so any local edits are moot — reset
+            // the data first so pushState's navigation guard doesn't intercept the redirect with a "discard
+            // changes?" prompt the user never asked for.
+            this.#workspaceContext?.resetData();
+            try {
+                this.#redirectToParent();
+            }
+            catch (error) {
+                console.error('Failed to redirect after trashing, reloading in place instead:', error);
+                this.#workspaceContext?.reload();
+            }
+            return;
+        }
+        this.#workspaceContext?.reload();
+    };
+    #redirectToParent() {
+        const path = this.#navigationParentItemPath;
+        if (!path)
+            throw new Error('Navigation parent item path is not available.');
+        // Trashing doesn't delete the entity — it stays reachable, readonly, at its own edit URL. So unlike a
+        // delete or a rename, that URL is still worth keeping in history: pushState rather than replaceState.
+        window.history.pushState(null, '', path);
+    }
+    #onTrashStateChange(isTrashed) {
+        // TODO v20
+        // `undefined` means "not settled yet" (loading, or data just cleared), not "not trashed". Ideally
+        // that distinction would be forwarded to `#isTrashedContext` and left for consumers (e.g. the
+        // trashed/not-trashed conditions) to ignore as they see fit — but `UmbIsTrashedEntityContext` is
+        // public API typed as `boolean`, and widening it to `boolean | undefined` would be a breaking
+        // change. So keep the last settled value here instead of forwarding an unsettled one.
+        if (isTrashed === undefined)
+            return;
+        this.#isTrashedContext.setIsTrashed(isTrashed);
+        const guardUnique = `UMB_PREVENT_EDIT_TRASHED_ITEM`;
+        if (!isTrashed) {
+            this.#workspaceContext?.readOnlyGuard?.removeRule(guardUnique);
+            this.#workspaceContext?.nameWriteGuard?.removeRule(guardUnique);
+            return;
+        }
+        // `readOnlyGuard`'s rule reads as "permitted to be read-only" (true = locked), the opposite sense of
+        // `nameWriteGuard`'s, whose rule reads as "permitted to write" (false = blocked) — so trashed needs
+        // `permitted: true` on one and `permitted: false` on the other to mean the same thing.
+        this.#workspaceContext?.readOnlyGuard?.addRule({ unique: guardUnique, permitted: true });
+        const nameWriteGuardRule = { unique: guardUnique, permitted: false };
+        this.#workspaceContext?.nameWriteGuard?.addRule(nameWriteGuardRule);
+    }
+    destroy() {
+        this.#removeEventListeners();
+        super.destroy();
+    }
+}

package/dist-cms/packages/core/recycle-bin/workspace-context/types.d.ts

@@ -0,0 +1,22 @@
+import type { Observable } from '../../../../libs/observable-api/index.js';
+import type { UmbGuardRule, UmbReadOnlyGuardManager } from '../../utils/index.js';
+import type { UmbEntityWorkspaceContext, UmbNameWriteGuardManager } from '../../workspace/index.js';
+/**
+ * The minimal contract a workspace context must satisfy for recycle-bin support to be plugged into it.
+ */
+export interface UmbTrashableEntityWorkspaceContext extends UmbEntityWorkspaceContext {
+    readonly modalContext?: unknown;
+    readonly isTrashed: Observable<boolean | undefined>;
+    readonly isNew: Observable<boolean | undefined>;
+    readonly navigationParentItemPath: Observable<string | undefined>;
+    reload(): Promise<void>;
+    /**
+     * The guard that locks editing while the entity is trashed. When absent, the recycle-bin controller skips it.
+     */
+    readonly readOnlyGuard?: UmbReadOnlyGuardManager<UmbGuardRule>;
+    /**
+     * The guard that blocks renaming while the entity is trashed. When absent, the recycle-bin controller skips it.
+     */
+    readonly nameWriteGuard?: UmbNameWriteGuardManager;
+    resetData(): void;
+}

package/dist-cms/packages/core/recycle-bin/workspace-context/types.js

@@ -0,0 +1 @@
+export {};

package/dist-cms/packages/core/resources/api-interceptor.controller.d.ts

@@ -33,7 +33,7 @@ export declare class UmbApiInterceptorController extends UmbControllerBase {
      */
     addErrorInterceptor(client: typeof umbHttpClient): void;
     /**
-     * Interceptor which checks responses for the umb-notifications header and displays them as a notification if any. Removes the umb-notifications from the headers.
+     * Interceptor which checks responses for the umb-notifications header and displays them as a notification if any.
      * @param {umbHttpClient} client The OpenAPI client to add the interceptor to. It can be any client supporting Response and Request interceptors.
      * @internal
      */