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

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

@@ -0,0 +1,40 @@
+import type { UmbElementVariantPublishModel } from '../types.js';
+import type { UmbControllerHost } from '../../../../libs/controller-api/index.js';
+import type { UmbVariantId } from '../../../core/variant/index.js';
+/**
+ * A server data source for Element publishing
+ * @class UmbElementPublishingServerDataSource
+ */
+export declare class UmbElementPublishingServerDataSource {
+    #private;
+    /**
+     * Creates an instance of UmbElementPublishingServerDataSource.
+     * @param {UmbControllerHost} host - The controller host for this controller to be appended to
+     * @memberof UmbElementPublishingServerDataSource
+     */
+    constructor(host: UmbControllerHost);
+    /**
+     * Publish one or more variants of an Element
+     * @param {string} unique
+     * @param {Array<UmbElementVariantPublishModel>} variants
+     * @returns {*}
+     * @memberof UmbElementPublishingServerDataSource
+     */
+    publish(unique: string, variants: Array<UmbElementVariantPublishModel>): Promise<import("../../../core/resources/index.js").UmbApiResponse<{
+        data: unknown;
+        request: Request;
+        response: Response;
+    }>>;
+    /**
+     * Unpublish one or more variants of an Element
+     * @param {string} unique
+     * @param {Array<UmbVariantId>} variantIds
+     * @returns {*}
+     * @memberof UmbElementPublishingServerDataSource
+     */
+    unpublish(unique: string, variantIds: Array<UmbVariantId>): Promise<import("../../../core/resources/index.js").UmbApiResponse<{
+        data: unknown;
+        request: Request;
+        response: Response;
+    }>>;
+}

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

@@ -0,0 +1,59 @@
+import { tryExecute } from '../../../core/resources/index.js';
+import { ElementService } from '../../../core/backend-api/index.js';
+/**
+ * A server data source for Element publishing
+ * @class UmbElementPublishingServerDataSource
+ */
+export class UmbElementPublishingServerDataSource {
+    #host;
+    /**
+     * Creates an instance of UmbElementPublishingServerDataSource.
+     * @param {UmbControllerHost} host - The controller host for this controller to be appended to
+     * @memberof UmbElementPublishingServerDataSource
+     */
+    constructor(host) {
+        this.#host = host;
+    }
+    /**
+     * Publish one or more variants of an Element
+     * @param {string} unique
+     * @param {Array<UmbElementVariantPublishModel>} variants
+     * @returns {*}
+     * @memberof UmbElementPublishingServerDataSource
+     */
+    async publish(unique, variants) {
+        if (!unique)
+            throw new Error('Id is missing');
+        const publishSchedules = variants.map((variant) => ({
+            culture: variant.variantId.isCultureInvariant() ? null : variant.variantId.toCultureString(),
+            schedule: variant.schedule ?? null,
+        }));
+        return tryExecute(this.#host, ElementService.putElementByIdPublish({
+            path: { id: unique },
+            body: { publishSchedules },
+        }));
+    }
+    /**
+     * Unpublish one or more variants of an Element
+     * @param {string} unique
+     * @param {Array<UmbVariantId>} variantIds
+     * @returns {*}
+     * @memberof UmbElementPublishingServerDataSource
+     */
+    async unpublish(unique, variantIds) {
+        if (!unique)
+            throw new Error('Id is missing');
+        // If variants are culture invariant, we need to pass null to the API
+        const hasInvariant = variantIds.some((variant) => variant.isCultureInvariant());
+        if (hasInvariant) {
+            return tryExecute(this.#host, ElementService.putElementByIdUnpublish({
+                path: { id: unique },
+                body: { cultures: null },
+            }));
+        }
+        return tryExecute(this.#host, ElementService.putElementByIdUnpublish({
+            path: { id: unique },
+            body: { cultures: variantIds.map((variant) => variant.toCultureString()) },
+        }));
+    }
+}

