@dotcms/angular 0.0.1-alpha.62 → 0.0.1-beta.10

package/esm2022/next/components/dotcms-editable-text/dotcms-editable-text.component.mjs

@@ -0,0 +1,225 @@
+import { EditorComponent, TINYMCE_SCRIPT_SRC } from '@tinymce/tinymce-angular';
+import { Component, ElementRef, HostListener, inject, Input, Renderer2, SecurityContext, ViewChild } from '@angular/core';
+import { DomSanitizer } from '@angular/platform-browser';
+import { CLIENT_ACTIONS, DotCmsClient, isInsideEditor, NOTIFY_CLIENT, postMessageToEditor } from '@dotcms/client';
+import { TINYMCE_CONFIG } from './utils';
+import * as i0 from "@angular/core";
+/**
+ * Dot editable text component.
+ * This component is responsible to render a text field that can be edited inline.
+ *
+ * @export
+ * @class DotCMSEditableTextComponent
+ * @implements {OnInit}
+ * @implements {OnChanges}
+ */
+export class DotCMSEditableTextComponent {
+    constructor() {
+        /**
+         * Represents the mode of the editor which can be `plain`, `minimal`, or `full`
+         *
+         * @type {DOT_EDITABLE_TEXT_MODE}
+         * @memberof DotCMSEditableTextComponent
+         */
+        this.mode = 'plain';
+        /**
+         * Represents the format of the editor which can be `text` or `html`
+         *
+         * @type {DOT_EDITABLE_TEXT_FORMAT}
+         * @memberof DotCMSEditableTextComponent
+         */
+        this.format = 'text';
+        /**
+         * Represents the field name of the `contentlet` that can be edited
+         *
+         * @memberof DotCMSEditableTextComponent
+         */
+        this.fieldName = '';
+        /**
+         * Represents the content of the `contentlet` that can be edited
+         *
+         * @protected
+         * @memberof DotCMSEditableTextComponent
+         */
+        this.content = '';
+        this.#sanitizer = inject(DomSanitizer);
+        this.#renderer = inject(Renderer2);
+        this.#elementRef = inject(ElementRef);
+    }
+    #sanitizer;
+    #renderer;
+    #elementRef;
+    /**
+     * The TinyMCE editor
+     *
+     * @readonly
+     * @memberof DotCMSEditableTextComponent
+     */
+    get editor() {
+        return this.editorComponent?.editor;
+    }
+    /**
+     * Returns the number of pages the contentlet is on
+     *
+     * @readonly
+     * @memberof DotCMSEditableTextComponent
+     */
+    get onNumberOfPages() {
+        return this.contentlet['onNumberOfPages'] || 1;
+    }
+    /**
+     * Handle copy contentlet inline editing success event
+     *
+     * @param {MessageEvent} { data }
+     * @return {*}
+     * @memberof DotCMSEditableTextComponent
+     */
+    onMessage({ data }) {
+        const { name, payload } = data;
+        if (name !== NOTIFY_CLIENT.UVE_COPY_CONTENTLET_INLINE_EDITING_SUCCESS) {
+            return;
+        }
+        const { oldInode, inode } = payload;
+        const currentInode = this.contentlet.inode;
+        if (currentInode === oldInode || currentInode === inode) {
+            this.editorComponent.editor.focus();
+            return;
+        }
+    }
+    ngOnInit() {
+        this.isInsideEditor = isInsideEditor();
+        if (!this.isInsideEditor) {
+            this.innerHTMLToElement();
+            return;
+        }
+        this.init = {
+            ...TINYMCE_CONFIG[this.mode],
+            base_url: `${DotCmsClient.dotcmsUrl}/ext/tinymcev7`
+        };
+    }
+    ngOnChanges() {
+        this.content = this.contentlet[this.fieldName] || '';
+        if (this.editor) {
+            this.editor.setContent(this.content, { format: this.format });
+        }
+    }
+    /**
+     * Handle mouse down event
+     *
+     * @param {EventObj<MouseEvent>} { event }
+     * @return {*}
+     * @memberof DotCMSEditableTextComponent
+     */
+    onMouseDown({ event }) {
+        if (this.onNumberOfPages <= 1 || this.editorComponent.editor.hasFocus()) {
+            return;
+        }
+        const { inode, languageId: language } = this.contentlet;
+        event.stopPropagation();
+        event.preventDefault();
+        try {
+            postMessageToEditor({
+                action: CLIENT_ACTIONS.COPY_CONTENTLET_INLINE_EDITING,
+                payload: {
+                    dataset: {
+                        inode,
+                        language,
+                        fieldName: this.fieldName
+                    }
+                }
+            });
+        }
+        catch (error) {
+            console.error('Failed to post message to editor:', error);
+        }
+    }
+    /**
+     * Handle focus out event
+     *
+     * @return {*}
+     * @memberof DotCMSEditableTextComponent
+     */
+    onFocusOut() {
+        const content = this.editor.getContent({ format: this.format });
+        if (!this.editor.isDirty() || !this.didContentChange(content)) {
+            return;
+        }
+        const { inode, languageId: langId } = this.contentlet;
+        try {
+            postMessageToEditor({
+                action: CLIENT_ACTIONS.UPDATE_CONTENTLET_INLINE_EDITING,
+                payload: {
+                    content,
+                    dataset: {
+                        inode,
+                        langId,
+                        fieldName: this.fieldName
+                    }
+                }
+            });
+        }
+        catch (error) {
+            console.error('Failed to post message to editor:', error);
+        }
+    }
+    /**
+     * inner HTML to element
+     *
+     * @private
+     * @param {string} editedContent
+     * @return {*}
+     * @memberof DotCMSEditableTextComponent
+     */
+    innerHTMLToElement() {
+        const element = this.#elementRef.nativeElement;
+        const safeHtml = this.#sanitizer.bypassSecurityTrustHtml(this.content);
+        const content = this.#sanitizer.sanitize(SecurityContext.HTML, safeHtml) || '';
+        this.#renderer.setProperty(element, 'innerHTML', content);
+    }
+    /**
+     * Check if the content has changed
+     *
+     * @private
+     * @param {string} editedContent
+     * @return {*}
+     * @memberof DotCMSEditableTextComponent
+     */
+    didContentChange(editedContent) {
+        return this.content !== editedContent;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.3", ngImport: i0, type: DotCMSEditableTextComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.3", type: DotCMSEditableTextComponent, isStandalone: true, selector: "dotcms-editable-text", inputs: { mode: "mode", format: "format", contentlet: "contentlet", fieldName: "fieldName" }, host: { listeners: { "window:message": "onMessage($event)" } }, providers: [
+            {
+                provide: TINYMCE_SCRIPT_SRC,
+                useFactory: () => {
+                    return `${DotCmsClient.dotcmsUrl}/ext/tinymcev7/tinymce.min.js`;
+                }
+            }
+        ], viewQueries: [{ propertyName: "editorComponent", first: true, predicate: EditorComponent, descendants: true }], usesOnChanges: true, ngImport: i0, template: "@if (isInsideEditor) {\n    <editor\n        #tinyEditor\n        [init]=\"init\"\n        [initialValue]=\"content\"\n        (onMouseDown)=\"onMouseDown($event)\"\n        (onFocusOut)=\"onFocusOut()\" />\n}\n", styles: [":host ::ng-deep .mce-content-body:not(.mce-edit-focus):hover{outline:2px solid #006ce7;border-radius:4px}\n"], dependencies: [{ kind: "component", type: EditorComponent, selector: "editor", inputs: ["cloudChannel", "apiKey", "init", "id", "initialValue", "outputFormat", "inline", "tagName", "plugins", "toolbar", "modelEvents", "allowedEvents", "ignoreEvents", "disabled"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.3", ngImport: i0, type: DotCMSEditableTextComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'dotcms-editable-text', standalone: true, imports: [EditorComponent], providers: [
+                        {
+                            provide: TINYMCE_SCRIPT_SRC,
+                            useFactory: () => {
+                                return `${DotCmsClient.dotcmsUrl}/ext/tinymcev7/tinymce.min.js`;
+                            }
+                        }
+                    ], template: "@if (isInsideEditor) {\n    <editor\n        #tinyEditor\n        [init]=\"init\"\n        [initialValue]=\"content\"\n        (onMouseDown)=\"onMouseDown($event)\"\n        (onFocusOut)=\"onFocusOut()\" />\n}\n", styles: [":host ::ng-deep .mce-content-body:not(.mce-edit-focus):hover{outline:2px solid #006ce7;border-radius:4px}\n"] }]
+        }], propDecorators: { editorComponent: [{
+                type: ViewChild,
+                args: [EditorComponent]
+            }], mode: [{
+                type: Input
+            }], format: [{
+                type: Input
+            }], contentlet: [{
+                type: Input
+            }], fieldName: [{
+                type: Input
+            }], onMessage: [{
+                type: HostListener,
+                args: ['window:message', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dotcms-editable-text.component.js","sourceRoot":"","sources":["../../../../../../../../libs/sdk/angular/next/components/dotcms-editable-text/dotcms-editable-text.component.ts","../../../../../../../../libs/sdk/angular/next/components/dotcms-editable-text/dotcms-editable-text.component.html"],"names":[],"mappings":"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","sourcesContent":["import { EditorComponent, TINYMCE_SCRIPT_SRC } from '@tinymce/tinymce-angular';\nimport { EventObj } from '@tinymce/tinymce-angular/editor/Events';\n\nimport {\n    Component,\n    ElementRef,\n    HostListener,\n    inject,\n    Input,\n    OnChanges,\n    OnInit,\n    Renderer2,\n    SecurityContext,\n    ViewChild\n} from '@angular/core';\nimport { DomSanitizer } from '@angular/platform-browser';\n\nimport {\n    CLIENT_ACTIONS,\n    DotCmsClient,\n    isInsideEditor,\n    NOTIFY_CLIENT,\n    postMessageToEditor\n} from '@dotcms/client';\n\nimport { TINYMCE_CONFIG, DOT_EDITABLE_TEXT_FORMAT, DOT_EDITABLE_TEXT_MODE } from './utils';\n\nimport { DotCMSContentlet } from '../../models';\n\n/**\n * Dot editable text component.\n * This component is responsible to render a text field that can be edited inline.\n *\n * @export\n * @class DotCMSEditableTextComponent\n * @implements {OnInit}\n * @implements {OnChanges}\n */\n@Component({\n    selector: 'dotcms-editable-text',\n    standalone: true,\n    templateUrl: './dotcms-editable-text.component.html',\n    styleUrl: './dotcms-editable-text.component.css',\n    imports: [EditorComponent],\n    providers: [\n        {\n            provide: TINYMCE_SCRIPT_SRC,\n            useFactory: () => {\n                return `${DotCmsClient.dotcmsUrl}/ext/tinymcev7/tinymce.min.js`;\n            }\n        }\n    ]\n})\nexport class DotCMSEditableTextComponent implements OnInit, OnChanges {\n    @ViewChild(EditorComponent) editorComponent!: EditorComponent;\n\n    /**\n     * Represents the mode of the editor which can be `plain`, `minimal`, or `full`\n     *\n     * @type {DOT_EDITABLE_TEXT_MODE}\n     * @memberof DotCMSEditableTextComponent\n     */\n    @Input() mode: DOT_EDITABLE_TEXT_MODE = 'plain';\n    /**\n     * Represents the format of the editor which can be `text` or `html`\n     *\n     * @type {DOT_EDITABLE_TEXT_FORMAT}\n     * @memberof DotCMSEditableTextComponent\n     */\n    @Input() format: DOT_EDITABLE_TEXT_FORMAT = 'text';\n    /**\n     * Represents the `contentlet` that can be inline edited\n     *\n     * @type {DotCMSContentlet}\n     * @memberof DotCMSEditableTextComponent\n     */\n    @Input() contentlet!: DotCMSContentlet;\n    /**\n     * Represents the field name of the `contentlet` that can be edited\n     *\n     * @memberof DotCMSEditableTextComponent\n     */\n    @Input() fieldName = '';\n\n    /**\n     * Represents the content of the `contentlet` that can be edited\n     *\n     * @protected\n     * @memberof DotCMSEditableTextComponent\n     */\n    protected content = '';\n    /**\n     * Represents the configuration of the editor\n     *\n     * @protected\n     * @type {EditorComponent['init']}\n     * @memberof DotCMSEditableTextComponent\n     */\n    protected init!: EditorComponent['init'];\n    /**\n     * Represents if the component is inside the editor\n     *\n     * @protected\n     * @type {boolean}\n     * @memberof DotCMSEditableTextComponent\n     */\n    protected isInsideEditor!: boolean;\n\n    readonly #sanitizer = inject<DomSanitizer>(DomSanitizer);\n    readonly #renderer = inject<Renderer2>(Renderer2);\n    readonly #elementRef = inject<ElementRef>(ElementRef);\n\n    /**\n     * The TinyMCE editor\n     *\n     * @readonly\n     * @memberof DotCMSEditableTextComponent\n     */\n    get editor() {\n        return this.editorComponent?.editor;\n    }\n\n    /**\n     * Returns the number of pages the contentlet is on\n     *\n     * @readonly\n     * @memberof DotCMSEditableTextComponent\n     */\n    get onNumberOfPages() {\n        return this.contentlet['onNumberOfPages'] || 1;\n    }\n\n    /**\n     * Handle copy contentlet inline editing success event\n     *\n     * @param {MessageEvent} { data }\n     * @return {*}\n     * @memberof DotCMSEditableTextComponent\n     */\n    @HostListener('window:message', ['$event'])\n    onMessage({ data }: MessageEvent) {\n        const { name, payload } = data;\n        if (name !== NOTIFY_CLIENT.UVE_COPY_CONTENTLET_INLINE_EDITING_SUCCESS) {\n            return;\n        }\n\n        const { oldInode, inode } = payload;\n        const currentInode = this.contentlet.inode;\n\n        if (currentInode === oldInode || currentInode === inode) {\n            this.editorComponent.editor.focus();\n\n            return;\n        }\n    }\n\n    ngOnInit() {\n        this.isInsideEditor = isInsideEditor();\n\n        if (!this.isInsideEditor) {\n            this.innerHTMLToElement();\n\n            return;\n        }\n\n        this.init = {\n            ...TINYMCE_CONFIG[this.mode],\n            base_url: `${DotCmsClient.dotcmsUrl}/ext/tinymcev7`\n        };\n    }\n\n    ngOnChanges() {\n        this.content = this.contentlet[this.fieldName] || '';\n        if (this.editor) {\n            this.editor.setContent(this.content, { format: this.format });\n        }\n    }\n\n    /**\n     * Handle mouse down event\n     *\n     * @param {EventObj<MouseEvent>} { event }\n     * @return {*}\n     * @memberof DotCMSEditableTextComponent\n     */\n    onMouseDown({ event }: EventObj<MouseEvent>) {\n        if (this.onNumberOfPages <= 1 || this.editorComponent.editor.hasFocus()) {\n            return;\n        }\n\n        const { inode, languageId: language } = this.contentlet;\n\n        event.stopPropagation();\n        event.preventDefault();\n\n        try {\n            postMessageToEditor({\n                action: CLIENT_ACTIONS.COPY_CONTENTLET_INLINE_EDITING,\n                payload: {\n                    dataset: {\n                        inode,\n                        language,\n                        fieldName: this.fieldName\n                    }\n                }\n            });\n        } catch (error) {\n            console.error('Failed to post message to editor:', error);\n        }\n    }\n    /**\n     * Handle focus out event\n     *\n     * @return {*}\n     * @memberof DotCMSEditableTextComponent\n     */\n    onFocusOut() {\n        const content = this.editor.getContent({ format: this.format });\n\n        if (!this.editor.isDirty() || !this.didContentChange(content)) {\n            return;\n        }\n\n        const { inode, languageId: langId } = this.contentlet;\n\n        try {\n            postMessageToEditor({\n                action: CLIENT_ACTIONS.UPDATE_CONTENTLET_INLINE_EDITING,\n                payload: {\n                    content,\n                    dataset: {\n                        inode,\n                        langId,\n                        fieldName: this.fieldName\n                    }\n                }\n            });\n        } catch (error) {\n            console.error('Failed to post message to editor:', error);\n        }\n    }\n\n    /**\n     * inner HTML to element\n     *\n     * @private\n     * @param {string} editedContent\n     * @return {*}\n     * @memberof DotCMSEditableTextComponent\n     */\n    private innerHTMLToElement() {\n        const element = this.#elementRef.nativeElement;\n        const safeHtml = this.#sanitizer.bypassSecurityTrustHtml(this.content);\n        const content = this.#sanitizer.sanitize(SecurityContext.HTML, safeHtml) || '';\n\n        this.#renderer.setProperty(element, 'innerHTML', content);\n    }\n\n    /**\n     * Check if the content has changed\n     *\n     * @private\n     * @param {string} editedContent\n     * @return {*}\n     * @memberof DotCMSEditableTextComponent\n     */\n    private didContentChange(editedContent: string) {\n        return this.content !== editedContent;\n    }\n}\n","@if (isInsideEditor) {\n    <editor\n        #tinyEditor\n        [init]=\"init\"\n        [initialValue]=\"content\"\n        (onMouseDown)=\"onMouseDown($event)\"\n        (onFocusOut)=\"onFocusOut()\" />\n}\n"]}

package/esm2022/{lib/components/dot-editable-text → next/components/dotcms-editable-text}/utils.mjs

@@ -40,4 +40,4 @@ export const TINYMCE_CONFIG = {
         toolbar: ''
     }
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# 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 { getUVEState } from '@dotcms/uve';
+import { UVE_MODE } from '@dotcms/uve/types';
+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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZG90Y21zLXNob3ctd2hlbi5kaXJlY3RpdmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL3Nkay9hbmd1bGFyL25leHQvZGlyZWN0aXZlcy9kb3RjbXMtc2hvdy13aGVuL2RvdGNtcy1zaG93LXdoZW4uZGlyZWN0aXZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsS0FBSyxFQUFFLGdCQUFnQixFQUFFLFdBQVcsRUFBRSxNQUFNLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFFeEYsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLGFBQWEsQ0FBQztBQUMxQyxPQUFPLEVBQUUsUUFBUSxFQUFZLE1BQU0sbUJBQW1CLENBQUM7O0FBRXZEOzs7Ozs7Ozs7O0dBVUc7QUFLSCxNQUFNLE9BQU8sdUJBQXVCO0lBQ2hDLEtBQUssR0FBYSxRQUFRLENBQUMsSUFBSSxDQUFDO0lBQ2hDLFFBQVEsR0FBRyxLQUFLLENBQUM7SUFFakIsSUFBYSxjQUFjLENBQUMsS0FBZTtRQUN2QyxJQUFJLENBQUMsS0FBSyxHQUFHLEtBQUssQ0FBQztRQUNuQixJQUFJLENBQUMsbUJBQW1CLEVBQUUsQ0FBQztJQUMvQixDQUFDO0lBRUQsaUJBQWlCLEdBQUcsTUFBTSxDQUFDLGdCQUFnQixDQUFDLENBQUM7SUFDN0MsWUFBWSxHQUFHLE1BQU0sQ0FBQyxXQUFXLENBQUMsQ0FBQztJQUUzQixtQkFBbUI7UUFDdkIsTUFBTSxLQUFLLEdBQXlCLFdBQVcsRUFBRSxDQUFDO1FBRWxELE1BQU0sVUFBVSxHQUFHLEtBQUssRUFBRSxJQUFJLEtBQUssSUFBSSxDQUFDLEtBQUssQ0FBQztRQUU5QyxJQUFJLFVBQVUsSUFBSSxDQUFDLElBQUksQ0FBQyxRQUFRLEVBQUUsQ0FBQztZQUMvQixJQUFJLENBQUMsaUJBQWlCLENBQUMsa0JBQWtCLENBQUMsSUFBSSxDQUFDLFlBQVksQ0FBQyxDQUFDO1lBQzdELElBQUksQ0FBQyxRQUFRLEdBQUcsSUFBSSxDQUFDO1FBQ3pCLENBQUM7YUFBTSxJQUFJLENBQUMsVUFBVSxJQUFJLElBQUksQ0FBQyxRQUFRLEVBQUUsQ0FBQztZQUN0QyxJQUFJLENBQUMsaUJBQWlCLENBQUMsS0FBSyxFQUFFLENBQUM7WUFDL0IsSUFBSSxDQUFDLFFBQVEsR0FBRyxLQUFLLENBQUM7UUFDMUIsQ0FBQztJQUNMLENBQUM7OEdBeEJRLHVCQUF1QjtrR0FBdkIsdUJBQXVCOzsyRkFBdkIsdUJBQXVCO2tCQUpuQyxTQUFTO21CQUFDO29CQUNQLFFBQVEsRUFBRSxrQkFBa0I7b0JBQzVCLFVBQVUsRUFBRSxJQUFJO2lCQUNuQjs4QkFLZ0IsY0FBYztzQkFBMUIsS0FBSyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IERpcmVjdGl2ZSwgSW5wdXQsIFZpZXdDb250YWluZXJSZWYsIFRlbXBsYXRlUmVmLCBpbmplY3QgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuaW1wb3J0IHsgZ2V0VVZFU3RhdGUgfSBmcm9tICdAZG90Y21zL3V2ZSc7XG5pbXBvcnQgeyBVVkVfTU9ERSwgVVZFU3RhdGUgfSBmcm9tICdAZG90Y21zL3V2ZS90eXBlcyc7XG5cbi8qKlxuICogRGlyZWN0aXZlIHRvIHNob3cgYSB0ZW1wbGF0ZSB3aGVuIHRoZSBVVkUgaXMgaW4gYSBzcGVjaWZpYyBtb2RlLlxuICpcbiAqIEBleGFtcGxlXG4gKiA8ZGl2ICpkb3RDTVNTaG93V2hlbj1cIlVWRV9NT0RFLkVESVRcIj5cbiAqICAgICBUaGlzIHdpbGwgYmUgc2hvd24gd2hlbiB0aGUgVVZFIGlzIGluIGVkaXQgbW9kZS5cbiAqIDwvZGl2PlxuICpcbiAqIEBleHBvcnRcbiAqIEBjbGFzcyBEb3RDTVNTaG93V2hlbkRpcmVjdGl2ZVxuICovXG5ARGlyZWN0aXZlKHtcbiAgICBzZWxlY3RvcjogJ1tkb3RDTVNTaG93V2hlbl0nLFxuICAgIHN0YW5kYWxvbmU6IHRydWVcbn0pXG5leHBvcnQgY2xhc3MgRG90Q01TU2hvd1doZW5EaXJlY3RpdmUge1xuICAgICN3aGVuOiBVVkVfTU9ERSA9IFVWRV9NT0RFLkVESVQ7XG4gICAgI2hhc1ZpZXcgPSBmYWxzZTtcblxuICAgIEBJbnB1dCgpIHNldCBkb3RDTVNTaG93V2hlbih2YWx1ZTogVVZFX01PREUpIHtcbiAgICAgICAgdGhpcy4jd2hlbiA9IHZhbHVlO1xuICAgICAgICB0aGlzLnVwZGF0ZVZpZXdDb250YWluZXIoKTtcbiAgICB9XG5cbiAgICAjdmlld0NvbnRhaW5lclJlZiA9IGluamVjdChWaWV3Q29udGFpbmVyUmVmKTtcbiAgICAjdGVtcGxhdGVSZWYgPSBpbmplY3QoVGVtcGxhdGVSZWYpO1xuXG4gICAgcHJpdmF0ZSB1cGRhdGVWaWV3Q29udGFpbmVyKCkge1xuICAgICAgICBjb25zdCBzdGF0ZTogVVZFU3RhdGUgfCB1bmRlZmluZWQgPSBnZXRVVkVTdGF0ZSgpO1xuXG4gICAgICAgIGNvbnN0IHNob3VsZFNob3cgPSBzdGF0ZT8ubW9kZSA9PT0gdGhpcy4jd2hlbjtcblxuICAgICAgICBpZiAoc2hvdWxkU2hvdyAmJiAhdGhpcy4jaGFzVmlldykge1xuICAgICAgICAgICAgdGhpcy4jdmlld0NvbnRhaW5lclJlZi5jcmVhdGVFbWJlZGRlZFZpZXcodGhpcy4jdGVtcGxhdGVSZWYpO1xuICAgICAgICAgICAgdGhpcy4jaGFzVmlldyA9IHRydWU7XG4gICAgICAgIH0gZWxzZSBpZiAoIXNob3VsZFNob3cgJiYgdGhpcy4jaGFzVmlldykge1xuICAgICAgICAgICAgdGhpcy4jdmlld0NvbnRhaW5lclJlZi5jbGVhcigpO1xuICAgICAgICAgICAgdGhpcy4jaGFzVmlldyA9IGZhbHNlO1xuICAgICAgICB9XG4gICAgfVxufVxuIl19

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/dotcms.model.mjs

@@ -0,0 +1,3 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+export {};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dotcms.model.js","sourceRoot":"","sources":["../../../../../../../libs/sdk/angular/next/models/dotcms.model.ts"],"names":[],"mappings":"AAAA,uDAAuD","sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\n\nexport interface DotCMSPageAsset {\n    canCreateTemplate: boolean;\n    containers: DotCMSPageAssetContainer;\n    layout: DotCMSLayout;\n    page: DotCMSPage;\n    site: DotCMSSite;\n    template: DotCMSTemplate;\n    viewAs: DotCMSViewAs;\n    vanityUrl?: {\n        pattern: string;\n        vanityUrlId: string;\n        url: string;\n        siteId: string;\n        languageId: number;\n        forwardTo: string;\n        response: number;\n        order: number;\n        temporaryRedirect: boolean;\n        permanentRedirect: boolean;\n        forward: boolean;\n    };\n}\n\nexport interface DotPageAssetLayoutRow {\n    identifier: number;\n    value?: string;\n    id?: string;\n    columns: DotPageAssetLayoutColumn[];\n    styleClass?: string;\n}\n\nexport interface DotPageAssetLayoutColumn {\n    preview: boolean;\n    containers: DotCMSContainer[];\n    widthPercent: number;\n    width: number;\n    leftOffset: number;\n    left: number;\n    styleClass?: string;\n}\n\nexport interface DotCMSPageAssetContainer {\n    [key: string]: {\n        container: DotCMSContainer;\n        containerStructures: DotCMSContainerStructure[];\n        contentlets: {\n            [key: string]: DotCMSContentlet[];\n        };\n    };\n}\n\nexport interface DotCMSContainer {\n    identifier: string;\n    uuid: string;\n    iDate: number;\n    type: string;\n    owner?: string;\n    inode: string;\n    source: string;\n    title: string;\n    friendlyName: string;\n    modDate: number;\n    modUser: string;\n    sortOrder: number;\n    showOnMenu: boolean;\n    code?: string;\n    maxContentlets: number;\n    useDiv: boolean;\n    sortContentletsBy?: string;\n    preLoop: string;\n    postLoop: string;\n    staticify: boolean;\n    luceneQuery?: string;\n    notes: string;\n    languageId?: number;\n    path?: string;\n    live: boolean;\n    locked: boolean;\n    working: boolean;\n    deleted: boolean;\n    name: string;\n    archived: boolean;\n    permissionId: string;\n    versionId: string;\n    versionType: string;\n    permissionType: string;\n    categoryId: string;\n    idate: number;\n    new: boolean;\n    acceptTypes: string;\n    contentlets: DotCMSContentlet[];\n    parentPermissionable: DotCMSSiteParentPermissionable;\n}\n\nexport interface DotCMSContentlet {\n    archived: boolean;\n    baseType: string;\n    deleted?: boolean;\n    binary?: string;\n    binaryContentAsset?: string;\n    binaryVersion?: string;\n    contentType: string;\n    file?: string;\n    folder: string;\n    hasLiveVersion?: boolean;\n    hasTitleImage: boolean;\n    host: string;\n    hostName: string;\n    identifier: string;\n    inode: string;\n    image?: string;\n    languageId: number;\n    language?: string;\n    live: boolean;\n    locked: boolean;\n    mimeType?: string;\n    modDate: string;\n    modUser: string;\n    modUserName: string;\n    owner: string;\n    sortOrder: number;\n    stInode: string;\n    title: string;\n    titleImage: string;\n    text?: string;\n    url: string;\n    working: boolean;\n    body?: string;\n    contentTypeIcon?: string;\n    variant?: string;\n    __icon__?: string;\n    [key: string]: any; // This is a catch-all for any other custom properties that might be on the contentlet.\n}\n\nexport interface DotcmsNavigationItem {\n    code?: any;\n    folder: string;\n    children?: DotcmsNavigationItem[];\n    host: string;\n    languageId: number;\n    href: string;\n    title: string;\n    type: string;\n    hash: number;\n    target: string;\n    order: number;\n}\n\ninterface DotCMSTemplate {\n    iDate: number;\n    type: string;\n    owner: string;\n    inode: string;\n    identifier: string;\n    source: string;\n    title: string;\n    friendlyName: string;\n    modDate: number;\n    modUser: string;\n    sortOrder: number;\n    showOnMenu: boolean;\n    image: string;\n    drawed: boolean;\n    drawedBody: string;\n    theme: string;\n    anonymous: boolean;\n    template: boolean;\n    name: string;\n    live: boolean;\n    archived: boolean;\n    locked: boolean;\n    working: boolean;\n    permissionId: string;\n    versionId: string;\n    versionType: string;\n    deleted: boolean;\n    permissionType: string;\n    categoryId: string;\n    idate: number;\n    new: boolean;\n    canEdit: boolean;\n}\n\ninterface DotCMSPage {\n    template: string;\n    modDate: number;\n    metadata: string;\n    cachettl: string;\n    pageURI: string;\n    title: string;\n    type: string;\n    showOnMenu: string;\n    httpsRequired: boolean;\n    inode: string;\n    disabledWYSIWYG: any[];\n    seokeywords: string;\n    host: string;\n    lastReview: number;\n    working: boolean;\n    locked: boolean;\n    stInode: string;\n    friendlyName: string;\n    live: boolean;\n    owner: string;\n    identifier: string;\n    nullProperties: any[];\n    friendlyname: string;\n    pagemetadata: string;\n    languageId: number;\n    url: string;\n    seodescription: string;\n    modUserName: string;\n    folder: string;\n    deleted: boolean;\n    sortOrder: number;\n    modUser: string;\n    pageUrl: string;\n    workingInode: string;\n    shortyWorking: string;\n    canEdit: boolean;\n    canRead: boolean;\n    canLock: boolean;\n    lockedOn: number;\n    lockedBy: string;\n    lockedByName: string;\n    liveInode: string;\n    shortyLive: string;\n}\n\ninterface DotCMSViewAs {\n    language: {\n        id: number;\n        languageCode: string;\n        countryCode: string;\n        language: string;\n        country: string;\n    };\n    mode: string;\n}\n\ninterface DotCMSLayout {\n    pageWidth: string;\n    width: string;\n    layout: string;\n    title: string;\n    header: boolean;\n    footer: boolean;\n    body: DotPageAssetLayoutBody;\n    sidebar: DotPageAssetLayoutSidebar;\n}\n\ninterface DotCMSContainerStructure {\n    id: string;\n    structureId: string;\n    containerInode: string;\n    containerId: string;\n    code: string;\n    contentTypeVar: string;\n}\n\ninterface DotPageAssetLayoutSidebar {\n    preview: boolean;\n    containers: DotCMSContainer[];\n    location: string;\n    widthPercent: number;\n    width: string;\n}\n\ninterface DotPageAssetLayoutBody {\n    rows: DotPageAssetLayoutRow[];\n}\n\ninterface DotCMSSite {\n    lowIndexPriority: boolean;\n    name: string;\n    default: boolean;\n    aliases: string;\n    parent: boolean;\n    tagStorage: string;\n    systemHost: boolean;\n    inode: string;\n    versionType: string;\n    structureInode: string;\n    hostname: string;\n    hostThumbnail?: any;\n    owner: string;\n    permissionId: string;\n    permissionType: string;\n    type: string;\n    identifier: string;\n    modDate: number;\n    host: string;\n    live: boolean;\n    indexPolicy: string;\n    categoryId: string;\n    actionId?: any;\n    new: boolean;\n    archived: boolean;\n    locked: boolean;\n    disabledWysiwyg: any[];\n    modUser: string;\n    working: boolean;\n    titleImage: {\n        present: boolean;\n    };\n    folder: string;\n    htmlpage: boolean;\n    fileAsset: boolean;\n    vanityUrl: boolean;\n    keyValue: boolean;\n    structure?: DotCMSSiteStructure;\n    title: string;\n    languageId: number;\n    indexPolicyDependencies: string;\n    contentTypeId: string;\n    versionId: string;\n    lastReview: number;\n    nextReview?: any;\n    reviewInterval?: any;\n    sortOrder: number;\n    contentType: DotCMSSiteContentType;\n}\n\ninterface DotCMSSiteContentType {\n    owner?: any;\n    parentPermissionable: DotCMSSiteParentPermissionable;\n    permissionId: string;\n    permissionType: string;\n}\n\nexport interface DotCMSSiteParentPermissionable {\n    Inode: string;\n    Identifier: string;\n    permissionByIdentifier: boolean;\n    type: string;\n    owner?: any;\n    identifier: string;\n    permissionId: string;\n    parentPermissionable?: any;\n    permissionType: string;\n    inode: string;\n    childrenPermissionable?: any;\n    variantId?: string;\n}\n\ninterface DotCMSSiteStructure {\n    iDate: number;\n    type: string;\n    owner?: any;\n    inode: string;\n    identifier: string;\n    name: string;\n    description: string;\n    defaultStructure: boolean;\n    reviewInterval?: any;\n    reviewerRole?: any;\n    pagedetail?: any;\n    structureType: number;\n    fixed: boolean;\n    system: boolean;\n    velocityVarName: string;\n    urlMapPattern?: any;\n    host: string;\n    folder: string;\n    publishDateVar?: any;\n    expireDateVar?: any;\n    modDate: number;\n    fields: DotCMSSiteField[];\n    widget: boolean;\n    detailPage?: any;\n    fieldsBySortOrder: DotCMSSiteField[];\n    form: boolean;\n    htmlpageAsset: boolean;\n    content: boolean;\n    fileAsset: boolean;\n    persona: boolean;\n    permissionId: string;\n    permissionType: string;\n    live: boolean;\n    categoryId: string;\n    idate: number;\n    new: boolean;\n    archived: boolean;\n    locked: boolean;\n    modUser: string;\n    working: boolean;\n    title: string;\n    versionId: string;\n    versionType: string;\n}\n\ninterface DotCMSSiteField {\n    iDate: number;\n    type: string;\n    owner?: any;\n    inode: string;\n    identifier: string;\n    structureInode: string;\n    fieldName: string;\n    fieldType: string;\n    fieldRelationType?: any;\n    fieldContentlet: string;\n    required: boolean;\n    velocityVarName: string;\n    sortOrder: number;\n    values?: any;\n    regexCheck?: any;\n    hint?: any;\n    defaultValue?: any;\n    indexed: boolean;\n    listed: boolean;\n    fixed: boolean;\n    readOnly: boolean;\n    searchable: boolean;\n    unique: boolean;\n    modDate: number;\n    dataType: string;\n    live: boolean;\n    categoryId: string;\n    idate: number;\n    new: boolean;\n    archived: boolean;\n    locked: boolean;\n    modUser: string;\n    working: boolean;\n    permissionId: string;\n    parentPermissionable?: any;\n    permissionType: string;\n    title: string;\n    versionId: string;\n    versionType: string;\n}\n"]}

package/esm2022/next/models/index.mjs

@@ -0,0 +1,3 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+export * from './dotcms.model';
+//# sourceMappingURL=data:application/json;base64,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

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,4 @@
+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';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvc2RrL2FuZ3VsYXIvbmV4dC9wdWJsaWNfYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxNQUFNLDBEQUEwRCxDQUFDO0FBRW5HLE9BQU8sRUFBRSx3QkFBd0IsRUFBRSxNQUFNLHFEQUFxRCxDQUFDO0FBRS9GLE9BQU8sRUFBRSwyQkFBMkIsRUFBRSxNQUFNLGtFQUFrRSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgRG90Q01TU2hvd1doZW5EaXJlY3RpdmUgfSBmcm9tICcuL2RpcmVjdGl2ZXMvZG90Y21zLXNob3ctd2hlbi9kb3RjbXMtc2hvdy13aGVuLmRpcmVjdGl2ZSc7XG5cbmV4cG9ydCB7IHByb3ZpZGVEb3RDTVNJbWFnZUxvYWRlciB9IGZyb20gJy4vcHJvdmlkZXJzL2RvdGNtcy1pbWFnZS1sb2FkZXIvZG90Y21zLWltYWdlX2xvYWRlcic7XG5cbmV4cG9ydCB7IERvdENNU0VkaXRhYmxlVGV4dENvbXBvbmVudCB9IGZyb20gJy4vY29tcG9uZW50cy9kb3RjbXMtZWRpdGFibGUtdGV4dC9kb3RjbXMtZWRpdGFibGUtdGV4dC5jb21wb25lbnQnO1xuIl19

package/esm2022/public_api.mjs

@@ -0,0 +1,2 @@
+export * from './lib/deprecated/deprecated-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL2xpYnMvc2RrL2FuZ3VsYXIvc3JjL3B1YmxpY19hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxpQ0FBaUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vbGliL2RlcHJlY2F0ZWQvZGVwcmVjYXRlZC1hcGknO1xuIl19