@umbraco-cms/backoffice 17.4.0-rc3 → 18.0.0-beta2

package/dist-cms/packages/elements/folder/tree/element-folder-tree-item.element.js

@@ -0,0 +1,19 @@
+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 { customElement } from '../../../../external/lit/index.js';
+import { UmbTreeItemElementBase } from '../../../core/tree/index.js';
+let UmbElementFolderTreeItemElement = class UmbElementFolderTreeItemElement extends UmbTreeItemElementBase {
+    set api(value) {
+        this.observe(value?.noAccess, (noAccess) => (this._noAccess = noAccess ?? false));
+        super.api = value;
+    }
+};
+UmbElementFolderTreeItemElement = __decorate([
+    customElement('umb-element-folder-tree-item')
+], UmbElementFolderTreeItemElement);
+export { UmbElementFolderTreeItemElement };
+export { UmbElementFolderTreeItemElement as element };

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

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

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

@@ -0,0 +1,10 @@
+import { UMB_ELEMENT_FOLDER_ENTITY_TYPE } from '../../entity.js';
+const treeItem = {
+    type: 'treeItem',
+    alias: 'Umb.TreeItem.ElementFolder',
+    name: 'Element Folder Tree Item',
+    element: () => import('./element-folder-tree-item.element.js'),
+    api: () => import('./element-folder-tree-item.context.js'),
+    forEntityTypes: [UMB_ELEMENT_FOLDER_ENTITY_TYPE],
+};
+export const manifests = [treeItem];

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

@@ -0,0 +1,11 @@
+import type { UmbElementTreeItemModel } from '../tree/types.js';
+import type { UMB_ELEMENT_FOLDER_ENTITY_TYPE } from '../entity.js';
+import type { UmbFolderModel } from '../../core/tree/index.js';
+export type * from './repository/types.js';
+export type * from './user-permissions/types.js';
+export interface UmbElementFolderTreeItemModel extends UmbElementTreeItemModel {
+    entityType: typeof UMB_ELEMENT_FOLDER_ENTITY_TYPE;
+}
+export interface UmbElementFolderModel extends UmbFolderModel {
+    isTrashed?: boolean;
+}

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

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

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

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

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

@@ -0,0 +1 @@
+export const UMB_ELEMENT_FOLDER_USER_PERMISSION_CONDITION_ALIAS = 'Umb.Condition.UserPermission.ElementFolder';

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

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

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

