@umbraco-cms/backoffice 17.5.2 → 17.6.0-rc

package/dist-cms/packages/core/tree/view/table/tree-name-table-column-layout.element.js

@@ -0,0 +1,35 @@
+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 { html, nothing, customElement, property } from '../../../../../external/lit/index.js';
+import { UmbLitElement } from '../../../lit-element/index.js';
+import { UmbTextStyles } from '../../../style/index.js';
+let UmbTreeNameTableColumnLayoutElement = class UmbTreeNameTableColumnLayoutElement extends UmbLitElement {
+    #onOpenClick(e) {
+        e.stopPropagation();
+        this.value.onOpen?.();
+    }
+    render() {
+        if (!this.value)
+            return nothing;
+        const name = this.localize.string(this.value.name);
+        if (this.value.href) {
+            return html `<uui-button compact label=${name} href=${this.value.href}>${name}</uui-button>`;
+        }
+        if (this.value.onOpen) {
+            return html `<uui-button compact label=${name} @click=${this.#onOpenClick}>${name}</uui-button>`;
+        }
+        return html `<span>${name}</span>`;
+    }
+    static { this.styles = [UmbTextStyles]; }
+};
+__decorate([
+    property({ attribute: false })
+], UmbTreeNameTableColumnLayoutElement.prototype, "value", void 0);
+UmbTreeNameTableColumnLayoutElement = __decorate([
+    customElement('umb-tree-name-table-column-layout')
+], UmbTreeNameTableColumnLayoutElement);
+export { UmbTreeNameTableColumnLayoutElement };

package/dist-cms/packages/core/tree/view/table/types.d.ts

@@ -0,0 +1,23 @@
+import type { ManifestTreeView, MetaTreeView } from '../tree-view.extension.js';
+export interface MetaTreeViewTableKindColumn {
+    /** The property name on the tree item model to display in this column. */
+    field: string;
+    /** The column header label. Supports localization strings (e.g. `#general_status`). */
+    label: string;
+    /** Optional value type for rendering a value summary in this column. */
+    valueType?: keyof UmbValueTypeMap;
+}
+export interface MetaTreeViewTableKind extends Partial<MetaTreeView> {
+    /** Additional columns to render between the name and entity actions columns. */
+    columns?: Array<MetaTreeViewTableKindColumn>;
+}
+export interface ManifestTreeViewTableKind extends Omit<ManifestTreeView, 'meta'> {
+    type: 'treeView';
+    kind: 'table';
+    meta: MetaTreeViewTableKind;
+}
+declare global {
+    interface UmbExtensionManifestMap {
+        umbTreeViewTableKind: ManifestTreeViewTableKind;
+    }
+}

package/dist-cms/packages/core/tree/view/table/types.js

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

package/dist-cms/packages/core/tree/view/tree-view-element-base.d.ts

@@ -0,0 +1,21 @@
+import type { UmbTreeContext } from '../tree.context.interface.js';
+import type { UmbTreeItemModel, UmbTreeRootModel } from '../types.js';
+import { UmbLitElement } from '../../lit-element/index.js';
+/**
+ * Base class for tree view elements, providing the tree's root and selection state to subclasses.
+ * @template TreeItemType - The tree item model rendered by this view.
+ * @template TreeRootType - The tree root model for this view.
+ */
+export declare abstract class UmbTreeViewElementBase<TreeItemType extends UmbTreeItemModel = UmbTreeItemModel, TreeRootType extends UmbTreeRootModel = UmbTreeRootModel> extends UmbLitElement {
+    protected _treeContext?: UmbTreeContext<TreeItemType, TreeRootType>;
+    protected _treeRoot?: TreeRootType;
+    protected _selectable: boolean;
+    protected _selectOnly: boolean;
+    protected _selection: Array<string | null>;
+    constructor();
+    protected _gotTreeContext(): void;
+    protected _isSelectableItem(item: TreeItemType): boolean;
+    protected _isSelectedItem(unique: string | null): boolean;
+    protected _selectItem(unique: string | null): void;
+    protected _deselectItem(unique: string | null): void;
+}

package/dist-cms/packages/core/tree/view/tree-view-element-base.js