package/dist-cms/packages/elements/publishing/repository/index.d.ts

@@ -0,0 +1,2 @@
+export { UmbElementPublishingRepository } from './element-publishing.repository.js';
+export { UMB_ELEMENT_PUBLISHING_REPOSITORY_ALIAS } from './constants.js';

package/dist-cms/packages/elements/publishing/repository/index.js

@@ -0,0 +1,2 @@
+export { UmbElementPublishingRepository } from './element-publishing.repository.js';
+export { UMB_ELEMENT_PUBLISHING_REPOSITORY_ALIAS } from './constants.js';

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

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

package/dist-cms/packages/elements/publishing/repository/manifests.js

@@ -0,0 +1,9 @@
+import { UMB_ELEMENT_PUBLISHING_REPOSITORY_ALIAS } from './constants.js';
+export const manifests = [
+    {
+        type: 'repository',
+        alias: UMB_ELEMENT_PUBLISHING_REPOSITORY_ALIAS,
+        name: 'Element Publishing Repository',
+        api: () => import('./element-publishing.repository.js'),
+    },
+];

package/dist-cms/packages/elements/publishing/schedule-publish/constants.d.ts

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

package/dist-cms/packages/elements/publishing/schedule-publish/constants.js

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

package/dist-cms/packages/elements/publishing/schedule-publish/manifests.d.ts

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

package/dist-cms/packages/elements/publishing/schedule-publish/manifests.js

@@ -0,0 +1,3 @@
+import { manifests as modalManifests } from './modal/manifests.js';
+import { manifests as workspaceActionManifests } from './workspace-action/manifests.js';
+export const manifests = [...modalManifests, ...workspaceActionManifests];

package/dist-cms/packages/elements/publishing/schedule-publish/modal/constants.d.ts

@@ -0,0 +1 @@
+export { UMB_ELEMENT_SCHEDULE_MODAL, UMB_ELEMENT_SCHEDULE_MODAL_ALIAS } from './element-schedule-modal.token.js';

package/dist-cms/packages/elements/publishing/schedule-publish/modal/constants.js

@@ -0,0 +1 @@
+export { UMB_ELEMENT_SCHEDULE_MODAL, UMB_ELEMENT_SCHEDULE_MODAL_ALIAS } from './element-schedule-modal.token.js';

package/dist-cms/packages/elements/publishing/schedule-publish/modal/element-schedule-modal.element.d.ts

@@ -0,0 +1,21 @@
+import type { UmbElementScheduleModalData, UmbElementScheduleModalValue } from './element-schedule-modal.token.js';
+import { UmbModalBaseElement } from '../../../../core/modal/index.js';
+export declare class UmbElementScheduleModalElement extends UmbModalBaseElement<UmbElementScheduleModalData, UmbElementScheduleModalValue> {
+    #private;
+    private _options;
+    private _hasNotSelectedMandatory?;
+    private readonly _selection;
+    private _isAllSelected;
+    private _internalValues;
+    private _submitButtonState?;
+    constructor();
+    firstUpdated(): void;
+    render(): import("lit-html").TemplateResult<1>;
+    static readonly styles: import("lit").CSSResult[];
+}
+export default UmbElementScheduleModalElement;
+declare global {
+    interface HTMLElementTagNameMap {
+        'umb-element-schedule-modal': UmbElementScheduleModalElement;
+    }
+}

package/dist-cms/packages/elements/publishing/schedule-publish/modal/element-schedule-modal.element.js