@@ -0,0 +1,103 @@
+import { observeMultiple } from '../../../../../libs/observable-api/index.js';
+import { UmbConditionBase } from '../../../../core/extension-registry/index.js';
+import { UMB_ANCESTORS_ENTITY_CONTEXT, UMB_ENTITY_CONTEXT } from '../../../../core/entity/index.js';
+import { UMB_CURRENT_USER_CONTEXT } from '../../../../user/current-user/index.js';
+export class UmbElementFolderUserPermissionCondition extends UmbConditionBase {
+    #entityType;
+    #unique;
+    #elementFolderPermissions;
+    #fallbackPermissions;
+    #ancestors = [];
+    constructor(host, args) {
+        super(host, args);
+        this.consumeContext(UMB_CURRENT_USER_CONTEXT, (context) => {
+            this.observe(context?.currentUser, (currentUser) => {
+                this.#elementFolderPermissions = currentUser?.permissions?.filter(this.#isElementFolderUserPermission);
+                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;
+        // Wait until the current user's permissions have loaded before evaluating,
+        // so we don't permit/deny based on incomplete data.
+        if (this.#elementFolderPermissions === undefined)
+            return;
+        if (this.#fallbackPermissions === undefined)
+            return;
+        const hasElementFolderPermissions = this.#elementFolderPermissions.length > 0;
+        // if there is no permissions for any elements we use the fallback permissions
+        if (!hasElementFolderPermissions) {
+            this.#check(this.#fallbackPermissions);
+            return;
+        }
+        // If there are element folder 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 (hasElementFolderPermissions) {
+            // 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 folder permission quickly
+            const reversedPath = [...path].reverse();
+            const elementFolderPermissionsMap = new Map(this.#elementFolderPermissions.map((p) => [p.elementContainer.id, p]));
+            // Find the closest element folder permission in the path
+            const closestElementFolderPermission = reversedPath.find((id) => elementFolderPermissionsMap.has(id));
+            // Retrieve the corresponding permission data
+            const match = closestElementFolderPermission
+                ? elementFolderPermissionsMap.get(closestElementFolderPermission)
+                : undefined;
+            // no permissions for the current element folder - 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;
+    }
+    #isElementFolderUserPermission(permission) {
+        return (permission.$type ===
+            'ElementContainerPermissionPresentationModel');
+    }
+}
+export { UmbElementFolderUserPermissionCondition as api };

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

@@ -0,0 +1,2 @@
+export * from './constants.js';
+export { UmbElementFolderUserPermissionCondition } from './element-folder-user-permission.condition.js';

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

@@ -0,0 +1,2 @@
+export * from './constants.js';
+export { UmbElementFolderUserPermissionCondition } from './element-folder-user-permission.condition.js';

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,6 @@
+export declare const UMB_USER_PERMISSION_ELEMENT_FOLDER_CREATE = "Umb.ElementContainer.Create";
+export declare const UMB_USER_PERMISSION_ELEMENT_FOLDER_DELETE = "Umb.ElementContainer.Delete";
+export declare const UMB_USER_PERMISSION_ELEMENT_FOLDER_MOVE = "Umb.ElementContainer.Move";
+export declare const UMB_USER_PERMISSION_ELEMENT_FOLDER_READ = "Umb.ElementContainer.Read";
+export declare const UMB_USER_PERMISSION_ELEMENT_FOLDER_UPDATE = "Umb.ElementContainer.Update";
+export * from './conditions/constants.js';

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

@@ -0,0 +1,6 @@
+export const UMB_USER_PERMISSION_ELEMENT_FOLDER_CREATE = 'Umb.ElementContainer.Create';
+export const UMB_USER_PERMISSION_ELEMENT_FOLDER_DELETE = 'Umb.ElementContainer.Delete';
+export const UMB_USER_PERMISSION_ELEMENT_FOLDER_MOVE = 'Umb.ElementContainer.Move';
+export const UMB_USER_PERMISSION_ELEMENT_FOLDER_READ = 'Umb.ElementContainer.Read';
+export const UMB_USER_PERMISSION_ELEMENT_FOLDER_UPDATE = 'Umb.ElementContainer.Update';
+export * from './conditions/constants.js';

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

@@ -0,0 +1,2 @@
+export * from './constants.js';
+export type * from './types.js';

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

@@ -0,0 +1 @@
+export * from './constants.js';

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

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

package/dist-cms/packages/elements/folder/user-permissions/input-element-folder-granular-user-permission.element.js

@@ -0,0 +1,222 @@
+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 { UmbElementFolderItemRepository } from '../repository/item/element-folder-item.repository.js';
+import { UMB_ELEMENT_PICKER_MODAL } from '../../modals/element-picker-modal.token.js';
+import { css, customElement, html, property, repeat, state } from '../../../../external/lit/index.js';
+import { umbExtensionsRegistry } from '../../../core/extension-registry/index.js';
+import { UmbLitElement } from '../../../core/lit-element/index.js';
+import { UmbChangeEvent, UmbSelectedEvent } from '../../../core/event/index.js';
+import { UMB_ENTITY_USER_PERMISSION_MODAL } from '../../../user/user-permission/index.js';
+import { UMB_MODAL_MANAGER_CONTEXT } from '../../../core/modal/index.js';
+import { UUIFormControlMixin } from '../../../../external/uui/index.js';
+let UmbInputElementFolderGranularUserPermissionElement = class UmbInputElementFolderGranularUserPermissionElement extends UUIFormControlMixin(UmbLitElement, '') {
+    constructor() {
+        super(...arguments);
+        this.#permissions = [];
+        this.fallbackPermissions = [];
+        this.#folderItemRepository = new UmbElementFolderItemRepository(this);
+    }
+    #permissions;
+    get permissions() {
+        return this.#permissions;
+    }
+    set permissions(value) {
+        this.#permissions = value;
+        const uniques = value.map((item) => item.elementContainer.id);
+        this.#observePickedFolders(uniques);
+    }
+    #folderItemRepository;
+    #folderPickerModalContext;
+    #entityUserPermissionModalContext;
+    getFormElement() {
+        return undefined;
+    }
+    async #observePickedFolders(uniques) {
+        const { asObservable } = await this.#folderItemRepository.requestItems(uniques);
+        this.observe(asObservable?.(), (items) => {
+            this._items = items;
+        }, 'observeItems');
+    }
+    async #editGranularPermission(item) {
+        const currentPermissionVerbs = this.#getPermissionForFolder(item.unique)?.verbs ?? [];
+        const result = await this.#selectEntityUserPermissionsForFolder(item, currentPermissionVerbs);
+        // don't do anything if the verbs have not been updated
+        if (JSON.stringify(result) === JSON.stringify(currentPermissionVerbs))
+            return;
+        // update permission with new verbs
+        this.permissions = this.#permissions.map((permission) => {
+            if (permission.elementContainer.id === item.unique) {
+                return {
+                    ...permission,
+                    verbs: result,
+                };
+            }
+            return permission;
+        });
+        this.dispatchEvent(new UmbChangeEvent());
+    }
+    async #addGranularPermission() {
+        const modalManager = await this.getContext(UMB_MODAL_MANAGER_CONTEXT);
+        this.#folderPickerModalContext = modalManager?.open(this, UMB_ELEMENT_PICKER_MODAL, {
+            data: {
+                hideTreeRoot: true,
+                foldersOnly: true,
+                // prevent already selected items to be picked again
+                pickableFilter: (treeItem) => !this._items?.map((i) => i.unique).includes(treeItem.unique),
+            },
+        });
+        this.#folderPickerModalContext?.addEventListener(UmbSelectedEvent.TYPE, async (event) => {
+            const unique = event.unique;
+            if (!unique)
+                return;
+            const folderItem = await this.#requestFolderItem(unique);
+            this.#selectEntityUserPermissionsForFolder(folderItem).then((result) => {
+                this.#folderPickerModalContext?.reject();
+                const permissionItem = {
+                    $type: 'ElementContainerPermissionPresentationModel',
+                    elementContainer: { id: unique },
+                    verbs: result,
+                };
+                this.permissions = [...this.#permissions, permissionItem];
+                this.dispatchEvent(new UmbChangeEvent());
+            }, () => {
+                this.#folderPickerModalContext?.reject();
+            });
+        });
+    }
+    async #requestFolderItem(unique) {
+        if (!unique)
+            throw new Error('Could not open permissions modal, no unique was provided');
+        const { data } = await this.#folderItemRepository.requestItems([unique]);
+        const folderItem = data?.[0];
+        if (!folderItem)
+            throw new Error('No element folder item found');
+        return folderItem;
+    }
+    async #selectEntityUserPermissionsForFolder(item, allowedVerbs = []) {
+        const headline = item.name ? `Permissions for ${item.name}` : 'Permissions';
+        const fallbackVerbs = this.#getFallbackPermissionVerbsForEntityType(item.entityType);
+        const value = allowedVerbs.length > 0 ? { allowedVerbs } : undefined;
+        const modalManager = await this.getContext(UMB_MODAL_MANAGER_CONTEXT);
+        this.#entityUserPermissionModalContext = modalManager?.open(this, UMB_ENTITY_USER_PERMISSION_MODAL, {
+            data: {
+                entityType: item.entityType,
+                headline,
+                preset: {
+                    allowedVerbs: fallbackVerbs,
+                },
+            },
+            value,
+        });
+        try {
+            // When the modal is submitted we return the new value from the modal
+            const value = await this.#entityUserPermissionModalContext?.onSubmit();
+            return value?.allowedVerbs;
+        }
+        catch {
+            // When the modal is rejected we return the current value
+            return allowedVerbs;
+        }
+    }
+    #removeGranularPermission(item) {
+        const permission = this.#getPermissionForFolder(item.unique);
+        if (!permission)
+            return;
+        this.permissions = this.#permissions.filter((v) => JSON.stringify(v) !== JSON.stringify(permission));
+        this.dispatchEvent(new UmbChangeEvent());
+    }
+    render() {
+        return html `${this.#renderItems()} ${this.#renderAddButton()}`;
+    }
+    #renderItems() {
+        if (!this._items)
+            return;
+        return html `
+			<uui-ref-list>
+				${repeat(this._items, (item) => item.unique, (item) => this.#renderRef(item))}
+			</uui-ref-list>
+		`;
+    }
+    #renderAddButton() {
+        return html `<uui-button
+			id="btn-add"
+			look="placeholder"
+			@click=${this.#addGranularPermission}
+			label=${this.localize.term('general_add')}></uui-button>`;
+    }
+    #renderRef(item) {
+        if (!item.unique)
+            return;
+        const permissionNames = this.#getPermissionNamesForFolder(item);
+        return html `
+			<uui-ref-node .name=${item.name} .detail=${permissionNames || ''}>
+				${this.#renderIcon(item)}
+				<uui-action-bar slot="actions">
+					${this.#renderEditButton(item)} ${this.#renderRemoveButton(item)}
+				</uui-action-bar>
+			</uui-ref-node>
+		`;
+    }
+    #renderIcon(item) {
+        if (!item.icon)
+            return;
+        return html `<umb-icon slot="icon" name=${item.icon}></umb-icon>`;
+    }
+    #renderEditButton(item) {
+        return html `
+			<uui-button
+				@click=${() => this.#editGranularPermission(item)}
+				label=${this.localize.term('general_edit')}></uui-button>
+		`;
+    }
+    #renderRemoveButton(item) {
+        return html `<uui-button
+			@click=${() => this.#removeGranularPermission(item)}
+			label=${this.localize.term('general_remove')}></uui-button>`;
+    }
+    #getPermissionForFolder(unique) {
+        return this.#permissions?.find((permission) => permission.elementContainer.id === unique);
+    }
+    #getPermissionNamesForFolder(item) {
+        const permission = this.#getPermissionForFolder(item.unique);
+        if (!permission)
+            return;
+        return umbExtensionsRegistry
+            .getByTypeAndFilter('entityUserPermission', (manifest) => manifest.forEntityTypes.includes(item.entityType) &&
+            manifest.meta.verbs.every((verb) => permission.verbs.includes(verb)))
+            .map((m) => {
+            const manifest = m;
+            return manifest.meta.label ? this.localize.string(manifest.meta.label) : manifest.name;
+        })
+            .join(', ');
+    }
+    #getFallbackPermissionVerbsForEntityType(entityType) {
+        const verbs = umbExtensionsRegistry
+            .getByTypeAndFilter('entityUserPermission', (manifest) => manifest.forEntityTypes.includes(entityType) &&
+            this.fallbackPermissions.map((verb) => manifest.meta.verbs.includes(verb)).includes(true))
+            .flatMap((permission) => permission.meta.verbs);
+        return [...new Set([...verbs])];
+    }
+    static { this.styles = [
+        css `
+			#btn-add {
+				width: 100%;
+			}
+		`,
+    ]; }
+};
+__decorate([
+    property({ type: Array, attribute: false })
+], UmbInputElementFolderGranularUserPermissionElement.prototype, "fallbackPermissions", void 0);
+__decorate([
+    state()
+], UmbInputElementFolderGranularUserPermissionElement.prototype, "_items", void 0);
+UmbInputElementFolderGranularUserPermissionElement = __decorate([
+    customElement('umb-input-element-folder-granular-user-permission')
+], UmbInputElementFolderGranularUserPermissionElement);
+export { UmbInputElementFolderGranularUserPermissionElement };
+export default UmbInputElementFolderGranularUserPermissionElement;

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

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

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