@@ -0,0 +1,58 @@
+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 { UMB_TREE_CONTEXT } from '../tree.context.token.js';
+import { state } from '../../../../external/lit/index.js';
+import { UmbLitElement } from '../../lit-element/index.js';
+/**
+ * Base class for tree view elements, providing the tree's root and selection state to subclasses.
+ * @template TreeItemType - The tree item model rendered by this view.
+ * @template TreeRootType - The tree root model for this view.
+ */
+export class UmbTreeViewElementBase extends UmbLitElement {
+    constructor() {
+        super();
+        this._selectable = false;
+        this._selectOnly = false;
+        this._selection = [];
+        this.consumeContext(UMB_TREE_CONTEXT, (context) => {
+            this._treeContext = context;
+            this._gotTreeContext();
+        });
+    }
+    _gotTreeContext() {
+        this.observe(this._treeContext?.treeRoot, (treeRoot) => (this._treeRoot = treeRoot), '_observeTreeRoot');
+        this.observe(this._treeContext?.selection.selectable, (selectable) => (this._selectable = selectable ?? false), '_observeSelectable');
+        this.observe(this._treeContext?.selectOnly, (selectOnly) => (this._selectOnly = selectOnly ?? false), '_observeSelectOnly');
+        this.observe(this._treeContext?.selection.selection, (selection) => (this._selection = selection ?? []), '_observeSelection');
+    }
+    _isSelectableItem(item) {
+        if (!this._selectable)
+            return false;
+        return this._treeContext?.selectableFilter?.(item) ?? true;
+    }
+    _isSelectedItem(unique) {
+        return this._treeContext?.selection.isSelected(unique) ?? false;
+    }
+    _selectItem(unique) {
+        this._treeContext?.selection.select(unique);
+    }
+    _deselectItem(unique) {
+        this._treeContext?.selection.deselect(unique);
+    }
+}
+__decorate([
+    state()
+], UmbTreeViewElementBase.prototype, "_treeRoot", void 0);
+__decorate([
+    state()
+], UmbTreeViewElementBase.prototype, "_selectable", void 0);
+__decorate([
+    state()
+], UmbTreeViewElementBase.prototype, "_selectOnly", void 0);
+__decorate([
+    state()
+], UmbTreeViewElementBase.prototype, "_selection", void 0);

package/dist-cms/packages/core/tree/view/tree-view.extension.d.ts

@@ -0,0 +1,28 @@
+import type { ManifestElement, ManifestWithDynamicConditions } from '../../../../libs/extension-api/index.js';
+export interface ManifestTreeView extends ManifestElement, ManifestWithDynamicConditions<UmbExtensionConditionConfig> {
+    type: 'treeView';
+    /**
+     * The tree aliases this view applies to. When omitted, the view applies to all trees.
+     */
+    forTrees?: Array<string>;
+    meta: MetaTreeView;
+}
+export interface MetaTreeView {
+    /**
+     * The friendly name of the tree view
+     */
+    label: string;
+    /**
+     * An icon to represent the tree view
+     * @examples [
+     *   "icon-list",
+     *   "icon-grid"
+     * ]
+     */
+    icon: string;
+}
+declare global {
+    interface UmbExtensionManifestMap {
+        umbTreeView: ManifestTreeView;
+    }
+}

package/dist-cms/packages/core/tree/view/tree-view.extension.js

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

package/dist-cms/packages/core/tree/view/tree-view.manager.d.ts

@@ -0,0 +1,29 @@
+import type { ManifestTreeView } from './tree-view.extension.js';
+import { UmbControllerBase } from '../../../../libs/class-api/index.js';
+import type { UmbControllerHost } from '../../../../libs/controller-api/index.js';
+import type { UmbInteractionMemoryManager } from '../../interaction-memory/index.js';
+/**
+ * Construction arguments for {@link UmbTreeViewManager}.
+ */
+export interface UmbTreeViewManagerArgs {
+    /**
+     * When provided, the selected tree view is remembered and restored across sessions.
+     */
+    interactionMemoryManager?: UmbInteractionMemoryManager;
+}
+/**
+ * Manages the available views for a tree and tracks which one is currently active.
+ */
+export declare class UmbTreeViewManager extends UmbControllerBase {
+    #private;
+    readonly views: import("rxjs").Observable<ManifestTreeView[]>;
+    readonly currentView: import("rxjs").Observable<ManifestTreeView | undefined>;
+    /**
+     * @param {UmbControllerHost} host - The controller host this manager is bound to.
+     * @param {UmbTreeViewManagerArgs} [args] - Optional construction arguments.
+     */
+    constructor(host: UmbControllerHost, args?: UmbTreeViewManagerArgs);
+    setTreeAlias(treeAlias: string): void;
+    setCurrentView(view: ManifestTreeView): void;
+    getCurrentView(): ManifestTreeView | undefined;
+}

