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

package/dist-cms/packages/elements/modals/save-modal/constants.d.ts

@@ -0,0 +1 @@
+export declare const UMB_ELEMENT_SAVE_MODAL_ALIAS = "Umb.Modal.ElementSave";

package/dist-cms/packages/elements/modals/save-modal/constants.js

@@ -0,0 +1 @@
+export const UMB_ELEMENT_SAVE_MODAL_ALIAS = 'Umb.Modal.ElementSave';

package/dist-cms/packages/elements/modals/save-modal/element-save-modal.element.d.ts

@@ -0,0 +1,16 @@
+import type { UmbElementSaveModalData, UmbElementSaveModalValue } from './element-save-modal.token.js';
+import { UmbModalBaseElement } from '../../../core/modal/index.js';
+import '../shared/element-variant-language-picker.element.js';
+export declare class UmbElementSaveModalElement extends UmbModalBaseElement<UmbElementSaveModalData, UmbElementSaveModalValue> {
+    #private;
+    private _options;
+    firstUpdated(): void;
+    render(): import("lit-html").TemplateResult<1>;
+    static styles: import("lit").CSSResult[];
+}
+export default UmbElementSaveModalElement;
+declare global {
+    interface HTMLElementTagNameMap {
+        'umb-element-save-modal': UmbElementSaveModalElement;
+    }
+}

package/dist-cms/packages/elements/modals/save-modal/element-save-modal.element.js

@@ -0,0 +1,86 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { css, customElement, html, state } from '../../../../external/lit/index.js';
+import { umbFocus } from '../../../core/lit-element/index.js';
+import { UmbModalBaseElement } from '../../../core/modal/index.js';
+import { UmbSelectionManager } from '../../../core/utils/index.js';
+import { UmbTextStyles } from '../../../core/style/index.js';
+import '../shared/element-variant-language-picker.element.js';
+let UmbElementSaveModalElement = class UmbElementSaveModalElement extends UmbModalBaseElement {
+    constructor() {
+        super(...arguments);
+        this.#selectionManager = new UmbSelectionManager(this);
+        this._options = [];
+        this.#pickableFilter = (option) => {
+            if (!option.variant) {
+                // If no data is present, then it's not pickable.
+                return false;
+            }
+            return this.data?.pickableFilter ? this.data.pickableFilter(option) : true;
+        };
+    }
+    #selectionManager;
+    #pickableFilter;
+    firstUpdated() {
+        this.#configureSelectionManager();
+    }
+    async #configureSelectionManager() {
+        this.#selectionManager.setMultiple(true);
+        this.#selectionManager.setSelectable(true);
+        // Only display variants that are relevant to pick from, i.e. variants that are draft or published with pending changes:
+        this._options = this.data?.options ?? [];
+        let selected = this.value?.selection ?? [];
+        const validOptions = this._options.filter((o) => this.#pickableFilter(o));
+        // Filter selection based on options:
+        selected = selected.filter((s) => validOptions.some((o) => o.unique === s));
+        this.#selectionManager.setSelection(selected);
+    }
+    #submit() {
+        this.value = { selection: this.#selectionManager.getSelection() };
+        this.modalContext?.submit();
+    }
+    #close() {
+        this.modalContext?.reject();
+    }
+    render() {
+        return html `
+			<uui-dialog-layout headline=${this.localize.term('content_saveModalTitle')}>
+				<umb-element-variant-language-picker
+					.selectionManager=${this.#selectionManager}
+					.variantLanguageOptions=${this._options}
+					.pickableFilter=${this.#pickableFilter}></umb-element-variant-language-picker>
+				<div slot="actions">
+					<uui-button label=${this.localize.term('general_close')} @click=${this.#close}></uui-button>
+					<uui-button
+						label=${this.localize.term('buttons_save')}
+						look="primary"
+						color="positive"
+						@click=${this.#submit}
+						${umbFocus()}></uui-button>
+				</div>
+			</uui-dialog-layout>
+		`;
+    }
+    static { this.styles = [
+        UmbTextStyles,
+        css `
+			:host {
+				display: block;
+				width: 400px;
+				max-width: 90vw;
+			}
+		`,
+    ]; }
+};
+__decorate([
+    state()
+], UmbElementSaveModalElement.prototype, "_options", void 0);
+UmbElementSaveModalElement = __decorate([
+    customElement('umb-element-save-modal')
+], UmbElementSaveModalElement);
+export { UmbElementSaveModalElement };
+export default UmbElementSaveModalElement;

