@dotcms/angular 0.0.1-beta.3 → 0.0.1-beta.30

package/esm2022/next/providers/dotcms-image-loader/dotcms-image_loader.mjs

@@ -0,0 +1,74 @@
+import { IMAGE_LOADER } from '@angular/common';
+/**
+ * Validates if a given path is a valid URL string
+ *
+ * @param path - The path to validate
+ * @returns boolean indicating if the path is valid
+ */
+function isValidPath(path) {
+    if (typeof path !== 'string' || path.trim() === '') {
+        return false;
+    }
+    try {
+        new URL(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Provides a DotCMS image loader configuration for the Angular Image directive
+ *
+ * @param path - The base URL path to the DotCMS instance, or empty to use current site
+ * @returns An array of providers for the IMAGE_LOADER token
+ * @throws Error if the provided path is invalid
+ * @example
+ * ```typescript
+ * // In your app.config.ts
+ * export const appConfig: ApplicationConfig = {
+ *   providers: [
+ *     provideDotCMSImageLoader('https://demo.dotcms.com')
+ *     // Or use current site:
+ *     // provideDotCMSImageLoader()
+ *   ]
+ * };
+ * ```
+ */
+export function provideDotCMSImageLoader(path) {
+    // If path is provided, validate it
+    if (path && !isValidPath(path)) {
+        throw new Error(`Image loader has detected an invalid path (\`${path}\`). ` +
+            `To fix this, supply either the full URL to the dotCMS site, or leave it empty to use the current site.`);
+    }
+    return [
+        {
+            provide: IMAGE_LOADER,
+            useValue: (config) => createDotCMSURL(config, path)
+        }
+    ];
+}
+/**
+ * Creates a DotCMS-compatible URL for image loading
+ *
+ * @param config - The image loader configuration
+ * @param path - The base URL path to the DotCMS instance
+ * @returns A fully qualified URL for the image
+ * @internal
+ */
+function createDotCMSURL(config, path) {
+    const { loaderParams, src, width } = config;
+    const params = loaderParams;
+    if (params?.isOutsideSRC) {
+        return src;
+    }
+    // Use empty string as fallback to support using current site
+    const dotcmsHost = path ? new URL(path).origin : '';
+    const imageSRC = src.includes('/dA/') ? src : `/dA/${src}`;
+    const languageId = params?.languageId ?? '1';
+    if (width) {
+        return `${dotcmsHost}${imageSRC}/${width}w?language_id=${languageId}`;
+    }
+    return `${dotcmsHost}${imageSRC}?language_id=${languageId}`;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/next/public_api.mjs

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

package/esm2022/next/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 | null>}
+     */
+    #responseSubject = new Subject();
+    /**
+     * Observable stream of the page asset changes.
+     * Exposes the pageAssetSubject as an Observable for subscribers.
+     *
+     * @private
+     * @type {Observable<DotCMSPageResponse | null>}
+     */
+    #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 null
+     */
+    listen(response) {
+        if (!getUVEState()) {
+            return of(response || null);
+        }
+        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/next/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,2 @@
+export * from './lib/deprecated/deprecated-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL2xpYnMvc2RrL2FuZ3VsYXIvc3JjL3B1YmxpY19hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxpQ0FBaUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vbGliL2RlcHJlY2F0ZWQvZGVwcmVjYXRlZC1hcGknO1xuIl19