package/dist-cms/packages/core/tree/view/tree-view.manager.js

@@ -0,0 +1,104 @@
+import { UmbControllerBase } from '../../../../libs/class-api/index.js';
+import { UmbExtensionsManifestInitializer } from '../../../../libs/extension-api/index.js';
+import { umbExtensionsRegistry } from '../../extension-registry/index.js';
+import { UmbArrayState, UmbObjectState } from '../../../../libs/observable-api/index.js';
+import { UmbDeprecation } from '../../utils/index.js';
+/**
+ * Fallback used when no `treeView` manifests are registered.
+ * Trees should register at least one treeView manifest using `kind: 'classic'`.
+ * @deprecated Register a treeView manifest with `kind: 'classic'` on your tree instead.
+ */
+const CLASSIC_FALLBACK = {
+    type: 'treeView',
+    kind: 'classic',
+    alias: 'Umb.TreeView.Classic.Fallback',
+    name: 'Classic Tree View (fallback)',
+    element: () => import('./classic/classic-tree-view.element.js'),
+    weight: 0,
+    meta: {
+        label: '#tree_classicViewLabel',
+        icon: 'icon-blockquote',
+    },
+};
+const MEMORY_UNIQUE = 'UmbTreeCurrentView';
+/**
+ * Manages the available views for a tree and tracks which one is currently active.
+ */
+export class UmbTreeViewManager extends UmbControllerBase {
+    #views;
+    #currentView;
+    #treeAlias;
+    #extensionsInitializer;
+    #interactionMemoryManager;
+    #muteMemoryObservation;
+    /**
+     * @param {UmbControllerHost} host - The controller host this manager is bound to.
+     * @param {UmbTreeViewManagerArgs} [args] - Optional construction arguments.
+     */
+    constructor(host, args) {
+        super(host);
+        this.#views = new UmbArrayState([], (x) => x.alias);
+        this.views = this.#views.asObservable();
+        this.#currentView = new UmbObjectState(undefined);
+        this.currentView = this.#currentView.asObservable();
+        this.#muteMemoryObservation = false;
+        this.#interactionMemoryManager = args?.interactionMemoryManager;
+        if (this.#interactionMemoryManager) {
+            this.#observeInteractionMemory();
+        }
+    }
+    setTreeAlias(treeAlias) {
+        if (this.#treeAlias === treeAlias)
+            return;
+        this.#treeAlias = treeAlias;
+        this.#extensionsInitializer?.destroy();
+        this.#extensionsInitializer = new UmbExtensionsManifestInitializer(this, umbExtensionsRegistry, 'treeView', (manifest) => !manifest.forTrees?.length || manifest.forTrees.includes(treeAlias), (result) => {
+            const views = result.map((v) => v.manifest);
+            this.#views.setValue(views);
+            if (!views.length) {
+                // No treeView manifests registered for this tree — use the built-in classic fallback.
+                new UmbDeprecation({
+                    removeInVersion: '20.0.0',
+                    deprecated: 'Implicit classic tree view fallback',
+                    solution: "Register a treeView manifest with `kind: 'classic'` on your tree. The automatic fallback will be removed in Umbraco 20.",
+                }).warn();
+                this.#currentView.setValue(CLASSIC_FALLBACK);
+                return;
+            }
+            const storedAlias = this.#interactionMemoryManager?.getMemory(MEMORY_UNIQUE)?.value?.alias;
+            const initialView = storedAlias ? (views.find((v) => v.alias === storedAlias) ?? views[0]) : views[0];
+            this.#writeToMemory(initialView);
+            this.#currentView.setValue(initialView);
+        });
+    }
+    setCurrentView(view) {
+        this.#writeToMemory(view);
+        this.#currentView.setValue(view);
+    }
+    getCurrentView() {
+        return this.#currentView.getValue();
+    }
+    #writeToMemory(view) {
+        if (!this.#interactionMemoryManager)
+            return;
+        const memory = { unique: MEMORY_UNIQUE, value: { alias: view.alias } };
+        this.#muteMemoryObservation = true;
+        this.#interactionMemoryManager.setMemory(memory);
+        this.#muteMemoryObservation = false;
+    }
+    #observeInteractionMemory() {
+        this.observe(this.#interactionMemoryManager.memory(MEMORY_UNIQUE), (memory) => {
+            if (this.#muteMemoryObservation)
+                return;
+            if (!memory)
+                return;
+            const views = this.#views.getValue();
+            if (!views.length)
+                return; // extensions not loaded yet; initializer callback will handle it
+            const match = views.find((v) => v.alias === memory.value?.alias);
+            if (match) {
+                this.#currentView.setValue(match);
+            }
+        }, 'umbTreeViewMemoryObserver');
+    }
+}