@@ -0,0 +1,80 @@
+import { UMB_ELEMENT_FOLDER_ENTITY_TYPE } from '../../entity.js';
+import { UMB_USER_PERMISSION_ELEMENT_FOLDER_CREATE, UMB_USER_PERMISSION_ELEMENT_FOLDER_DELETE, UMB_USER_PERMISSION_ELEMENT_FOLDER_MOVE, UMB_USER_PERMISSION_ELEMENT_FOLDER_READ, UMB_USER_PERMISSION_ELEMENT_FOLDER_UPDATE, } from './constants.js';
+import { manifests as conditions } from './conditions/manifests.js';
+const entityUserPermissions = [
+    {
+        type: 'entityUserPermission',
+        alias: 'Umb.EntityUserPermission.ElementFolder.Create',
+        name: 'Create Element Folder User Permission',
+        weight: 90,
+        forEntityTypes: [UMB_ELEMENT_FOLDER_ENTITY_TYPE],
+        meta: {
+            verbs: [UMB_USER_PERMISSION_ELEMENT_FOLDER_CREATE],
+            label: '#userPermissions_create',
+            description: '#userPermissions_create_element_folder',
+        },
+    },
+    {
+        type: 'entityUserPermission',
+        alias: 'Umb.EntityUserPermission.ElementFolder.Delete',
+        name: 'Delete Element Folder User Permission',
+        weight: 80,
+        forEntityTypes: [UMB_ELEMENT_FOLDER_ENTITY_TYPE],
+        meta: {
+            verbs: [UMB_USER_PERMISSION_ELEMENT_FOLDER_DELETE],
+            label: '#userPermissions_delete',
+            description: '#userPermissions_delete_element_folder',
+        },
+    },
+    {
+        type: 'entityUserPermission',
+        alias: 'Umb.EntityUserPermission.ElementFolder.Move',
+        name: 'Move Element Folder User Permission',
+        forEntityTypes: [UMB_ELEMENT_FOLDER_ENTITY_TYPE],
+        meta: {
+            verbs: [UMB_USER_PERMISSION_ELEMENT_FOLDER_MOVE],
+            label: '#userPermissions_move',
+            description: '#userPermissions_move_element_folder',
+            group: 'structure',
+        },
+    },
+    {
+        type: 'entityUserPermission',
+        alias: 'Umb.EntityUserPermission.ElementFolder.Read',
+        name: 'Read Element Folder User Permission',
+        weight: 100,
+        forEntityTypes: [UMB_ELEMENT_FOLDER_ENTITY_TYPE],
+        meta: {
+            verbs: [UMB_USER_PERMISSION_ELEMENT_FOLDER_READ],
+            label: '#userPermissions_read',
+            description: '#userPermissions_read_element_folder',
+        },
+    },
+    {
+        type: 'entityUserPermission',
+        alias: 'Umb.EntityUserPermission.ElementFolder.Update',
+        name: 'Update Element Folder User Permission',
+        forEntityTypes: [UMB_ELEMENT_FOLDER_ENTITY_TYPE],
+        meta: {
+            verbs: [UMB_USER_PERMISSION_ELEMENT_FOLDER_UPDATE],
+            label: '#userPermissions_update',
+            description: '#userPermissions_update_element_folder',
+        },
+    },
+];
+// const granularPermissions: Array<ManifestGranularUserPermission> = [
+// 	{
+// 		type: 'userGranularPermission',
+// 		alias: 'Umb.UserGranularPermission.ElementFolder',
+// 		name: 'Element Folder Granular User Permission',
+// 		weight: 900,
+// 		forEntityTypes: [UMB_ELEMENT_FOLDER_ENTITY_TYPE],
+// 		element: () => import('./input-element-folder-granular-user-permission.element.js'),
+// 		meta: {
+// 			schemaType: 'ElementContainerPermissionPresentationModel',
+// 			label: '#user_permissionsGranular',
+// 			description: '{#userPermissions_granular_elementFolder}',
+// 		},
+// 	},
+// ];
+export const manifests = [...conditions, ...entityUserPermissions];

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

