@dotcms/angular 0.0.1-beta.4 → 0.0.1-beta.41

package/esm2022/next/components/dotcms-layout-body/dotcms-layout-body.component.mjs

@@ -0,0 +1,69 @@
+import { ChangeDetectionStrategy, Component, inject, Input, signal } from '@angular/core';
+import { PageErrorMessageComponent } from './components/page-error-message/page-error-message.component';
+import { RowComponent } from './components/row/row.component';
+import { DotCMSStore } from '../../store/dotcms.store';
+import * as i0 from "@angular/core";
+/**
+ * @description This component is used to render the layout for a DotCMS page.
+ * @param {DotCMSPageAsset} page - The page to render the layout for
+ * @param {DotCMSPageComponent} components - The components to render the layout for
+ * @param {DotCMSPageRendererMode} mode - The mode to render the layout for
+ *
+ * @example
+ * <dotcms-layout-body [page]="page" [components]="components" [mode]="'development'" />
+ *
+ * @export
+ * @implements {OnChanges}
+ * @class DotCMSLayoutBodyComponent
+ */
+export class DotCMSLayoutBodyComponent {
+    constructor() {
+        this.components = {};
+        this.mode = 'production';
+        this.#dotCMSStore = inject(DotCMSStore);
+        this.$isDevMode = this.#dotCMSStore.$isDevMode;
+        this.$rows = signal([]);
+        this.$isEmpty = signal(false);
+    }
+    #dotCMSStore;
+    ngOnChanges() {
+        this.#dotCMSStore.setStore({
+            page: this.page,
+            components: this.components,
+            mode: this.mode
+        });
+        this.$isEmpty.set(!this.page?.layout?.body);
+        this.$rows.set(this.page?.layout?.body?.rows ?? []);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.3", ngImport: i0, type: DotCMSLayoutBodyComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.3", type: DotCMSLayoutBodyComponent, isStandalone: true, selector: "dotcms-layout-body", inputs: { page: "page", components: "components", mode: "mode" }, providers: [DotCMSStore], usesOnChanges: true, ngImport: i0, template: `
+        @if ($isEmpty() && $isDevMode()) {
+            <dotcms-page-error-message />
+        } @else {
+            @for (row of $rows(); track row.identifier) {
+                <dotcms-row [row]="row" />
+            }
+        }
+    `, isInline: true, styles: [":host{display:block}\n"], dependencies: [{ kind: "component", type: PageErrorMessageComponent, selector: "dotcms-page-error-message" }, { kind: "component", type: RowComponent, selector: "dotcms-row", inputs: ["row"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.3", ngImport: i0, type: DotCMSLayoutBodyComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'dotcms-layout-body', standalone: true, imports: [PageErrorMessageComponent, RowComponent], providers: [DotCMSStore], template: `
+        @if ($isEmpty() && $isDevMode()) {
+            <dotcms-page-error-message />
+        } @else {
+            @for (row of $rows(); track row.identifier) {
+                <dotcms-row [row]="row" />
+            }
+        }
+    `, changeDetection: ChangeDetectionStrategy.OnPush, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { page: [{
+                type: Input,
+                args: [{ required: true }]
+            }], components: [{
+                type: Input,
+                args: [{ required: true }]
+            }], mode: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/next/directives/dotcms-show-when/dotcms-show-when.directive.mjs

@@ -0,0 +1,49 @@
+import { Directive, Input, ViewContainerRef, TemplateRef, inject } from '@angular/core';
+import { UVE_MODE } from '@dotcms/types';
+import { getUVEState } from '@dotcms/uve';
+import * as i0 from "@angular/core";
+/**
+ * Directive to show a template when the UVE is in a specific mode.
+ *
+ * @example
+ * <div *dotCMSShowWhen="UVE_MODE.EDIT">
+ *     This will be shown when the UVE is in edit mode.
+ * </div>
+ *
+ * @export
+ * @class DotCMSShowWhenDirective
+ */
+export class DotCMSShowWhenDirective {
+    #when = UVE_MODE.EDIT;
+    #hasView = false;
+    set dotCMSShowWhen(value) {
+        this.#when = value;
+        this.updateViewContainer();
+    }
+    #viewContainerRef = inject(ViewContainerRef);
+    #templateRef = inject(TemplateRef);
+    updateViewContainer() {
+        const state = getUVEState();
+        const shouldShow = state?.mode === this.#when;
+        if (shouldShow && !this.#hasView) {
+            this.#viewContainerRef.createEmbeddedView(this.#templateRef);
+            this.#hasView = true;
+        }
+        else if (!shouldShow && this.#hasView) {
+            this.#viewContainerRef.clear();
+            this.#hasView = false;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.3", ngImport: i0, type: DotCMSShowWhenDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.3", type: DotCMSShowWhenDirective, isStandalone: true, selector: "[dotCMSShowWhen]", inputs: { dotCMSShowWhen: "dotCMSShowWhen" }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.3", ngImport: i0, type: DotCMSShowWhenDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[dotCMSShowWhen]',
+                    standalone: true
+                }]
+        }], propDecorators: { dotCMSShowWhen: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/next/dotcms-angular-next.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public_api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZG90Y21zLWFuZ3VsYXItbmV4dC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvc2RrL2FuZ3VsYXIvbmV4dC9kb3RjbXMtYW5ndWxhci1uZXh0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxjQUFjLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEdlbmVyYXRlZCBidW5kbGUgaW5kZXguIERvIG5vdCBlZGl0LlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vcHVibGljX2FwaSc7XG4iXX0=

package/esm2022/next/models/index.mjs

@@ -0,0 +1,3 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL3Nkay9hbmd1bGFyL25leHQvbW9kZWxzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLHVEQUF1RCIsInNvdXJjZXNDb250ZW50IjpbIi8qIGVzbGludC1kaXNhYmxlIEB0eXBlc2NyaXB0LWVzbGludC9uby1leHBsaWNpdC1hbnkgKi9cblxuaW1wb3J0IHsgVHlwZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5pbXBvcnQgeyBEb3RDTVNQYWdlQXNzZXQsIERvdENNU1BhZ2VSZW5kZXJlck1vZGUgfSBmcm9tICdAZG90Y21zL3R5cGVzJztcblxuLyoqXG4gKiBSZXByZXNlbnRzIGEgZHluYW1pYyBjb21wb25lbnQgZW50aXR5LlxuICogQHR5cGVkZWYge1Byb21pc2U8VHlwZTxhbnk+Pn0gRHluYW1pY0NvbXBvbmVudEVudGl0eVxuICogQG1lbWJlcm9mIEBkb3RjbXMvYW5ndWxhclxuICovXG5leHBvcnQgdHlwZSBEeW5hbWljQ29tcG9uZW50RW50aXR5ID0gUHJvbWlzZTxUeXBlPGFueT4+O1xuXG4vKipcbiAqIFJlcHJlc2VudHMgdGhlIGNvbnRleHQgb2YgYSBEb3RDTVMgcGFnZS5cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBEb3RDTVNQYWdlU3RvcmUge1xuICAgIC8qKlxuICAgICAqIFJlcHJlc2VudHMgdGhlIERvdENNUyBwYWdlIGFzc2V0LlxuICAgICAqIEB0eXBlIHtEb3RDTVNQYWdlQXNzZXR9XG4gICAgICogQG1lbWJlcm9mIERvdENNU1BhZ2VTdG9yZVxuICAgICAqL1xuICAgIHBhZ2U6IERvdENNU1BhZ2VBc3NldDtcblxuICAgIC8qKlxuICAgICAqIFJlcHJlc2VudHMgdGhlIGR5bmFtaWMgY29tcG9uZW50cyBvZiB0aGUgcGFnZSBmb3IgZWFjaCBDb250ZW50IFR5cGUuXG4gICAgICogQHR5cGUge0RvdENNU1BhZ2VDb21wb25lbnR9XG4gICAgICogQG1lbWJlcm9mIERvdENNU1BhZ2VTdG9yZVxuICAgICAqL1xuICAgIGNvbXBvbmVudHM6IERvdENNU1BhZ2VDb21wb25lbnQ7XG5cbiAgICAvKipcbiAgICAgKiBJbmRpY2F0ZXMgdGhlIHJlbmRlcmVyIG1vZGUuXG4gICAgICogQHR5cGUge0RvdENNU1BhZ2VSZW5kZXJlck1vZGV9XG4gICAgICogQG1lbWJlcm9mIERvdENNU1BhZ2VTdG9yZVxuICAgICAqL1xuICAgIG1vZGU6IERvdENNU1BhZ2VSZW5kZXJlck1vZGU7XG59XG5cbi8qKlxuICogUmVwcmVzZW50cyBhIERvdENNUyBwYWdlIGNvbXBvbmVudC5cbiAqIFVzZWQgdG8gc3RvcmUgdGhlIGR5bmFtaWMgY29tcG9uZW50cyBvZiBhIERvdENNUyBwYWdlLlxuICogQHR5cGVkZWYge1JlY29yZDxzdHJpbmcsIER5bmFtaWNDb21wb25lbnRFbnRpdHk+fSBEb3RDTVNQYWdlQ29tcG9uZW50XG4gKiBAbWVtYmVyb2YgQGRvdGNtcy9hbmd1bGFyXG4gKi9cbmV4cG9ydCB0eXBlIERvdENNU1BhZ2VDb21wb25lbnQgPSBSZWNvcmQ8c3RyaW5nLCBEeW5hbWljQ29tcG9uZW50RW50aXR5PjtcbiJdfQ==

package/esm2022/next/providers/dotcms-client/dotcms-client.provider.mjs

@@ -0,0 +1,52 @@
+import { makeEnvironmentProviders } from '@angular/core';
+import { createDotCMSClient } from '@dotcms/client/next';
+// eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
+export class DotCMSClient {
+    constructor(client) {
+        return client;
+    }
+}
+/**
+ * Creates environment providers for the DotCMS client to be used in Angular applications.
+ * This function configures the DI container to provide a DotCMSClient instance
+ * throughout the application using the specified configuration.
+ *
+ * The provider should be registered at the application level (typically in main.ts)
+ * to ensure a single instance is shared across the entire application.
+ *
+ * @param options - Configuration object for the DotCMS client
+ * @param options.apiUrl - The base URL for the DotCMS API
+ * @param options.authToken - Authentication token for API requests (optional)
+ * @param options.siteId - The site identifier (optional)
+ * @returns Environment providers array that can be used with bootstrapApplication
+ *
+ * @example
+ * ```typescript
+ * // main.ts
+ * import { bootstrapApplication } from '@angular/platform-browser';
+ * import { AppComponent } from './app/app.component';
+ * import { provideDotCMSClient } from '@dotcms/angular';
+ *
+ * bootstrapApplication(AppComponent, {
+ *   providers: [
+ *     provideDotCMSClient({
+ *       apiUrl: 'https://demo.dotcms.com',
+ *       authToken: 'your-auth-token',
+ *       siteId: 'your-site-id'
+ *     }),
+ *     // other providers...
+ *   ]
+ * });
+ * ```
+ *
+ */
+export function provideDotCMSClient(options) {
+    const dotCMSClient = createDotCMSClient(options);
+    return makeEnvironmentProviders([
+        {
+            provide: DotCMSClient,
+            useFactory: () => new DotCMSClient(dotCMSClient)
+        }
+    ]);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZG90Y21zLWNsaWVudC5wcm92aWRlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvc2RrL2FuZ3VsYXIvbmV4dC9wcm92aWRlcnMvZG90Y21zLWNsaWVudC9kb3RjbXMtY2xpZW50LnByb3ZpZGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSx3QkFBd0IsRUFBd0IsTUFBTSxlQUFlLENBQUM7QUFFL0UsT0FBTyxFQUFFLGtCQUFrQixFQUFFLE1BQU0scUJBQXFCLENBQUM7QUF3QnpELDRFQUE0RTtBQUM1RSxNQUFNLE9BQU8sWUFBWTtJQUNyQixZQUFZLE1BQWtCO1FBQzFCLE9BQU8sTUFBTSxDQUFDO0lBQ2xCLENBQUM7Q0FDSjtBQUVEOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7R0FpQ0c7QUFDSCxNQUFNLFVBQVUsbUJBQW1CLENBQUMsT0FBMkI7SUFDM0QsTUFBTSxZQUFZLEdBQUcsa0JBQWtCLENBQUMsT0FBTyxDQUFDLENBQUM7SUFFakQsT0FBTyx3QkFBd0IsQ0FBQztRQUM1QjtZQUNJLE9BQU8sRUFBRSxZQUFZO1lBQ3JCLFVBQVUsRUFBRSxHQUFHLEVBQUUsQ0FBQyxJQUFJLFlBQVksQ0FBQyxZQUFZLENBQUM7U0FDbkQ7S0FDSixDQUFDLENBQUM7QUFDUCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgbWFrZUVudmlyb25tZW50UHJvdmlkZXJzLCBFbnZpcm9ubWVudFByb3ZpZGVycyB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5pbXBvcnQgeyBjcmVhdGVEb3RDTVNDbGllbnQgfSBmcm9tICdAZG90Y21zL2NsaWVudC9uZXh0JztcbmltcG9ydCB7IERvdENNU0NsaWVudENvbmZpZyB9IGZyb20gJ0Bkb3RjbXMvdHlwZXMnO1xuXG4vKipcbiAqIFR5cGUgYWxpYXMgZm9yIHRoZSByZXR1cm4gdHlwZSBvZiBjcmVhdGVEb3RDTVNDbGllbnQgZnVuY3Rpb24uXG4gKiBVc2VkIHRvIGVuc3VyZSB0eXBlIGNvbnNpc3RlbmN5IGFjcm9zcyB0aGUgRG90Q01TQ2xpZW50IGludGVyZmFjZSBhbmQgY2xhc3MuXG4gKi9cbnR5cGUgQ2xpZW50VHlwZSA9IFJldHVyblR5cGU8dHlwZW9mIGNyZWF0ZURvdENNU0NsaWVudD47XG5cbi8vIFRoaXMgaXMgYSBoYWNrIGluc3BpcmVkIGJ5IGh0dHBzOi8vZ2l0aHViLmNvbS9hbmd1bGFyL2FuZ3VsYXJmaXJlL2Jsb2IvYzFjNmFmOTc3OTE1NGNhZmY2YmMwZDliODM3ZjZjM2UyZDkxMzQ1Ni9zcmMvZmlyZXN0b3JlL2ZpcmVzdG9yZS50cyNMOFxuXG4vKipcbiAqIEludGVyZmFjZSB0aGF0IGV4dGVuZHMgdGhlIGNsaWVudCB0eXBlIGNyZWF0ZWQgYnkgY3JlYXRlRG90Q01TQ2xpZW50LlxuICogVGhpcyBpbnRlcmZhY2UgcHJvdmlkZXMgdHlwZSBzYWZldHkgYW5kIEludGVsbGlTZW5zZSBzdXBwb3J0IGZvciB0aGUgRG90Q01TIGNsaWVudFxuICogd2hlbiB1c2VkIGFzIGEgZGVwZW5kZW5jeSBpbmplY3Rpb24gdG9rZW4gaW4gQW5ndWxhciBhcHBsaWNhdGlvbnMuXG4gKlxuICogQGV4YW1wbGVcbiAqIGBgYHR5cGVzY3JpcHRcbiAqIGRvdGNtc0NsaWVudCA9IGluamVjdChEb3RDTVNDbGllbnQpO1xuICogYGBgXG4gKi9cbi8vIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBAdHlwZXNjcmlwdC1lc2xpbnQvbm8tdW5zYWZlLWRlY2xhcmF0aW9uLW1lcmdpbmcsIEB0eXBlc2NyaXB0LWVzbGludC9uby1lbXB0eS1pbnRlcmZhY2VcbmV4cG9ydCBpbnRlcmZhY2UgRG90Q01TQ2xpZW50IGV4dGVuZHMgQ2xpZW50VHlwZSB7fVxuXG4vLyBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgQHR5cGVzY3JpcHQtZXNsaW50L25vLXVuc2FmZS1kZWNsYXJhdGlvbi1tZXJnaW5nXG5leHBvcnQgY2xhc3MgRG90Q01TQ2xpZW50IHtcbiAgICBjb25zdHJ1Y3RvcihjbGllbnQ6IENsaWVudFR5cGUpIHtcbiAgICAgICAgcmV0dXJuIGNsaWVudDtcbiAgICB9XG59XG5cbi8qKlxuICogQ3JlYXRlcyBlbnZpcm9ubWVudCBwcm92aWRlcnMgZm9yIHRoZSBEb3RDTVMgY2xpZW50IHRvIGJlIHVzZWQgaW4gQW5ndWxhciBhcHBsaWNhdGlvbnMuXG4gKiBUaGlzIGZ1bmN0aW9uIGNvbmZpZ3VyZXMgdGhlIERJIGNvbnRhaW5lciB0byBwcm92aWRlIGEgRG90Q01TQ2xpZW50IGluc3RhbmNlXG4gKiB0aHJvdWdob3V0IHRoZSBhcHBsaWNhdGlvbiB1c2luZyB0aGUgc3BlY2lmaWVkIGNvbmZpZ3VyYXRpb24uXG4gKlxuICogVGhlIHByb3ZpZGVyIHNob3VsZCBiZSByZWdpc3RlcmVkIGF0IHRoZSBhcHBsaWNhdGlvbiBsZXZlbCAodHlwaWNhbGx5IGluIG1haW4udHMpXG4gKiB0byBlbnN1cmUgYSBzaW5nbGUgaW5zdGFuY2UgaXMgc2hhcmVkIGFjcm9zcyB0aGUgZW50aXJlIGFwcGxpY2F0aW9uLlxuICpcbiAqIEBwYXJhbSBvcHRpb25zIC0gQ29uZmlndXJhdGlvbiBvYmplY3QgZm9yIHRoZSBEb3RDTVMgY2xpZW50XG4gKiBAcGFyYW0gb3B0aW9ucy5hcGlVcmwgLSBUaGUgYmFzZSBVUkwgZm9yIHRoZSBEb3RDTVMgQVBJXG4gKiBAcGFyYW0gb3B0aW9ucy5hdXRoVG9rZW4gLSBBdXRoZW50aWNhdGlvbiB0b2tlbiBmb3IgQVBJIHJlcXVlc3RzIChvcHRpb25hbClcbiAqIEBwYXJhbSBvcHRpb25zLnNpdGVJZCAtIFRoZSBzaXRlIGlkZW50aWZpZXIgKG9wdGlvbmFsKVxuICogQHJldHVybnMgRW52aXJvbm1lbnQgcHJvdmlkZXJzIGFycmF5IHRoYXQgY2FuIGJlIHVzZWQgd2l0aCBib290c3RyYXBBcHBsaWNhdGlvblxuICpcbiAqIEBleGFtcGxlXG4gKiBgYGB0eXBlc2NyaXB0XG4gKiAvLyBtYWluLnRzXG4gKiBpbXBvcnQgeyBib290c3RyYXBBcHBsaWNhdGlvbiB9IGZyb20gJ0Bhbmd1bGFyL3BsYXRmb3JtLWJyb3dzZXInO1xuICogaW1wb3J0IHsgQXBwQ29tcG9uZW50IH0gZnJvbSAnLi9hcHAvYXBwLmNvbXBvbmVudCc7XG4gKiBpbXBvcnQgeyBwcm92aWRlRG90Q01TQ2xpZW50IH0gZnJvbSAnQGRvdGNtcy9hbmd1bGFyJztcbiAqXG4gKiBib290c3RyYXBBcHBsaWNhdGlvbihBcHBDb21wb25lbnQsIHtcbiAqICAgcHJvdmlkZXJzOiBbXG4gKiAgICAgcHJvdmlkZURvdENNU0NsaWVudCh7XG4gKiAgICAgICBhcGlVcmw6ICdodHRwczovL2RlbW8uZG90Y21zLmNvbScsXG4gKiAgICAgICBhdXRoVG9rZW46ICd5b3VyLWF1dGgtdG9rZW4nLFxuICogICAgICAgc2l0ZUlkOiAneW91ci1zaXRlLWlkJ1xuICogICAgIH0pLFxuICogICAgIC8vIG90aGVyIHByb3ZpZGVycy4uLlxuICogICBdXG4gKiB9KTtcbiAqIGBgYFxuICpcbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHByb3ZpZGVEb3RDTVNDbGllbnQob3B0aW9uczogRG90Q01TQ2xpZW50Q29uZmlnKTogRW52aXJvbm1lbnRQcm92aWRlcnMge1xuICAgIGNvbnN0IGRvdENNU0NsaWVudCA9IGNyZWF0ZURvdENNU0NsaWVudChvcHRpb25zKTtcblxuICAgIHJldHVybiBtYWtlRW52aXJvbm1lbnRQcm92aWRlcnMoW1xuICAgICAgICB7XG4gICAgICAgICAgICBwcm92aWRlOiBEb3RDTVNDbGllbnQsXG4gICAgICAgICAgICB1c2VGYWN0b3J5OiAoKSA9PiBuZXcgRG90Q01TQ2xpZW50KGRvdENNU0NsaWVudClcbiAgICAgICAgfVxuICAgIF0pO1xufVxuIl19

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,8 @@
+export { DotCMSShowWhenDirective } from './directives/dotcms-show-when/dotcms-show-when.directive';
+export { provideDotCMSImageLoader } from './providers/dotcms-image-loader/dotcms-image_loader';
+export { provideDotCMSClient, DotCMSClient } from './providers/dotcms-client/dotcms-client.provider';
+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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvc2RrL2FuZ3VsYXIvbmV4dC9wdWJsaWNfYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxNQUFNLDBEQUEwRCxDQUFDO0FBRW5HLE9BQU8sRUFBRSx3QkFBd0IsRUFBRSxNQUFNLHFEQUFxRCxDQUFDO0FBRS9GLE9BQU8sRUFDSCxtQkFBbUIsRUFDbkIsWUFBWSxFQUNmLE1BQU0sa0RBQWtELENBQUM7QUFFMUQsT0FBTyxFQUFFLDJCQUEyQixFQUFFLE1BQU0sa0VBQWtFLENBQUM7QUFFL0csT0FBTyxFQUFFLGtDQUFrQyxFQUFFLE1BQU0sa0ZBQWtGLENBQUM7QUFFdEksT0FBTyxFQUFFLHlCQUF5QixFQUFFLE1BQU0sOERBQThELENBQUM7QUFFekcsT0FBTyxFQUFFLHlCQUF5QixFQUFFLE1BQU0seUNBQXlDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBEb3RDTVNTaG93V2hlbkRpcmVjdGl2ZSB9IGZyb20gJy4vZGlyZWN0aXZlcy9kb3RjbXMtc2hvdy13aGVuL2RvdGNtcy1zaG93LXdoZW4uZGlyZWN0aXZlJztcblxuZXhwb3J0IHsgcHJvdmlkZURvdENNU0ltYWdlTG9hZGVyIH0gZnJvbSAnLi9wcm92aWRlcnMvZG90Y21zLWltYWdlLWxvYWRlci9kb3RjbXMtaW1hZ2VfbG9hZGVyJztcblxuZXhwb3J0IHtcbiAgICBwcm92aWRlRG90Q01TQ2xpZW50LFxuICAgIERvdENNU0NsaWVudFxufSBmcm9tICcuL3Byb3ZpZGVycy9kb3RjbXMtY2xpZW50L2RvdGNtcy1jbGllbnQucHJvdmlkZXInO1xuXG5leHBvcnQgeyBEb3RDTVNFZGl0YWJsZVRleHRDb21wb25lbnQgfSBmcm9tICcuL2NvbXBvbmVudHMvZG90Y21zLWVkaXRhYmxlLXRleHQvZG90Y21zLWVkaXRhYmxlLXRleHQuY29tcG9uZW50JztcblxuZXhwb3J0IHsgRG90Q01TQmxvY2tFZGl0b3JSZW5kZXJlckNvbXBvbmVudCB9IGZyb20gJy4vY29tcG9uZW50cy9kb3RjbXMtYmxvY2stZWRpdG9yLXJlbmRlcmVyL2RvdGNtcy1ibG9jay1lZGl0b3ItcmVuZGVyZXIuY29tcG9uZW50JztcblxuZXhwb3J0IHsgRG90Q01TTGF5b3V0Qm9keUNvbXBvbmVudCB9IGZyb20gJy4vY29tcG9uZW50cy9kb3RjbXMtbGF5b3V0LWJvZHkvZG90Y21zLWxheW91dC1ib2R5LmNvbXBvbmVudCc7XG5cbmV4cG9ydCB7IERvdENNU0VkaXRhYmxlUGFnZVNlcnZpY2UgfSBmcm9tICcuL3NlcnZpY2VzL2RvdGNtcy1lZGl0YWJsZS1wYWdlLnNlcnZpY2UnO1xuIl19

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 | 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/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