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

package/dist-cms/packages/elements/publishing/workspace-context/element-publishing.workspace-context.js

@@ -0,0 +1,401 @@
+import { UMB_ELEMENT_WORKSPACE_CONTEXT } from '../../workspace/element-workspace.context-token.js';
+import { UmbElementVariantState } from '../../variant-state.js';
+import { UmbElementPublishingRepository } from '../repository/index.js';
+import { UmbElementPublishedPendingChangesManager } from '../pending-changes/index.js';
+import { UMB_ELEMENT_PUBLISH_MODAL } from '../publish/constants.js';
+import { UMB_ELEMENT_UNPUBLISH_MODAL } from '../unpublish/constants.js';
+import { UMB_ELEMENT_SCHEDULE_MODAL } from '../schedule-publish/constants.js';
+import { UMB_ELEMENT_ENTITY_TYPE } from '../../entity.js';
+import { UMB_ELEMENT_WORKSPACE_ALIAS } from '../../workspace/constants.js';
+import { UMB_ELEMENT_PUBLISHING_WORKSPACE_CONTEXT } from './element-publishing.workspace-context.token.js';
+import { UMB_ELEMENT_PUBLISHING_SHORTCUT_UNIQUE } from './constants.js';
+import { firstValueFrom } from '../../../../external/rxjs/index.js';
+import { observeMultiple } from '../../../../libs/observable-api/index.js';
+import { umbOpenModal } from '../../../core/modal/index.js';
+import { UmbContextBase } from '../../../../libs/class-api/index.js';
+import { UmbLocalizationController } from '../../../../libs/localization-api/index.js';
+import { UmbRequestReloadStructureForEntityEvent } from '../../../core/entity-action/index.js';
+import { UmbVariantId } from '../../../core/variant/index.js';
+import { UMB_ACTION_EVENT_CONTEXT } from '../../../core/action/index.js';
+import { UMB_NOTIFICATION_CONTEXT } from '../../../core/notification/index.js';
+export class UmbElementPublishingWorkspaceContext extends UmbContextBase {
+    #init;
+    #elementWorkspaceContext;
+    #eventContext;
+    #publishingRepository;
+    #publishedElementData;
+    #currentUnique;
+    #notificationContext;
+    #localize;
+    constructor(host) {
+        super(host, UMB_ELEMENT_PUBLISHING_WORKSPACE_CONTEXT);
+        /**
+         * Manages the pending changes for the published element.
+         * @memberof UmbElementPublishingWorkspaceContext
+         */
+        this.publishedPendingChanges = new UmbElementPublishedPendingChangesManager(this);
+        this.#publishingRepository = new UmbElementPublishingRepository(this);
+        this.#localize = new UmbLocalizationController(this);
+        this.workspaceAlias = UMB_ELEMENT_WORKSPACE_ALIAS;
+        this.#publishableVariantsFilter = (option) => {
+            const variantId = UmbVariantId.Create(option);
+            // If the read only guard is permitted it means the variant is read only
+            const isReadOnly = this.#elementWorkspaceContext.readOnlyGuard.getIsPermittedForVariant(variantId);
+            // If the variant is read only, we can't publish it
+            return !isReadOnly;
+        };
+        this.#init = Promise.all([
+            this.consumeContext(UMB_ELEMENT_WORKSPACE_CONTEXT, async (context) => {
+                if (this.#elementWorkspaceContext) {
+                    // remove shortcut:
+                    this.#elementWorkspaceContext.view.shortcuts.removeOne(UMB_ELEMENT_PUBLISHING_SHORTCUT_UNIQUE);
+                }
+                this.#elementWorkspaceContext = context;
+                this.#elementWorkspaceContext?.view.shortcuts.addOne({
+                    unique: UMB_ELEMENT_PUBLISHING_SHORTCUT_UNIQUE,
+                    label: this.#localize.term('content_saveAndPublishShortcut'),
+                    key: 'p',
+                    modifier: true,
+                    action: () => this.saveAndPublish(),
+                });
+                this.#initPendingChanges();
+            })
+                .asPromise({ preventTimeout: true })
+                .catch(() => {
+                this.#elementWorkspaceContext = undefined;
+            }),
+            this.consumeContext(UMB_ACTION_EVENT_CONTEXT, async (context) => {
+                this.#eventContext = context;
+            })
+                .asPromise({ preventTimeout: true })
+                .catch(() => {
+                this.#eventContext = undefined;
+            }),
+        ]);
+        this.consumeContext(UMB_NOTIFICATION_CONTEXT, (context) => {
+            this.#notificationContext = context;
+        });
+    }
+    getEntityType() {
+        return UMB_ELEMENT_ENTITY_TYPE;
+    }
+    async publish() {
+        throw new Error('Method not implemented. Use saveAndPublish() instead.');
+    }
+    /**
+     * Save and publish the element
+     * @returns {Promise<void>}
+     * @memberof UmbElementPublishingWorkspaceContext
+     */
+    async saveAndPublish() {
+        const elementStyle = this.getHostElement().style;
+        elementStyle.removeProperty('--uui-color-invalid');
+        elementStyle.removeProperty('--uui-color-invalid-emphasis');
+        elementStyle.removeProperty('--uui-color-invalid-standalone');
+        elementStyle.removeProperty('--uui-color-invalid-contrast');
+        return this.#handleSaveAndPublish();
+    }
+    /**
+     * Unpublish the element
+     * @returns {Promise<void>}
+     * @memberof UmbElementPublishingWorkspaceContext
+     */
+    async unpublish() {
+        await this.#init;
+        if (!this.#elementWorkspaceContext)
+            throw new Error('Element workspace context is missing');
+        const unique = this.#elementWorkspaceContext.getUnique();
+        if (!unique)
+            throw new Error('Unique is missing');
+        const entityType = this.#elementWorkspaceContext.getEntityType();
+        if (!entityType)
+            throw new Error('Entity type is missing');
+        const { options, selected } = await this.#determineVariantOptions();
+        // Filter to only show published variants
+        const publishedOptions = options.filter((option) => option.variant?.state === UmbElementVariantState.PUBLISHED ||
+            option.variant?.state === UmbElementVariantState.PUBLISHED_PENDING_CHANGES);
+        if (publishedOptions.length === 0) {
+            this.#notificationContext?.peek('warning', {
+                data: { message: this.#localize.term('content_itemNotPublished') },
+            });
+            return;
+        }
+        // If invariant (single culture = null), unpublish directly without modal
+        if (publishedOptions.length === 1 && publishedOptions[0].culture === null) {
+            const variantIds = [UmbVariantId.CreateInvariant()];
+            await this.#performUnpublish(unique, entityType, variantIds);
+            return;
+        }
+        const result = await umbOpenModal(this, UMB_ELEMENT_UNPUBLISH_MODAL, {
+            data: {
+                options: publishedOptions,
+                pickableFilter: this.#publishableVariantsFilter,
+            },
+            value: { selection: selected.filter((s) => publishedOptions.some((o) => o.unique === s)) },
+        }).catch(() => undefined);
+        if (!result?.selection.length)
+            return;
+        const variantIds = result.selection.map((x) => UmbVariantId.FromString(x));
+        await this.#performUnpublish(unique, entityType, variantIds);
+    }
+    async #performUnpublish(unique, entityType, variantIds) {
+        const { error } = await this.#publishingRepository.unpublish(unique, variantIds);
+        if (!error) {
+            this.#notificationContext?.peek('positive', {
+                data: { message: this.#localize.term('speechBubbles_editElementUnpublishedHeader') },
+            });
+            this.#clear();
+            await this.#elementWorkspaceContext?.reload();
+            await this.#loadAndProcessLastPublished();
+            const event = new UmbRequestReloadStructureForEntityEvent({ unique, entityType });
+            this.#eventContext?.dispatchEvent(event);
+        }
+    }
+    /**
+     * Schedule the element for publishing
+     * @returns {Promise<void>}
+     * @memberof UmbElementPublishingWorkspaceContext
+     */
+    async schedule() {
+        await this.#init;
+        if (!this.#elementWorkspaceContext)
+            throw new Error('Element workspace context is missing');
+        const unique = this.#elementWorkspaceContext.getUnique();
+        if (!unique)
+            throw new Error('Unique is missing');
+        const entityType = this.#elementWorkspaceContext.getEntityType();
+        if (!entityType)
+            throw new Error('Entity type is missing');
+        const { options, selected } = await this.#determineVariantOptions();
+        const result = await umbOpenModal(this, UMB_ELEMENT_SCHEDULE_MODAL, {
+            data: {
+                options,
+                activeVariants: selected,
+                pickableFilter: this.#publishableVariantsFilter,
+                prevalues: options.map((option) => ({
+                    unique: option.unique,
+                    schedule: {
+                        publishTime: option.variant?.scheduledPublishDate,
+                        unpublishTime: option.variant?.scheduledUnpublishDate,
+                    },
+                })),
+            },
+        }).catch(() => undefined);
+        if (!result?.selection.length)
+            return;
+        // Map to the correct format for the API (UmbElementVariantPublishModel)
+        const variants = result?.selection.map((x) => ({
+            variantId: UmbVariantId.FromString(x.unique),
+            schedule: {
+                publishTime: this.#convertToDateTimeOffset(x.schedule?.publishTime),
+                unpublishTime: this.#convertToDateTimeOffset(x.schedule?.unpublishTime),
+            },
+        })) ?? [];
+        if (!variants.length)
+            return;
+        const variantIds = variants.map((x) => x.variantId);
+        const saveData = await this.#elementWorkspaceContext.constructSaveData(variantIds);
+        await this.#elementWorkspaceContext.runMandatoryValidationForSaveData(saveData, variantIds);
+        await this.#elementWorkspaceContext.askServerToValidate(saveData, variantIds);
+        return this.#elementWorkspaceContext.validateAndSubmit(async () => {
+            if (!this.#elementWorkspaceContext) {
+                throw new Error('Element workspace context is missing');
+            }
+            // Save the element before scheduling
+            await this.#elementWorkspaceContext.performCreateOrUpdate(variantIds, saveData);
+            // Schedule the element
+            const { error } = await this.#publishingRepository.publish(unique, variants);
+            if (error) {
+                return Promise.reject(error);
+            }
+            const notification = { data: { message: this.#localize.term('speechBubbles_editContentScheduledSavedText') } };
+            this.#notificationContext?.peek('positive', notification);
+            // reload the element so all states are updated after the schedule operation
+            await this.#elementWorkspaceContext.reload();
+            // request reload of this entity
+            const structureEvent = new UmbRequestReloadStructureForEntityEvent({ entityType, unique });
+            this.#eventContext?.dispatchEvent(structureEvent);
+        }, async (reason) => {
+            this.#notificationContext?.peek('danger', {
+                data: { message: this.#localize.term('speechBubbles_editContentScheduledNotSavedText') },
+            });
+            return Promise.reject(reason);
+        });
+    }
+    /**
+     * Convert a date string to a server time string in ISO format, example: 2021-01-01T12:00:00.000+00:00.
+     * The input must be a valid date string, otherwise it will return null.
+     * The output matches the DateTimeOffset format in C#.
+     * @param dateString
+     */
+    #convertToDateTimeOffset(dateString) {
+        if (!dateString || dateString.length === 0) {
+            return null;
+        }
+        const date = new Date(dateString);
+        if (isNaN(date.getTime())) {
+            console.warn(`[Schedule]: Invalid date: ${dateString}`);
+            return null;
+        }
+        // Convert the date to UTC time in ISO format before sending it to the server
+        return date.toISOString();
+    }
+    async #handleSaveAndPublish() {
+        await this.#init;
+        if (!this.#elementWorkspaceContext)
+            throw new Error('Element workspace context is missing');
+        const unique = this.#elementWorkspaceContext.getUnique();
+        if (!unique)
+            throw new Error('Unique is missing');
+        let variantIds = [];
+        const { options, selected } = await this.#determineVariantOptions();
+        // If there is only one variant, we don't need to open the modal.
+        if (options.length === 0) {
+            throw new Error('No variants are available');
+        }
+        else if (options.length === 1) {
+            // If only one option we will skip ahead and save the element with the only variant available:
+            variantIds.push(UmbVariantId.Create(options[0]));
+        }
+        else {
+            // If there are multiple variants, we will open the modal to let the user pick which variants to publish.
+            const result = await umbOpenModal(this, UMB_ELEMENT_PUBLISH_MODAL, {
+                data: {
+                    headline: this.#localize.term('content_saveAndPublishModalTitle'),
+                    options,
+                    pickableFilter: this.#publishableVariantsFilter,
+                },
+                value: { selection: selected },
+            }).catch(() => undefined);
+            if (!result?.selection.length || !unique)
+                return;
+            variantIds = result?.selection.map((x) => UmbVariantId.FromString(x)) ?? [];
+        }
+        const saveData = await this.#elementWorkspaceContext.constructSaveData(variantIds);
+        await this.#elementWorkspaceContext.runMandatoryValidationForSaveData(saveData, variantIds);
+        await this.#elementWorkspaceContext.askServerToValidate(saveData, variantIds);
+        return this.#elementWorkspaceContext.validateAndSubmit(async () => {
+            return this.#performSaveAndPublish(variantIds, saveData);
+        }, async (reason) => {
+            // If data of the selection is not valid Then just save:
+            await this.#elementWorkspaceContext.performCreateOrUpdate(variantIds, saveData);
+            // Notifying that the save was successful, but we did not publish
+            this.#notificationContext?.peek('danger', {
+                data: { message: this.#localize.term('speechBubbles_editContentPublishedFailedByValidation') },
+            });
+            return await Promise.reject(reason);
+        });
+    }
+    async #performSaveAndPublish(variantIds, saveData) {
+        await this.#init;
+        if (!this.#elementWorkspaceContext)
+            throw new Error('Element workspace context is missing');
+        const unique = this.#elementWorkspaceContext.getUnique();
+        if (!unique)
+            throw new Error('Unique is missing');
+        const entityType = this.#elementWorkspaceContext.getEntityType();
+        if (!entityType)
+            throw new Error('Entity type is missing');
+        await this.#elementWorkspaceContext.performCreateOrUpdate(variantIds, saveData);
+        const { error } = await this.#publishingRepository.publish(unique, variantIds.map((variantId) => ({ variantId })));
+        if (!error) {
+            this.#notificationContext?.peek('positive', {
+                data: { message: this.#localize.term('speechBubbles_editElementPublishedHeader') },
+            });
+            // Clear stale published data and pending changes state so the
+            // persistedData observer does not run a comparison against outdated
+            // data during reload, which would briefly show a false-positive
+            // "pending changes" state.
+            this.#clear();
+            // reload the element so all states are updated after the publish operation
+            await this.#elementWorkspaceContext.reload();
+            await this.#loadAndProcessLastPublished();
+            const event = new UmbRequestReloadStructureForEntityEvent({ unique, entityType });
+            this.#eventContext?.dispatchEvent(event);
+        }
+    }
+    #publishableVariantsFilter;
+    async #determineVariantOptions() {
+        await this.#init;
+        if (!this.#elementWorkspaceContext)
+            throw new Error('Element workspace context is missing');
+        const allOptions = await firstValueFrom(this.#elementWorkspaceContext.variantOptions);
+        const options = allOptions.filter((option) => option.segment === null);
+        let selected = this.#getPublishVariantsSelection();
+        // Selected can contain entries that are not part of the options, therefor filter based on options.
+        selected = selected.filter((x) => options.some((o) => o.unique === x));
+        // Filter out read-only variants
+        selected = selected.filter((x) => this.#elementWorkspaceContext.readOnlyGuard.getIsPermittedForVariant(new UmbVariantId(x)) === false);
+        return {
+            options,
+            selected,
+        };
+    }
+    #getPublishVariantsSelection() {
+        if (!this.#elementWorkspaceContext)
+            throw new Error('Element workspace context is missing');
+        const activeVariants = this.#elementWorkspaceContext.splitView.getActiveVariants();
+        const activeVariantIds = activeVariants.map((x) => UmbVariantId.Create(x));
+        const changedVariantIds = this.#elementWorkspaceContext.getChangedVariants();
+        const activeAndChangedVariantIds = [...activeVariantIds, ...changedVariantIds];
+        // if a segment has been changed, we select the "parent" culture variant
+        const changedParentCultureVariantIds = activeAndChangedVariantIds
+            .filter((x) => x.segment !== null)
+            .map((x) => x.toSegmentInvariant());
+        const selected = [...activeAndChangedVariantIds, ...changedParentCultureVariantIds].map((variantId) => variantId.toString());
+        return [...new Set(selected)];
+    }
+    async #initPendingChanges() {
+        if (!this.#elementWorkspaceContext) {
+            return;
+        }
+        this.observe(observeMultiple([this.#elementWorkspaceContext.unique, this.#elementWorkspaceContext.isNew]), ([unique, isNew]) => {
+            // We have loaded in a new element, so we need to clear the states
+            if (unique !== this.#currentUnique) {
+                this.#clear();
+            }
+            this.#currentUnique = unique;
+            if (isNew === false && unique) {
+                this.#loadAndProcessLastPublished();
+            }
+        }, 'uniqueObserver');
+        this.observe(this.#elementWorkspaceContext.persistedData, () => this.#processPendingChanges(), 'umbPersistedDataObserver');
+    }
+    #hasPublishedVariant() {
+        const variants = this.#elementWorkspaceContext?.getVariants();
+        return (variants?.some((variant) => variant.state === UmbElementVariantState.PUBLISHED ||
+            variant.state === UmbElementVariantState.PUBLISHED_PENDING_CHANGES) ?? false);
+    }
+    async #loadAndProcessLastPublished() {
+        if (!this.#elementWorkspaceContext)
+            throw new Error('Element workspace context is missing');
+        // No need to check pending changes for new elements
+        if (this.#elementWorkspaceContext.getIsNew())
+            return;
+        const unique = this.#elementWorkspaceContext.getUnique();
+        if (!unique)
+            throw new Error('Unique is missing');
+        // Only load the published data if the element is already published or has been published before
+        const hasPublishedVariant = this.#hasPublishedVariant();
+        if (!hasPublishedVariant)
+            return;
+        // TODO: Implement once ElementService.getElementByIdPublished endpoint exists [LK]
+        // const { data } = await this.#publishingRepository.published(unique);
+        // this.#publishedElementData = data;
+        // this.#processPendingChanges();
+    }
+    #processPendingChanges() {
+        if (!this.#elementWorkspaceContext)
+            throw new Error('Element workspace context is missing');
+        const persistedData = this.#elementWorkspaceContext.getPersistedData();
+        const publishedData = this.#publishedElementData;
+        if (!persistedData || !publishedData)
+            return;
+        this.publishedPendingChanges.process({ persistedData, publishedData });
+    }
+    #clear() {
+        this.#publishedElementData = undefined;
+        this.publishedPendingChanges.clear();
+    }
+}
+export { UmbElementPublishingWorkspaceContext as api };

package/dist-cms/packages/elements/publishing/workspace-context/element-publishing.workspace-context.token.d.ts

@@ -0,0 +1,3 @@
+import type { UmbElementPublishingWorkspaceContext } from './element-publishing.workspace-context.js';
+import { UmbContextToken } from '../../../../libs/context-api/index.js';
+export declare const UMB_ELEMENT_PUBLISHING_WORKSPACE_CONTEXT: UmbContextToken<UmbElementPublishingWorkspaceContext, UmbElementPublishingWorkspaceContext>;

package/dist-cms/packages/elements/publishing/workspace-context/element-publishing.workspace-context.token.js

@@ -0,0 +1,2 @@
+import { UmbContextToken } from '../../../../libs/context-api/index.js';
+export const UMB_ELEMENT_PUBLISHING_WORKSPACE_CONTEXT = new UmbContextToken('UmbWorkspaceContext', undefined, (context) => context.saveAndPublish !== undefined);

package/dist-cms/packages/elements/publishing/workspace-context/manifests.d.ts

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

package/dist-cms/packages/elements/publishing/workspace-context/manifests.js

@@ -0,0 +1,16 @@
+import { UMB_ELEMENT_WORKSPACE_ALIAS } from '../../workspace/constants.js';
+import { UMB_WORKSPACE_CONDITION_ALIAS } from '../../../core/workspace/index.js';
+export const manifests = [
+    {
+        type: 'workspaceContext',
+        name: 'Element Publishing Workspace Context',
+        alias: 'Umb.WorkspaceContext.Element.Publishing',
+        api: () => import('./element-publishing.workspace-context.js'),
+        conditions: [
+            {
+                alias: UMB_WORKSPACE_CONDITION_ALIAS,
+                match: UMB_ELEMENT_WORKSPACE_ALIAS,
+            },
+        ],
+    },
+];

package/dist-cms/packages/elements/publishing/workspace-context/types.d.ts

@@ -0,0 +1 @@
+export type * from './element-publishing.workspace-context.js';

package/dist-cms/packages/elements/publishing/workspace-context/types.js

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

package/dist-cms/packages/elements/recycle-bin/collection/action/manifests.d.ts

@@ -0,0 +1,2 @@
+import type { ManifestCollectionActionEmptyRecycleBinKind } from '../../../../core/recycle-bin/index.js';
+export declare const manifests: Array<ManifestCollectionActionEmptyRecycleBinKind>;

package/dist-cms/packages/elements/recycle-bin/collection/action/manifests.js

@@ -0,0 +1,32 @@
+import { UMB_ELEMENT_RECYCLE_BIN_REPOSITORY_ALIAS } from '../../repository/constants.js';
+import { UMB_ELEMENT_RECYCLE_BIN_COLLECTION_ALIAS } from '../constants.js';
+import { UMB_ELEMENT_RECYCLE_BIN_ROOT_ENTITY_TYPE } from '../../constants.js';
+import { UMB_ELEMENT_USER_PERMISSION_CONDITION_ALIAS, UMB_USER_PERMISSION_ELEMENT_DELETE, } from '../../../user-permissions/constants.js';
+import { UMB_COLLECTION_ALIAS_CONDITION } from '../../../../core/collection/index.js';
+import { UMB_ENTITY_TYPE_CONDITION_ALIAS } from '../../../../core/entity/index.js';
+export const manifests = [
+    {
+        type: 'collectionAction',
+        kind: 'emptyRecycleBin',
+        alias: 'Umb.CollectionAction.Element.EmptyRecycleBin',
+        name: 'Element Collection Empty Recycle Bin Action',
+        meta: {
+            label: '#actions_emptyrecyclebin',
+            recycleBinRepositoryAlias: UMB_ELEMENT_RECYCLE_BIN_REPOSITORY_ALIAS,
+        },
+        conditions: [
+            {
+                alias: UMB_COLLECTION_ALIAS_CONDITION,
+                match: UMB_ELEMENT_RECYCLE_BIN_COLLECTION_ALIAS,
+            },
+            {
+                alias: UMB_ENTITY_TYPE_CONDITION_ALIAS,
+                match: UMB_ELEMENT_RECYCLE_BIN_ROOT_ENTITY_TYPE,
+            },
+            {
+                alias: UMB_ELEMENT_USER_PERMISSION_CONDITION_ALIAS,
+                allOf: [UMB_USER_PERMISSION_ELEMENT_DELETE],
+            },
+        ],
+    },
+];

package/dist-cms/packages/elements/recycle-bin/collection/constants.d.ts

@@ -0,0 +1,2 @@
+export * from './repository/constants.js';
+export declare const UMB_ELEMENT_RECYCLE_BIN_COLLECTION_ALIAS = "Umb.Collection.Element.RecycleBin";

package/dist-cms/packages/elements/recycle-bin/collection/constants.js

@@ -0,0 +1,2 @@
+export * from './repository/constants.js';
+export const UMB_ELEMENT_RECYCLE_BIN_COLLECTION_ALIAS = 'Umb.Collection.Element.RecycleBin';

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

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

package/dist-cms/packages/elements/recycle-bin/collection/index.js

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

package/dist-cms/packages/elements/recycle-bin/collection/manifests.d.ts

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

package/dist-cms/packages/elements/recycle-bin/collection/manifests.js

@@ -0,0 +1,19 @@
+import { manifests as actionManifests } from './action/manifests.js';
+import { manifests as repositoryManifests } from './repository/manifests.js';
+import { manifests as viewManifests } from './views/manifests.js';
+import { UMB_ELEMENT_RECYCLE_BIN_COLLECTION_ALIAS } from './constants.js';
+import { UMB_ELEMENT_RECYCLE_BIN_TREE_ITEM_CHILDREN_COLLECTION_REPOSITORY_ALIAS } from './repository/index.js';
+export const manifests = [
+    {
+        type: 'collection',
+        kind: 'default',
+        alias: UMB_ELEMENT_RECYCLE_BIN_COLLECTION_ALIAS,
+        name: 'Element Recycle Bin Tree Item Children Collection',
+        meta: {
+            repositoryAlias: UMB_ELEMENT_RECYCLE_BIN_TREE_ITEM_CHILDREN_COLLECTION_REPOSITORY_ALIAS,
+        },
+    },
+    ...actionManifests,
+    ...repositoryManifests,
+    ...viewManifests,
+];

package/dist-cms/packages/elements/recycle-bin/collection/repository/constants.d.ts

@@ -0,0 +1 @@
+export declare const UMB_ELEMENT_RECYCLE_BIN_TREE_ITEM_CHILDREN_COLLECTION_REPOSITORY_ALIAS = "Umb.Repository.ElementRecycleBin.TreeItemChildrenCollection";

package/dist-cms/packages/elements/recycle-bin/collection/repository/constants.js

@@ -0,0 +1 @@
+export const UMB_ELEMENT_RECYCLE_BIN_TREE_ITEM_CHILDREN_COLLECTION_REPOSITORY_ALIAS = 'Umb.Repository.ElementRecycleBin.TreeItemChildrenCollection';

package/dist-cms/packages/elements/recycle-bin/collection/repository/element-recycle-bin-tree-item-children-collection.repository.d.ts

@@ -0,0 +1,11 @@
+import { UmbRepositoryBase } from '../../../../core/repository/index.js';
+import type { UmbCollectionFilterModel, UmbCollectionRepository } from '../../../../core/collection/index.js';
+export declare class UmbElementRecycleBinTreeItemChildrenCollectionRepository extends UmbRepositoryBase implements UmbCollectionRepository {
+    #private;
+    requestCollection(filter?: UmbCollectionFilterModel): Promise<{
+        data: import("../../../../core/repository/index.js").UmbTargetPagedModel<import("../../types.js").UmbElementRecycleBinTreeItemModel> | undefined;
+        error: Error | import("../../../../core/resources/index.js").UmbError | import("../../../../core/resources/index.js").UmbCancelError | import("../../../../core/resources/index.js").UmbApiError | undefined;
+        asObservable: () => undefined;
+    }>;
+}
+export { UmbElementRecycleBinTreeItemChildrenCollectionRepository as api };

package/dist-cms/packages/elements/recycle-bin/collection/repository/element-recycle-bin-tree-item-children-collection.repository.js

@@ -0,0 +1,31 @@
+import { UmbElementRecycleBinTreeRepository } from '../../tree/element-recycle-bin-tree.repository.js';
+import { UmbRepositoryBase } from '../../../../core/repository/index.js';
+import { UMB_ENTITY_CONTEXT } from '../../../../core/entity/index.js';
+export class UmbElementRecycleBinTreeItemChildrenCollectionRepository extends UmbRepositoryBase {
+    #treeRepository = new UmbElementRecycleBinTreeRepository(this);
+    async requestCollection(filter = {}) {
+        const entityContext = await this.getContext(UMB_ENTITY_CONTEXT);
+        if (!entityContext)
+            throw new Error('Entity context not found');
+        const entityType = entityContext.getEntityType();
+        const unique = entityContext.getUnique();
+        if (!entityType)
+            throw new Error('Entity type not found');
+        if (unique === undefined)
+            throw new Error('Unique not found');
+        // TODO: get parent from args
+        const parent = { entityType, unique };
+        if (parent.unique === null) {
+            return this.#treeRepository.requestTreeRootItems({
+                paging: { skip: filter.skip ?? 0, take: filter.take ?? 100 },
+            });
+        }
+        else {
+            return this.#treeRepository.requestTreeItemsOf({
+                parent,
+                paging: { skip: filter.skip ?? 0, take: filter.take ?? 100 },
+            });
+        }
+    }
+}
+export { UmbElementRecycleBinTreeItemChildrenCollectionRepository as api };