package/dist-cms/packages/core/tree/view/types.d.ts

@@ -0,0 +1,2 @@
+export type * from './tree-view.extension.js';
+export type * from './table/types.js';

package/dist-cms/packages/core/tree/view/types.js

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

package/dist-cms/packages/core/tree/workspace-view/index.d.ts

@@ -0,0 +1 @@
+export * from './tree-workspace-view.element.js';

package/dist-cms/packages/core/tree/workspace-view/index.js

@@ -0,0 +1 @@
+export * from './tree-workspace-view.element.js';

package/dist-cms/packages/core/tree/workspace-view/manifests.d.ts

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

package/dist-cms/packages/core/tree/workspace-view/manifests.js

@@ -0,0 +1,19 @@
+import { UmbTreeWorkspaceViewElement } from './tree-workspace-view.element.js';
+export const manifests = [
+    {
+        type: 'kind',
+        alias: 'Umb.Kind.WorkspaceView.Tree',
+        matchKind: 'tree',
+        matchType: 'workspaceView',
+        manifest: {
+            type: 'workspaceView',
+            kind: 'tree',
+            element: UmbTreeWorkspaceViewElement,
+            meta: {
+                label: '#tree_children',
+                pathname: 'children',
+                icon: 'icon-bulleted-list',
+            },
+        },
+    },
+];

package/dist-cms/packages/core/tree/workspace-view/tree-workspace-view.element.d.ts

@@ -0,0 +1,20 @@
+import type { ManifestWorkspaceViewTreeKind } from './types.js';
+import { nothing } from '../../../../external/lit/index.js';
+import { UmbLitElement } from '../../lit-element/index.js';
+import type { PropertyValues } from '../../../../external/lit/index.js';
+export declare class UmbTreeWorkspaceViewElement extends UmbLitElement {
+    #private;
+    manifest?: ManifestWorkspaceViewTreeKind;
+    private _parent?;
+    private _interactionMemories?;
+    constructor();
+    protected updated(changedProperties: PropertyValues): void;
+    render(): typeof nothing | import("lit-html").TemplateResult<1>;
+    static styles: import("lit").CSSResult;
+}
+export { UmbTreeWorkspaceViewElement as element };
+declare global {
+    interface HTMLElementTagNameMap {
+        'umb-tree-workspace-view': UmbTreeWorkspaceViewElement;
+    }
+}

package/dist-cms/packages/core/tree/workspace-view/tree-workspace-view.element.js

