@dotcms/angular 0.0.1-beta.9 → 1.0.0

package/esm2022/lib/services/dotcms-editable-page.service.mjs

@@ -0,0 +1,93 @@
+import { of, Subject } from 'rxjs';
+import { Injectable } from '@angular/core';
+import { finalize } from 'rxjs/operators';
+import { UVEEventType } from '@dotcms/types';
+import { createUVESubscription, getUVEState, initUVE, updateNavigation } from '@dotcms/uve';
+import * as i0 from "@angular/core";
+export class DotCMSEditablePageService {
+    /**
+     * Subject that emits the current editable page asset or null.
+     * Used internally to track changes to the page data.
+     *
+     * @private
+     * @type {Subject<DotCMSPageResponse | undefined>}
+     */
+    #responseSubject = new Subject();
+    /**
+     * Observable stream of the page asset changes.
+     * Exposes the pageAssetSubject as an Observable for subscribers.
+     *
+     * @private
+     * @type {Observable<DotCMSPageResponse | undefined>}
+     */
+    #response$ = this.#responseSubject.asObservable();
+    /**
+     * Listens for changes to an editable page and returns an Observable that emits the updated page data.
+     * This method initializes the UVE (Universal Visual Editor) and sets up subscriptions to track content changes.
+     *
+     * @example
+     * ```ts
+     * // Import the service
+     * import { DotCMSEditablePageService } from '@dotcms/angular';
+     *
+     * // Inject the service
+     * constructor(private editablePageService: DotCMSEditablePageService) {}
+     *
+     * // Get the page data from your API call
+     * const page = await client.page.get('/');
+     *
+     * // Listen for changes
+     * const subscription = this.editablePageService.listen(page).subscribe(updatedPage => {
+     *   if (updatedPage) {
+     *     // Handle updated page data
+     *     console.log('Page updated:', updatedPage);
+     *   }
+     * });
+     *
+     * // When done listening, unsubscribe
+     * subscription.unsubscribe();
+     * ```
+     *
+     * @param response Optional initial page data
+     * @returns Observable that emits the updated page data or undefined
+     */
+    listen(response) {
+        if (!getUVEState()) {
+            return of(response);
+        }
+        const pageURI = response?.pageAsset?.page?.pageURI;
+        initUVE(response);
+        // Update the navigation to the pageURI, when we have a pageURI
+        // Sometimes the page is null due to permissions, so we don't want to update the navigation
+        // And wait for the UVE to resolve the page
+        if (pageURI) {
+            updateNavigation(pageURI);
+        }
+        const unsubscribeUVEChanges = this.#listenUVEChanges();
+        return this.#response$.pipe(finalize(() => {
+            unsubscribeUVEChanges();
+        }));
+    }
+    /**
+     * Sets up a subscription to listen for UVE content changes and updates the page asset subject.
+     * This is an internal method used by listenEditablePage() to handle UVE events.
+     *
+     * @returns {UVEUnsubscribeFunction} Function to unsubscribe from the UVE content changes
+     * @private
+     */
+    #listenUVEChanges() {
+        const { unsubscribe } = createUVESubscription(UVEEventType.CONTENT_CHANGES, (payload) => {
+            this.#responseSubject.next(payload);
+        });
+        return unsubscribe;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.3", ngImport: i0, type: DotCMSEditablePageService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.3", ngImport: i0, type: DotCMSEditablePageService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.3", ngImport: i0, type: DotCMSEditablePageService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/store/dotcms.store.mjs