@@ -0,0 +1,7 @@
+import type { UmbUserPermissionModel } from '../../../user/user-permission/index.js';
+export type * from './conditions/types.js';
+export interface UmbElementFolderUserPermissionModel extends UmbUserPermissionModel {
+    elementContainer: {
+        id: string;
+    };
+}

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

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

package/dist-cms/packages/elements/folder/workspace/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const UMB_ELEMENT_FOLDER_WORKSPACE_ALIAS = "Umb.Workspace.ElementFolder";
+export * from './paths.js';
+export { UMB_ELEMENT_FOLDER_WORKSPACE_CONTEXT } from './element-folder.workspace.context-token.js';

package/dist-cms/packages/elements/folder/workspace/constants.js

@@ -0,0 +1,3 @@
+export const UMB_ELEMENT_FOLDER_WORKSPACE_ALIAS = 'Umb.Workspace.ElementFolder';
+export * from './paths.js';
+export { UMB_ELEMENT_FOLDER_WORKSPACE_CONTEXT } from './element-folder.workspace.context-token.js';

package/dist-cms/packages/elements/folder/workspace/element-folder-editor.element.d.ts

@@ -0,0 +1,10 @@
+import { UmbLitElement } from '../../../core/lit-element/index.js';
+export declare class UmbElementFolderWorkspaceEditorElement extends UmbLitElement {
+    render(): import("lit-html").TemplateResult<1>;
+}
+export { UmbElementFolderWorkspaceEditorElement as element };
+declare global {
+    interface HTMLElementTagNameMap {
+        'umb-element-folder-workspace-editor': UmbElementFolderWorkspaceEditorElement;
+    }
+}