@@ -0,0 +1,94 @@
+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 { UMB_ENTITY_CONTEXT } from '../../entity/index.js';
+import { html, nothing, customElement, property, state, css } from '../../../../external/lit/index.js';
+import { UmbLitElement } from '../../lit-element/index.js';
+import { UMB_INTERACTION_MEMORY_CONTEXT } from '../../interaction-memory/index.js';
+let UmbTreeWorkspaceViewElement = class UmbTreeWorkspaceViewElement extends UmbLitElement {
+    #interactionMemoryContext;
+    constructor() {
+        super();
+        this.consumeContext(UMB_ENTITY_CONTEXT, (context) => {
+            const entityType = context?.getEntityType();
+            const unique = context?.getUnique();
+            this._parent = entityType && unique !== undefined ? { entityType, unique } : undefined;
+        });
+        this.consumeContext(UMB_INTERACTION_MEMORY_CONTEXT, (context) => {
+            this.#interactionMemoryContext = context;
+            this.#readInteractionMemory();
+        });
+    }
+    updated(changedProperties) {
+        super.updated(changedProperties);
+        if (changedProperties.has('manifest')) {
+            this.#readInteractionMemory();
+        }
+    }
+    #readInteractionMemory() {
+        const alias = this.manifest?.alias;
+        if (!alias || !this.#interactionMemoryContext)
+            return;
+        const stored = this.#interactionMemoryContext.memory.getMemory(alias);
+        this._interactionMemories = stored?.memories ?? [];
+    }
+    #onInteractionMemoriesChange(event) {
+        event.stopPropagation();
+        const alias = this.manifest?.alias;
+        if (!alias || !this.#interactionMemoryContext)
+            return;
+        const tree = event.currentTarget;
+        const memories = tree.interactionMemories;
+        if (memories.length > 0) {
+            this.#interactionMemoryContext.memory.setMemory({ unique: alias, memories });
+        }
+        else {
+            this.#interactionMemoryContext.memory.deleteMemory(alias);
+        }
+    }
+    render() {
+        if (!this.manifest)
+            return html ` <div>Missing Workspace View Manifest</div>`;
+        if (!this.manifest.meta.treeAlias)
+            return html ` <div>Missing Tree Alias as part of this Workspace View Manifest</div>`;
+        if (this._parent === undefined)
+            return nothing;
+        return html `<umb-tree
+			data-mark="tree:${this.manifest.meta.treeAlias}"
+			alias=${this.manifest.meta.treeAlias}
+			.props=${{
+            showToolbar: true,
+            showTreeActions: true,
+            hideTreeRoot: true,
+            startNode: this._parent,
+            interactionMemories: this._interactionMemories,
+            selectionConfiguration: {
+                selectable: false,
+            },
+        }}
+			@interaction-memories-change=${this.#onInteractionMemoriesChange}></umb-tree>`;
+    }
+    static { this.styles = css `
+		:host {
+			display: block;
+			padding: var(--uui-size-layout-1);
+		}
+	`; }
+};
+__decorate([
+    property({ type: Object, attribute: false })
+], UmbTreeWorkspaceViewElement.prototype, "manifest", void 0);
+__decorate([
+    state()
+], UmbTreeWorkspaceViewElement.prototype, "_parent", void 0);
+__decorate([
+    state()
+], UmbTreeWorkspaceViewElement.prototype, "_interactionMemories", void 0);
+UmbTreeWorkspaceViewElement = __decorate([
+    customElement('umb-tree-workspace-view')
+], UmbTreeWorkspaceViewElement);
+export { UmbTreeWorkspaceViewElement };
+export { UmbTreeWorkspaceViewElement as element };

package/dist-cms/packages/core/tree/workspace-view/types.d.ts

@@ -0,0 +1,14 @@
+import type { ManifestWorkspaceView, MetaWorkspaceView } from '../../workspace/index.js';
+export interface ManifestWorkspaceViewTreeKind extends ManifestWorkspaceView {
+    type: 'workspaceView';
+    kind: 'tree';
+    meta: MetaWorkspaceViewTreeKind;
+}
+export interface MetaWorkspaceViewTreeKind extends MetaWorkspaceView {
+    treeAlias: string;
+}
+declare global {
+    interface UmbExtensionManifestMap {
+        umbManifestWorkspaceViewTreeKind: ManifestWorkspaceViewTreeKind;
+    }
+}

package/dist-cms/packages/core/tree/workspace-view/types.js

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