@@ -0,0 +1,410 @@
+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 { UmbElementVariantState } from '../../../variant-state.js';
+import { isNotPublishedMandatory } from '../../utils.js';
+import { UmbElementVariantLanguagePickerElement } from '../../../modals/index.js';
+import { css, customElement, html, ref, repeat, state, when } from '../../../../../external/lit/index.js';
+import { UmbModalBaseElement } from '../../../../core/modal/index.js';
+import { UmbTextStyles } from '../../../../core/style/index.js';
+import { UmbSelectionManager } from '../../../../core/utils/index.js';
+import { umbBindToValidation, UmbValidationContext } from '../../../../core/validation/index.js';
+let UmbElementScheduleModalElement = class UmbElementScheduleModalElement extends UmbModalBaseElement {
+    #selectionManager;
+    #validation;
+    #pickableFilter;
+    constructor() {
+        super();
+        this.#selectionManager = new UmbSelectionManager(this);
+        this._options = [];
+        this._selection = [];
+        this._isAllSelected = false;
+        this._internalValues = [];
+        this.#validation = new UmbValidationContext(this);
+        this.#pickableFilter = (option) => {
+            if (isNotPublishedMandatory(option)) {
+                return true;
+            }
+            if (!option.variant || option.variant.state === UmbElementVariantState.NOT_CREATED) {
+                // If no data present, then its not pickable.
+                return false;
+            }
+            return this.data?.pickableFilter ? this.data.pickableFilter(option) : true;
+        };
+        this.observe(this.#selectionManager.selection, (selection) => {
+            if (!this._options && !selection)
+                return;
+            // New selections are mapped to the schedule data
+            this._selection.length = 0;
+            for (const unique of selection) {
+                const existing = this._internalValues.find((s) => s.unique === unique);
+                if (existing) {
+                    this._selection.push(existing);
+                }
+            }
+            this._isAllSelected = this.#isAllSelected();
+            // Getting not published mandatory options — the options that are mandatory and not currently published.
+            const missingMandatoryOptions = this._options.filter(isNotPublishedMandatory);
+            this._hasNotSelectedMandatory = missingMandatoryOptions.some((option) => !selection.includes(option.unique));
+            this.requestUpdate();
+        }, '_selection');
+    }
+    firstUpdated() {
+        this._internalValues = this.data?.prevalues ? [...this.data.prevalues] : [];
+        this.#configureSelectionManager();
+    }
+    async #configureSelectionManager() {
+        this.#selectionManager.setMultiple(true);
+        this.#selectionManager.setSelectable(true);
+        this.#selectionManager.setAllowLimitation((unique) => {
+            const option = this._options.find((o) => o.unique === unique);
+            return option ? this.#pickableFilter(option) : true;
+        });
+        // Only display variants that are relevant to pick from, i.e. variants that are draft, not-published-mandatory or published with pending changes.
+        // If we don't know the state (e.g. from a bulk publishing selection) we need to consider it available for selection.
+        this._options =
+            this.data?.options.filter((option) => (option.variant && option.variant.state === null) ||
+                isNotPublishedMandatory(option) ||
+                option.variant?.state !== UmbElementVariantState.NOT_CREATED) ?? [];
+        let selected = this.data?.activeVariants ?? [];
+        // Only display variants that are relevant to pick from, i.e. variants that are draft, not-published-mandatory or published with pending changes.
+        // If we don't know the state (e.g. from a bulk publishing selection) we need to consider it available for selection.
+        const validOptions = this._options.filter((option) => this.#pickableFilter(option));
+        // Filter selection based on options:
+        selected = selected.filter((unique) => validOptions.some((o) => o.unique === unique));
+        this.#selectionManager.setSelection(selected);
+    }
+    async #submit() {
+        this._submitButtonState = 'waiting';
+        try {
+            await this.#validation.validate();
+            this._submitButtonState = 'success';
+            this.value = {
+                selection: this._selection,
+            };
+            this.modalContext?.submit();
+        }
+        catch {
+            this._submitButtonState = 'failed';
+        }
+        finally {
+            this._submitButtonState = undefined;
+        }
+    }
+    #close() {
+        this.modalContext?.reject();
+    }
+    #isSelected(unique) {
+        return this._selection.some((s) => s.unique === unique);
+    }
+    #onSelectAllChange(event) {
+        const allUniques = this._options.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._options.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() {
+        return html `<uui-dialog-layout headline=${this.localize.term('general_scheduledPublishing')}>
+			${this.#renderOptions()}
+
+			<div slot="actions">
+				<uui-button label=${this.localize.term('general_close')} @click=${this.#close}></uui-button>
+				<uui-button
+					.state=${this._submitButtonState}
+					label="${this.localize.term('buttons_schedulePublish')}"
+					look="primary"
+					color="positive"
+					?disabled=${!this._selection.length || this._hasNotSelectedMandatory}
+					@click=${this.#submit}></uui-button>
+			</div>
+		</uui-dialog-layout> `;
+    }
+    #renderOptions() {
+        return html `
+			${when(this._options.length > 1, () => html `
+					<uui-checkbox
+						@change=${this.#onSelectAllChange}
+						label=${this.localize.term('general_selectAll')}
+						.checked=${this._isAllSelected}></uui-checkbox>
+				`)}
+			${repeat(this._options, (option) => option.unique, (option) => this.#renderItem(option))}
+		`;
+    }
+    #renderItem(option) {
+        const pickable = this.#pickableFilter(option);
+        const fromDate = this.#fromDate(option.unique);
+        const toDate = this.#toDate(option.unique);
+        const isChanged = fromDate !== option.variant?.scheduledPublishDate || toDate !== option.variant?.scheduledUnpublishDate;
+        return html `
+			<uui-menu-item
+				?selectable=${pickable}
+				?disabled=${!pickable}
+				label=${option.variant?.name ?? option.language.name}
+				@selected=${() => this.#selectionManager.select(option.unique)}
+				@deselected=${() => this.#selectionManager.deselect(option.unique)}
+				?selected=${this.#isSelected(option.unique)}>
+				<uui-icon slot="icon" name="icon-globe"></uui-icon>
+				${UmbElementVariantLanguagePickerElement.renderLabel(option)}
+			</uui-menu-item>
+			${when(this.#isSelected(option.unique), () => this.#renderPublishDateInput(option, fromDate, toDate))}
+			${when(isChanged, () => html `<p>
+						${this.localize.term('content_scheduledPendingChanges', this.localize.term('buttons_schedulePublish'))}
+					</p>`)}
+		`;
+    }
+    #attachValidatorsToPublish(element) {
+        if (!element)
+            return;
+        element.addValidator('badInput', () => this.localize.term('speechBubbles_scheduleErrReleaseDate1'), () => {
+            const value = element.value.toString();
+            if (!value)
+                return false;
+            const date = new Date(value);
+            return date < new Date();
+        });
+    }
+    #attachValidatorsToUnpublish(element, unique) {
+        if (!element)
+            return;
+        element.addValidator('badInput', () => this.localize.term('speechBubbles_scheduleErrExpireDate1'), () => {
+            const value = element.value.toString();
+            if (!value)
+                return false;
+            const date = new Date(value);
+            return date < new Date();
+        });
+        element.addValidator('customError', () => this.localize.term('speechBubbles_scheduleErrExpireDate2'), () => {
+            const value = element.value.toString();
+            if (!value)
+                return false;
+            // Check if the unpublish date is before the publish date
+            const variant = this._internalValues.find((s) => s.unique === unique);
+            if (!variant)
+                return false;
+            const publishTime = variant.schedule?.publishTime;
+            if (!publishTime)
+                return false;
+            const date = new Date(value);
+            const publishDate = new Date(publishTime);
+            return date < publishDate;
+        });
+    }
+    #renderPublishDateInput(option, fromDate, toDate) {
+        return html `
+			<div class="publish-date">
+				<uui-form-layout-item>
+					<uui-label slot="label"><umb-localize key="content_releaseDate">Publish at</umb-localize></uui-label>
+					<div>
+						<umb-input-date
+							${ref((e) => this.#attachValidatorsToPublish(e))}
+							${umbBindToValidation(this)}
+							type="datetime-local"
+							.value=${this.#formatDate(fromDate)}
+							@change=${(e) => this.#onFromDateChange(e, option.unique)}
+							label=${this.localize.term('general_publishDate')}>
+							<div slot="append">
+								${when(fromDate, () => html `
+										<uui-button
+											compact
+											label=${this.localize.term('general_clear')}
+											title=${this.localize.term('general_clear')}
+											@click=${() => this.#removeFromDate(option.unique)}>
+											<uui-icon name="remove"></uui-icon>
+										</uui-button>
+									`)}
+							</div>
+						</umb-input-date>
+					</div>
+				</uui-form-layout-item>
+
+				<uui-form-layout-item>
+					<uui-label slot="label"><umb-localize key="content_unpublishDate">Unpublish at</umb-localize></uui-label>
+					<div>
+						<umb-input-date
+							${ref((e) => this.#attachValidatorsToUnpublish(e, option.unique))}
+							${umbBindToValidation(this)}
+							type="datetime-local"
+							.value=${this.#formatDate(toDate)}
+							@change=${(e) => this.#onToDateChange(e, option.unique)}
+							label=${this.localize.term('general_publishDate')}>
+							<div slot="append">
+								${when(toDate, () => html `
+										<uui-button
+											compact
+											label=${this.localize.term('general_clear')}
+											title=${this.localize.term('general_clear')}
+											@click=${() => this.#removeToDate(option.unique)}>
+											<uui-icon name="remove"></uui-icon>
+										</uui-button>
+									`)}
+							</div>
+						</umb-input-date>
+					</div>
+				</uui-form-layout-item>
+			</div>
+		`;
+    }
+    #fromDate(unique) {
+        const variant = this._internalValues.find((s) => s.unique === unique);
+        return variant?.schedule?.publishTime ?? null;
+    }
+    #toDate(unique) {
+        const variant = this._internalValues.find((s) => s.unique === unique);
+        return variant?.schedule?.unpublishTime ?? null;
+    }
+    #removeFromDate(unique) {
+        const variant = this._internalValues.find((s) => s.unique === unique);
+        if (!variant)
+            return;
+        variant.schedule = {
+            ...variant.schedule,
+            publishTime: null,
+        };
+        this.#validation.validate();
+        this.requestUpdate('_internalValues');
+    }
+    #removeToDate(unique) {
+        const variant = this._internalValues.find((s) => s.unique === unique);
+        if (!variant)
+            return;
+        variant.schedule = {
+            ...variant.schedule,
+            unpublishTime: null,
+        };
+        this.#validation.validate();
+        this.requestUpdate('_internalValues');
+    }
+    /**
+     * Formats the date to be compatible with the input type datetime-local
+     * @param {string} dateStr The date to format, example: 2021-01-01T12:00:00.000+01:00
+     * @returns {string | undefined} The formatted date in local time with no offset, example: 2021-01-01T11:00
+     */
+    #formatDate(dateStr) {
+        if (!dateStr)
+            return '';
+        const d = new Date(dateStr);
+        if (isNaN(d.getTime())) {
+            console.warn('[Schedule]: Invalid date:', dateStr);
+            return '';
+        }
+        // We need to subtract the offset to get the correct time in the input field
+        // the input field expects local time without offset and the Date object will convert the date to local time
+        return (d.getFullYear() +
+            '-' +
+            String(d.getMonth() + 1).padStart(2, '0') +
+            '-' +
+            String(d.getDate()).padStart(2, '0') +
+            'T' +
+            String(d.getHours()).padStart(2, '0') +
+            ':' +
+            String(d.getMinutes()).padStart(2, '0'));
+    }
+    #onFromDateChange(e, unique) {
+        const variant = this._internalValues.find((s) => s.unique === unique);
+        if (!variant)
+            return;
+        variant.schedule = {
+            ...variant.schedule,
+            publishTime: this.#getDateValue(e),
+        };
+        this.#validation.validate();
+        this.requestUpdate('_internalValues');
+    }
+    #onToDateChange(e, unique) {
+        const variant = this._internalValues.find((s) => s.unique === unique);
+        if (!variant)
+            return;
+        variant.schedule = {
+            ...variant.schedule,
+            unpublishTime: this.#getDateValue(e),
+        };
+        this.#validation.validate();
+        this.requestUpdate('_internalValues');
+    }
+    #getDateValue(e) {
+        const value = e.target.value.toString();
+        return value.length ? value : null;
+    }
+    static { this.styles = [
+        UmbTextStyles,
+        css `
+			:host {
+				display: block;
+				min-width: 600px;
+				max-width: 90vw;
+			}
+
+			.label {
+				padding: 0.5rem 0;
+			}
+			.label-status {
+				font-size: 0.8rem;
+			}
+
+			.publish-date {
+				display: flex;
+				flex-direction: row;
+				justify-content: space-between;
+				gap: 1rem;
+				border-top: 1px solid var(--uui-color-border);
+				border-bottom: 1px solid var(--uui-color-border);
+				margin-top: var(--uui-size-space-4);
+			}
+
+			.publish-date > uui-form-layout-item {
+				flex: 1;
+				margin: 0;
+				padding: 0.5rem 0 1rem;
+			}
+
+			.publish-date > uui-form-layout-item:first-child {
+				border-right: 1px dashed var(--uui-color-border);
+			}
+
+			uui-checkbox {
+				margin-bottom: var(--uui-size-space-3);
+			}
+
+			uui-menu-item {
+				--uui-menu-item-flat-structure: 1;
+			}
+		`,
+    ]; }
+};
+__decorate([
+    state()
+], UmbElementScheduleModalElement.prototype, "_options", void 0);
+__decorate([
+    state()
+], UmbElementScheduleModalElement.prototype, "_hasNotSelectedMandatory", void 0);
+__decorate([
+    state()
+], UmbElementScheduleModalElement.prototype, "_selection", void 0);
+__decorate([
+    state()
+], UmbElementScheduleModalElement.prototype, "_isAllSelected", void 0);
+__decorate([
+    state()
+], UmbElementScheduleModalElement.prototype, "_internalValues", void 0);
+__decorate([
+    state()
+], UmbElementScheduleModalElement.prototype, "_submitButtonState", void 0);
+UmbElementScheduleModalElement = __decorate([
+    customElement('umb-element-schedule-modal')
+], UmbElementScheduleModalElement);
+export { UmbElementScheduleModalElement };
+export default UmbElementScheduleModalElement;