package/dist-cms/packages/elements/folder/workspace/element-folder-editor.element.js

@@ -0,0 +1,18 @@
+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, customElement } from '../../../../external/lit/index.js';
+import { UmbLitElement } from '../../../core/lit-element/index.js';
+let UmbElementFolderWorkspaceEditorElement = class UmbElementFolderWorkspaceEditorElement extends UmbLitElement {
+    render() {
+        return html `<umb-folder-workspace-editor></umb-folder-workspace-editor>`;
+    }
+};
+UmbElementFolderWorkspaceEditorElement = __decorate([
+    customElement('umb-element-folder-workspace-editor')
+], UmbElementFolderWorkspaceEditorElement);
+export { UmbElementFolderWorkspaceEditorElement };
+export { UmbElementFolderWorkspaceEditorElement as element };

package/dist-cms/packages/elements/folder/workspace/element-folder-menu-structure.context.d.ts

@@ -0,0 +1,8 @@
+import { UmbMenuTreeStructureWorkspaceContextBase } from '../../../core/menu/index.js';
+import type { UmbStructureItemModel } from '../../../core/menu/index.js';
+import type { UmbControllerHost } from '../../../../libs/controller-api/index.js';
+export declare class UmbElementFolderMenuStructureContext extends UmbMenuTreeStructureWorkspaceContextBase {
+    constructor(host: UmbControllerHost);
+    getItemHref(structureItem: UmbStructureItemModel): string | undefined;
+}
+export default UmbElementFolderMenuStructureContext;