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

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

@@ -0,0 +1,120 @@
+import { ChangeDetectionStrategy, Component, HostBinding, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * This component is responsible to display a contentlet.
+ *
+ * @export
+ * @class ContentletComponent
+ * @implements {OnChanges}
+ */
+export class ContentletComponent {
+    constructor() {
+        /**
+         * The identifier of contentlet component.
+         *
+         * @type {(string | null)}
+         * @memberof ContentletComponent
+         */
+        this.identifier = null;
+        /**
+         * The base type of contentlet component.
+         *
+         * @type {(string | null)}
+         * @memberof ContentletComponent
+         */
+        this.baseType = null;
+        /**
+         * The title of contentlet component.
+         *
+         * @type {(string | null)}
+         * @memberof ContentletComponent
+         */
+        this.title = null;
+        /**
+         * The inode of contentlet component.
+         *
+         * @type {(string | null)}
+         * @memberof ContentletComponent
+         */
+        this.inode = null;
+        /**
+         * The type of contentlet component.
+         *
+         * @type {(string | null)}
+         * @memberof ContentletComponent
+         */
+        this.dotType = null;
+        /**
+         * The container of contentlet component.
+         *
+         * @type {(string | null)}
+         * @memberof ContentletComponent
+         */
+        this.dotContainer = null;
+        /**
+         * The number of pages where the contentlet appears
+         *
+         * @type {(string | null)}
+         * @memberof ContentletComponent
+         */
+        this.numberOfPages = null;
+        /**
+         * The content of contentlet component.
+         *
+         * @type {(string | null)}
+         * @memberof ContentletComponent
+         */
+        this.dotContent = null;
+    }
+    ngOnChanges() {
+        this.identifier = this.contentlet.identifier;
+        this.baseType = this.contentlet.baseType;
+        this.title = this.contentlet.title;
+        this.inode = this.contentlet.inode;
+        this.dotType = this.contentlet.contentType;
+        this.dotContainer = this.container;
+        this.numberOfPages = this.contentlet['onNumberOfPages'];
+        this.dotContent = 'contentlet';
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.3", ngImport: i0, type: ContentletComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.3", type: ContentletComponent, isStandalone: true, selector: "dotcms-contentlet-wrapper", inputs: { contentlet: "contentlet", container: "container" }, host: { properties: { "attr.data-dot-identifier": "this.identifier", "attr.data-dot-basetype": "this.baseType", "attr.data-dot-title": "this.title", "attr.data-dot-inode": "this.inode", "attr.data-dot-type": "this.dotType", "attr.data-dot-container": "this.dotContainer", "attr.data-dot-on-number-of-pages": "this.numberOfPages", "attr.data-dot-object": "this.dotContent" } }, usesOnChanges: true, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.3", ngImport: i0, type: ContentletComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'dotcms-contentlet-wrapper',
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    changeDetection: ChangeDetectionStrategy.OnPush
+                }]
+        }], propDecorators: { contentlet: [{
+                type: Input,
+                args: [{ required: true }]
+            }], container: [{
+                type: Input
+            }], identifier: [{
+                type: HostBinding,
+                args: ['attr.data-dot-identifier']
+            }], baseType: [{
+                type: HostBinding,
+                args: ['attr.data-dot-basetype']
+            }], title: [{
+                type: HostBinding,
+                args: ['attr.data-dot-title']
+            }], inode: [{
+                type: HostBinding,
+                args: ['attr.data-dot-inode']
+            }], dotType: [{
+                type: HostBinding,
+                args: ['attr.data-dot-type']
+            }], dotContainer: [{
+                type: HostBinding,
+                args: ['attr.data-dot-container']
+            }], numberOfPages: [{
+                type: HostBinding,
+                args: ['attr.data-dot-on-number-of-pages']
+            }], dotContent: [{
+                type: HostBinding,
+                args: ['attr.data-dot-object']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/deprecated/layout/dotcms-layout/dotcms-layout.component.mjs

@@ -0,0 +1,106 @@
+import { AsyncPipe } from '@angular/common';
+import { ChangeDetectionStrategy, Component, DestroyRef, Input, inject } from '@angular/core';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { ActivatedRoute } from '@angular/router';
+import { CLIENT_ACTIONS, DotCmsClient, initEditor, isInsideEditor, postMessageToEditor, updateNavigation } from '@dotcms/client';
+import { UVEEventType } from '@dotcms/types';
+import { createUVESubscription } from '@dotcms/uve';
+import { PageContextService } from '../../services/dotcms-context/page-context.service';
+import { RowComponent } from '../row/row.component';
+import * as i0 from "@angular/core";
+/**
+ * @deprecated This component is deprecated and will be removed in future versions.
+ * Please use the new Page Layout component from the main SDK.
+ * For more information, refer to the migration guide in the documentation.
+ *
+ * `DotcmsLayoutComponent` is a class that represents the layout for a DotCMS page.
+ *  It includes a `pageAsset` property that represents the DotCMS page asset and a `components` property that represents the dynamic components for the page.
+ *
+ * @export
+ * @class DotcmsLayoutComponent
+ */
+export class DotcmsLayoutComponent {
+    constructor() {
+        this.route = inject(ActivatedRoute);
+        this.pageContextService = inject(PageContextService);
+        this.destroyRef$ = inject(DestroyRef);
+        this.pageAsset$ = this.pageContextService.currentPage$;
+    }
+    /**
+     * Represents the DotCMS page asset.
+     *
+     * @type {DotCMSPageAsset}
+     * @memberof DotcmsLayoutComponent
+     */
+    set pageAsset(value) {
+        this._pageAsset = value;
+        if (!value.layout) {
+            console.warn('Warning: pageAsset does not have a `layout` property. Might be using an advaced template or your dotCMS instance not have a enterprise license.');
+        }
+    }
+    /**
+     * Returns the DotCMS page asset.
+     *
+     * @readonly
+     * @type {DotCMSPageAsset}
+     * @memberof DotcmsLayoutComponent
+     */
+    get pageAsset() {
+        return this._pageAsset;
+    }
+    ngOnInit() {
+        this.pageContextService.setContext(this.pageAsset, this.components);
+        if (!isInsideEditor()) {
+            return;
+        }
+        this.client = DotCmsClient.instance;
+        this.route.url.pipe(takeUntilDestroyed(this.destroyRef$)).subscribe((urlSegments) => {
+            const pathname = '/' + urlSegments.join('/');
+            initEditor({ pathname });
+            updateNavigation(pathname || '/');
+        });
+        this.uveSubscription = createUVESubscription(UVEEventType.CONTENT_CHANGES, (data) => {
+            if (this.onReload) {
+                this.onReload();
+                return;
+            }
+            this.pageContextService.setPageAsset(data);
+        });
+        postMessageToEditor({ action: CLIENT_ACTIONS.CLIENT_READY, payload: this.editor });
+    }
+    ngOnDestroy() {
+        if (!isInsideEditor()) {
+            return;
+        }
+        this.uveSubscription?.unsubscribe();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.3", ngImport: i0, type: DotcmsLayoutComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.3", type: DotcmsLayoutComponent, isStandalone: true, selector: "dotcms-layout", inputs: { pageAsset: "pageAsset", components: "components", onReload: "onReload", editor: "editor" }, ngImport: i0, template: `
+        @if (pageAsset$ | async; as page) {
+            @for (row of page?.layout?.body?.rows; track $index) {
+                <dotcms-row [row]="row" />
+            }
+        }
+    `, isInline: true, styles: [":host{display:block}\n"], dependencies: [{ kind: "component", type: RowComponent, selector: "dotcms-row", inputs: ["row"] }, { kind: "pipe", type: AsyncPipe, name: "async" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.3", ngImport: i0, type: DotcmsLayoutComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'dotcms-layout', standalone: true, imports: [RowComponent, AsyncPipe], template: `
+        @if (pageAsset$ | async; as page) {
+            @for (row of page?.layout?.body?.rows; track $index) {
+                <dotcms-row [row]="row" />
+            }
+        }
+    `, changeDetection: ChangeDetectionStrategy.OnPush, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { pageAsset: [{
+                type: Input,
+                args: [{ required: true }]
+            }], components: [{
+                type: Input,
+                args: [{ required: true }]
+            }], onReload: [{
+                type: Input
+            }], editor: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dotcms-layout.component.js","sourceRoot":"","sources":["../../../../../../../../../libs/sdk/angular/src/lib/deprecated/layout/dotcms-layout/dotcms-layout.component.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,EACH,uBAAuB,EACvB,SAAS,EACT,UAAU,EACV,KAAK,EAEL,MAAM,EACT,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAChE,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAEjD,OAAO,EACH,cAAc,EACd,YAAY,EAEZ,UAAU,EACV,cAAc,EACd,mBAAmB,EACnB,gBAAgB,EACnB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAwB,YAAY,EAAE,MAAM,eAAe,CAAC;AACnE,OAAO,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAIpD,OAAO,EAAE,kBAAkB,EAAE,MAAM,oDAAoD,CAAC;AACxF,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;;AAEpD;;;;;;;;;;GAUG;AAeH,MAAM,OAAO,qBAAqB;IAdlC;QA0EqB,UAAK,GAAG,MAAM,CAAC,cAAc,CAAC,CAAC;QAC/B,uBAAkB,GAAG,MAAM,CAAC,kBAAkB,CAAC,CAAC;QAChD,gBAAW,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC;QAE/B,eAAU,GAAG,IAAI,CAAC,kBAAkB,CAAC,YAAY,CAAC;KAuCxE;IApGG;;;;;OAKG;IACH,IACI,SAAS,CAAC,KAAsB;QAChC,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;QACxB,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC;YAChB,OAAO,CAAC,IAAI,CACR,iJAAiJ,CACpJ,CAAC;QACN,CAAC;IACL,CAAC;IAED;;;;;;OAMG;IACH,IAAI,SAAS;QACT,OAAO,IAAI,CAAC,UAAU,CAAC;IAC3B,CAAC;IAwCD,QAAQ;QACJ,IAAI,CAAC,kBAAkB,CAAC,UAAU,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC;QAEpE,IAAI,CAAC,cAAc,EAAE,EAAE,CAAC;YACpB,OAAO;QACX,CAAC;QAED,IAAI,CAAC,MAAM,GAAG,YAAY,CAAC,QAAQ,CAAC;QACpC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,WAAW,EAAE,EAAE;YAChF,MAAM,QAAQ,GAAG,GAAG,GAAG,WAAW,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;YAE7C,UAAU,CAAC,EAAE,QAAQ,EAAE,CAAC,CAAC;YACzB,gBAAgB,CAAC,QAAQ,IAAI,GAAG,CAAC,CAAC;QACtC,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC,eAAe,GAAG,qBAAqB,CAAC,YAAY,CAAC,eAAe,EAAE,CAAC,IAAI,EAAE,EAAE;YAChF,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;gBAChB,IAAI,CAAC,QAAQ,EAAE,CAAC;gBAEhB,OAAO;YACX,CAAC;YAED,IAAI,CAAC,kBAAkB,CAAC,YAAY,CAAC,IAAkC,CAAC,CAAC;QAC7E,CAAC,CAAC,CAAC;QAEH,mBAAmB,CAAC,EAAE,MAAM,EAAE,cAAc,CAAC,YAAY,EAAE,OAAO,EAAE,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC;IACvF,CAAC;IAED,WAAW;QACP,IAAI,CAAC,cAAc,EAAE,EAAE,CAAC;YACpB,OAAO;QACX,CAAC;QAED,IAAI,CAAC,eAAe,EAAE,WAAW,EAAE,CAAC;IACxC,CAAC;8GAtGQ,qBAAqB;kGAArB,qBAAqB,+KAVpB;;;;;;KAMT,gGAPS,YAAY,mEAAE,SAAS;;2FAWxB,qBAAqB;kBAdjC,SAAS;+BACI,eAAe,cACb,IAAI,WACP,CAAC,YAAY,EAAE,SAAS,CAAC,YACxB;;;;;;KAMT,mBAEgB,uBAAuB,CAAC,MAAM;8BAY3C,SAAS;sBADZ,KAAK;uBAAC,EAAE,QAAQ,EAAE,IAAI,EAAE;gBA4BE,UAAU;sBAApC,KAAK;uBAAC,EAAE,QAAQ,EAAE,IAAI,EAAE;gBAQhB,QAAQ;sBAAhB,KAAK;gBAaG,MAAM;sBAAd,KAAK","sourcesContent":["import { AsyncPipe } from '@angular/common';\nimport {\n    ChangeDetectionStrategy,\n    Component,\n    DestroyRef,\n    Input,\n    OnInit,\n    inject\n} from '@angular/core';\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\nimport { ActivatedRoute } from '@angular/router';\n\nimport {\n    CLIENT_ACTIONS,\n    DotCmsClient,\n    EditorConfig,\n    initEditor,\n    isInsideEditor,\n    postMessageToEditor,\n    updateNavigation\n} from '@dotcms/client';\nimport { UVEEventSubscription, UVEEventType } from '@dotcms/types';\nimport { createUVESubscription } from '@dotcms/uve';\n\nimport { DotCMSPageComponent } from '../../models';\nimport { DotCMSPageAsset } from '../../models/dotcms.model';\nimport { PageContextService } from '../../services/dotcms-context/page-context.service';\nimport { RowComponent } from '../row/row.component';\n\n/**\n * @deprecated This component is deprecated and will be removed in future versions.\n * Please use the new Page Layout component from the main SDK.\n * For more information, refer to the migration guide in the documentation.\n *\n * `DotcmsLayoutComponent` is a class that represents the layout for a DotCMS page.\n *  It includes a `pageAsset` property that represents the DotCMS page asset and a `components` property that represents the dynamic components for the page.\n *\n * @export\n * @class DotcmsLayoutComponent\n */\n@Component({\n    selector: 'dotcms-layout',\n    standalone: true,\n    imports: [RowComponent, AsyncPipe],\n    template: `\n        @if (pageAsset$ | async; as page) {\n            @for (row of page?.layout?.body?.rows; track $index) {\n                <dotcms-row [row]=\"row\" />\n            }\n        }\n    `,\n    styleUrl: './dotcms-layout.component.css',\n    changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class DotcmsLayoutComponent implements OnInit {\n    private _pageAsset!: DotCMSPageAsset;\n\n    /**\n     * Represents the DotCMS page asset.\n     *\n     * @type {DotCMSPageAsset}\n     * @memberof DotcmsLayoutComponent\n     */\n    @Input({ required: true })\n    set pageAsset(value: DotCMSPageAsset) {\n        this._pageAsset = value;\n        if (!value.layout) {\n            console.warn(\n                'Warning: pageAsset does not have a `layout` property. Might be using an advaced template or your dotCMS instance not have a enterprise license.'\n            );\n        }\n    }\n\n    /**\n     * Returns the DotCMS page asset.\n     *\n     * @readonly\n     * @type {DotCMSPageAsset}\n     * @memberof DotcmsLayoutComponent\n     */\n    get pageAsset(): DotCMSPageAsset {\n        return this._pageAsset;\n    }\n\n    /**\n     * The `components` property is a record of dynamic components for each Contentlet on the page.\n     *\n     * @type {DotCMSPageComponent}\n     * @memberof DotcmsLayoutComponent\n     * @required\n     */\n    @Input({ required: true }) components!: DotCMSPageComponent;\n\n    /**\n     * The `onReload` property is a function that reloads the page after changes are made.\n     *\n     * @memberof DotcmsLayoutComponent\n     * @deprecated In future implementation we will be listening for the changes from the editor to update the page state so reload will not be needed.\n     */\n    @Input() onReload!: () => void;\n\n    /**\n     *\n     * @type {DotCMSFetchConfig}\n     * @memberof DotCMSPageEditorConfig\n     * @description The configuration custom params for data fetching on Edit Mode.\n     * @example <caption>Example with Custom GraphQL query</caption>\n     * <dotcms-layout [editor]=\"{ query: 'query { ... }' }\"/>\n     *\n     * @example <caption>Example usage with Custom Page API parameters</caption>\n     * <dotcms-layout [editor]=\"{ params: { depth: '2' } }\"/>;\n     */\n    @Input() editor!: EditorConfig;\n\n    private readonly route = inject(ActivatedRoute);\n    private readonly pageContextService = inject(PageContextService);\n    private readonly destroyRef$ = inject(DestroyRef);\n    private client!: DotCmsClient;\n    protected readonly pageAsset$ = this.pageContextService.currentPage$;\n\n    private uveSubscription?: UVEEventSubscription;\n\n    ngOnInit() {\n        this.pageContextService.setContext(this.pageAsset, this.components);\n\n        if (!isInsideEditor()) {\n            return;\n        }\n\n        this.client = DotCmsClient.instance;\n        this.route.url.pipe(takeUntilDestroyed(this.destroyRef$)).subscribe((urlSegments) => {\n            const pathname = '/' + urlSegments.join('/');\n\n            initEditor({ pathname });\n            updateNavigation(pathname || '/');\n        });\n\n        this.uveSubscription = createUVESubscription(UVEEventType.CONTENT_CHANGES, (data) => {\n            if (this.onReload) {\n                this.onReload();\n\n                return;\n            }\n\n            this.pageContextService.setPageAsset(data as unknown as DotCMSPageAsset);\n        });\n\n        postMessageToEditor({ action: CLIENT_ACTIONS.CLIENT_READY, payload: this.editor });\n    }\n\n    ngOnDestroy() {\n        if (!isInsideEditor()) {\n            return;\n        }\n\n        this.uveSubscription?.unsubscribe();\n    }\n}\n"]}

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

@@ -26,4 +26,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.3", ngImpor
                 type: Input,
                 args: [{ required: true }]
             }] } });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicm93LmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvc2RrL2FuZ3VsYXIvc3JjL2xpYi9sYXlvdXQvcm93L3Jvdy5jb21wb25lbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLHVCQUF1QixFQUFFLFNBQVMsRUFBRSxLQUFLLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFHMUUsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLDRCQUE0QixDQUFDOztBQUU3RDs7Ozs7R0FLRztBQWFILE1BQU0sT0FBTyxZQUFZOzhHQUFaLFlBQVk7a0dBQVosWUFBWSw4RkFSWDs7OztLQUlULDBKQUxTLGVBQWU7OzJGQVNoQixZQUFZO2tCQVp4QixTQUFTOytCQUNJLFlBQVksY0FDVixJQUFJLFdBQ1AsQ0FBQyxlQUFlLENBQUMsWUFDaEI7Ozs7S0FJVCxtQkFFZ0IsdUJBQXVCLENBQUMsTUFBTTs4QkFTcEIsR0FBRztzQkFBN0IsS0FBSzt1QkFBQyxFQUFFLFFBQVEsRUFBRSxJQUFJLEVBQUUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDaGFuZ2VEZXRlY3Rpb25TdHJhdGVneSwgQ29tcG9uZW50LCBJbnB1dCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5pbXBvcnQgeyBEb3RQYWdlQXNzZXRMYXlvdXRSb3cgfSBmcm9tICcuLi8uLi9tb2RlbHMnO1xuaW1wb3J0IHsgQ29sdW1uQ29tcG9uZW50IH0gZnJvbSAnLi4vY29sdW1uL2NvbHVtbi5jb21wb25lbnQnO1xuXG4vKipcbiAqIFRoaXMgY29tcG9uZW50IGlzIHJlc3BvbnNpYmxlIHRvIGRpc3BsYXkgYSByb3cgd2l0aCBjb2x1bW5zLlxuICpcbiAqIEBleHBvcnRcbiAqIEBjbGFzcyBSb3dDb21wb25lbnRcbiAqL1xuQENvbXBvbmVudCh7XG4gICAgc2VsZWN0b3I6ICdkb3RjbXMtcm93JyxcbiAgICBzdGFuZGFsb25lOiB0cnVlLFxuICAgIGltcG9ydHM6IFtDb2x1bW5Db21wb25lbnRdLFxuICAgIHRlbXBsYXRlOiBgXG4gICAgICAgIEBmb3IgKGNvbHVtbiBvZiByb3cuY29sdW1uczsgdHJhY2sgJGluZGV4KSB7XG4gICAgICAgICAgICA8ZG90Y21zLWNvbHVtbiBbY29sdW1uXT1cImNvbHVtblwiIC8+XG4gICAgICAgIH1cbiAgICBgLFxuICAgIHN0eWxlVXJsOiAnLi9yb3cuY29tcG9uZW50LmNzcycsXG4gICAgY2hhbmdlRGV0ZWN0aW9uOiBDaGFuZ2VEZXRlY3Rpb25TdHJhdGVneS5PblB1c2hcbn0pXG5leHBvcnQgY2xhc3MgUm93Q29tcG9uZW50IHtcbiAgICAvKipcbiAgICAgKiBUaGUgcm93IG9iamVjdCBjb250YWluaW5nIHRoZSBjb2x1bW5zLlxuICAgICAqXG4gICAgICogQHR5cGUge0RvdFBhZ2VBc3NldExheW91dFJvd31cbiAgICAgKiBAbWVtYmVyb2YgUm93Q29tcG9uZW50XG4gICAgICovXG4gICAgQElucHV0KHsgcmVxdWlyZWQ6IHRydWUgfSkgcm93ITogRG90UGFnZUFzc2V0TGF5b3V0Um93O1xufVxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicm93LmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvc2RrL2FuZ3VsYXIvc3JjL2xpYi9kZXByZWNhdGVkL2xheW91dC9yb3cvcm93LmNvbXBvbmVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsdUJBQXVCLEVBQUUsU0FBUyxFQUFFLEtBQUssRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUcxRSxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0sNEJBQTRCLENBQUM7O0FBRTdEOzs7OztHQUtHO0FBYUgsTUFBTSxPQUFPLFlBQVk7OEdBQVosWUFBWTtrR0FBWixZQUFZLDhGQVJYOzs7O0tBSVQsMEpBTFMsZUFBZTs7MkZBU2hCLFlBQVk7a0JBWnhCLFNBQVM7K0JBQ0ksWUFBWSxjQUNWLElBQUksV0FDUCxDQUFDLGVBQWUsQ0FBQyxZQUNoQjs7OztLQUlULG1CQUVnQix1QkFBdUIsQ0FBQyxNQUFNOzhCQVNwQixHQUFHO3NCQUE3QixLQUFLO3VCQUFDLEVBQUUsUUFBUSxFQUFFLElBQUksRUFBRSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENoYW5nZURldGVjdGlvblN0cmF0ZWd5LCBDb21wb25lbnQsIElucHV0IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmltcG9ydCB7IERvdFBhZ2VBc3NldExheW91dFJvdyB9IGZyb20gJy4uLy4uL21vZGVscyc7XG5pbXBvcnQgeyBDb2x1bW5Db21wb25lbnQgfSBmcm9tICcuLi9jb2x1bW4vY29sdW1uLmNvbXBvbmVudCc7XG5cbi8qKlxuICogVGhpcyBjb21wb25lbnQgaXMgcmVzcG9uc2libGUgdG8gZGlzcGxheSBhIHJvdyB3aXRoIGNvbHVtbnMuXG4gKlxuICogQGV4cG9ydFxuICogQGNsYXNzIFJvd0NvbXBvbmVudFxuICovXG5AQ29tcG9uZW50KHtcbiAgICBzZWxlY3RvcjogJ2RvdGNtcy1yb3cnLFxuICAgIHN0YW5kYWxvbmU6IHRydWUsXG4gICAgaW1wb3J0czogW0NvbHVtbkNvbXBvbmVudF0sXG4gICAgdGVtcGxhdGU6IGBcbiAgICAgICAgQGZvciAoY29sdW1uIG9mIHJvdy5jb2x1bW5zOyB0cmFjayAkaW5kZXgpIHtcbiAgICAgICAgICAgIDxkb3RjbXMtY29sdW1uIFtjb2x1bW5dPVwiY29sdW1uXCIgLz5cbiAgICAgICAgfVxuICAgIGAsXG4gICAgc3R5bGVVcmw6ICcuL3Jvdy5jb21wb25lbnQuY3NzJyxcbiAgICBjaGFuZ2VEZXRlY3Rpb246IENoYW5nZURldGVjdGlvblN0cmF0ZWd5Lk9uUHVzaFxufSlcbmV4cG9ydCBjbGFzcyBSb3dDb21wb25lbnQge1xuICAgIC8qKlxuICAgICAqIFRoZSByb3cgb2JqZWN0IGNvbnRhaW5pbmcgdGhlIGNvbHVtbnMuXG4gICAgICpcbiAgICAgKiBAdHlwZSB7RG90UGFnZUFzc2V0TGF5b3V0Um93fVxuICAgICAqIEBtZW1iZXJvZiBSb3dDb21wb25lbnRcbiAgICAgKi9cbiAgICBASW5wdXQoeyByZXF1aXJlZDogdHJ1ZSB9KSByb3chOiBEb3RQYWdlQXNzZXRMYXlvdXRSb3c7XG59XG4iXX0=

package/esm2022/lib/deprecated/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/src/lib/deprecated/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/lib/deprecated/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/lib/deprecated/services/dotcms-context/page-context.service.mjs

@@ -0,0 +1,79 @@
+import { BehaviorSubject } from 'rxjs';
+import { Injectable } from '@angular/core';
+import { map } from 'rxjs/operators';
+import { isInsideEditor } from '@dotcms/client';
+import * as i0 from "@angular/core";
+/**
+ * @deprecated This service is deprecated and will be removed in future versions.
+ * Please use the new Page Context service from the main SDK.
+ * For more information, refer to the migration guide in the documentation.
+ *
+ * @author dotCMS
+ * @description This service is responsible for managing the page context.
+ * @export
+ * @class PageContextService
+ */
+export class PageContextService {
+    constructor() {
+        this.context$ = new BehaviorSubject(null);
+    }
+    /**
+     * @description Get the context
+     * @readonly
+     * @type {DotCMSPageContext}
+     * @memberof PageContextService
+     */
+    get context() {
+        return this.context$.getValue();
+    }
+    /**
+     * @description Get the context as an observable
+     * @readonly
+     * @memberof PageContextService
+     */
+    get contextObs$() {
+        return this.context$.asObservable();
+    }
+    /**
+     * @description Get the current page asset
+     * @readonly
+     * @type {(Observable<DotCMSPageAsset | null>)}
+     * @memberof PageContextService
+     */
+    get currentPage$() {
+        return this.contextObs$.pipe(map((context) => context?.pageAsset || null));
+    }
+    /**
+     *
+     * @description Set the context
+     * @param {DotCMSPageAsset} value
+     * @memberof DotcmsContextService
+     */
+    setContext(pageAsset, components) {
+        this.context$.next({
+            pageAsset,
+            components,
+            isInsideEditor: isInsideEditor()
+        });
+    }
+    /**
+     * @description Set the page asset in the context
+     * @param {DotCMSPageAsset} pageAsset
+     * @memberof PageContextService
+     */
+    setPageAsset(pageAsset) {
+        this.context$.next({
+            ...this.context,
+            pageAsset
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.3", ngImport: i0, type: PageContextService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.3", ngImport: i0, type: PageContextService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.3", ngImport: i0, type: PageContextService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/deprecated/utils/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/lib/deprecated/utils/index.mjs

@@ -0,0 +1,84 @@
+//Changed the type, to avoid SQ issue.
+//This should be put inside a lib
+/**
+ * Represents a mapping of numbers to corresponding CSS class names for column end values.
+ * @typedef {Record<number, string | null>} EndClassMap
+ */
+const endClassMap = {
+    1: 'col-end-1',
+    2: 'col-end-2',
+    3: 'col-end-3',
+    4: 'col-end-4',
+    5: 'col-end-5',
+    6: 'col-end-6',
+    7: 'col-end-7',
+    8: 'col-end-8',
+    9: 'col-end-9',
+    10: 'col-end-10',
+    11: 'col-end-11',
+    12: 'col-end-12',
+    13: 'col-end-13'
+};
+//Changed the type, to avoid SQ issue.
+//This should be put inside a lib
+/**
+ * Represents a mapping of numbers to CSS class names for starting columns.
+ * @typedef {Record<number, string | null>} StartClassMap
+ */
+const startClassMap = {
+    1: 'col-start-1',
+    2: 'col-start-2',
+    3: 'col-start-3',
+    4: 'col-start-4',
+    5: 'col-start-5',
+    6: 'col-start-6',
+    7: 'col-start-7',
+    8: 'col-start-8',
+    9: 'col-start-9',
+    10: 'col-start-10',
+    11: 'col-start-11',
+    12: 'col-start-12'
+};
+/**
+ * Retrieves the data for a set of containers.
+ *
+ * @param containers - The DotCMSPageAssetContainer object containing the containers.
+ * @param containerRef - The DotCMSContainer object representing the container reference.
+ * @returns An object containing the container data, accept types, contentlets, and variant ID.
+ */
+export const getContainersData = (containers, containerRef) => {
+    const { identifier, uuid } = containerRef;
+    const { containerStructures, container } = containers[identifier];
+    const { variantId } = container?.parentPermissionable || {};
+    const acceptTypes = containerStructures
+        .map((structure) => structure.contentTypeVar)
+        .join(',');
+    // Get the contentlets for "this" container
+    const contentlets = containers[identifier].contentlets[`uuid-${uuid}`] ??
+        containers[identifier].contentlets[`uuid-dotParser_${uuid}`];
+    if (!contentlets) {
+        console.warn(`We couldn't find the contentlets for the container with the identifier ${identifier} and the uuid ${uuid} becareful by adding content to this container.\nWe recommend to change the container in the layout and add the content again.`);
+    }
+    return {
+        ...containers[identifier].container,
+        acceptTypes,
+        contentlets: contentlets ?? [],
+        variantId
+    };
+};
+/**
+ * Returns the position style classes based on the start and end values.
+ * Used to set the grid column start and end values.
+ * @param start - The start value.
+ * @param end - The end value.
+ * @returns An object containing the startClass and endClass.
+ */
+export const getPositionStyleClasses = (start, end) => {
+    const startClass = startClassMap[start];
+    const endClass = endClassMap[end];
+    return {
+        startClass,
+        endClass
+    };
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/next/components/dotcms-block-editor-renderer/blocks/code.component.mjs

@@ -0,0 +1,49 @@
+import { ChangeDetectionStrategy, Component } from '@angular/core';
+import * as i0 from "@angular/core";
+export class DotCodeBlock {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.3", ngImport: i0, type: DotCodeBlock, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.3", type: DotCodeBlock, isStandalone: true, selector: "dotcms-block-editor-renderer-code-block", ngImport: i0, template: `
+        <pre>
+            <code>
+                <ng-content />
+            </code>
+        </pre>
+    `, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.3", ngImport: i0, type: DotCodeBlock, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'dotcms-block-editor-renderer-code-block',
+                    standalone: true,
+                    template: `
+        <pre>
+            <code>
+                <ng-content />
+            </code>
+        </pre>
+    `,
+                    changeDetection: ChangeDetectionStrategy.OnPush
+                }]
+        }] });
+export class DotBlockQuote {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.3", ngImport: i0, type: DotBlockQuote, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.3", type: DotBlockQuote, isStandalone: true, selector: "dotcms-block-editor-renderer-block-quote", ngImport: i0, template: `
+        <blockquote>
+            <ng-content />
+        </blockquote>
+    `, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.3", ngImport: i0, type: DotBlockQuote, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'dotcms-block-editor-renderer-block-quote',
+                    standalone: true,
+                    template: `
+        <blockquote>
+            <ng-content />
+        </blockquote>
+    `,
+                    changeDetection: ChangeDetectionStrategy.OnPush
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29kZS5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL3Nkay9hbmd1bGFyL25leHQvY29tcG9uZW50cy9kb3RjbXMtYmxvY2stZWRpdG9yLXJlbmRlcmVyL2Jsb2Nrcy9jb2RlLmNvbXBvbmVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsdUJBQXVCLEVBQUUsU0FBUyxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQWNuRSxNQUFNLE9BQU8sWUFBWTs4R0FBWixZQUFZO2tHQUFaLFlBQVksbUdBVFg7Ozs7OztLQU1UOzsyRkFHUSxZQUFZO2tCQVp4QixTQUFTO21CQUFDO29CQUNQLFFBQVEsRUFBRSx5Q0FBeUM7b0JBQ25ELFVBQVUsRUFBRSxJQUFJO29CQUNoQixRQUFRLEVBQUU7Ozs7OztLQU1UO29CQUNELGVBQWUsRUFBRSx1QkFBdUIsQ0FBQyxNQUFNO2lCQUNsRDs7QUFhRCxNQUFNLE9BQU8sYUFBYTs4R0FBYixhQUFhO2tHQUFiLGFBQWEsb0dBUFo7Ozs7S0FJVDs7MkZBR1EsYUFBYTtrQkFWekIsU0FBUzttQkFBQztvQkFDUCxRQUFRLEVBQUUsMENBQTBDO29CQUNwRCxVQUFVLEVBQUUsSUFBSTtvQkFDaEIsUUFBUSxFQUFFOzs7O0tBSVQ7b0JBQ0QsZUFBZSxFQUFFLHVCQUF1QixDQUFDLE1BQU07aUJBQ2xEIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ2hhbmdlRGV0ZWN0aW9uU3RyYXRlZ3ksIENvbXBvbmVudCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5AQ29tcG9uZW50KHtcbiAgICBzZWxlY3RvcjogJ2RvdGNtcy1ibG9jay1lZGl0b3ItcmVuZGVyZXItY29kZS1ibG9jaycsXG4gICAgc3RhbmRhbG9uZTogdHJ1ZSxcbiAgICB0ZW1wbGF0ZTogYFxuICAgICAgICA8cHJlPlxuICAgICAgICAgICAgPGNvZGU+XG4gICAgICAgICAgICAgICAgPG5nLWNvbnRlbnQgLz5cbiAgICAgICAgICAgIDwvY29kZT5cbiAgICAgICAgPC9wcmU+XG4gICAgYCxcbiAgICBjaGFuZ2VEZXRlY3Rpb246IENoYW5nZURldGVjdGlvblN0cmF0ZWd5Lk9uUHVzaFxufSlcbmV4cG9ydCBjbGFzcyBEb3RDb2RlQmxvY2sge31cblxuQENvbXBvbmVudCh7XG4gICAgc2VsZWN0b3I6ICdkb3RjbXMtYmxvY2stZWRpdG9yLXJlbmRlcmVyLWJsb2NrLXF1b3RlJyxcbiAgICBzdGFuZGFsb25lOiB0cnVlLFxuICAgIHRlbXBsYXRlOiBgXG4gICAgICAgIDxibG9ja3F1b3RlPlxuICAgICAgICAgICAgPG5nLWNvbnRlbnQgLz5cbiAgICAgICAgPC9ibG9ja3F1b3RlPlxuICAgIGAsXG4gICAgY2hhbmdlRGV0ZWN0aW9uOiBDaGFuZ2VEZXRlY3Rpb25TdHJhdGVneS5PblB1c2hcbn0pXG5leHBvcnQgY2xhc3MgRG90QmxvY2tRdW90ZSB7fVxuIl19