@umbraco-cms/backoffice 17.4.0-rc2 → 18.0.0-beta1

package/dist-cms/packages/elements/tree/element.tree.server.data-source.d.ts

@@ -0,0 +1,32 @@
+import type { UmbElementTreeChildrenOfRequestArgs, UmbElementTreeItemModel, UmbElementTreeRootItemsRequestArgs } from '../types.js';
+import { UmbControllerBase } from '../../../libs/class-api/index.js';
+import type { UmbTreeAncestorsOfRequestArgs, UmbTreeDataSource } from '../../core/tree/index.js';
+/**
+ * A data source for the Element tree that fetches data from the server
+ * @class UmbElementTreeServerDataSource
+ */
+export declare class UmbElementTreeServerDataSource extends UmbControllerBase implements UmbTreeDataSource<UmbElementTreeItemModel> {
+    #private;
+    getRootItems(args: UmbElementTreeRootItemsRequestArgs): Promise<{
+        data: {
+            items: UmbElementTreeItemModel[];
+            total: number;
+            totalBefore: number;
+            totalAfter: number;
+        } | undefined;
+        error: import("../../core/resources/index.js").UmbError | undefined;
+    }>;
+    getChildrenOf(args: UmbElementTreeChildrenOfRequestArgs): Promise<{
+        data: {
+            items: UmbElementTreeItemModel[];
+            total: number;
+            totalBefore: number;
+            totalAfter: number;
+        } | undefined;
+        error: import("../../core/resources/index.js").UmbError | undefined;
+    }>;
+    getAncestorsOf(args: UmbTreeAncestorsOfRequestArgs): Promise<{
+        data: UmbElementTreeItemModel[] | undefined;
+        error: import("../../core/resources/index.js").UmbCancelError | import("../../core/resources/index.js").UmbApiError | undefined;
+    }>;
+}

package/dist-cms/packages/elements/tree/element.tree.server.data-source.js