package/dist-cms/packages/elements/recycle-bin/collection/repository/index.d.ts

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

package/dist-cms/packages/elements/recycle-bin/collection/repository/index.js

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

package/dist-cms/packages/elements/recycle-bin/collection/repository/manifests.d.ts

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

package/dist-cms/packages/elements/recycle-bin/collection/repository/manifests.js

@@ -0,0 +1,9 @@
+import { UMB_ELEMENT_RECYCLE_BIN_TREE_ITEM_CHILDREN_COLLECTION_REPOSITORY_ALIAS } from './constants.js';
+export const manifests = [
+    {
+        type: 'repository',
+        alias: UMB_ELEMENT_RECYCLE_BIN_TREE_ITEM_CHILDREN_COLLECTION_REPOSITORY_ALIAS,
+        name: 'Element Recycle Bin Tree Item Children Collection Repository',
+        api: () => import('./element-recycle-bin-tree-item-children-collection.repository.js'),
+    },
+];

package/dist-cms/packages/elements/recycle-bin/collection/types.d.ts

@@ -0,0 +1,5 @@
+import type { UmbCollectionFilterModel } from '../../../core/collection/index.js';
+import type { UmbEntityModel } from '../../../core/entity/index.js';
+export interface UmbElementRecycleBinTreeItemChildrenCollectionFilterModel extends UmbCollectionFilterModel {
+    parent: UmbEntityModel;
+}

package/dist-cms/packages/elements/recycle-bin/collection/types.js

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

package/dist-cms/packages/elements/recycle-bin/collection/views/element-recycle-bin-tree-item-table-collection-view.element.d.ts

@@ -0,0 +1,17 @@
+import { UmbLitElement } from '../../../../core/lit-element/index.js';
+import './trashed-element-name-table-column.element.js';
+export declare class UmbElementRecycleBinTreeItemTableCollectionViewElement extends UmbLitElement {
+    #private;
+    private _tableConfig;
+    private _tableColumns;
+    private _tableItems;
+    constructor();
+    render(): import("lit-html").TemplateResult<1>;
+    static styles: import("lit").CSSResult[];
+}
+export { UmbElementRecycleBinTreeItemTableCollectionViewElement as element };
+declare global {
+    interface HTMLElementTagNameMap {
+        'umb-element-recycle-bin-tree-item-table-collection-view': UmbElementRecycleBinTreeItemTableCollectionViewElement;
+    }
+}