package/dist-cms/packages/elements/publishing/schedule-publish/modal/element-schedule-modal.token.d.ts

@@ -0,0 +1,16 @@
+import type { UmbElementVariantPickerData } from '../../../modals/types.js';
+import { UmbModalToken } from '../../../../core/modal/index.js';
+import type { ScheduleRequestModel } from '../../../../core/backend-api/index.js';
+export declare const UMB_ELEMENT_SCHEDULE_MODAL_ALIAS = "Umb.Modal.ElementSchedule";
+export interface UmbElementScheduleSelectionModel {
+    unique: string;
+    schedule?: ScheduleRequestModel | null;
+}
+export interface UmbElementScheduleModalData extends UmbElementVariantPickerData {
+    activeVariants: Array<string>;
+    prevalues: Array<UmbElementScheduleSelectionModel>;
+}
+export interface UmbElementScheduleModalValue {
+    selection: Array<UmbElementScheduleSelectionModel>;
+}
+export declare const UMB_ELEMENT_SCHEDULE_MODAL: UmbModalToken<UmbElementScheduleModalData, UmbElementScheduleModalValue>;

package/dist-cms/packages/elements/publishing/schedule-publish/modal/element-schedule-modal.token.js

@@ -0,0 +1,7 @@
+import { UmbModalToken } from '../../../../core/modal/index.js';
+export const UMB_ELEMENT_SCHEDULE_MODAL_ALIAS = 'Umb.Modal.ElementSchedule';
+export const UMB_ELEMENT_SCHEDULE_MODAL = new UmbModalToken(UMB_ELEMENT_SCHEDULE_MODAL_ALIAS, {
+    modal: {
+        type: 'dialog',
+    },
+});