package/dist-cms/packages/core/utils/deprecation/deprecation-origin.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Where a deprecated API was most likely called from, derived from the call stack.
+ * Best-effort and only used to annotate console warnings — never load-bearing.
+ */
+export interface UmbDeprecationOrigin {
+    /**
+     * - `core`: Umbraco backoffice itself
+     * - `package`: an `/App_Plugins/` package
+     * - `external`: other non-core code (e.g. a Razor Class Library)
+     * - `unknown`: could not be determined (e.g. a development build or no stack)
+     */
+    type: 'core' | 'package' | 'external' | 'unknown';
+    /** Human-readable label for the console message. */
+    label: string;
+}
+/**
+ * Classifies the caller of a deprecated API from a stack trace.
+ *
+ * The frames read: the deprecation util → the deprecated API (core) → … → the caller. So the first
+ * frame that is *not* core code is the most likely caller; if every frame is core, the caller is core
+ * itself. Detection only works for production builds where core is served under `/umbraco/backoffice/`
+ * — in development builds it returns `unknown`.
+ * @param {string | undefined} stack - A raw `Error.stack` string (the format differs per engine).
+ * @param {string} selfUrl - The deprecation util's own module URL (`import.meta.url`), used both to recognise core and to drop its own frames.
+ * @returns {UmbDeprecationOrigin} The classified origin.
+ */
+export declare function umbParseDeprecationOrigin(stack: string | undefined, selfUrl: string): UmbDeprecationOrigin;
+/**
+ * Decides whether a deprecation should be logged.
+ *
+ * Core-origin deprecations are noise in production — a consumer cannot act on Umbraco's own code — so
+ * they are suppressed there. Package, external and unknown origins are always logged so the responsible
+ * developer sees them.
+ * @param {UmbDeprecationOrigin} origin - The classified origin.
+ * @param {boolean} suppressCore - Whether core-origin warnings should be suppressed (production).
+ * @returns {boolean} `true` if the warning should be logged.
+ */
+export declare function umbShouldLogDeprecation(origin: UmbDeprecationOrigin, suppressCore: boolean): boolean;

package/dist-cms/packages/core/utils/deprecation/deprecation-origin.js