@@ -0,0 +1,68 @@
+import { UmbElementVariantState } from '../variant-state.js';
+import { UMB_ELEMENT_ENTITY_TYPE, UMB_ELEMENT_ROOT_ENTITY_TYPE, UMB_ELEMENT_FOLDER_ENTITY_TYPE } from '../entity.js';
+import { UmbManagementApiElementTreeDataRequestManager } from './element-tree.server.request-manager.js';
+import { UmbControllerBase } from '../../../libs/class-api/index.js';
+/**
+ * A data source for the Element tree that fetches data from the server
+ * @class UmbElementTreeServerDataSource
+ */
+export class UmbElementTreeServerDataSource extends UmbControllerBase {
+    #treeRequestManager = new UmbManagementApiElementTreeDataRequestManager(this);
+    async getRootItems(args) {
+        const { data, error } = await this.#treeRequestManager.getRootItems(args);
+        const mappedData = data
+            ? {
+                ...data,
+                items: data?.items.map((item) => this.#mapItem(item)),
+            }
+            : undefined;
+        return { data: mappedData, error };
+    }
+    async getChildrenOf(args) {
+        const { data, error } = await this.#treeRequestManager.getChildrenOf(args);
+        const mappedData = data
+            ? {
+                ...data,
+                items: data?.items.map((item) => this.#mapItem(item)),
+            }
+            : undefined;
+        return { data: mappedData, error };
+    }
+    async getAncestorsOf(args) {
+        const { data, error } = await this.#treeRequestManager.getAncestorsOf(args);
+        const mappedData = data?.map((item) => this.#mapItem(item));
+        return { data: mappedData, error };
+    }
+    #mapItem(item) {
+        return {
+            unique: item.id,
+            parent: {
+                unique: item.parent ? item.parent.id : null,
+                entityType: item.parent ? UMB_ELEMENT_ENTITY_TYPE : UMB_ELEMENT_ROOT_ENTITY_TYPE,
+            },
+            name: item.name,
+            entityType: item.isFolder ? UMB_ELEMENT_FOLDER_ENTITY_TYPE : UMB_ELEMENT_ENTITY_TYPE,
+            hasChildren: item.hasChildren,
+            isTrashed: false,
+            noAccess: item.noAccess,
+            isFolder: item.isFolder,
+            documentType: {
+                unique: item.documentType?.id ?? '',
+                icon: item.documentType?.icon ?? 'icon-document',
+                collection: null,
+            },
+            icon: item.isFolder ? 'icon-folder' : (item.documentType?.icon ?? 'icon-document'),
+            flags: item.flags,
+            createDate: item.createDate,
+            variants: item.isFolder
+                ? [{ name: item.name, culture: null, segment: null, state: UmbElementVariantState.PUBLISHED, flags: [] }]
+                : item.variants.map((variant) => ({
+                    name: variant.name,
+                    culture: variant.culture || null,
+                    segment: null, // TODO: add segment to the backend API?
+                    state: variant.state,
+                    flags: variant.flags,
+                })),
+        };
+    }
+}

package/dist-cms/packages/elements/tree/manifests.d.ts

@@ -0,0 +1 @@
+export declare const manifests: Array<UmbExtensionManifest>;

package/dist-cms/packages/elements/tree/manifests.js

@@ -0,0 +1,35 @@
+import { UMB_ELEMENT_ENTITY_TYPE, UMB_ELEMENT_ROOT_ENTITY_TYPE } from '../entity.js';
+import { UMB_ELEMENT_TREE_ALIAS, UMB_ELEMENT_TREE_REPOSITORY_ALIAS } from './constants.js';
+const repository = {
+    type: 'repository',
+    alias: UMB_ELEMENT_TREE_REPOSITORY_ALIAS,
+    name: 'Element Tree Repository',
+    api: () => import('./element-tree.repository.js'),
+};
+const tree = {
+    type: 'tree',
+    kind: 'default',
+    alias: UMB_ELEMENT_TREE_ALIAS,
+    name: 'Element Tree',
+    meta: {
+        repositoryAlias: UMB_ELEMENT_TREE_REPOSITORY_ALIAS,
+    },
+};
+const treeItems = [
+    {
+        type: 'treeItem',
+        alias: 'Umb.TreeItem.Element',
+        name: 'Element Tree Item',
+        element: () => import('./element-tree-item.element.js'),
+        api: () => import('./element-tree-item.context.js'),
+        forEntityTypes: [UMB_ELEMENT_ENTITY_TYPE],
+    },
+    {
+        type: 'treeItem',
+        kind: 'default',
+        alias: 'Umb.TreeItem.Element.Root',
+        name: 'Element Tree Root',
+        forEntityTypes: [UMB_ELEMENT_ROOT_ENTITY_TYPE],
+    },
+];
+export const manifests = [repository, tree, ...treeItems];

package/dist-cms/packages/elements/tree/types.d.ts

@@ -0,0 +1,39 @@
+import type { UmbElementVariantState } from '../variant-state.js';
+import type { UmbElementEntityType, UmbElementRootEntityType, UmbElementFolderEntityType } from '../entity.js';
+import type { UmbEntityFlag, UmbEntityWithFlags } from '../../core/entity-flag/index.js';
+import type { UmbReferenceByUnique } from '../../core/models/index.js';
+import type { UmbTreeChildrenOfRequestArgs, UmbTreeItemModel, UmbTreeRootItemsRequestArgs, UmbTreeRootModel } from '../../core/tree/index.js';
+export type { UmbElementTreeItemContext } from './element-tree-item.context.js';
+export type { UmbElementTreeRepository } from './element-tree.repository.js';
+export interface UmbElementTreeItemModel extends Omit<UmbTreeItemModel, 'flags'>, UmbEntityWithFlags {
+    entityType: UmbElementEntityType | UmbElementFolderEntityType;
+    isTrashed: boolean;
+    noAccess: boolean;
+    documentType: {
+        unique: string;
+        icon: string;
+        collection: UmbReferenceByUnique | null;
+    };
+    createDate: string;
+    variants: Array<UmbElementTreeItemVariantModel>;
+}
+export interface UmbElementTreeRootModel extends UmbTreeRootModel {
+    entityType: UmbElementRootEntityType;
+}
+export interface UmbElementTreeItemVariantModel {
+    name: string;
+    culture: string | null;
+    segment: string | null;
+    state: UmbElementVariantState;
+    flags: Array<UmbEntityFlag>;
+}
+export interface UmbElementTreeRootItemsRequestArgs extends UmbTreeRootItemsRequestArgs {
+    dataType?: {
+        unique: string;
+    };
+}
+export interface UmbElementTreeChildrenOfRequestArgs extends UmbTreeChildrenOfRequestArgs {
+    dataType?: {
+        unique: string;
+    };
+}

package/dist-cms/packages/elements/tree/types.js

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

package/dist-cms/packages/elements/types.d.ts

@@ -0,0 +1,36 @@
+import type { UmbElementEntityType } from './entity.js';
+import type { UmbElementVariantState } from './variant-state.js';
+import type { UmbContentDetailModel, UmbContentValueModel } from '../content/content/index.js';
+import type { UmbEntityVariantModel, UmbEntityVariantOptionModel } from '../core/variant/index.js';
+export type * from './audit-log/types.js';
+export type * from './collection/types.js';
+export type * from './entity.js';
+export type * from './item/types.js';
+export type * from './modals/types.js';
+export type * from './publishing/types.js';
+export type * from './recycle-bin/types.js';
+export type * from './tree/types.js';
+export type * from './user-permissions/types.js';
+export type * from './workspace/types.js';
+export interface UmbElementDetailModel extends UmbContentDetailModel {
+    documentType: {
+        unique: string;
+        collection: null;
+        icon?: string | null;
+    };
+    entityType: UmbElementEntityType;
+    unique: string;
+    isTrashed: boolean;
+    values: Array<UmbElementValueModel>;
+    variants: Array<UmbElementVariantModel>;
+}
+export interface UmbElementVariantModel extends UmbEntityVariantModel {
+    state?: UmbElementVariantState | null;
+    publishDate?: string | null;
+    scheduledPublishDate?: string | null;
+    scheduledUnpublishDate?: string | null;
+}
+export interface UmbElementValueModel<ValueType = unknown> extends UmbContentValueModel<ValueType> {
+}
+export interface UmbElementVariantOptionModel extends UmbEntityVariantOptionModel<UmbElementVariantModel> {
+}

package/dist-cms/packages/elements/types.js

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

package/dist-cms/packages/elements/umbraco-package.d.ts

@@ -0,0 +1,7 @@
+export declare const name = "Umbraco.Core.ElementManagement";
+export declare const extensions: {
+    name: string;
+    alias: string;
+    type: string;
+    js: () => Promise<typeof import("./manifests.js")>;
+}[];

package/dist-cms/packages/elements/umbraco-package.js

@@ -0,0 +1,9 @@
+export const name = 'Umbraco.Core.ElementManagement';
+export const extensions = [
+    {
+        name: 'Umbraco Element Management Bundle',
+        alias: 'Umb.Bundle.ElementManagement',
+        type: 'bundle',
+        js: () => import('./manifests.js'),
+    },
+];

package/dist-cms/packages/elements/user-permissions/conditions/constants.d.ts

@@ -0,0 +1 @@
+export declare const UMB_ELEMENT_USER_PERMISSION_CONDITION_ALIAS = "Umb.Condition.UserPermission.Element";

package/dist-cms/packages/elements/user-permissions/conditions/constants.js

@@ -0,0 +1 @@
+export const UMB_ELEMENT_USER_PERMISSION_CONDITION_ALIAS = 'Umb.Condition.UserPermission.Element';

package/dist-cms/packages/elements/user-permissions/conditions/element-user-permission.condition.d.ts

@@ -0,0 +1,9 @@
+import type { UmbElementUserPermissionConditionConfig } from './types.js';
+import type { UmbConditionControllerArguments, UmbExtensionCondition } from '../../../../libs/extension-api/index.js';
+import type { UmbControllerHost } from '../../../../libs/controller-api/index.js';
+import { UmbConditionBase } from '../../../core/extension-registry/index.js';
+export declare class UmbElementUserPermissionCondition extends UmbConditionBase<UmbElementUserPermissionConditionConfig> implements UmbExtensionCondition {
+    #private;
+    constructor(host: UmbControllerHost, args: UmbConditionControllerArguments<UmbElementUserPermissionConditionConfig>);
+}
+export { UmbElementUserPermissionCondition as api };

package/dist-cms/packages/elements/user-permissions/conditions/element-user-permission.condition.js

@@ -0,0 +1,95 @@
+import { UMB_CURRENT_USER_CONTEXT } from '../../../user/current-user/index.js';
+import { UMB_ANCESTORS_ENTITY_CONTEXT, UMB_ENTITY_CONTEXT } from '../../../core/entity/index.js';
+import { observeMultiple } from '../../../../libs/observable-api/index.js';
+import { UmbConditionBase } from '../../../core/extension-registry/index.js';
+export class UmbElementUserPermissionCondition extends UmbConditionBase {
+    #entityType;
+    #unique;
+    #elementPermissions = [];
+    #fallbackPermissions = [];
+    #ancestors = [];
+    constructor(host, args) {
+        super(host, args);
+        this.consumeContext(UMB_CURRENT_USER_CONTEXT, (context) => {
+            this.observe(context?.currentUser, (currentUser) => {
+                this.#elementPermissions = currentUser?.permissions?.filter(this.#isElementUserPermission) || [];
+                this.#fallbackPermissions = currentUser?.fallbackPermissions || [];
+                this.#checkPermissions();
+            }, 'umbUserPermissionConditionObserver');
+        });
+        this.consumeContext(UMB_ENTITY_CONTEXT, (context) => {
+            if (!context) {
+                this.removeUmbControllerByAlias('umbUserPermissionEntityContextObserver');
+                return;
+            }
+            this.observe(observeMultiple([context.entityType, context.unique]), ([entityType, unique]) => {
+                this.#entityType = entityType;
+                this.#unique = unique;
+                this.#checkPermissions();
+            }, 'umbUserPermissionEntityContextObserver');
+        });
+        this.consumeContext(UMB_ANCESTORS_ENTITY_CONTEXT, (instance) => {
+            this.observe(instance?.ancestors, (ancestors) => {
+                this.#ancestors = ancestors?.map((item) => item.unique) ?? [];
+                this.#checkPermissions();
+            }, 'observeAncestors');
+        });
+    }
+    #checkPermissions() {
+        if (!this.#entityType)
+            return;
+        if (this.#unique === undefined)
+            return;
+        const hasElementPermissions = this.#elementPermissions.length > 0;
+        // if there is no permissions for any elements we use the fallback permissions
+        if (!hasElementPermissions) {
+            this.#check(this.#fallbackPermissions);
+            return;
+        }
+        // If there are element permissions, we need to check the full path to see if any permissions are defined for the current element
+        // If we find multiple permissions in the same path, we will apply the closest one
+        if (hasElementPermissions) {
+            // Path including the current element and all ancestors
+            const path = [...this.#ancestors, this.#unique].filter((unique) => unique !== null);
+            // Reverse the path to find the closest element permission quickly
+            const reversedPath = [...path].reverse();
+            const elementPermissionsMap = new Map(this.#elementPermissions.map((p) => [p.element.id, p]));
+            // Find the closest element permission in the path
+            const closestElementPermission = reversedPath.find((id) => elementPermissionsMap.has(id));
+            // Retrieve the corresponding permission data
+            const match = closestElementPermission ? elementPermissionsMap.get(closestElementPermission) : undefined;
+            // no permissions for the current element - use the fallback permissions
+            if (!match) {
+                this.#check(this.#fallbackPermissions);
+                return;
+            }
+            // we found permissions - check them
+            this.#check(match.verbs);
+        }
+    }
+    #check(verbs) {
+        /* we default to true se we don't require both allOf and oneOf to be defined
+         but they can be combined for more complex scenarios */
+        let allOfPermitted = true;
+        let oneOfPermitted = true;
+        // check if all of the verbs are present
+        if (this.config.allOf?.length) {
+            allOfPermitted = this.config.allOf.every((verb) => verbs.includes(verb));
+        }
+        // check if at least one of the verbs is present
+        if (this.config.oneOf?.length) {
+            oneOfPermitted = this.config.oneOf.some((verb) => verbs.includes(verb));
+        }
+        // if neither allOf or oneOf is defined we default to false
+        if (!allOfPermitted && !oneOfPermitted) {
+            allOfPermitted = false;
+            oneOfPermitted = false;
+        }
+        this.permitted = allOfPermitted && oneOfPermitted;
+    }
+    #isElementUserPermission(permission) {
+        return (permission.$type ===
+            'ElementPermissionPresentationModel');
+    }
+}
+export { UmbElementUserPermissionCondition as api };

package/dist-cms/packages/elements/user-permissions/conditions/index.d.ts

@@ -0,0 +1 @@
+export { UmbElementUserPermissionCondition } from './element-user-permission.condition.js';

package/dist-cms/packages/elements/user-permissions/conditions/index.js

@@ -0,0 +1 @@
+export { UmbElementUserPermissionCondition } from './element-user-permission.condition.js';

package/dist-cms/packages/elements/user-permissions/conditions/manifests.d.ts

@@ -0,0 +1 @@
+export declare const manifests: Array<UmbExtensionManifest>;

package/dist-cms/packages/elements/user-permissions/conditions/manifests.js

@@ -0,0 +1,10 @@
+import { UMB_ELEMENT_USER_PERMISSION_CONDITION_ALIAS } from './constants.js';
+import { UmbElementUserPermissionCondition } from './element-user-permission.condition.js';
+export const manifests = [
+    {
+        type: 'condition',
+        name: 'Element User Permission Condition',
+        alias: UMB_ELEMENT_USER_PERMISSION_CONDITION_ALIAS,
+        api: UmbElementUserPermissionCondition,
+    },
+];

package/dist-cms/packages/elements/user-permissions/conditions/types.d.ts

@@ -0,0 +1,20 @@
+import type { UmbConditionConfigBase } from '../../../../libs/extension-api/index.js';
+export type UmbElementUserPermissionConditionConfig = UmbConditionConfigBase<'Umb.Condition.UserPermission.Element'> & {
+    /**
+     * The user must have all of the permissions in this array for the condition to be met.
+     * @example
+     * ["Umb.Element.Save", "Umb.Element.Publish"]
+     */
+    allOf?: Array<string>;
+    /**
+     * The user must have at least one of the permissions in this array for the condition to be met.
+     * @example
+     * ["Umb.Element.Save", "Umb.Element.Publish"]
+     */
+    oneOf?: Array<string>;
+};
+declare global {
+    interface UmbExtensionConditionConfigMap {
+        UmbElementUserPermissionConditionConfig: UmbElementUserPermissionConditionConfig;
+    }
+}

package/dist-cms/packages/elements/user-permissions/conditions/types.js

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

package/dist-cms/packages/elements/user-permissions/constants.d.ts

@@ -0,0 +1,10 @@
+export declare const UMB_USER_PERMISSION_ELEMENT_CREATE = "Umb.Element.Create";
+export declare const UMB_USER_PERMISSION_ELEMENT_DELETE = "Umb.Element.Delete";
+export declare const UMB_USER_PERMISSION_ELEMENT_DUPLICATE = "Umb.Element.Duplicate";
+export declare const UMB_USER_PERMISSION_ELEMENT_MOVE = "Umb.Element.Move";
+export declare const UMB_USER_PERMISSION_ELEMENT_PUBLISH = "Umb.Element.Publish";
+export declare const UMB_USER_PERMISSION_ELEMENT_READ = "Umb.Element.Read";
+export declare const UMB_USER_PERMISSION_ELEMENT_ROLLBACK = "Umb.Element.Rollback";
+export declare const UMB_USER_PERMISSION_ELEMENT_UNPUBLISH = "Umb.Element.Unpublish";
+export declare const UMB_USER_PERMISSION_ELEMENT_UPDATE = "Umb.Element.Update";
+export * from './conditions/constants.js';

package/dist-cms/packages/elements/user-permissions/constants.js

@@ -0,0 +1,10 @@
+export const UMB_USER_PERMISSION_ELEMENT_CREATE = 'Umb.Element.Create';
+export const UMB_USER_PERMISSION_ELEMENT_DELETE = 'Umb.Element.Delete';
+export const UMB_USER_PERMISSION_ELEMENT_DUPLICATE = 'Umb.Element.Duplicate';
+export const UMB_USER_PERMISSION_ELEMENT_MOVE = 'Umb.Element.Move';
+export const UMB_USER_PERMISSION_ELEMENT_PUBLISH = 'Umb.Element.Publish';
+export const UMB_USER_PERMISSION_ELEMENT_READ = 'Umb.Element.Read';
+export const UMB_USER_PERMISSION_ELEMENT_ROLLBACK = 'Umb.Element.Rollback';
+export const UMB_USER_PERMISSION_ELEMENT_UNPUBLISH = 'Umb.Element.Unpublish';
+export const UMB_USER_PERMISSION_ELEMENT_UPDATE = 'Umb.Element.Update';
+export * from './conditions/constants.js';

package/dist-cms/packages/elements/user-permissions/input-element-granular-user-permission.element.d.ts

@@ -0,0 +1,20 @@
+import type { UmbElementUserPermissionModel } from './types.js';
+import { UmbLitElement } from '../../core/lit-element/index.js';
+declare const UmbInputElementGranularUserPermissionElement_base: (new (...args: any[]) => import("@umbraco-ui/uui").UUIFormControlWithBasicsMixinElement<FormData | FormDataEntryValue>) & typeof UmbLitElement;
+export declare class UmbInputElementGranularUserPermissionElement extends UmbInputElementGranularUserPermissionElement_base {
+    #private;
+    get permissions(): Array<UmbElementUserPermissionModel>;
+    set permissions(value: Array<UmbElementUserPermissionModel>);
+    fallbackPermissions: Array<string>;
+    private _items?;
+    constructor();
+    protected getFormElement(): undefined;
+    render(): import("lit-html").TemplateResult<1>;
+    static styles: import("lit").CSSResult[];
+}
+export default UmbInputElementGranularUserPermissionElement;
+declare global {
+    interface HTMLElementTagNameMap {
+        'umb-input-element-granular-user-permission': UmbInputElementGranularUserPermissionElement;
+    }
+}