package/dist-cms/packages/elements/modals/save-modal/element-save-modal.token.d.ts

@@ -0,0 +1,7 @@
+import type { UmbElementVariantPickerData, UmbElementVariantPickerValue } from '../types.js';
+import { UmbModalToken } from '../../../core/modal/index.js';
+export interface UmbElementSaveModalData extends UmbElementVariantPickerData {
+}
+export interface UmbElementSaveModalValue extends UmbElementVariantPickerValue {
+}
+export declare const UMB_ELEMENT_SAVE_MODAL: UmbModalToken<UmbElementSaveModalData, UmbElementSaveModalValue>;

package/dist-cms/packages/elements/modals/save-modal/element-save-modal.token.js

@@ -0,0 +1,7 @@
+import { UMB_ELEMENT_SAVE_MODAL_ALIAS } from './constants.js';
+import { UmbModalToken } from '../../../core/modal/index.js';
+export const UMB_ELEMENT_SAVE_MODAL = new UmbModalToken(UMB_ELEMENT_SAVE_MODAL_ALIAS, {
+    modal: {
+        type: 'dialog',
+    },
+});

package/dist-cms/packages/elements/modals/save-modal/manifest.d.ts

@@ -0,0 +1,2 @@
+import type { ManifestModal } from '../../../core/modal/index.js';
+export declare const manifest: ManifestModal;

package/dist-cms/packages/elements/modals/save-modal/manifest.js

@@ -0,0 +1,7 @@
+import { UMB_ELEMENT_SAVE_MODAL_ALIAS } from './constants.js';
+export const manifest = {
+    type: 'modal',
+    alias: UMB_ELEMENT_SAVE_MODAL_ALIAS,
+    name: 'Element Save Modal',
+    element: () => import('./element-save-modal.element.js'),
+};

package/dist-cms/packages/elements/modals/shared/element-variant-language-picker.element.d.ts

@@ -0,0 +1,35 @@
+import type { UmbElementVariantOptionModel } from '../../types.js';
+import { type PropertyValues } from '../../../../external/lit/index.js';
+import { UmbLitElement } from '../../../core/lit-element/index.js';
+import type { UmbSelectionManager } from '../../../core/utils/index.js';
+export declare class UmbElementVariantLanguagePickerElement extends UmbLitElement {
+    #private;
+    variantLanguageOptions: Array<UmbElementVariantOptionModel>;
+    set selectionManager(value: UmbSelectionManager<string>);
+    get selectionManager(): UmbSelectionManager<string>;
+    private _selection;
+    private _isAllSelected;
+    /**
+     * A filter function that determines if an item is pickable or not.
+     * @memberof UmbElementVariantLanguagePickerElement
+     * @returns {boolean} - True if the item is pickable, false otherwise.
+     */
+    pickableFilter?: (item: UmbElementVariantOptionModel) => boolean;
+    /**
+     * A filter function that determines if an item should be highlighted as a must select.
+     * @memberof UmbElementVariantLanguagePickerElement
+     * @returns {boolean} - True if the item is required, false otherwise.
+     */
+    requiredFilter?: (item: UmbElementVariantOptionModel) => boolean;
+    protected updated(_changedProperties: PropertyValues): void;
+    render(): import("lit-html").TemplateResult<1>;
+    static renderLabel(option: UmbElementVariantOptionModel, mustSelect?: boolean): import("lit-html").TemplateResult<1>;
+    static renderVariantStatus(option: UmbElementVariantOptionModel): import("lit-html").TemplateResult<1>;
+    static styles: import("lit").CSSResult[];
+}
+export default UmbElementVariantLanguagePickerElement;
+declare global {
+    interface HTMLElementTagNameMap {
+        'umb-element-variant-language-picker': UmbElementVariantLanguagePickerElement;
+    }
+}