package/dist-cms/packages/elements/publishing/schedule-publish/modal/manifests.d.ts

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

package/dist-cms/packages/elements/publishing/schedule-publish/modal/manifests.js

@@ -0,0 +1,9 @@
+import { UMB_ELEMENT_SCHEDULE_MODAL_ALIAS } from './element-schedule-modal.token.js';
+export const manifests = [
+    {
+        type: 'modal',
+        alias: UMB_ELEMENT_SCHEDULE_MODAL_ALIAS,
+        name: 'Element Schedule Modal',
+        element: () => import('./element-schedule-modal.element.js'),
+    },
+];

package/dist-cms/packages/elements/publishing/schedule-publish/modal/types.d.ts

@@ -0,0 +1 @@
+export type * from './element-schedule-modal.token.js';

package/dist-cms/packages/elements/publishing/schedule-publish/modal/types.js

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

package/dist-cms/packages/elements/publishing/schedule-publish/workspace-action/manifests.d.ts

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

package/dist-cms/packages/elements/publishing/schedule-publish/workspace-action/manifests.js

@@ -0,0 +1,31 @@
+import { UMB_ELEMENT_USER_PERMISSION_CONDITION_ALIAS, UMB_USER_PERMISSION_ELEMENT_PUBLISH, UMB_USER_PERMISSION_ELEMENT_UPDATE, } from '../../../user-permissions/constants.js';
+import { UMB_WORKSPACE_ENTITY_IS_NEW_CONDITION_ALIAS } from '../../../../core/workspace/index.js';
+import { UMB_ENTITY_IS_NOT_TRASHED_CONDITION_ALIAS } from '../../../../core/recycle-bin/index.js';
+export const manifests = [
+    {
+        type: 'workspaceActionMenuItem',
+        kind: 'default',
+        alias: 'Umb.Element.WorkspaceActionMenuItem.SchedulePublishing',
+        name: 'Schedule publishing',
+        weight: 20,
+        api: () => import('./save-and-schedule.action.js'),
+        forWorkspaceActions: 'Umb.WorkspaceAction.Element.SaveAndPublish',
+        meta: {
+            label: '#buttons_schedulePublish',
+            icon: 'icon-globe',
+        },
+        conditions: [
+            {
+                alias: UMB_ENTITY_IS_NOT_TRASHED_CONDITION_ALIAS,
+            },
+            {
+                alias: UMB_ELEMENT_USER_PERMISSION_CONDITION_ALIAS,
+                allOf: [UMB_USER_PERMISSION_ELEMENT_UPDATE, UMB_USER_PERMISSION_ELEMENT_PUBLISH],
+            },
+            {
+                alias: UMB_WORKSPACE_ENTITY_IS_NEW_CONDITION_ALIAS,
+                match: false,
+            },
+        ],
+    },
+];

package/dist-cms/packages/elements/publishing/schedule-publish/workspace-action/save-and-schedule.action.d.ts

@@ -0,0 +1,5 @@
+import { UmbWorkspaceActionBase } from '../../../../core/workspace/index.js';
+export declare class UmbElementSaveAndScheduleWorkspaceAction extends UmbWorkspaceActionBase {
+    execute(): Promise<void>;
+}
+export { UmbElementSaveAndScheduleWorkspaceAction as api };