@@ -0,0 +1,61 @@
+import { computed, Injectable, signal } from '@angular/core';
+import { UVE_MODE } from '@dotcms/types';
+import { getUVEState } from '@dotcms/uve';
+import { DEVELOPMENT_MODE, PRODUCTION_MODE } from '@dotcms/uve/internal';
+import * as i0 from "@angular/core";
+export const EMPTY_DOTCMS_PAGE_STORE = {
+    page: {},
+    components: {},
+    mode: PRODUCTION_MODE
+};
+/**
+ * @description This service is responsible for managing the page context.
+ * @internal
+ * @author dotCMS
+ * @export
+ * @class DotCMSStore
+ */
+export class DotCMSStore {
+    constructor() {
+        this.$store = signal(EMPTY_DOTCMS_PAGE_STORE);
+        /**
+         * @description Get if the current context is in development mode
+         * @readonly
+         * @type {boolean}
+         * @memberof DotCMSStore
+         */
+        this.$isDevMode = computed(() => {
+            const uveState = getUVEState();
+            if (uveState?.mode) {
+                return uveState?.mode === UVE_MODE.EDIT;
+            }
+            return this.$store()?.mode === DEVELOPMENT_MODE;
+        });
+    }
+    /**
+     * @description Get the store
+     * @readonly
+     * @type {DotCMSPageStore}
+     * @memberof DotCMSStore
+     */
+    get store() {
+        return this.$store();
+    }
+    /**
+     * @description Set the store
+     * @param {DotCMSPageStore} value
+     * @memberof DotCMSStore
+     */
+    setStore(store) {
+        this.$store.set(store);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.3", ngImport: i0, type: DotCMSStore, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.3", ngImport: i0, type: DotCMSStore, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.3", ngImport: i0, type: DotCMSStore, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/public_api.mjs

@@ -0,0 +1,8 @@
+export { DotCMSShowWhenDirective } from './lib/directives/dotcms-show-when/dotcms-show-when.directive';
+export { provideDotCMSImageLoader } from './lib/providers/dotcms-image-loader/dotcms-image_loader';
+export { provideDotCMSClient, DotCMSClient } from './lib/providers/dotcms-client/dotcms-client.provider';
+export { DotCMSEditableTextComponent } from './lib/components/dotcms-editable-text/dotcms-editable-text.component';
+export { DotCMSBlockEditorRendererComponent } from './lib/components/dotcms-block-editor-renderer/dotcms-block-editor-renderer.component';
+export { DotCMSLayoutBodyComponent } from './lib/components/dotcms-layout-body/dotcms-layout-body.component';
+export { DotCMSEditablePageService } from './lib/services/dotcms-editable-page.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL2xpYnMvc2RrL2FuZ3VsYXIvc3JjL3B1YmxpY19hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLHVCQUF1QixFQUFFLE1BQU0sOERBQThELENBQUM7QUFFdkcsT0FBTyxFQUFFLHdCQUF3QixFQUFFLE1BQU0seURBQXlELENBQUM7QUFFbkcsT0FBTyxFQUNILG1CQUFtQixFQUNuQixZQUFZLEVBQ2YsTUFBTSxzREFBc0QsQ0FBQztBQUU5RCxPQUFPLEVBQUUsMkJBQTJCLEVBQUUsTUFBTSxzRUFBc0UsQ0FBQztBQUVuSCxPQUFPLEVBQUUsa0NBQWtDLEVBQUUsTUFBTSxzRkFBc0YsQ0FBQztBQUUxSSxPQUFPLEVBQUUseUJBQXlCLEVBQUUsTUFBTSxrRUFBa0UsQ0FBQztBQUU3RyxPQUFPLEVBQUUseUJBQXlCLEVBQUUsTUFBTSw2Q0FBNkMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7IERvdENNU1Nob3dXaGVuRGlyZWN0aXZlIH0gZnJvbSAnLi9saWIvZGlyZWN0aXZlcy9kb3RjbXMtc2hvdy13aGVuL2RvdGNtcy1zaG93LXdoZW4uZGlyZWN0aXZlJztcblxuZXhwb3J0IHsgcHJvdmlkZURvdENNU0ltYWdlTG9hZGVyIH0gZnJvbSAnLi9saWIvcHJvdmlkZXJzL2RvdGNtcy1pbWFnZS1sb2FkZXIvZG90Y21zLWltYWdlX2xvYWRlcic7XG5cbmV4cG9ydCB7XG4gICAgcHJvdmlkZURvdENNU0NsaWVudCxcbiAgICBEb3RDTVNDbGllbnRcbn0gZnJvbSAnLi9saWIvcHJvdmlkZXJzL2RvdGNtcy1jbGllbnQvZG90Y21zLWNsaWVudC5wcm92aWRlcic7XG5cbmV4cG9ydCB7IERvdENNU0VkaXRhYmxlVGV4dENvbXBvbmVudCB9IGZyb20gJy4vbGliL2NvbXBvbmVudHMvZG90Y21zLWVkaXRhYmxlLXRleHQvZG90Y21zLWVkaXRhYmxlLXRleHQuY29tcG9uZW50JztcblxuZXhwb3J0IHsgRG90Q01TQmxvY2tFZGl0b3JSZW5kZXJlckNvbXBvbmVudCB9IGZyb20gJy4vbGliL2NvbXBvbmVudHMvZG90Y21zLWJsb2NrLWVkaXRvci1yZW5kZXJlci9kb3RjbXMtYmxvY2stZWRpdG9yLXJlbmRlcmVyLmNvbXBvbmVudCc7XG5cbmV4cG9ydCB7IERvdENNU0xheW91dEJvZHlDb21wb25lbnQgfSBmcm9tICcuL2xpYi9jb21wb25lbnRzL2RvdGNtcy1sYXlvdXQtYm9keS9kb3RjbXMtbGF5b3V0LWJvZHkuY29tcG9uZW50JztcblxuZXhwb3J0IHsgRG90Q01TRWRpdGFibGVQYWdlU2VydmljZSB9IGZyb20gJy4vbGliL3NlcnZpY2VzL2RvdGNtcy1lZGl0YWJsZS1wYWdlLnNlcnZpY2UnO1xuXG5leHBvcnQgeyBEeW5hbWljQ29tcG9uZW50RW50aXR5IH0gZnJvbSAnLi9saWIvbW9kZWxzJztcbiJdfQ==