@@ -0,0 +1,44 @@
+// In a production build, core is served from this path; any frame under it is core code.
+const UMB_CORE_PATH_MARKER = '/umbraco/backoffice/';
+/**
+ * Classifies the caller of a deprecated API from a stack trace.
+ *
+ * The frames read: the deprecation util → the deprecated API (core) → … → the caller. So the first
+ * frame that is *not* core code is the most likely caller; if every frame is core, the caller is core
+ * itself. Detection only works for production builds where core is served under `/umbraco/backoffice/`
+ * — in development builds it returns `unknown`.
+ * @param {string | undefined} stack - A raw `Error.stack` string (the format differs per engine).
+ * @param {string} selfUrl - The deprecation util's own module URL (`import.meta.url`), used both to recognise core and to drop its own frames.
+ * @returns {UmbDeprecationOrigin} The classified origin.
+ */
+export function umbParseDeprecationOrigin(stack, selfUrl) {
+    if (!stack)
+        return { type: 'unknown', label: 'unknown' };
+    // Frame URLs, tolerant of Chrome "at fn (URL:1:2)" and Firefox/Safari "fn@URL:1:2"; strip line:col and any query/fragment.
+    const urls = Array.from(stack.matchAll(/(?:https?|blob|file):\/\/[^\s)'"]+/g)).map((match) => match[0].replace(/:\d+:\d+\)?$/, '').replace(/[?#].*$/, ''));
+    const selfBase = selfUrl.replace(/[?#].*$/, '');
+    const frames = urls.filter((url) => url !== selfBase);
+    const coreKnown = selfUrl.includes(UMB_CORE_PATH_MARKER) || frames.some((url) => url.includes(UMB_CORE_PATH_MARKER));
+    if (!coreKnown)
+        return { type: 'unknown', label: 'unknown' };
+    const caller = frames.find((url) => !url.includes(UMB_CORE_PATH_MARKER));
+    if (!caller)
+        return { type: 'core', label: 'Umbraco backoffice (core)' };
+    const appPlugin = caller.match(/\/App_Plugins\/([^/?#]+)/i);
+    if (appPlugin)
+        return { type: 'package', label: `package "${appPlugin[1]}" (/App_Plugins/${appPlugin[1]})` };
+    return { type: 'external', label: `custom code (${caller})` };
+}
+/**
+ * Decides whether a deprecation should be logged.
+ *
+ * Core-origin deprecations are noise in production — a consumer cannot act on Umbraco's own code — so
+ * they are suppressed there. Package, external and unknown origins are always logged so the responsible
+ * developer sees them.
+ * @param {UmbDeprecationOrigin} origin - The classified origin.
+ * @param {boolean} suppressCore - Whether core-origin warnings should be suppressed (production).
+ * @returns {boolean} `true` if the warning should be logged.
+ */
+export function umbShouldLogDeprecation(origin, suppressCore) {
+    return !(suppressCore && origin.type === 'core');
+}

package/dist-cms/packages/core/utils/deprecation/deprecation.d.ts

@@ -8,8 +8,22 @@ export declare class UmbDeprecation {
     #private;
     constructor(args: UmbDeprecationArgs);
     /**
-     * Logs a warning message to the console.
+     * Logs a deprecation warning to the console, annotated with the likely caller origin (Umbraco core,
+     * an `/App_Plugins` package, or other custom code). Core-origin warnings are suppressed in production
+     * builds, where a consumer cannot act on them.
      * @memberof UmbDeprecation
+     * @param {object} [options] - Options for the warning message.
+     * @param {boolean} [options.logAlways] - If true, the warning is always logged regardless of origin (defaults to false).
+     * @returns {void}
+     * @example
+     * const deprecation = new UmbDeprecation({
+     *   deprecated: 'The "foo" function is deprecated.',
+     *   removeInVersion: '2.0.0',
+     *   solution: 'Use the "bar" function instead.'
+     * });
+     * deprecation.warn();
      */
-    warn(): void;
+    warn(options?: {
+        logAlways?: boolean;
+    }): void;
 }

package/dist-cms/packages/core/utils/deprecation/deprecation.js

@@ -1,3 +1,5 @@
+import { umbIsProductionBuild } from '../is-production-build.function.js';
+import { umbParseDeprecationOrigin, umbShouldLogDeprecation } from './deprecation-origin.js';
 /**
  * Helper class for deprecation warnings.
  * @exports
@@ -14,10 +16,26 @@ export class UmbDeprecation {
         this.#solution = args.solution;
     }
     /**
-     * Logs a warning message to the console.
+     * Logs a deprecation warning to the console, annotated with the likely caller origin (Umbraco core,
+     * an `/App_Plugins` package, or other custom code). Core-origin warnings are suppressed in production
+     * builds, where a consumer cannot act on them.
      * @memberof UmbDeprecation
+     * @param {object} [options] - Options for the warning message.
+     * @param {boolean} [options.logAlways] - If true, the warning is always logged regardless of origin (defaults to false).
+     * @returns {void}
+     * @example
+     * const deprecation = new UmbDeprecation({
+     *   deprecated: 'The "foo" function is deprecated.',
+     *   removeInVersion: '2.0.0',
+     *   solution: 'Use the "bar" function instead.'
+     * });
+     * deprecation.warn();
      */
-    warn() {
-        console.warn(`${this.#messagePrefix} ${this.#deprecated} The feature will be removed in version ${this.#removeInVersion}. ${this.#solution}`);
+    warn(options = {}) {
+        const origin = umbParseDeprecationOrigin(new Error().stack, import.meta.url);
+        if (!options.logAlways && !umbShouldLogDeprecation(origin, umbIsProductionBuild()))
+            return;
+        const message = `${this.#messagePrefix} ${this.#deprecated} The feature will be removed in version ${this.#removeInVersion}. ${this.#solution}`;
+        console.warn(origin.type === 'unknown' ? message : `${message}\nOrigin: ${origin.label}`);
     }
 }

package/dist-cms/packages/core/utils/index.d.ts

@@ -11,6 +11,7 @@ export * from './expansion/index.js';
 export * from './get-guid-from-udi.function.js';
 export * from './get-processed-image-url.function.js';
 export * from './guard-manager/index.js';
+export * from './is-production-build.function.js';
 export * from './is-test-environment.function.js';
 export * from './math/math.js';
 export * from './media/image-size.function.js';

package/dist-cms/packages/core/utils/index.js

@@ -11,6 +11,7 @@ export * from './expansion/index.js';
 export * from './get-guid-from-udi.function.js';
 export * from './get-processed-image-url.function.js';
 export * from './guard-manager/index.js';
+export * from './is-production-build.function.js';
 export * from './is-test-environment.function.js';
 export * from './math/math.js';
 export * from './media/image-size.function.js';