package/dist-cms/packages/elements/modals/shared/element-variant-language-picker.element.js

@@ -0,0 +1,165 @@
+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;
+};
+var _a;
+var UmbElementVariantLanguagePickerElement_1;
+import { UmbElementVariantState } from '../../variant-state.js';
+import { css, customElement, html, nothing, property, repeat, state, } from '../../../../external/lit/index.js';
+import { UmbLitElement } from '../../../core/lit-element/index.js';
+import { UmbTextStyles } from '../../../core/style/index.js';
+let UmbElementVariantLanguagePickerElement = class UmbElementVariantLanguagePickerElement extends UmbLitElement {
+    constructor() {
+        super(...arguments);
+        this.variantLanguageOptions = [];
+        this._selection = [];
+        this._isAllSelected = false;
+    }
+    static { UmbElementVariantLanguagePickerElement_1 = this; }
+    #selectionManager;
+    set selectionManager(value) {
+        this.#selectionManager = value;
+        this.observe(this.selectionManager.selection, (selection) => {
+            this._selection = selection;
+            this._isAllSelected = this.#isAllSelected();
+        }, '_selectionManager');
+    }
+    get selectionManager() {
+        return this.#selectionManager;
+    }
+    updated(_changedProperties) {
+        super.updated(_changedProperties);
+        if (_changedProperties.has('variantLanguageOptions')) {
+            this._isAllSelected = this.#isAllSelected();
+        }
+        if (this.selectionManager && this.pickableFilter) {
+            this.#selectionManager.setAllowLimitation((unique) => {
+                const option = this.variantLanguageOptions.find((o) => o.unique === unique);
+                return option ? this.pickableFilter(option) : true;
+            });
+        }
+    }
+    #onSelectAllChange(event) {
+        const allUniques = this.variantLanguageOptions.map((o) => o.unique);
+        const filter = this.selectionManager.getAllowLimitation();
+        const allowedUniques = allUniques.filter((unique) => filter(unique));
+        if (event.target.checked) {
+            this.selectionManager.setSelection(allowedUniques);
+        }
+        else {
+            this.selectionManager.setSelection([]);
+        }
+    }
+    #isAllSelected() {
+        const allUniques = this.variantLanguageOptions.map((o) => o.unique);
+        const filter = this.selectionManager.getAllowLimitation();
+        const allowedUniques = allUniques.filter((unique) => filter(unique));
+        return this._selection.length !== 0 && this._selection.length === allowedUniques.length;
+    }
+    render() {
+        if (this.variantLanguageOptions.length === 0) {
+            return html `<uui-box>
+				<umb-localize key="content_noVariantsToProcess">There are no available variants</umb-localize>
+			</uui-box>`;
+        }
+        return html `
+			<uui-checkbox
+				@change=${this.#onSelectAllChange}
+				label=${this.localize.term('general_selectAll')}
+				.checked=${this._isAllSelected}></uui-checkbox>
+			${repeat(this.variantLanguageOptions, (option) => option.unique, (option) => html ` ${this.#renderItem(option)} `)}
+		`;
+    }
+    #renderItem(option) {
+        const pickable = this.pickableFilter ? this.pickableFilter(option) : true;
+        const selected = this._selection.includes(option.unique);
+        const mustSelect = (!selected && this.requiredFilter?.(option)) ?? false;
+        return html `
+			<uui-menu-item
+				class=${mustSelect ? 'required' : ''}
+				?selectable=${pickable}
+				?disabled=${!pickable}
+				label=${option.variant?.name ?? option.language.name}
+				@selected=${() => this.selectionManager.select(option.unique)}
+				@deselected=${() => this.selectionManager.deselect(option.unique)}
+				?selected=${selected}>
+				<uui-icon slot="icon" name="icon-globe"></uui-icon>
+				${UmbElementVariantLanguagePickerElement_1.renderLabel(option, mustSelect)}
+			</uui-menu-item>
+		`;
+    }
+    static renderLabel(option, mustSelect) {
+        return html `<div class="label" slot="label">
+			<strong> ${option.language.name} </strong>
+			<div class="label-status">${UmbElementVariantLanguagePickerElement_1.renderVariantStatus(option)}</div>
+			${option.language.isMandatory && mustSelect
+            ? html `<div class="label-status">
+						<umb-localize key="languages_mandatoryLanguage">Mandatory language</umb-localize>
+					</div>`
+            : nothing}
+		</div>`;
+    }
+    static renderVariantStatus(option) {
+        switch (option.variant?.state) {
+            case UmbElementVariantState.PUBLISHED:
+                return html `<umb-localize key="content_published">Published</umb-localize>`;
+            case UmbElementVariantState.PUBLISHED_PENDING_CHANGES:
+                return html `<umb-localize key="content_publishedPendingChanges">Published with pending changes</umb-localize>`;
+            case UmbElementVariantState.DRAFT:
+                return html `<umb-localize key="content_unpublished">Draft</umb-localize>`;
+            case UmbElementVariantState.NOT_CREATED:
+            default:
+                return html `<umb-localize key="content_notCreated">Not created</umb-localize>`;
+        }
+    }
+    static { this.styles = [
+        UmbTextStyles,
+        css `
+			.required {
+				color: var(--uui-color-danger);
+				--uui-menu-item-color-hover: var(--uui-color-danger-emphasis);
+				--uui-menu-item-color-disabled: var(--uui-color-danger);
+			}
+			.label {
+				padding: var(--uui-size-space-3) 0;
+			}
+			.label-status {
+				font-size: var(--uui-type-small-size);
+			}
+
+			uui-menu-item {
+				--uui-menu-item-flat-structure: 1;
+				--uui-menu-item-border-radius: var(--uui-border-radius);
+			}
+
+			uui-checkbox {
+				margin-bottom: var(--uui-size-space-3);
+			}
+		`,
+    ]; }
+};
+__decorate([
+    property({ type: Array, attribute: false })
+], UmbElementVariantLanguagePickerElement.prototype, "variantLanguageOptions", void 0);
+__decorate([
+    property({ attribute: false })
+], UmbElementVariantLanguagePickerElement.prototype, "selectionManager", null);
+__decorate([
+    state()
+], UmbElementVariantLanguagePickerElement.prototype, "_selection", void 0);
+__decorate([
+    state()
+], UmbElementVariantLanguagePickerElement.prototype, "_isAllSelected", void 0);
+__decorate([
+    property({ attribute: false })
+], UmbElementVariantLanguagePickerElement.prototype, "pickableFilter", void 0);
+__decorate([
+    property({ attribute: false })
+], UmbElementVariantLanguagePickerElement.prototype, "requiredFilter", void 0);
+UmbElementVariantLanguagePickerElement = UmbElementVariantLanguagePickerElement_1 = __decorate([
+    customElement('umb-element-variant-language-picker')
+], UmbElementVariantLanguagePickerElement);
+export { UmbElementVariantLanguagePickerElement };
+export default UmbElementVariantLanguagePickerElement;

package/dist-cms/packages/elements/modals/shared/index.d.ts

@@ -0,0 +1 @@
+export * from './element-variant-language-picker.element.js';

package/dist-cms/packages/elements/modals/shared/index.js

@@ -0,0 +1 @@
+export * from './element-variant-language-picker.element.js';

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

@@ -0,0 +1,4 @@
+import type { UmbElementVariantOptionModel } from '../types.js';
+import type { UmbContentVariantPickerData, UmbContentVariantPickerValue } from '../../content/content/index.js';
+export type UmbElementVariantPickerData = UmbContentVariantPickerData<UmbElementVariantOptionModel>;
+export type UmbElementVariantPickerValue = UmbContentVariantPickerValue;

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

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

package/dist-cms/packages/elements/package.json

@@ -0,0 +1,8 @@
+{
+    "name": "@umbraco-backoffice/element",
+    "private": true,
+    "type": "module",
+    "scripts": {
+        "build": "vite build"
+    }
+}

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

@@ -0,0 +1,17 @@
+import type { UmbElementEntityTypeUnion } from './entity.js';
+import { UmbPathPattern } from '../core/router/index.js';
+export declare const UMB_ELEMENT_WORKSPACE_PATH: string;
+export declare const UMB_CREATE_ELEMENT_WORKSPACE_PATH_PATTERN: UmbPathPattern<{
+    parentEntityType: UmbElementEntityTypeUnion;
+    parentUnique?: string | null;
+    documentTypeUnique: string;
+}, {
+    parentEntityType: UmbElementEntityTypeUnion;
+    parentUnique?: string | null;
+    documentTypeUnique: string;
+}>;
+export declare const UMB_EDIT_ELEMENT_WORKSPACE_PATH_PATTERN: UmbPathPattern<{
+    unique: string;
+}, {
+    unique: string;
+}>;

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

@@ -0,0 +1,10 @@
+import { UMB_ELEMENT_ENTITY_TYPE } from './entity.js';
+import { UmbPathPattern } from '../core/router/index.js';
+import { UMB_WORKSPACE_PATH_PATTERN } from '../core/workspace/index.js';
+import { UMB_LIBRARY_SECTION_PATHNAME } from '../library/index.js';
+export const UMB_ELEMENT_WORKSPACE_PATH = UMB_WORKSPACE_PATH_PATTERN.generateAbsolute({
+    sectionName: UMB_LIBRARY_SECTION_PATHNAME,
+    entityType: UMB_ELEMENT_ENTITY_TYPE,
+});
+export const UMB_CREATE_ELEMENT_WORKSPACE_PATH_PATTERN = new UmbPathPattern('create/parent/:parentEntityType/:parentUnique/:documentTypeUnique', UMB_ELEMENT_WORKSPACE_PATH);
+export const UMB_EDIT_ELEMENT_WORKSPACE_PATH_PATTERN = new UmbPathPattern('edit/:unique', UMB_ELEMENT_WORKSPACE_PATH);

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

@@ -0,0 +1,46 @@
+import { UmbControllerBase } from '../../../libs/class-api/index.js';
+import type { UmbPickerTreeDataSource } from '../../core/picker-data-source/index.js';
+import type { UmbTreeAncestorsOfRequestArgs, UmbTreeChildrenOfRequestArgs, UmbTreeItemModel, UmbTreeRootItemsRequestArgs, UmbTreeStartNode } from '../../core/tree/index.js';
+import type { UmbConfigCollectionModel } from '../../core/utils/index.js';
+import type { UmbControllerHost } from '../../../libs/controller-api/index.js';
+export declare class UmbElementTreePickerDataSource extends UmbControllerBase implements UmbPickerTreeDataSource {
+    #private;
+    constructor(host: UmbControllerHost);
+    setConfig(config: UmbConfigCollectionModel | undefined): void;
+    requestTreeStartNode: () => Promise<UmbTreeStartNode | undefined>;
+    requestTreeRoot: () => Promise<{
+        data: import("../types.js").UmbElementTreeRootModel;
+    }>;
+    requestTreeRootItems: (args: UmbTreeRootItemsRequestArgs) => Promise<{
+        data: import("../../core/repository/index.js").UmbTargetPagedModel<import("../types.js").UmbElementTreeItemModel> | undefined;
+        error: Error | import("../../core/resources/index.js").UmbError | import("../../core/resources/index.js").UmbCancelError | import("../../core/resources/index.js").UmbApiError | undefined;
+        asObservable: () => undefined;
+    }>;
+    requestTreeItemsOf: (args: UmbTreeChildrenOfRequestArgs) => Promise<{
+        data: import("../../core/repository/index.js").UmbTargetPagedModel<import("../types.js").UmbElementTreeItemModel> | undefined;
+        error: Error | import("../../core/resources/index.js").UmbError | import("../../core/resources/index.js").UmbCancelError | import("../../core/resources/index.js").UmbApiError | undefined;
+        asObservable: () => undefined;
+    }>;
+    requestTreeItemAncestors: (args: UmbTreeAncestorsOfRequestArgs) => Promise<{
+        data: import("../types.js").UmbElementTreeItemModel[] | undefined;
+        error: any;
+    }>;
+    requestItems: (uniques: Array<string>) => Promise<{
+        asObservable: () => undefined;
+        data?: undefined;
+        error?: undefined;
+    } | {
+        data: import("../types.js").UmbElementItemModel[] | undefined;
+        error: Error | import("../../core/resources/index.js").UmbError | import("../../core/resources/index.js").UmbCancelError | import("../../core/resources/index.js").UmbApiError | undefined;
+        asObservable: () => import("rxjs").Observable<import("../types.js").UmbElementItemModel[]> | undefined;
+    }> | Promise<{
+        asObservable: () => undefined;
+        data?: undefined;
+        error?: undefined;
+    } | {
+        data: import("../folder/types.js").UmbElementFolderItemModel[] | undefined;
+        error: Error | import("../../core/resources/index.js").UmbError | import("../../core/resources/index.js").UmbCancelError | import("../../core/resources/index.js").UmbApiError | undefined;
+        asObservable: () => import("rxjs").Observable<import("../folder/types.js").UmbElementFolderItemModel[]> | undefined;
+    }>;
+    treePickableFilter: (treeItem: UmbTreeItemModel) => boolean;
+}

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

@@ -0,0 +1,51 @@
+import { UmbElementFolderItemRepository } from '../folder/repository/item/element-folder-item.repository.js';
+import { UmbElementItemRepository } from '../item/repository/element-item.repository.js';
+import { UmbElementTreeRepository } from '../tree/element-tree.repository.js';
+import { getConfigValue } from '../../core/utils/index.js';
+import { UmbControllerBase } from '../../../libs/class-api/index.js';
+import { UMB_PROPERTY_TYPE_BASED_PROPERTY_CONTEXT } from '../../content/content/index.js';
+export class UmbElementTreePickerDataSource extends UmbControllerBase {
+    #dataType;
+    #elementItem;
+    #folderItem;
+    #folderOnly;
+    #tree;
+    #startNode;
+    constructor(host) {
+        super(host);
+        this.#elementItem = new UmbElementItemRepository(this);
+        this.#folderItem = new UmbElementFolderItemRepository(this);
+        this.#folderOnly = false;
+        this.#tree = new UmbElementTreeRepository(this);
+        this.requestTreeStartNode = async () => this.#startNode ?? undefined;
+        this.requestTreeRoot = () => this.#tree.requestTreeRoot();
+        this.requestTreeRootItems = (args) => {
+            const typedArgs = {
+                ...args,
+                foldersOnly: this.#folderOnly,
+                dataType: this.#dataType,
+            };
+            return this.#tree.requestTreeRootItems(typedArgs);
+        };
+        this.requestTreeItemsOf = (args) => {
+            const typedArgs = {
+                ...args,
+                foldersOnly: this.#folderOnly,
+                dataType: this.#dataType,
+            };
+            return this.#tree.requestTreeItemsOf(typedArgs);
+        };
+        this.requestTreeItemAncestors = (args) => this.#tree.requestTreeItemAncestors(args);
+        this.requestItems = (uniques) => this.#folderOnly ? this.#folderItem.requestItems(uniques) : this.#elementItem.requestItems(uniques);
+        this.treePickableFilter = (treeItem) => treeItem.isFolder === this.#folderOnly;
+        this.consumeContext(UMB_PROPERTY_TYPE_BASED_PROPERTY_CONTEXT, (context) => {
+            this.observe(context?.dataType, (dataType) => {
+                this.#dataType = dataType;
+            });
+        });
+    }
+    setConfig(config) {
+        this.#folderOnly = Boolean(getConfigValue(config, 'folderOnly'));
+        this.#startNode = getConfigValue(config, 'startNode');
+    }
+}

package/dist-cms/packages/elements/picker-data-source/index.d.ts

@@ -0,0 +1 @@
+export * from './element-tree.picker-data-source.js';

package/dist-cms/packages/elements/picker-data-source/index.js

@@ -0,0 +1 @@
+export * from './element-tree.picker-data-source.js';

package/dist-cms/packages/elements/property-editor/element-picker/Umbraco.ElementPicker.d.ts

@@ -0,0 +1,2 @@
+import type { ManifestPropertyEditorSchema } from '../../../core/property-editor/index.js';
+export declare const manifest: ManifestPropertyEditorSchema;

package/dist-cms/packages/elements/property-editor/element-picker/Umbraco.ElementPicker.js

@@ -0,0 +1,19 @@
+export const manifest = {
+    type: 'propertyEditorSchema',
+    name: 'Element Picker',
+    alias: 'Umbraco.ElementPicker',
+    meta: {
+        defaultPropertyEditorUiAlias: 'Umb.PropertyEditorUi.ElementPicker',
+        settings: {
+            properties: [
+                {
+                    alias: 'ignoreUserStartNodes',
+                    label: 'Ignore user start nodes',
+                    description: "Selecting this option allows a user to choose nodes that they normally don't have access to.",
+                    propertyEditorUiAlias: 'Umb.PropertyEditorUi.Toggle',
+                    weight: 120,
+                },
+            ],
+        },
+    },
+};

package/dist-cms/packages/elements/property-editor/element-picker/element-picker-property-editor-ui.element.d.ts

@@ -0,0 +1,26 @@
+import { UmbLitElement } from '../../../core/lit-element/index.js';
+import type { UmbPropertyEditorUiElement } from '../../../core/property-editor/index.js';
+declare const UmbElementPickerPropertyEditorUIElement_base: import("../../../../libs/extension-api/index.js").HTMLElementConstructor<import("../../../core/validation/index.js").UmbFormControlMixinElement<string[] | undefined>> & typeof UmbLitElement;
+export declare class UmbElementPickerPropertyEditorUIElement extends UmbElementPickerPropertyEditorUIElement_base implements UmbPropertyEditorUiElement {
+    #private;
+    mandatory?: boolean;
+    mandatoryMessage: string;
+    name?: string;
+    readonly: boolean;
+    set config(config: UmbPropertyEditorUiElement['config'] | undefined);
+    private _folderOnly;
+    private _min;
+    private _minMessage;
+    private _max;
+    private _maxMessage;
+    private _startNode?;
+    focus(): void | undefined;
+    firstUpdated(changedProperties: Map<string | number | symbol, unknown>): void;
+    render(): import("lit-html").TemplateResult<1>;
+}
+export { UmbElementPickerPropertyEditorUIElement as element };
+declare global {
+    interface HTMLElementTagNameMap {
+        'umb-element-picker-property-editor-ui': UmbElementPickerPropertyEditorUIElement;
+    }
+}