@dotcms/angular 0.0.1-beta.2 → 0.0.1-beta.20

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,6 @@
+export { DotCMSShowWhenDirective } from './directives/dotcms-show-when/dotcms-show-when.directive';
+export { provideDotCMSImageLoader } from './providers/dotcms-image-loader/dotcms-image_loader';
+export { DotCMSEditableTextComponent } from './components/dotcms-editable-text/dotcms-editable-text.component';
+export { DotCMSBlockEditorRendererComponent } from './components/dotcms-block-editor-renderer/dotcms-block-editor-renderer.component';
+export { DotCMSLayoutBodyComponent } from './components/dotcms-layout-body/dotcms-layout-body.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvc2RrL2FuZ3VsYXIvbmV4dC9wdWJsaWNfYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxNQUFNLDBEQUEwRCxDQUFDO0FBRW5HLE9BQU8sRUFBRSx3QkFBd0IsRUFBRSxNQUFNLHFEQUFxRCxDQUFDO0FBRS9GLE9BQU8sRUFBRSwyQkFBMkIsRUFBRSxNQUFNLGtFQUFrRSxDQUFDO0FBRS9HLE9BQU8sRUFBRSxrQ0FBa0MsRUFBRSxNQUFNLGtGQUFrRixDQUFDO0FBRXRJLE9BQU8sRUFBRSx5QkFBeUIsRUFBRSxNQUFNLDhEQUE4RCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgRG90Q01TU2hvd1doZW5EaXJlY3RpdmUgfSBmcm9tICcuL2RpcmVjdGl2ZXMvZG90Y21zLXNob3ctd2hlbi9kb3RjbXMtc2hvdy13aGVuLmRpcmVjdGl2ZSc7XG5cbmV4cG9ydCB7IHByb3ZpZGVEb3RDTVNJbWFnZUxvYWRlciB9IGZyb20gJy4vcHJvdmlkZXJzL2RvdGNtcy1pbWFnZS1sb2FkZXIvZG90Y21zLWltYWdlX2xvYWRlcic7XG5cbmV4cG9ydCB7IERvdENNU0VkaXRhYmxlVGV4dENvbXBvbmVudCB9IGZyb20gJy4vY29tcG9uZW50cy9kb3RjbXMtZWRpdGFibGUtdGV4dC9kb3RjbXMtZWRpdGFibGUtdGV4dC5jb21wb25lbnQnO1xuXG5leHBvcnQgeyBEb3RDTVNCbG9ja0VkaXRvclJlbmRlcmVyQ29tcG9uZW50IH0gZnJvbSAnLi9jb21wb25lbnRzL2RvdGNtcy1ibG9jay1lZGl0b3ItcmVuZGVyZXIvZG90Y21zLWJsb2NrLWVkaXRvci1yZW5kZXJlci5jb21wb25lbnQnO1xuXG5leHBvcnQgeyBEb3RDTVNMYXlvdXRCb2R5Q29tcG9uZW50IH0gZnJvbSAnLi9jb21wb25lbnRzL2RvdGNtcy1sYXlvdXQtYm9keS9kb3RjbXMtbGF5b3V0LWJvZHkuY29tcG9uZW50JztcbiJdfQ==

package/esm2022/next/store/dotcms.store.mjs

@@ -0,0 +1,61 @@
+import { computed, Injectable, signal } from '@angular/core';
+import { getUVEState } from '@dotcms/uve';
+import { DEVELOPMENT_MODE, PRODUCTION_MODE } from '@dotcms/uve/internal';
+import { UVE_MODE } from '@dotcms/uve/types';
+import * as i0 from "@angular/core";
+export const EMPTY_DOTCMS_PAGE_STORE = {
+    page: {},
+    components: {},
+    mode: PRODUCTION_MODE
+};
+/**
+ * @description This service is responsible for managing the page context.
+ * @internal
+ * @author dotCMS
+ * @export
+ * @class DotCMSStore
+ */
+export class DotCMSStore {
+    constructor() {
+        this.$store = signal(EMPTY_DOTCMS_PAGE_STORE);
+        /**
+         * @description Get if the current context is in development mode
+         * @readonly
+         * @type {boolean}
+         * @memberof DotCMSStore
+         */
+        this.$isDevMode = computed(() => {
+            const uveState = getUVEState();
+            if (uveState?.mode) {
+                return uveState?.mode === UVE_MODE.EDIT;
+            }
+            return this.$store()?.mode === DEVELOPMENT_MODE;
+        });
+    }
+    /**
+     * @description Get the store
+     * @readonly
+     * @type {DotCMSPageStore}
+     * @memberof DotCMSStore
+     */
+    get store() {
+        return this.$store();
+    }
+    /**
+     * @description Set the store
+     * @param {DotCMSPageStore} value
+     * @memberof DotCMSStore
+     */
+    setStore(store) {
+        this.$store.set(store);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.3", ngImport: i0, type: DotCMSStore, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.3", ngImport: i0, type: DotCMSStore, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.3", ngImport: i0, type: DotCMSStore, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/public_api.mjs

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