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

package/dotcms-angular.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dotcms-angular.d.ts","sourceRoot":"","sources":["../../../../libs/sdk/angular/src/dotcms-angular.ts"],"names":[],"mappings":"AAAA;;GAEG;;AAEH,cAAc,SAAS,CAAC"}
+{"version":3,"file":"dotcms-angular.d.ts","sourceRoot":"","sources":["../../../../libs/sdk/angular/src/dotcms-angular.ts"],"names":[],"mappings":"AAAA;;GAEG;;AAEH,cAAc,cAAc,CAAC"}

package/esm2022/dotcms-angular.mjs

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

package/esm2022/lib/deprecated/components/dot-editable-text/dot-editable-text.component.mjs

@@ -0,0 +1,229 @@
+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";
+/**
+ * @deprecated This component is deprecated and will be removed in future versions.
+ * Please use the new Rich Text Editor component from the main SDK.
+ * For more information, refer to the migration guide in the documentation.
+ *
+ * Dot editable text component.
+ * This component is responsible to render a text field that can be edited inline.
+ *
+ * @export
+ * @class DotEditableTextComponent
+ * @implements {OnInit}
+ * @implements {OnChanges}
+ */
+export class DotEditableTextComponent {
+    constructor() {
+        /**
+         * Represents the mode of the editor which can be `plain`, `minimal`, or `full`
+         *
+         * @type {DOT_EDITABLE_TEXT_MODE}
+         * @memberof DotEditableTextComponent
+         */
+        this.mode = 'plain';
+        /**
+         * Represents the format of the editor which can be `text` or `html`
+         *
+         * @type {DOT_EDITABLE_TEXT_FORMAT}
+         * @memberof DotEditableTextComponent
+         */
+        this.format = 'text';
+        /**
+         * Represents the field name of the `contentlet` that can be edited
+         *
+         * @memberof DotEditableTextComponent
+         */
+        this.fieldName = '';
+        /**
+         * Represents the content of the `contentlet` that can be edited
+         *
+         * @protected
+         * @memberof DotEditableTextComponent
+         */
+        this.content = '';
+        this.#sanitizer = inject(DomSanitizer);
+        this.#renderer = inject(Renderer2);
+        this.#elementRef = inject(ElementRef);
+    }
+    #sanitizer;
+    #renderer;
+    #elementRef;
+    /**
+     * The TinyMCE editor
+     *
+     * @readonly
+     * @memberof DotEditableTextComponent
+     */
+    get editor() {
+        return this.editorComponent?.editor;
+    }
+    /**
+     * Returns the number of pages the contentlet is on
+     *
+     * @readonly
+     * @memberof DotEditableTextComponent
+     */
+    get onNumberOfPages() {
+        return this.contentlet['onNumberOfPages'] || 1;
+    }
+    /**
+     * Handle copy contentlet inline editing success event
+     *
+     * @param {MessageEvent} { data }
+     * @return {*}
+     * @memberof DotEditableTextComponent
+     */
+    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 DotEditableTextComponent
+     */
+    onMouseDown({ event }) {
+        if (Number(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 DotEditableTextComponent
+     */
+    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 DotEditableTextComponent
+     */
+    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 DotEditableTextComponent
+     */
+    didContentChange(editedContent) {
+        return this.content !== editedContent;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.3", ngImport: i0, type: DotEditableTextComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.3", type: DotEditableTextComponent, isStandalone: true, selector: "dot-editable-text", inputs: { mode: "mode", format: "format", fieldName: "fieldName", contentlet: "contentlet" }, 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: DotEditableTextComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'dot-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
+            }], fieldName: [{
+                type: Input
+            }], contentlet: [{
+                type: Input
+            }], onMessage: [{
+                type: HostListener,
+                args: ['window:message', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dot-editable-text.component.js","sourceRoot":"","sources":["../../../../../../../../../libs/sdk/angular/src/lib/deprecated/components/dot-editable-text/dot-editable-text.component.ts","../../../../../../../../../libs/sdk/angular/src/lib/deprecated/components/dot-editable-text/dot-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 * @deprecated This component is deprecated and will be removed in future versions.\n * Please use the new Rich Text Editor component from the main SDK.\n * For more information, refer to the migration guide in the documentation.\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 DotEditableTextComponent\n * @implements {OnInit}\n * @implements {OnChanges}\n */\n@Component({\n    selector: 'dot-editable-text',\n    standalone: true,\n    templateUrl: './dot-editable-text.component.html',\n    styleUrl: './dot-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 DotEditableTextComponent 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 DotEditableTextComponent\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 DotEditableTextComponent\n     */\n    @Input() format: DOT_EDITABLE_TEXT_FORMAT = 'text';\n    /**\n     * Represents the field name of the `contentlet` that can be edited\n     *\n     * @memberof DotEditableTextComponent\n     */\n    @Input() fieldName = '';\n    /**\n     * Represents the `contentlet` that can be inline edited\n     *\n     * @type {DotCMSContentlet}\n     * @memberof DotEditableTextComponent\n     */\n    @Input() contentlet!: DotCMSContentlet;\n\n    /**\n     * Represents the content of the `contentlet` that can be edited\n     *\n     * @protected\n     * @memberof DotEditableTextComponent\n     */\n    protected content = '';\n    /**\n     * Represents the configuration of the editor\n     *\n     * @protected\n     * @type {EditorComponent['init']}\n     * @memberof DotEditableTextComponent\n     */\n    protected init!: EditorComponent['init'];\n    /**\n     * Represents if the component is inside the editor\n     *\n     * @protected\n     * @type {boolean}\n     * @memberof DotEditableTextComponent\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 DotEditableTextComponent\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 DotEditableTextComponent\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 DotEditableTextComponent\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 DotEditableTextComponent\n     */\n    onMouseDown({ event }: EventObj<MouseEvent>) {\n        if (Number(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 DotEditableTextComponent\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 DotEditableTextComponent\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 DotEditableTextComponent\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/deprecated/components/dot-editable-text/utils.mjs

@@ -0,0 +1,43 @@
+const DEFAULT_TINYMCE_CONFIG = {
+    menubar: false,
+    inline: true,
+    valid_styles: {
+        '*': 'font-size,font-family,color,text-decoration,text-align'
+    },
+    powerpaste_word_import: 'clean',
+    powerpaste_html_import: 'clean',
+    suffix: '.min', // Suffix to use when loading resources
+    license_key: 'gpl'
+};
+export const TINYMCE_CONFIG = {
+    minimal: {
+        ...DEFAULT_TINYMCE_CONFIG,
+        plugins: 'link autolink',
+        toolbar: 'bold italic underline | link',
+        valid_elements: 'strong,em,span[style],a[href]'
+    },
+    full: {
+        ...DEFAULT_TINYMCE_CONFIG,
+        plugins: 'link lists autolink charmap',
+        style_formats: [
+            { title: 'Paragraph', format: 'p' },
+            { title: 'Header 1', format: 'h1' },
+            { title: 'Header 2', format: 'h2' },
+            { title: 'Header 3', format: 'h3' },
+            { title: 'Header 4', format: 'h4' },
+            { title: 'Header 5', format: 'h5' },
+            { title: 'Header 6', format: 'h6' },
+            { title: 'Pre', format: 'pre' },
+            { title: 'Code', format: 'code' }
+        ],
+        toolbar: [
+            'styleselect undo redo | bold italic underline | forecolor backcolor | alignleft aligncenter alignright alignfull | numlist bullist outdent indent | hr charmap removeformat | link'
+        ]
+    },
+    plain: {
+        ...DEFAULT_TINYMCE_CONFIG,
+        plugins: '',
+        toolbar: ''
+    }
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/deprecated/components/no-component/no-component.component.mjs

@@ -0,0 +1,32 @@
+import { ChangeDetectionStrategy, Component, HostBinding, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * This component is responsible to display a message when there is no component for a contentlet.
+ *
+ * @export
+ * @class NoComponent
+ */
+export class NoComponent {
+    constructor() {
+        /**
+         * The data-testid attribute used for identifying the component during testing.
+         */
+        this.testId = 'no-component';
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.3", ngImport: i0, type: NoComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.3", type: NoComponent, isStandalone: true, selector: "dotcms-no-component", inputs: { contentlet: "contentlet" }, host: { properties: { "attr.data-testid": "this.testId" } }, ngImport: i0, template: `
+        No Component for {{ contentlet.contentType }}
+    `, isInline: true, styles: [":host{display:block}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.3", ngImport: i0, type: NoComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'dotcms-no-component', standalone: true, template: `
+        No Component for {{ contentlet.contentType }}
+    `, changeDetection: ChangeDetectionStrategy.OnPush, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { contentlet: [{
+                type: Input
+            }], testId: [{
+                type: HostBinding,
+                args: ['attr.data-testid']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/deprecated/deprecated-api.mjs

@@ -0,0 +1,11 @@
+/**
+ * @deprecated This API is deprecated and will be removed in future versions.
+ * Please migrate to the new components and services in the main SDK.
+ * For more information, refer to the migration guide in the documentation.
+ */
+export * from './components/dot-editable-text/dot-editable-text.component';
+export * from './layout/dotcms-layout/dotcms-layout.component';
+export * from './services/dotcms-context/page-context.service';
+export * from './models';
+export * from './utils/image_loader';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVwcmVjYXRlZC1hcGkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL3Nkay9hbmd1bGFyL3NyYy9saWIvZGVwcmVjYXRlZC9kZXByZWNhdGVkLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7OztHQUlHO0FBRUgsY0FBYyw0REFBNEQsQ0FBQztBQUMzRSxjQUFjLGdEQUFnRCxDQUFDO0FBQy9ELGNBQWMsZ0RBQWdELENBQUM7QUFDL0QsY0FBYyxVQUFVLENBQUM7QUFDekIsY0FBYyxzQkFBc0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGRlcHJlY2F0ZWQgVGhpcyBBUEkgaXMgZGVwcmVjYXRlZCBhbmQgd2lsbCBiZSByZW1vdmVkIGluIGZ1dHVyZSB2ZXJzaW9ucy5cbiAqIFBsZWFzZSBtaWdyYXRlIHRvIHRoZSBuZXcgY29tcG9uZW50cyBhbmQgc2VydmljZXMgaW4gdGhlIG1haW4gU0RLLlxuICogRm9yIG1vcmUgaW5mb3JtYXRpb24sIHJlZmVyIHRvIHRoZSBtaWdyYXRpb24gZ3VpZGUgaW4gdGhlIGRvY3VtZW50YXRpb24uXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9jb21wb25lbnRzL2RvdC1lZGl0YWJsZS10ZXh0L2RvdC1lZGl0YWJsZS10ZXh0LmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2xheW91dC9kb3RjbXMtbGF5b3V0L2RvdGNtcy1sYXlvdXQuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vc2VydmljZXMvZG90Y21zLWNvbnRleHQvcGFnZS1jb250ZXh0LnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9tb2RlbHMnO1xuZXhwb3J0ICogZnJvbSAnLi91dGlscy9pbWFnZV9sb2FkZXInO1xuIl19

package/esm2022/lib/{layout → deprecated/layout}/column/column.component.mjs

@@ -42,4 +42,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.3", ngImpor
                 type: HostBinding,
                 args: ['class']
             }] } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29sdW1uLmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvc2RrL2FuZ3VsYXIvc3JjL2xpYi9kZXByZWNhdGVkL2xheW91dC9jb2x1bW4vY29sdW1uLmNvbXBvbmVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsdUJBQXVCLEVBQUUsU0FBUyxFQUFFLFdBQVcsRUFBRSxLQUFLLEVBQVUsTUFBTSxlQUFlLENBQUM7QUFHL0YsT0FBTyxFQUFFLHVCQUF1QixFQUFFLE1BQU0sYUFBYSxDQUFDO0FBQ3RELE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLGtDQUFrQyxDQUFDOztBQUV0RTs7Ozs7O0dBTUc7QUFhSCxNQUFNLE9BQU8sZUFBZTtJQVo1QjtRQXFCSTs7OztXQUlHO1FBQ21CLHFCQUFnQixHQUFHLEVBQUUsQ0FBQztLQVMvQztJQVBHLFFBQVE7UUFDSixNQUFNLEVBQUUsVUFBVSxFQUFFLFFBQVEsRUFBRSxHQUFHLHVCQUF1QixDQUNwRCxJQUFJLENBQUMsTUFBTSxDQUFDLFVBQVUsRUFDdEIsSUFBSSxDQUFDLE1BQU0sQ0FBQyxLQUFLLEdBQUcsSUFBSSxDQUFDLE1BQU0sQ0FBQyxVQUFVLENBQzdDLENBQUM7UUFDRixJQUFJLENBQUMsZ0JBQWdCLEdBQUcsR0FBRyxVQUFVLElBQUksUUFBUSxFQUFFLENBQUM7SUFDeEQsQ0FBQzs4R0F0QlEsZUFBZTtrR0FBZixlQUFlLG1LQVJkOzs7O0tBSVQsNDlCQUxTLGtCQUFrQjs7MkZBU25CLGVBQWU7a0JBWjNCLFNBQVM7K0JBQ0ksZUFBZSxjQUNiLElBQUksV0FDUCxDQUFDLGtCQUFrQixDQUFDLFlBQ25COzs7O0tBSVQsbUJBRWdCLHVCQUF1QixDQUFDLE1BQU07OEJBU3RDLE1BQU07c0JBQWQsS0FBSztnQkFPZ0IsZ0JBQWdCO3NCQUFyQyxXQUFXO3VCQUFDLE9BQU8iLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDaGFuZ2VEZXRlY3Rpb25TdHJhdGVneSwgQ29tcG9uZW50LCBIb3N0QmluZGluZywgSW5wdXQsIE9uSW5pdCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5pbXBvcnQgeyBEb3RQYWdlQXNzZXRMYXlvdXRDb2x1bW4gfSBmcm9tICcuLi8uLi9tb2RlbHMnO1xuaW1wb3J0IHsgZ2V0UG9zaXRpb25TdHlsZUNsYXNzZXMgfSBmcm9tICcuLi8uLi91dGlscyc7XG5pbXBvcnQgeyBDb250YWluZXJDb21wb25lbnQgfSBmcm9tICcuLi9jb250YWluZXIvY29udGFpbmVyLmNvbXBvbmVudCc7XG5cbi8qKlxuICogVGhpcyBjb21wb25lbnQgaXMgcmVzcG9uc2libGUgdG8gZGlzcGxheSBhIGNvbHVtbiB3aXRoIGNvbnRhaW5lcnMuXG4gKlxuICogQGV4cG9ydFxuICogQGNsYXNzIENvbHVtbkNvbXBvbmVudFxuICogQGltcGxlbWVudHMge09uSW5pdH1cbiAqL1xuQENvbXBvbmVudCh7XG4gICAgc2VsZWN0b3I6ICdkb3RjbXMtY29sdW1uJyxcbiAgICBzdGFuZGFsb25lOiB0cnVlLFxuICAgIGltcG9ydHM6IFtDb250YWluZXJDb21wb25lbnRdLFxuICAgIHRlbXBsYXRlOiBgXG4gICAgICAgIEBmb3IgKGNvbnRhaW5lciBvZiBjb2x1bW4uY29udGFpbmVyczsgdHJhY2sgJGluZGV4KSB7XG4gICAgICAgICAgICA8ZG90Y21zLWNvbnRhaW5lciBbY29udGFpbmVyXT1cImNvbnRhaW5lclwiIC8+XG4gICAgICAgIH1cbiAgICBgLFxuICAgIHN0eWxlVXJsOiAnLi9jb2x1bW4uY29tcG9uZW50LmNzcycsXG4gICAgY2hhbmdlRGV0ZWN0aW9uOiBDaGFuZ2VEZXRlY3Rpb25TdHJhdGVneS5PblB1c2hcbn0pXG5leHBvcnQgY2xhc3MgQ29sdW1uQ29tcG9uZW50IGltcGxlbWVudHMgT25Jbml0IHtcbiAgICAvKipcbiAgICAgKiBUaGUgY29sdW1uIG9iamVjdCBjb250YWluaW5nIHRoZSBjb250YWluZXJzLlxuICAgICAqXG4gICAgICogQHR5cGUge0RvdFBhZ2VBc3NldExheW91dENvbHVtbn1cbiAgICAgKiBAbWVtYmVyb2YgQ29sdW1uQ29tcG9uZW50XG4gICAgICovXG4gICAgQElucHV0KCkgY29sdW1uITogRG90UGFnZUFzc2V0TGF5b3V0Q29sdW1uO1xuXG4gICAgLyoqXG4gICAgICogVGhlIGRhdGEtdGVzdGlkIGF0dHJpYnV0ZSB1c2VkIGZvciBpZGVudGlmeWluZyB0aGUgY29tcG9uZW50IGR1cmluZyB0ZXN0aW5nLlxuICAgICAqXG4gICAgICogQG1lbWJlcm9mIENvbHVtbkNvbXBvbmVudFxuICAgICAqL1xuICAgIEBIb3N0QmluZGluZygnY2xhc3MnKSBjb250YWluZXJDbGFzc2VzID0gJyc7XG5cbiAgICBuZ09uSW5pdCgpIHtcbiAgICAgICAgY29uc3QgeyBzdGFydENsYXNzLCBlbmRDbGFzcyB9ID0gZ2V0UG9zaXRpb25TdHlsZUNsYXNzZXMoXG4gICAgICAgICAgICB0aGlzLmNvbHVtbi5sZWZ0T2Zmc2V0LFxuICAgICAgICAgICAgdGhpcy5jb2x1bW4ud2lkdGggKyB0aGlzLmNvbHVtbi5sZWZ0T2Zmc2V0XG4gICAgICAgICk7XG4gICAgICAgIHRoaXMuY29udGFpbmVyQ2xhc3NlcyA9IGAke3N0YXJ0Q2xhc3N9ICR7ZW5kQ2xhc3N9YDtcbiAgICB9XG59XG4iXX0=

package/esm2022/lib/deprecated/layout/container/container.component.mjs

@@ -0,0 +1,126 @@
+import { AsyncPipe, NgComponentOutlet } from '@angular/common';
+import { ChangeDetectionStrategy, Component, HostBinding, Input, computed, inject, signal } from '@angular/core';
+import { NoComponent } from '../../components/no-component/no-component.component';
+import { PageContextService } from '../../services/dotcms-context/page-context.service';
+import { getContainersData } from '../../utils';
+import { ContentletComponent } from '../contentlet/contentlet.component';
+import * as i0 from "@angular/core";
+/**
+ * This component is responsible to display a container with contentlets.
+ *
+ * @export
+ * @class ContainerComponent
+ * @implements {OnChanges}
+ */
+export class ContainerComponent {
+    constructor() {
+        this.pageContextService = inject(PageContextService);
+        this.NoComponent = NoComponent;
+        this.$isInsideEditor = signal(false);
+        this.$contentlets = signal([]);
+        this.$dotContainer = signal(null);
+        this.$dotContainerAsString = computed(() => JSON.stringify(this.$dotContainer()));
+        /**
+         * The accept types for the container component.
+         *
+         * @type {(string | null)}
+         * @memberof ContainerComponent
+         */
+        this.acceptTypes = null;
+        /**
+         * The identifier for the container component.
+         *
+         * @type {(string | null)}
+         * @memberof ContainerComponent
+         */
+        this.identifier = null;
+        /**
+         * The max contentlets for the container component.
+         *
+         * @type {(number | null)}
+         * @memberof ContainerComponent
+         */
+        this.maxContentlets = null;
+        /**
+         * The uuid for the container component.
+         *
+         * @type {(string | null)}
+         * @memberof ContainerComponent
+         */
+        this.uuid = null;
+        /**
+         * The class for the container component.
+         *
+         * @type {(string | null)}
+         * @memberof ContainerComponent
+         */
+        this.class = null;
+        /**
+         * The dot object for the container component.
+         *
+         * @type {(string | null)}
+         * @memberof ContainerComponent
+         */
+        this.dotObject = null;
+        /**
+         * The data-testid attribute used for identifying the component during testing.
+         *
+         * @memberof ContainerComponent
+         */
+        this.testId = 'dot-container';
+    }
+    ngOnChanges() {
+        const { pageAsset, components, isInsideEditor } = this.pageContextService.context;
+        const { acceptTypes, maxContentlets, variantId, path, contentlets } = getContainersData(pageAsset.containers, this.container);
+        const { identifier, uuid } = this.container;
+        this.componentsMap = components;
+        this.$isInsideEditor.set(isInsideEditor);
+        this.$contentlets.set(contentlets);
+        this.$dotContainer.set({
+            identifier: path ?? identifier,
+            acceptTypes,
+            maxContentlets,
+            variantId,
+            uuid
+        });
+        if (this.$isInsideEditor()) {
+            this.acceptTypes = acceptTypes;
+            this.identifier = identifier;
+            this.maxContentlets = maxContentlets;
+            this.uuid = uuid;
+            this.class = this.$contentlets().length ? null : 'empty-container';
+            this.dotObject = 'container';
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.3", ngImport: i0, type: ContainerComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.3", type: ContainerComponent, isStandalone: true, selector: "dotcms-container", inputs: { container: "container" }, host: { properties: { "attr.data-dot-accept-types": "this.acceptTypes", "attr.data-dot-identifier": "this.identifier", "attr.data-max-contentlets": "this.maxContentlets", "attr.data-dot-uuid": "this.uuid", "class": "this.class", "attr.data-dot-object": "this.dotObject", "attr.data-testid": "this.testId" } }, usesOnChanges: true, ngImport: i0, template: "@if ($isInsideEditor()) {\n    @if ($contentlets().length) {\n        @for (contentlet of $contentlets(); track $index) {\n            <dotcms-contentlet-wrapper\n                [contentlet]=\"contentlet\"\n                [container]=\"$dotContainerAsString()\">\n                <ng-container\n                    *ngComponentOutlet=\"\n                        (componentsMap[contentlet.contentType] || componentsMap['CustomNoComponent']\n                            | async) || NoComponent;\n                        inputs: { contentlet }\n                    \" />\n            </dotcms-contentlet-wrapper>\n        }\n    } @else {\n        This container is empty.\n    }\n} @else {\n    @for (contentlet of $contentlets(); track $index) {\n        <ng-container\n            *ngComponentOutlet=\"\n                componentsMap[contentlet.contentType] | async;\n                inputs: { contentlet }\n            \" />\n    }\n}\n", styles: [":host.empty-container{width:100%;background-color:#ecf0fd;display:flex;justify-content:center;align-items:center;color:#030e32;height:10rem}\n"], dependencies: [{ kind: "pipe", type: AsyncPipe, name: "async" }, { kind: "directive", type: NgComponentOutlet, selector: "[ngComponentOutlet]", inputs: ["ngComponentOutlet", "ngComponentOutletInputs", "ngComponentOutletInjector", "ngComponentOutletContent", "ngComponentOutletNgModule", "ngComponentOutletNgModuleFactory"] }, { kind: "component", type: ContentletComponent, selector: "dotcms-contentlet-wrapper", inputs: ["contentlet", "container"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.3", ngImport: i0, type: ContainerComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'dotcms-container', standalone: true, imports: [AsyncPipe, NgComponentOutlet, NoComponent, ContentletComponent], changeDetection: ChangeDetectionStrategy.OnPush, template: "@if ($isInsideEditor()) {\n    @if ($contentlets().length) {\n        @for (contentlet of $contentlets(); track $index) {\n            <dotcms-contentlet-wrapper\n                [contentlet]=\"contentlet\"\n                [container]=\"$dotContainerAsString()\">\n                <ng-container\n                    *ngComponentOutlet=\"\n                        (componentsMap[contentlet.contentType] || componentsMap['CustomNoComponent']\n                            | async) || NoComponent;\n                        inputs: { contentlet }\n                    \" />\n            </dotcms-contentlet-wrapper>\n        }\n    } @else {\n        This container is empty.\n    }\n} @else {\n    @for (contentlet of $contentlets(); track $index) {\n        <ng-container\n            *ngComponentOutlet=\"\n                componentsMap[contentlet.contentType] | async;\n                inputs: { contentlet }\n            \" />\n    }\n}\n", styles: [":host.empty-container{width:100%;background-color:#ecf0fd;display:flex;justify-content:center;align-items:center;color:#030e32;height:10rem}\n"] }]
+        }], propDecorators: { container: [{
+                type: Input,
+                args: [{ required: true }]
+            }], acceptTypes: [{
+                type: HostBinding,
+                args: ['attr.data-dot-accept-types']
+            }], identifier: [{
+                type: HostBinding,
+                args: ['attr.data-dot-identifier']
+            }], maxContentlets: [{
+                type: HostBinding,
+                args: ['attr.data-max-contentlets']
+            }], uuid: [{
+                type: HostBinding,
+                args: ['attr.data-dot-uuid']
+            }], class: [{
+                type: HostBinding,
+                args: ['class']
+            }], dotObject: [{
+                type: HostBinding,
+                args: ['attr.data-dot-object']
+            }], testId: [{
+                type: HostBinding,
+                args: ['attr.data-testid']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"container.component.js","sourceRoot":"","sources":["../../../../../../../../../libs/sdk/angular/src/lib/deprecated/layout/container/container.component.ts","../../../../../../../../../libs/sdk/angular/src/lib/deprecated/layout/container/container.component.html"],"names":[],"mappings":"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","sourcesContent":["import { AsyncPipe, NgComponentOutlet } from '@angular/common';\nimport {\n    ChangeDetectionStrategy,\n    Component,\n    HostBinding,\n    Input,\n    OnChanges,\n    computed,\n    inject,\n    signal\n} from '@angular/core';\n\nimport { NoComponent } from '../../components/no-component/no-component.component';\nimport { DynamicComponentEntity } from '../../models';\nimport { DotCMSContainer, DotCMSContentlet } from '../../models/dotcms.model';\nimport { PageContextService } from '../../services/dotcms-context/page-context.service';\nimport { getContainersData } from '../../utils';\nimport { ContentletComponent } from '../contentlet/contentlet.component';\n\ninterface DotContainer {\n    acceptTypes: string;\n    identifier: string;\n    maxContentlets: number;\n    uuid: string;\n    variantId?: string;\n}\n\n/**\n * This component is responsible to display a container with contentlets.\n *\n * @export\n * @class ContainerComponent\n * @implements {OnChanges}\n */\n@Component({\n    selector: 'dotcms-container',\n    standalone: true,\n    imports: [AsyncPipe, NgComponentOutlet, NoComponent, ContentletComponent],\n    templateUrl: './container.component.html',\n    styleUrl: './container.component.css',\n    changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class ContainerComponent implements OnChanges {\n    /**\n     * The container object containing the contentlets.\n     *\n     * @type {DotCMSContainer}\n     * @memberof ContainerComponent\n     */\n    @Input({ required: true }) container!: DotCMSContainer;\n\n    private readonly pageContextService: PageContextService = inject(PageContextService);\n    protected readonly NoComponent = NoComponent;\n    protected readonly $isInsideEditor = signal<boolean>(false);\n\n    protected componentsMap!: Record<string, DynamicComponentEntity>;\n    protected $contentlets = signal<DotCMSContentlet[]>([]);\n    protected $dotContainer = signal<DotContainer | null>(null);\n    protected $dotContainerAsString = computed(() => JSON.stringify(this.$dotContainer()));\n\n    /**\n     * The accept types for the container component.\n     *\n     * @type {(string | null)}\n     * @memberof ContainerComponent\n     */\n    @HostBinding('attr.data-dot-accept-types') acceptTypes: string | null = null;\n\n    /**\n     * The identifier for the container component.\n     *\n     * @type {(string | null)}\n     * @memberof ContainerComponent\n     */\n    @HostBinding('attr.data-dot-identifier') identifier: string | null = null;\n    /**\n     * The max contentlets for the container component.\n     *\n     * @type {(number | null)}\n     * @memberof ContainerComponent\n     */\n    @HostBinding('attr.data-max-contentlets') maxContentlets: number | null = null;\n    /**\n     * The uuid for the container component.\n     *\n     * @type {(string | null)}\n     * @memberof ContainerComponent\n     */\n    @HostBinding('attr.data-dot-uuid') uuid: string | null = null;\n    /**\n     * The class for the container component.\n     *\n     * @type {(string | null)}\n     * @memberof ContainerComponent\n     */\n    @HostBinding('class') class: string | null = null;\n    /**\n     * The dot object for the container component.\n     *\n     * @type {(string | null)}\n     * @memberof ContainerComponent\n     */\n    @HostBinding('attr.data-dot-object') dotObject: string | null = null;\n    /**\n     * The data-testid attribute used for identifying the component during testing.\n     *\n     * @memberof ContainerComponent\n     */\n    @HostBinding('attr.data-testid') testId = 'dot-container';\n\n    ngOnChanges() {\n        const { pageAsset, components, isInsideEditor } = this.pageContextService.context;\n        const { acceptTypes, maxContentlets, variantId, path, contentlets } = getContainersData(\n            pageAsset.containers,\n            this.container\n        );\n        const { identifier, uuid } = this.container;\n\n        this.componentsMap = components;\n\n        this.$isInsideEditor.set(isInsideEditor);\n        this.$contentlets.set(contentlets);\n        this.$dotContainer.set({\n            identifier: path ?? identifier,\n            acceptTypes,\n            maxContentlets,\n            variantId,\n            uuid\n        });\n\n        if (this.$isInsideEditor()) {\n            this.acceptTypes = acceptTypes;\n            this.identifier = identifier;\n            this.maxContentlets = maxContentlets;\n            this.uuid = uuid;\n            this.class = this.$contentlets().length ? null : 'empty-container';\n            this.dotObject = 'container';\n        }\n    }\n}\n","@if ($isInsideEditor()) {\n    @if ($contentlets().length) {\n        @for (contentlet of $contentlets(); track $index) {\n            <dotcms-contentlet-wrapper\n                [contentlet]=\"contentlet\"\n                [container]=\"$dotContainerAsString()\">\n                <ng-container\n                    *ngComponentOutlet=\"\n                        (componentsMap[contentlet.contentType] || componentsMap['CustomNoComponent']\n                            | async) || NoComponent;\n                        inputs: { contentlet }\n                    \" />\n            </dotcms-contentlet-wrapper>\n        }\n    } @else {\n        This container is empty.\n    }\n} @else {\n    @for (contentlet of $contentlets(); track $index) {\n        <ng-container\n            *ngComponentOutlet=\"\n                componentsMap[contentlet.contentType] | async;\n                inputs: { contentlet }\n            \" />\n    }\n}\n"]}