@ethlete/contentful 2.1.2 → 3.0.0

package/esm2022/lib/components/rich-text-renderer/rich-text-renderer.component.mjs

@@ -1,100 +1,693 @@
-import { ComponentPortal, DomPortalOutlet } from '@angular/cdk/portal';
 import { DOCUMENT } from '@angular/common';
-import { ApplicationRef, ChangeDetectionStrategy, Component, ComponentFactoryResolver, ElementRef, Injector, Input, Renderer2, ViewEncapsulation, inject, } from '@angular/core';
+import { ChangeDetectionStrategy, Component, ElementRef, Renderer2, ViewContainerRef, ViewEncapsulation, computed, inject, input, } from '@angular/core';
+import { takeUntilDestroyed, toObservable, toSignal } from '@angular/core/rxjs-interop';
+import { BLOCKS, INLINES } from '@contentful/rich-text-types';
+import { getObjectProperty, isObject } from '@ethlete/core';
+import { pairwise, startWith, tap } from 'rxjs';
 import { CONTENTFUL_CONFIG } from '../../constants/contentful.constants';
 import { createContentfulConfig } from '../../utils/contentful-config';
-import { ContentfulImageComponent } from '../image';
-import { RICH_TEXT_RENDERER_COMPONENT_DATA } from './rich-text-renderer.constants';
-import { createRenderCommandsFromContentfulRichText } from './rich-text-renderer.util';
+import { richTextRendererError } from './rich-text-renderer.errors';
+import { isRichTextRootNode, translateContentfulNodeTypeToHtmlTag } from './rich-text-renderer.util';
 import * as i0 from "@angular/core";
+export const RENDER_COMMAND_TYPE = {
+    HTML_OPEN: 0,
+    HTML_CLOSE: 1,
+    TEXT: 2,
+    COMPONENT: 3,
+};
+export const RENDER_COMMAND_POSITION = {
+    TYPE: 0,
+    NESTING_LEVEL: 1,
+    DOM_POSITION: 2,
+    INDEX: 3,
+};
+export const HTML_OPEN_RENDER_COMMAND_POSITION = {
+    ATTRIBUTES: 4,
+    TAG_NAME: 5,
+    ELEMENT_ID: 6,
+};
+export const HTML_CLOSE_RENDER_COMMAND_POSITION = {
+    TAG_NAME: 4,
+    ELEMENT_ID: 5,
+};
+export const TEXT_RENDER_COMMAND_POSITION = {
+    TEXT: 4,
+};
+export const COMPONENT_RENDER_COMMAND_POSITION = {
+    ATTRIBUTES: 4,
+    COMPONENT: 5,
+    INPUTS: 6,
+    COMPONENT_TYPE: 7,
+};
+export const RENDER_INSTRUCTION_POSITION = {
+    TYPE: 0,
+    COMMAND: 1,
+};
+export const RENDER_INSTRUCTION_TYPE = {
+    CREATE: 0,
+    UPDATE: 1,
+    DELETE: 2,
+    MOVE: 3,
+};
+const MARK_TAILWIND_MAP = {
+    bold: 'font-bold',
+    italic: 'italic',
+    underline: 'underline',
+    code: 'font-mono',
+};
+export const marksToClass = (marks) => {
+    const classes = [];
+    for (const mark of marks) {
+        let klass = MARK_TAILWIND_MAP[mark.type];
+        if (!klass) {
+            console.warn(`No class found for mark type! Falling back to "${mark.type}".`, mark);
+            klass = mark.type;
+        }
+        classes.push(klass);
+    }
+    return classes.join(' ');
+};
+export const isHtmlOpenRenderCommand = (command) => {
+    return command[RENDER_COMMAND_POSITION.TYPE] === RENDER_COMMAND_TYPE.HTML_OPEN;
+};
+export const isHtmlCloseRenderCommand = (command) => {
+    return command[RENDER_COMMAND_POSITION.TYPE] === RENDER_COMMAND_TYPE.HTML_CLOSE;
+};
+export const isTextRenderCommand = (command) => {
+    return command[RENDER_COMMAND_POSITION.TYPE] === RENDER_COMMAND_TYPE.TEXT;
+};
+export const isComponentRenderCommand = (command) => {
+    return command[RENDER_COMMAND_POSITION.TYPE] === RENDER_COMMAND_TYPE.COMPONENT;
+};
+export const getRenderCommandId = (command) => {
+    if (isHtmlOpenRenderCommand(command)) {
+        return command[HTML_OPEN_RENDER_COMMAND_POSITION.ELEMENT_ID];
+    }
+    else if (isHtmlCloseRenderCommand(command)) {
+        return command[HTML_CLOSE_RENDER_COMMAND_POSITION.ELEMENT_ID];
+    }
+    else if (isTextRenderCommand(command)) {
+        return command[TEXT_RENDER_COMMAND_POSITION.TEXT];
+    }
+    else {
+        return command[COMPONENT_RENDER_COMMAND_POSITION.COMPONENT_TYPE];
+    }
+};
+const CLASS_ATTR = 'class';
+const DEFAULT_COMPONENT_TYPES = {
+    IMAGE: '$$$_et-image',
+    VIDEO: '$$$_et-video',
+    AUDIO: '$$$_et-audio',
+    FILE: '$$$_et-file',
+};
+export const isExecutedComponentCommandCacheItem = (cache) => {
+    return isComponentRenderCommand(cache.command);
+};
+export const isExecutedHtmlOrTextCommandCacheItem = (cache) => {
+    return isHtmlCloseRenderCommand(cache.command) || isHtmlOpenRenderCommand(cache.command);
+};
+export const isExecutedTextCommandCacheItem = (cache) => {
+    return isTextRenderCommand(cache.command);
+};
 export class ContentfulRichTextRendererComponent {
     constructor() {
-        this._richText = null;
+        this._viewContainerRef = inject(ViewContainerRef);
         this._renderer = inject(Renderer2);
         this._elementRef = inject(ElementRef);
-        this._componentFactoryResolver = inject(ComponentFactoryResolver);
         this._document = inject(DOCUMENT);
-        this._appRef = inject(ApplicationRef);
-        this._injector = inject(Injector);
         this._config = inject(CONTENTFUL_CONFIG, { optional: true }) ?? createContentfulConfig();
+        /**
+         * A cache for all executed commands that are not deleted.
+         * This is used to keep track of all rendered elements and components.
+         * The key is the render command element ID.
+         */
+        this._executedCommandsCache = new Map();
+        /**
+         * The contentful response gotten via their REST api.
+         * @see https://www.contentful.com/developers/docs/references/content-delivery-api/#/reference/entries/entries-collection
+         */
+        this.content = input.required();
+        /**
+         * The path to where the rich text field is inside the contentful response. Dot and array notation is allowed.
+         * @default "items[0].fields.html"
+         */
+        this.richTextPath = input.required();
+        /**
+         * A map of all includes in the contentful response.
+         * This is useful for looking up assets and entries that are referenced in the rich text without having to use loops.
+         */
+        this.contentIncludesMap = computed(() => {
+            const content = this.content();
+            const assets = content?.includes.Asset;
+            const entries = content?.includes.Entry;
+            return {
+                assets: assets?.reduce((acc, asset) => {
+                    acc[asset.sys.id] = asset;
+                    return acc;
+                }, {}) ?? {},
+                entries: entries?.reduce((acc, entry) => {
+                    acc[entry.sys.id] = entry;
+                    return acc;
+                }, {}) ?? {},
+            };
+        });
+        /**
+         * The rich text data that should be rendered.
+         */
+        this.richTextData = computed(() => {
+            const content = this.content();
+            const richTextPath = this.richTextPath();
+            if (!content) {
+                return null;
+            }
+            const richText = getObjectProperty(content, richTextPath);
+            if (!isObject(richText)) {
+                throw richTextRendererError('rich_text_undefined', false, { content, richTextPath });
+            }
+            if (!isRichTextRootNode(richText)) {
+                throw richTextRendererError('rich_text_wrong_type', false, { content, richTextPath });
+            }
+            return richText;
+        });
+        this.renderCommands = computed(() => {
+            const richTextData = this.richTextData();
+            if (!richTextData) {
+                return [];
+            }
+            return this._createRenderCommands(richTextData);
+        });
+        this.renderCommandHistory = toSignal(toObservable(this.renderCommands).pipe(startWith([]), pairwise()), { initialValue: [[], []] });
+        this.previousRenderCommandMap = computed(() => {
+            const [prevCommands] = this.renderCommandHistory();
+            const map = new Map();
+            for (const command of prevCommands) {
+                map.set(getRenderCommandId(command), command);
+            }
+            return map;
+        });
+        this.renderInstructions = computed(() => {
+            const commands = this.renderCommands();
+            const previousRenderCommandMap = new Map(this.previousRenderCommandMap());
+            const instructions = [];
+            // remove deleted components as well as all other elements
+            for (const [, command] of previousRenderCommandMap) {
+                if (isComponentRenderCommand(command)) {
+                    // keep the component around if it's still in the new commands
+                    if (commands.some((c) => getRenderCommandId(c) === getRenderCommandId(command))) {
+                        continue;
+                    }
+                }
+                instructions.push([RENDER_INSTRUCTION_TYPE.DELETE, command]);
+                // remove from map to mark as used
+                previousRenderCommandMap.delete(getRenderCommandId(command));
+            }
+            // Find the indexes of the commands remaining in the previousRenderCommandMap in the new commands array.
+            const lastComponentIndexes = [];
+            for (const [id, command] of previousRenderCommandMap) {
+                const index = commands.findIndex((c) => getRenderCommandId(c) === id);
+                const newCommand = commands[index];
+                if (index === -1) {
+                    throw new Error('Command not found!');
+                }
+                lastComponentIndexes.push({
+                    newIndex: index,
+                    prevIndex: command[RENDER_COMMAND_POSITION.INDEX],
+                    command: newCommand,
+                });
+            }
+            lastComponentIndexes.sort((a, b) => a.newIndex - b.newIndex);
+            // check if the prevIndex are in order ascending
+            // for indexes that are not in order, create a move instruction
+            // for indexes that are in order, create an update instruction
+            let moveCheckIndex = 0;
+            while (moveCheckIndex < lastComponentIndexes.length - 1) {
+                const moveCurr = lastComponentIndexes[moveCheckIndex];
+                const moveNext = lastComponentIndexes[moveCheckIndex + 1];
+                if (!moveCurr || !moveNext) {
+                    break;
+                }
+                if (moveCurr.prevIndex > moveNext.prevIndex) {
+                    lastComponentIndexes.splice(moveCheckIndex + 1, 1);
+                    instructions.push([RENDER_INSTRUCTION_TYPE.MOVE, moveNext.command]);
+                }
+                else {
+                    instructions.push([RENDER_INSTRUCTION_TYPE.UPDATE, moveNext.command]);
+                    moveCheckIndex++;
+                }
+            }
+            for (const command of commands) {
+                const id = getRenderCommandId(command);
+                if (isComponentRenderCommand(command)) {
+                    const previousCommand = previousRenderCommandMap.get(id);
+                    if (!previousCommand) {
+                        // create
+                        instructions.push([RENDER_INSTRUCTION_TYPE.CREATE, command]);
+                    }
+                }
+                else {
+                    // create
+                    instructions.push([RENDER_INSTRUCTION_TYPE.CREATE, command]);
+                }
+            }
+            return instructions;
+        });
+        toObservable(this.renderInstructions)
+            .pipe(takeUntilDestroyed(), tap((instructions) => {
+            this._execInstructions(instructions);
+        }))
+            .subscribe();
+    }
+    _createRenderCommands(richTextData) {
+        /** List of all render commands */
+        const rootCommands = [];
+        /** Counter for generating unique html element IDs. */
+        let elementId = 0;
+        /** Counter for generating unique component IDs. */
+        const componentIdMap = new Map();
+        /** The nesting level of the current node. */
+        let nestingLevel = 0;
+        /** The position (index) of the current node inside the parent node. */
+        let domPosition = 0;
+        let commandIndex = 0;
+        const traverse = (node, parent = null) => {
+            switch (node.nodeType) {
+                case 'text': {
+                    // Render media
+                    const type = RENDER_COMMAND_TYPE.TEXT;
+                    const text = node.value;
+                    if (!text)
+                        break;
+                    const command = [type, nestingLevel, domPosition, commandIndex++, text];
+                    rootCommands.push(command);
+                    domPosition++;
+                    if (!parent) {
+                        throw richTextRendererError('text_parent_not_found', false, { node });
+                    }
+                    if (!isHtmlOpenRenderCommand(parent) && !isComponentRenderCommand(parent)) {
+                        throw richTextRendererError('text_parent_wrong_type', false, { node, parent });
+                    }
+                    const attributesPosition = parent[RENDER_COMMAND_POSITION.TYPE] === RENDER_COMMAND_TYPE.HTML_OPEN
+                        ? HTML_OPEN_RENDER_COMMAND_POSITION.ATTRIBUTES
+                        : COMPONENT_RENDER_COMMAND_POSITION.ATTRIBUTES;
+                    const attributes = parent[attributesPosition];
+                    if (node.marks.length) {
+                        const markClasses = marksToClass(node.marks);
+                        if (CLASS_ATTR in attributes) {
+                            attributes[CLASS_ATTR] += ` ${markClasses}`;
+                        }
+                        else {
+                            attributes[CLASS_ATTR] = markClasses;
+                        }
+                    }
+                    break;
+                }
+                case BLOCKS.EMBEDDED_ASSET: {
+                    // Render media
+                    const type = RENDER_COMMAND_TYPE.COMPONENT;
+                    const assetId = node.data['target']?.sys?.id;
+                    if (!assetId) {
+                        throw richTextRendererError('asset_id_not_found', false, { node });
+                    }
+                    const asset = this.contentIncludesMap().assets[assetId];
+                    if (!asset) {
+                        throw richTextRendererError('asset_not_found', false, { assetId, node });
+                    }
+                    const contentType = asset.fields.file.contentType;
+                    const assetComponents = this._config.components;
+                    const isImage = contentType.startsWith('image/');
+                    const isVideo = contentType.startsWith('video/');
+                    const isAudio = contentType.startsWith('audio/');
+                    const component = isImage
+                        ? assetComponents.image
+                        : isVideo
+                            ? assetComponents.video
+                            : isAudio
+                                ? assetComponents.audio
+                                : assetComponents.file;
+                    const componentType = isImage
+                        ? DEFAULT_COMPONENT_TYPES.IMAGE
+                        : isVideo
+                            ? DEFAULT_COMPONENT_TYPES.VIDEO
+                            : isAudio
+                                ? DEFAULT_COMPONENT_TYPES.AUDIO
+                                : DEFAULT_COMPONENT_TYPES.FILE;
+                    let componentId = componentIdMap.get(componentType) ?? -1;
+                    const id = componentType + ++componentId;
+                    componentIdMap.set(componentType, componentId);
+                    const attributes = {};
+                    const inputs = {
+                        asset,
+                    };
+                    const command = [
+                        type,
+                        nestingLevel,
+                        domPosition,
+                        commandIndex++,
+                        attributes,
+                        component,
+                        inputs,
+                        id,
+                    ];
+                    rootCommands.push(command);
+                    domPosition++;
+                    break;
+                }
+                case BLOCKS.EMBEDDED_ENTRY:
+                case INLINES.EMBEDDED_ENTRY: {
+                    // Render component
+                    const type = RENDER_COMMAND_TYPE.COMPONENT;
+                    const entryId = node.data['target']?.sys?.id;
+                    if (!entryId) {
+                        throw richTextRendererError('entry_id_not_found', false, { node });
+                    }
+                    const entry = this.contentIncludesMap().entries[entryId];
+                    if (!entry) {
+                        throw richTextRendererError('entry_not_found', false, { entryId, node });
+                    }
+                    const componentType = entry.sys.contentType.sys.id;
+                    const component = this._config.customComponents[componentType];
+                    if (!component) {
+                        throw richTextRendererError('custom_component_not_found', false, {
+                            componentType,
+                            customComponents: this._config.customComponents,
+                            entry,
+                        });
+                    }
+                    const attributes = {};
+                    let componentId = componentIdMap.get(componentType) ?? -1;
+                    const id = componentType + ++componentId;
+                    componentIdMap.set(componentType, componentId);
+                    const inputs = {
+                        fields: entry.fields,
+                        metadata: entry.metadata,
+                        sys: entry.sys,
+                        includes: this.contentIncludesMap(),
+                    };
+                    const command = [
+                        type,
+                        nestingLevel,
+                        domPosition,
+                        commandIndex++,
+                        attributes,
+                        component,
+                        inputs,
+                        id,
+                    ];
+                    rootCommands.push(command);
+                    domPosition++;
+                    break;
+                }
+                default: {
+                    const type = RENDER_COMMAND_TYPE.HTML_OPEN;
+                    const tag = translateContentfulNodeTypeToHtmlTag(node.nodeType);
+                    const attributes = {};
+                    const id = 'e' + elementId++;
+                    const command = [type, nestingLevel, domPosition, commandIndex++, attributes, tag, id];
+                    rootCommands.push(command);
+                    const domPositionAtThisLevel = domPosition;
+                    // Normal html elements can have children
+                    for (const child of node.content) {
+                        domPosition = 0;
+                        nestingLevel++;
+                        traverse(child, command);
+                        nestingLevel--;
+                        domPosition = domPositionAtThisLevel;
+                    }
+                    const lastCommand = rootCommands[rootCommands.length - 1];
+                    if (lastCommand?.[RENDER_COMMAND_POSITION.TYPE] === RENDER_COMMAND_TYPE.HTML_OPEN) {
+                        // If the last command is an open command, we can remove it since it's empty
+                        rootCommands.pop();
+                    }
+                    else {
+                        const closeId = 'e' + elementId++;
+                        const closeCommand = [
+                            RENDER_COMMAND_TYPE.HTML_CLOSE,
+                            nestingLevel,
+                            domPosition,
+                            commandIndex++,
+                            tag,
+                            closeId,
+                        ];
+                        rootCommands.push(closeCommand);
+                        domPosition++;
+                    }
+                    if (node.nodeType === INLINES.HYPERLINK) {
+                        const uri = node.data['uri'];
+                        attributes['href'] = uri;
+                        const host = this._document.location.host;
+                        const isExternal = !uri.includes(host);
+                        if (isExternal) {
+                            attributes['target'] = '_blank';
+                        }
+                    }
+                    break;
+                }
+            }
+        };
+        for (const node of richTextData.content) {
+            traverse(node, null);
+        }
+        return rootCommands;
+    }
+    _execInstructions(instructions) {
+        for (const instruction of instructions) {
+            const type = instruction[RENDER_INSTRUCTION_POSITION.TYPE];
+            const command = instruction[RENDER_INSTRUCTION_POSITION.COMMAND];
+            switch (type) {
+                case RENDER_INSTRUCTION_TYPE.CREATE:
+                    this._runCreateInstruction(command);
+                    break;
+                case RENDER_INSTRUCTION_TYPE.UPDATE:
+                    this._runUpdateInstruction(command);
+                    break;
+                case RENDER_INSTRUCTION_TYPE.MOVE:
+                    this._runMoveInstruction(command);
+                    break;
+                case RENDER_INSTRUCTION_TYPE.DELETE:
+                    this._runDeleteInstruction(command);
+                    break;
+            }
+        }
     }
-    get richText() {
-        return this._richText;
+    _runCreateInstruction(command) {
+        const id = getRenderCommandId(command);
+        const parentElement = this._findParent(command);
+        const nextElement = this._findFollowingElement(command);
+        if (isComponentRenderCommand(command)) {
+            const componentRef = this._viewContainerRef.createComponent(command[COMPONENT_RENDER_COMMAND_POSITION.COMPONENT]);
+            this._updateComponentInputs(command, componentRef);
+            const rootNode = this._getComponentRootNode(componentRef);
+            this._renderInsertOrAppend(rootNode, parentElement, nextElement);
+            this._executedCommandsCache.set(id, {
+                command,
+                componentRef,
+                element: rootNode,
+            });
+        }
+        else if (isTextRenderCommand(command)) {
+            const text = command[TEXT_RENDER_COMMAND_POSITION.TEXT];
+            const textNode = this._renderer.createText(text);
+            const span = this._renderer.createElement('span');
+            this._renderer.appendChild(span, textNode);
+            this._renderInsertOrAppend(span, parentElement, nextElement);
+            this._executedCommandsCache.set(id, {
+                command,
+                element: span,
+                textNode,
+            });
+        }
+        else if (isHtmlOpenRenderCommand(command)) {
+            const tag = command[HTML_OPEN_RENDER_COMMAND_POSITION.TAG_NAME];
+            const attributes = command[HTML_OPEN_RENDER_COMMAND_POSITION.ATTRIBUTES];
+            const element = this._renderer.createElement(tag);
+            for (const [key, value] of Object.entries(attributes)) {
+                this._renderer.setAttribute(element, key, value);
+            }
+            this._renderInsertOrAppend(element, parentElement, nextElement);
+            this._executedCommandsCache.set(id, {
+                command,
+                element,
+            });
+        }
     }
-    set richText(v) {
-        this._richText = v ?? null;
-        this.resetAndRender();
+    _runUpdateInstruction(command) {
+        const id = getRenderCommandId(command);
+        const cached = this._executedCommandsCache.get(id);
+        if (!cached) {
+            throw new Error('Cached command not found!');
+        }
+        if (isComponentRenderCommand(command)) {
+            if (!isExecutedComponentCommandCacheItem(cached)) {
+                throw new Error('Cached command is not a component command!');
+            }
+            const componentRef = cached.componentRef;
+            if (!componentRef) {
+                throw new Error('Component ref not found!');
+            }
+            this._updateComponentInputs(command, componentRef);
+        }
+        this._executedCommandsCache.set(id, {
+            ...cached,
+            command: command,
+        });
     }
-    resetAndRender() {
-        // clear childNodes to prevent appending new richtext elements to existing one
-        const childElements = this._elementRef.nativeElement.childNodes;
-        for (const child of childElements) {
-            this._renderer.removeChild(this._elementRef.nativeElement, child);
+    _runMoveInstruction(command) {
+        const id = getRenderCommandId(command);
+        const cached = this._executedCommandsCache.get(id);
+        if (!cached) {
+            throw new Error('Cached command not found!');
         }
-        if (!this._richText) {
-            return;
+        if (isComponentRenderCommand(command)) {
+            if (!isExecutedComponentCommandCacheItem(cached)) {
+                throw new Error('Cached command is not a component command!');
+            }
+            const componentRef = cached.componentRef;
+            if (!componentRef) {
+                throw new Error('Component ref not found!');
+            }
+            const rootNode = cached.element;
+            const oldParentElement = cached.element.parentElement;
+            this._renderer.removeChild(oldParentElement, rootNode);
+            const newParentElement = this._findParent(command);
+            const nextElement = this._findFollowingElement(command);
+            this._renderInsertOrAppend(rootNode, newParentElement, nextElement);
+            this._updateComponentInputs(command, componentRef);
+            this._executedCommandsCache.set(id, {
+                ...cached,
+                command: command,
+            });
         }
-        const commands = createRenderCommandsFromContentfulRichText({ data: this._richText, config: this._config });
-        this._render(commands);
     }
-    _render(commands) {
-        // create a document fragment to hold the elements while we create them
-        const fragment = document.createDocumentFragment();
-        const hostCommand = {
-            payload: 'document',
-            children: commands,
-        };
-        // loop over the commands
-        this._executeCommand({ command: hostCommand, parent: fragment });
-        // append the fragment to the host element
-        this._renderer.appendChild(this._elementRef.nativeElement, fragment);
-    }
-    _executeCommand(data) {
-        const { command, parent } = data;
-        let element = null;
-        if (command.payload !== 'document') {
-            if (typeof command.payload === 'string') {
-                element = this._renderer.createElement(command.payload);
-                if (command.data) {
-                    this._renderer.setProperty(element, 'innerText', command.data);
-                }
-                if (command.attributes) {
-                    for (const [name, value] of Object.entries(command.attributes)) {
-                        this._renderer.setAttribute(element, name, value);
-                    }
+    _runDeleteInstruction(command) {
+        const id = getRenderCommandId(command);
+        const cached = this._executedCommandsCache.get(id);
+        if (!cached) {
+            if (isHtmlCloseRenderCommand(command)) {
+                return;
+            }
+            throw new Error('Cached command not found!');
+        }
+        if (isComponentRenderCommand(command)) {
+            if (!isExecutedComponentCommandCacheItem(cached)) {
+                throw new Error('Cached command is not a component command!');
+            }
+            cached.componentRef?.destroy();
+        }
+        else if (isTextRenderCommand(command)) {
+            this._renderer.removeChild(cached.element?.parentElement, cached.element);
+        }
+        else if (isHtmlOpenRenderCommand(command)) {
+            this._renderer.removeChild(cached.element?.parentElement, cached.element);
+        }
+        this._executedCommandsCache.delete(id);
+    }
+    _getComponentRootNode(componentRef) {
+        return componentRef.hostView.rootNodes[0];
+    }
+    _updateComponentInputs(command, componentRef) {
+        for (const [key, value] of Object.entries(command[COMPONENT_RENDER_COMMAND_POSITION.INPUTS])) {
+            if (!componentRef.instance[key])
+                continue;
+            componentRef.setInput(key, value);
+        }
+    }
+    _findParent(command) {
+        const hostElement = this._elementRef.nativeElement;
+        const nestingLevel = command[RENDER_COMMAND_POSITION.NESTING_LEVEL];
+        let parentElement = undefined;
+        if (nestingLevel === 0) {
+            parentElement = hostElement;
+        }
+        else {
+            // Reverse search all render commands beginning from the current one using a for loop.
+            // The parent is found when the command's nesting level ist the same as the current nesting level minus 1.
+            // If the parent is not found, throw an error.
+            const allCommands = this.renderCommands();
+            const currentCommandIndex = command[RENDER_COMMAND_POSITION.INDEX];
+            let parentCommand = null;
+            for (let i = currentCommandIndex - 1; i >= 0; i--) {
+                const cmd = allCommands[i];
+                if (!cmd) {
+                    throw new Error('Command not found!');
                 }
-                this._renderer.appendChild(parent, element);
-            }
-            else {
-                const injector = Injector.create({
-                    providers: [
-                        {
-                            provide: RICH_TEXT_RENDERER_COMPONENT_DATA,
-                            useValue: command.data,
-                        },
-                    ],
-                    parent: this._injector,
-                });
-                const portal = new DomPortalOutlet(parent, this._componentFactoryResolver, this._appRef, injector, this._document);
-                const comp = new ComponentPortal(command.payload);
-                const ref = comp.attach(portal);
-                if (ref.instance instanceof ContentfulImageComponent) {
-                    ref.instance.sizes = this._config.imageOptions.sizes;
-                    ref.instance.srcsetSizes = this._config.imageOptions.srcsetSizes;
-                    ref.instance.backgroundColor = this._config.imageOptions.backgroundColor;
+                if (cmd[RENDER_COMMAND_POSITION.NESTING_LEVEL] === nestingLevel - 1) {
+                    parentCommand = cmd;
+                    break;
                 }
-                element = ref.location.nativeElement;
+            }
+            if (!parentCommand) {
+                throw new Error('Parent command not found!');
+            }
+            parentElement = this._executedCommandsCache.get(getRenderCommandId(parentCommand))?.element;
+        }
+        if (!parentElement) {
+            throw new Error('Parent element not found!');
+        }
+        return parentElement;
+    }
+    _findFollowingElement(command) {
+        const cacheArray = Array.from(this._executedCommandsCache.values());
+        let nextElement = undefined;
+        const domPosition = command[RENDER_COMMAND_POSITION.DOM_POSITION];
+        const nestingLevel = command[RENDER_COMMAND_POSITION.NESTING_LEVEL];
+        const type = command[RENDER_COMMAND_POSITION.TYPE];
+        //  Try to find an already rendered element with a domPosition that is greater than the current domPosition. If there are multiple, use the one with the smallest domPosition.
+        // If it does not exist, use .appendChild to simply append the element to the end of the parent element.
+        // If it does exist, use .insertBefore to insert the element before the found element.
+        for (const cached of cacheArray) {
+            if (cached.command[RENDER_COMMAND_POSITION.DOM_POSITION] > domPosition &&
+                cached.command[RENDER_COMMAND_POSITION.NESTING_LEVEL] === nestingLevel &&
+                // Make sure the element does not find itself
+                cached.command[RENDER_COMMAND_POSITION.TYPE] !== type) {
+                nextElement = cached.element;
+                break;
             }
         }
-        // loop over the commands
-        for (const childCommand of command.children) {
-            this._executeCommand({ command: childCommand, parent: element ?? parent });
+        return nextElement;
+    }
+    _renderInsertOrAppend(nodeToRender, parentElement, nextElement) {
+        if (nextElement) {
+            this._renderer.insertBefore(parentElement, nodeToRender, nextElement);
+        }
+        else {
+            this._renderer.appendChild(parentElement, nodeToRender);
         }
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.0", ngImport: i0, type: ContentfulRichTextRendererComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.0", type: ContentfulRichTextRendererComponent, isStandalone: true, selector: "et-contentful-rich-text-renderer", inputs: { richText: "richText" }, host: { classAttribute: "et-contentful-rich-text-renderer" }, ngImport: i0, template: ``, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+    _debugVisualizeRenderCommands(commands) {
+        const debug = commands.map((command) => this._stringifyRenderCommand(command)).flat();
+        const prettified = formatHTML(debug);
+        return prettified;
+    }
+    _stringifyRenderCommand(command) {
+        const nestAttr = `nest="${command[RENDER_COMMAND_POSITION.NESTING_LEVEL]}"`;
+        const domAttr = `dom="${command[RENDER_COMMAND_POSITION.DOM_POSITION]}"`;
+        if (isHtmlOpenRenderCommand(command)) {
+            return `<${command[HTML_OPEN_RENDER_COMMAND_POSITION.TAG_NAME]} ${nestAttr} ${domAttr}>`;
+        }
+        else if (isHtmlCloseRenderCommand(command)) {
+            return `</${command[HTML_CLOSE_RENDER_COMMAND_POSITION.TAG_NAME]} ${nestAttr} ${domAttr}>`;
+        }
+        else if (isTextRenderCommand(command)) {
+            return [`<span ${nestAttr} ${domAttr}>`, command[TEXT_RENDER_COMMAND_POSITION.TEXT], '</span>'];
+        }
+        else if (isComponentRenderCommand(command)) {
+            const selector = command[COMPONENT_RENDER_COMMAND_POSITION.COMPONENT_TYPE];
+            return [`<${selector} ${nestAttr} ${domAttr}>`, `</${selector}>`];
+        }
+        else {
+            return 'UNKNOWN';
+        }
+    }
+    _stringifyRenderInstruction(instruction) {
+        const type = instruction[RENDER_INSTRUCTION_POSITION.TYPE];
+        const translatedType = Object.entries(RENDER_INSTRUCTION_TYPE).find(([, value]) => value === type)?.[0];
+        const command = this._stringifyRenderCommand(instruction[RENDER_INSTRUCTION_POSITION.COMMAND]);
+        return `${translatedType}: ${command}`;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: ContentfulRichTextRendererComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "17.3.3", type: ContentfulRichTextRendererComponent, isStandalone: true, selector: "et-contentful-rich-text-renderer", inputs: { content: { classPropertyName: "content", publicName: "content", isSignal: true, isRequired: true, transformFunction: null }, richTextPath: { classPropertyName: "richTextPath", publicName: "richTextPath", isSignal: true, isRequired: true, transformFunction: null } }, host: { classAttribute: "et-contentful-rich-text-renderer" }, ngImport: i0, template: ``, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.0", ngImport: i0, type: ContentfulRichTextRendererComponent, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: ContentfulRichTextRendererComponent, decorators: [{
             type: Component,
             args: [{
                     selector: 'et-contentful-rich-text-renderer',
@@ -106,7 +699,19 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.0", ngImpor
                         class: 'et-contentful-rich-text-renderer',
                     },
                 }]
-        }], propDecorators: { richText: [{
-                type: Input
-            }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rich-text-renderer.component.js","sourceRoot":"","sources":["../../../../../../../libs/contentful/src/lib/components/rich-text-renderer/rich-text-renderer.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { ComponentPortal, DomPortalOutlet } from '@angular/cdk/portal';\nimport { DOCUMENT } from '@angular/common';\nimport {\n  ApplicationRef,\n  ChangeDetectionStrategy,\n  Component,\n  ComponentFactoryResolver,\n  ElementRef,\n  Injector,\n  Input,\n  Renderer2,\n  ViewEncapsulation,\n  inject,\n} from '@angular/core';\nimport { CONTENTFUL_CONFIG } from '../../constants/contentful.constants';\nimport { RichTextResponse } from '../../types';\nimport { createContentfulConfig } from '../../utils/contentful-config';\nimport { ContentfulImageComponent } from '../image';\nimport { RICH_TEXT_RENDERER_COMPONENT_DATA } from './rich-text-renderer.constants';\nimport { RichTextRenderCommand } from './rich-text-renderer.types';\nimport { createRenderCommandsFromContentfulRichText } from './rich-text-renderer.util';\n\n@Component({\n  selector: 'et-contentful-rich-text-renderer',\n  template: ``,\n  encapsulation: ViewEncapsulation.None,\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  standalone: true,\n  host: {\n    class: 'et-contentful-rich-text-renderer',\n  },\n})\nexport class ContentfulRichTextRendererComponent {\n  @Input()\n  get richText() {\n    return this._richText;\n  }\n  set richText(v: RichTextResponse | null | undefined) {\n    this._richText = v ?? null;\n\n    this.resetAndRender();\n  }\n  private _richText: RichTextResponse | null = null;\n\n  private _renderer = inject(Renderer2);\n  private _elementRef = inject(ElementRef);\n  private _componentFactoryResolver = inject(ComponentFactoryResolver);\n  private _document = inject<Document>(DOCUMENT);\n  private _appRef = inject(ApplicationRef);\n  private _injector = inject(Injector);\n  private _config = inject(CONTENTFUL_CONFIG, { optional: true }) ?? createContentfulConfig();\n\n  resetAndRender() {\n    // clear childNodes to prevent appending new richtext elements to existing one\n    const childElements = this._elementRef.nativeElement.childNodes;\n    for (const child of childElements) {\n      this._renderer.removeChild(this._elementRef.nativeElement, child);\n    }\n\n    if (!this._richText) {\n      return;\n    }\n\n    const commands = createRenderCommandsFromContentfulRichText({ data: this._richText, config: this._config });\n\n    this._render(commands);\n  }\n\n  private _render(commands: RichTextRenderCommand[]) {\n    // create a document fragment to hold the elements while we create them\n    const fragment = document.createDocumentFragment();\n\n    const hostCommand: RichTextRenderCommand = {\n      payload: 'document',\n      children: commands,\n    };\n\n    // loop over the commands\n    this._executeCommand({ command: hostCommand, parent: fragment });\n\n    // append the fragment to the host element\n    this._renderer.appendChild(this._elementRef.nativeElement, fragment);\n  }\n\n  private _executeCommand(data: { command: RichTextRenderCommand; parent: Element | DocumentFragment }) {\n    const { command, parent } = data;\n\n    let element: Element | null = null;\n    if (command.payload !== 'document') {\n      if (typeof command.payload === 'string') {\n        element = this._renderer.createElement(command.payload);\n\n        if (command.data) {\n          this._renderer.setProperty(element, 'innerText', command.data);\n        }\n\n        if (command.attributes) {\n          for (const [name, value] of Object.entries(command.attributes)) {\n            this._renderer.setAttribute(element, name, value);\n          }\n        }\n        this._renderer.appendChild(parent, element);\n      } else {\n        const injector = Injector.create({\n          providers: [\n            {\n              provide: RICH_TEXT_RENDERER_COMPONENT_DATA,\n              useValue: command.data,\n            },\n          ],\n          parent: this._injector,\n        });\n\n        const portal = new DomPortalOutlet(\n          parent as Element,\n          this._componentFactoryResolver,\n          this._appRef,\n          injector,\n          this._document,\n        );\n\n        const comp = new ComponentPortal(command.payload);\n        const ref = comp.attach(portal);\n\n        if (ref.instance instanceof ContentfulImageComponent) {\n          ref.instance.sizes = this._config.imageOptions.sizes;\n          ref.instance.srcsetSizes = this._config.imageOptions.srcsetSizes;\n          ref.instance.backgroundColor = this._config.imageOptions.backgroundColor;\n        }\n\n        element = ref.location.nativeElement;\n      }\n    }\n\n    // loop over the commands\n    for (const childCommand of command.children) {\n      this._executeCommand({ command: childCommand, parent: element ?? parent });\n    }\n  }\n}\n"]}
+        }], ctorParameters: () => [] });
+function formatHTML(html) {
+    const result = [];
+    let indent = 0;
+    for (const tag of html) {
+        if (tag.startsWith('</')) {
+            indent--;
+        }
+        result.push(' '.repeat(indent * 2) + tag);
+        if (tag.startsWith('<') && !tag.startsWith('</')) {
+            indent++;
+        }
+    }
+    return result.join('\n');
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rich-text-renderer.component.js","sourceRoot":"","sources":["../../../../../../../libs/contentful/src/lib/components/rich-text-renderer/rich-text-renderer.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { ComponentType } from '@angular/cdk/portal';\nimport { DOCUMENT } from '@angular/common';\nimport {\n  ChangeDetectionStrategy,\n  Component,\n  ComponentRef,\n  ElementRef,\n  EmbeddedViewRef,\n  Renderer2,\n  ViewContainerRef,\n  ViewEncapsulation,\n  computed,\n  inject,\n  input,\n} from '@angular/core';\nimport { takeUntilDestroyed, toObservable, toSignal } from '@angular/core/rxjs-interop';\nimport { BLOCKS, Block, INLINES, Inline, Mark, Text } from '@contentful/rich-text-types';\nimport { getObjectProperty, isObject } from '@ethlete/core';\nimport { pairwise, startWith, tap } from 'rxjs';\nimport { CONTENTFUL_CONFIG } from '../../constants/contentful.constants';\nimport { ContentfulAsset, ContentfulCollection, ContentfulEntry, RichTextResponse } from '../../types';\nimport { createContentfulConfig } from '../../utils/contentful-config';\nimport { richTextRendererError } from './rich-text-renderer.errors';\nimport { isRichTextRootNode, translateContentfulNodeTypeToHtmlTag } from './rich-text-renderer.util';\n\nexport const RENDER_COMMAND_TYPE = {\n  HTML_OPEN: 0,\n  HTML_CLOSE: 1,\n  TEXT: 2,\n  COMPONENT: 3,\n} as const;\n\nexport const RENDER_COMMAND_POSITION = {\n  TYPE: 0,\n  NESTING_LEVEL: 1,\n  DOM_POSITION: 2,\n  INDEX: 3,\n} as const;\n\nexport const HTML_OPEN_RENDER_COMMAND_POSITION = {\n  ATTRIBUTES: 4,\n  TAG_NAME: 5,\n  ELEMENT_ID: 6,\n} as const;\n\nexport const HTML_CLOSE_RENDER_COMMAND_POSITION = {\n  TAG_NAME: 4,\n  ELEMENT_ID: 5,\n} as const;\n\nexport const TEXT_RENDER_COMMAND_POSITION = {\n  TEXT: 4,\n} as const;\n\nexport const COMPONENT_RENDER_COMMAND_POSITION = {\n  ATTRIBUTES: 4,\n  COMPONENT: 5,\n  INPUTS: 6,\n  COMPONENT_TYPE: 7,\n} as const;\n\ntype HtmlOpenRenderCommand = [\n  type: typeof RENDER_COMMAND_TYPE.HTML_OPEN,\n  nestingLevel: number,\n  domPosition: number,\n  index: number,\n  attributes: Record<string, string>,\n  tagName: string,\n  elementId: string,\n];\n\ntype HtmlCloseRenderCommand = [\n  type: typeof RENDER_COMMAND_TYPE.HTML_CLOSE,\n  nestingLevel: number,\n  domPosition: number,\n  index: number,\n  tagName: string,\n  elementId: string,\n];\n\ntype TextRenderCommand = [\n  type: typeof RENDER_COMMAND_TYPE.TEXT,\n  nestingLevel: number,\n  domPosition: number,\n  index: number,\n  text: string,\n];\n\ntype ComponentRenderCommand = [\n  type: typeof RENDER_COMMAND_TYPE.COMPONENT,\n  nestingLevel: number,\n  domPosition: number,\n  index: number,\n  attributes: Record<string, string>,\n  component: ComponentType<unknown>,\n  inputs: Record<string, unknown>,\n  componentType: string,\n];\n\ntype RenderCommand = HtmlOpenRenderCommand | HtmlCloseRenderCommand | TextRenderCommand | ComponentRenderCommand;\n\nexport const RENDER_INSTRUCTION_POSITION = {\n  TYPE: 0,\n  COMMAND: 1,\n} as const;\n\nexport const RENDER_INSTRUCTION_TYPE = {\n  CREATE: 0,\n  UPDATE: 1,\n  DELETE: 2,\n  MOVE: 3,\n} as const;\n\ntype RenderInstructionTypeValue = (typeof RENDER_INSTRUCTION_TYPE)[keyof typeof RENDER_INSTRUCTION_TYPE];\n\ntype RenderInstruction = [RenderInstructionTypeValue, RenderCommand];\n\nconst MARK_TAILWIND_MAP: Record<string, string> = {\n  bold: 'font-bold',\n  italic: 'italic',\n  underline: 'underline',\n  code: 'font-mono',\n};\n\nexport const marksToClass = (marks: Mark[]) => {\n  const classes: string[] = [];\n\n  for (const mark of marks) {\n    let klass = MARK_TAILWIND_MAP[mark.type];\n\n    if (!klass) {\n      console.warn(`No class found for mark type! Falling back to \"${mark.type}\".`, mark);\n\n      klass = mark.type;\n    }\n\n    classes.push(klass);\n  }\n\n  return classes.join(' ');\n};\n\nexport const isHtmlOpenRenderCommand = (command: RenderCommand): command is HtmlOpenRenderCommand => {\n  return command[RENDER_COMMAND_POSITION.TYPE] === RENDER_COMMAND_TYPE.HTML_OPEN;\n};\n\nexport const isHtmlCloseRenderCommand = (command: RenderCommand): command is HtmlCloseRenderCommand => {\n  return command[RENDER_COMMAND_POSITION.TYPE] === RENDER_COMMAND_TYPE.HTML_CLOSE;\n};\n\nexport const isTextRenderCommand = (command: RenderCommand): command is TextRenderCommand => {\n  return command[RENDER_COMMAND_POSITION.TYPE] === RENDER_COMMAND_TYPE.TEXT;\n};\n\nexport const isComponentRenderCommand = (command: RenderCommand): command is ComponentRenderCommand => {\n  return command[RENDER_COMMAND_POSITION.TYPE] === RENDER_COMMAND_TYPE.COMPONENT;\n};\n\nexport const getRenderCommandId = (command: RenderCommand) => {\n  if (isHtmlOpenRenderCommand(command)) {\n    return command[HTML_OPEN_RENDER_COMMAND_POSITION.ELEMENT_ID];\n  } else if (isHtmlCloseRenderCommand(command)) {\n    return command[HTML_CLOSE_RENDER_COMMAND_POSITION.ELEMENT_ID];\n  } else if (isTextRenderCommand(command)) {\n    return command[TEXT_RENDER_COMMAND_POSITION.TEXT];\n  } else {\n    return command[COMPONENT_RENDER_COMMAND_POSITION.COMPONENT_TYPE];\n  }\n};\n\nconst CLASS_ATTR = 'class';\nconst DEFAULT_COMPONENT_TYPES = {\n  IMAGE: '$$$_et-image',\n  VIDEO: '$$$_et-video',\n  AUDIO: '$$$_et-audio',\n  FILE: '$$$_et-file',\n};\n\ntype ExecutedCommandCacheItemBase = {\n  element: HTMLElement;\n};\n\ntype ExecutedComponentCommandCacheItem = {\n  command: ComponentRenderCommand;\n  componentRef: ComponentRef<unknown>;\n} & ExecutedCommandCacheItemBase;\n\ntype ExecutedHtmlCommandCacheItem = {\n  command: HtmlOpenRenderCommand | HtmlCloseRenderCommand;\n} & ExecutedCommandCacheItemBase;\n\ntype ExecutedTextCommandCacheItem = {\n  command: TextRenderCommand;\n  textNode: unknown;\n} & ExecutedCommandCacheItemBase;\n\ntype ExecutedCommandCacheItem =\n  | ExecutedComponentCommandCacheItem\n  | ExecutedHtmlCommandCacheItem\n  | ExecutedTextCommandCacheItem;\n\nexport const isExecutedComponentCommandCacheItem = (\n  cache: ExecutedCommandCacheItem,\n): cache is ExecutedComponentCommandCacheItem => {\n  return isComponentRenderCommand(cache.command);\n};\n\nexport const isExecutedHtmlOrTextCommandCacheItem = (\n  cache: ExecutedCommandCacheItem,\n): cache is ExecutedHtmlCommandCacheItem => {\n  return isHtmlCloseRenderCommand(cache.command) || isHtmlOpenRenderCommand(cache.command);\n};\n\nexport const isExecutedTextCommandCacheItem = (\n  cache: ExecutedCommandCacheItem,\n): cache is ExecutedTextCommandCacheItem => {\n  return isTextRenderCommand(cache.command);\n};\n\nexport type ContentfulIncludeMap = {\n  assets: Record<string, ContentfulAsset>;\n  entries: Record<string, ContentfulEntry>;\n};\n\n@Component({\n  selector: 'et-contentful-rich-text-renderer',\n  template: ``,\n  encapsulation: ViewEncapsulation.None,\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  standalone: true,\n  host: {\n    class: 'et-contentful-rich-text-renderer',\n  },\n})\nexport class ContentfulRichTextRendererComponent {\n  _viewContainerRef = inject(ViewContainerRef);\n  _renderer = inject(Renderer2);\n  _elementRef = inject<ElementRef<HTMLElement>>(ElementRef);\n  _document = inject(DOCUMENT);\n  _config = inject(CONTENTFUL_CONFIG, { optional: true }) ?? createContentfulConfig();\n\n  /**\n   * A cache for all executed commands that are not deleted.\n   * This is used to keep track of all rendered elements and components.\n   * The key is the render command element ID.\n   */\n  _executedCommandsCache = new Map<string, ExecutedCommandCacheItem>();\n\n  /**\n   * The contentful response gotten via their REST api.\n   * @see https://www.contentful.com/developers/docs/references/content-delivery-api/#/reference/entries/entries-collection\n   */\n  content = input.required<ContentfulCollection | null | undefined>();\n\n  /**\n   * The path to where the rich text field is inside the contentful response. Dot and array notation is allowed.\n   * @default \"items[0].fields.html\"\n   */\n  richTextPath = input.required<string>();\n\n  /**\n   * A map of all includes in the contentful response.\n   * This is useful for looking up assets and entries that are referenced in the rich text without having to use loops.\n   */\n  contentIncludesMap = computed<ContentfulIncludeMap>(() => {\n    const content = this.content();\n    const assets = content?.includes.Asset;\n    const entries = content?.includes.Entry;\n\n    return {\n      assets:\n        assets?.reduce(\n          (acc, asset) => {\n            acc[asset.sys.id] = asset;\n            return acc;\n          },\n          {} as Record<string, ContentfulAsset>,\n        ) ?? {},\n      entries:\n        entries?.reduce(\n          (acc, entry) => {\n            acc[entry.sys.id] = entry;\n            return acc;\n          },\n          {} as Record<string, ContentfulEntry>,\n        ) ?? {},\n    };\n  });\n\n  /**\n   * The rich text data that should be rendered.\n   */\n  richTextData = computed(() => {\n    const content = this.content();\n    const richTextPath = this.richTextPath();\n\n    if (!content) {\n      return null;\n    }\n\n    const richText = getObjectProperty(content as unknown as Record<string, unknown>, richTextPath);\n\n    if (!isObject(richText)) {\n      throw richTextRendererError('rich_text_undefined', false, { content, richTextPath });\n    }\n\n    if (!isRichTextRootNode(richText)) {\n      throw richTextRendererError('rich_text_wrong_type', false, { content, richTextPath });\n    }\n\n    return richText as RichTextResponse;\n  });\n\n  renderCommands = computed(() => {\n    const richTextData = this.richTextData();\n\n    if (!richTextData) {\n      return [];\n    }\n\n    return this._createRenderCommands(richTextData);\n  });\n\n  renderCommandHistory = toSignal(\n    toObservable(this.renderCommands).pipe(startWith([] as RenderCommand[]), pairwise()),\n    { initialValue: [[], []] },\n  );\n\n  previousRenderCommandMap = computed(() => {\n    const [prevCommands] = this.renderCommandHistory();\n\n    const map = new Map<string | number, RenderCommand>();\n\n    for (const command of prevCommands) {\n      map.set(getRenderCommandId(command), command);\n    }\n\n    return map;\n  });\n\n  renderInstructions = computed(() => {\n    const commands = this.renderCommands();\n    const previousRenderCommandMap = new Map(this.previousRenderCommandMap());\n\n    const instructions: RenderInstruction[] = [];\n\n    // remove deleted components as well as all other elements\n    for (const [, command] of previousRenderCommandMap) {\n      if (isComponentRenderCommand(command)) {\n        // keep the component around if it's still in the new commands\n        if (commands.some((c) => getRenderCommandId(c) === getRenderCommandId(command))) {\n          continue;\n        }\n      }\n\n      instructions.push([RENDER_INSTRUCTION_TYPE.DELETE, command]);\n\n      // remove from map to mark as used\n      previousRenderCommandMap.delete(getRenderCommandId(command));\n    }\n\n    // Find the indexes of the commands remaining in the previousRenderCommandMap in the new commands array.\n    const lastComponentIndexes: { newIndex: number; prevIndex: number; command: RenderCommand }[] = [];\n    for (const [id, command] of previousRenderCommandMap) {\n      const index = commands.findIndex((c) => getRenderCommandId(c) === id);\n      const newCommand = commands[index]!;\n\n      if (index === -1) {\n        throw new Error('Command not found!');\n      }\n\n      lastComponentIndexes.push({\n        newIndex: index,\n        prevIndex: command[RENDER_COMMAND_POSITION.INDEX],\n        command: newCommand,\n      });\n    }\n\n    lastComponentIndexes.sort((a, b) => a.newIndex - b.newIndex);\n\n    // check if the prevIndex are in order ascending\n    // for indexes that are not in order, create a move instruction\n    // for indexes that are in order, create an update instruction\n    let moveCheckIndex = 0;\n    while (moveCheckIndex < lastComponentIndexes.length - 1) {\n      const moveCurr = lastComponentIndexes[moveCheckIndex];\n      const moveNext = lastComponentIndexes[moveCheckIndex + 1];\n\n      if (!moveCurr || !moveNext) {\n        break;\n      }\n\n      if (moveCurr.prevIndex > moveNext.prevIndex) {\n        lastComponentIndexes.splice(moveCheckIndex + 1, 1);\n        instructions.push([RENDER_INSTRUCTION_TYPE.MOVE, moveNext.command]);\n      } else {\n        instructions.push([RENDER_INSTRUCTION_TYPE.UPDATE, moveNext.command]);\n        moveCheckIndex++;\n      }\n    }\n\n    for (const command of commands) {\n      const id = getRenderCommandId(command);\n\n      if (isComponentRenderCommand(command)) {\n        const previousCommand = previousRenderCommandMap.get(id);\n\n        if (!previousCommand) {\n          // create\n          instructions.push([RENDER_INSTRUCTION_TYPE.CREATE, command]);\n        }\n      } else {\n        // create\n        instructions.push([RENDER_INSTRUCTION_TYPE.CREATE, command]);\n      }\n    }\n\n    return instructions;\n  });\n\n  constructor() {\n    toObservable(this.renderInstructions)\n      .pipe(\n        takeUntilDestroyed(),\n        tap((instructions) => {\n          this._execInstructions(instructions);\n        }),\n      )\n      .subscribe();\n  }\n\n  private _createRenderCommands(richTextData: RichTextResponse) {\n    /** List of all render commands */\n    const rootCommands: RenderCommand[] = [];\n\n    /** Counter for generating unique html element IDs. */\n    let elementId = 0;\n\n    /** Counter for generating unique component IDs. */\n    const componentIdMap = new Map<string, number>();\n\n    /** The nesting level of the current node. */\n    let nestingLevel = 0;\n\n    /** The position (index) of the current node inside the parent node. */\n    let domPosition = 0;\n\n    let commandIndex = 0;\n\n    const traverse = (node: Block | Inline | Text, parent: RenderCommand | null = null) => {\n      switch (node.nodeType) {\n        case 'text': {\n          // Render media\n          const type = RENDER_COMMAND_TYPE.TEXT;\n          const text = node.value;\n\n          if (!text) break;\n\n          const command: TextRenderCommand = [type, nestingLevel, domPosition, commandIndex++, text];\n\n          rootCommands.push(command);\n          domPosition++;\n\n          if (!parent) {\n            throw richTextRendererError('text_parent_not_found', false, { node });\n          }\n          if (!isHtmlOpenRenderCommand(parent) && !isComponentRenderCommand(parent)) {\n            throw richTextRendererError('text_parent_wrong_type', false, { node, parent });\n          }\n\n          const attributesPosition =\n            parent[RENDER_COMMAND_POSITION.TYPE] === RENDER_COMMAND_TYPE.HTML_OPEN\n              ? HTML_OPEN_RENDER_COMMAND_POSITION.ATTRIBUTES\n              : COMPONENT_RENDER_COMMAND_POSITION.ATTRIBUTES;\n\n          const attributes = parent[attributesPosition];\n\n          if (node.marks.length) {\n            const markClasses = marksToClass(node.marks);\n\n            if (CLASS_ATTR in attributes) {\n              attributes[CLASS_ATTR] += ` ${markClasses}`;\n            } else {\n              attributes[CLASS_ATTR] = markClasses;\n            }\n          }\n\n          break;\n        }\n\n        case BLOCKS.EMBEDDED_ASSET: {\n          // Render media\n          const type = RENDER_COMMAND_TYPE.COMPONENT;\n          const assetId = node.data['target']?.sys?.id;\n\n          if (!assetId) {\n            throw richTextRendererError('asset_id_not_found', false, { node });\n          }\n\n          const asset = this.contentIncludesMap().assets[assetId];\n\n          if (!asset) {\n            throw richTextRendererError('asset_not_found', false, { assetId, node });\n          }\n\n          const contentType = asset.fields.file.contentType;\n          const assetComponents = this._config.components;\n\n          const isImage = contentType.startsWith('image/');\n          const isVideo = contentType.startsWith('video/');\n          const isAudio = contentType.startsWith('audio/');\n\n          const component = isImage\n            ? assetComponents.image\n            : isVideo\n              ? assetComponents.video\n              : isAudio\n                ? assetComponents.audio\n                : assetComponents.file;\n\n          const componentType = isImage\n            ? DEFAULT_COMPONENT_TYPES.IMAGE\n            : isVideo\n              ? DEFAULT_COMPONENT_TYPES.VIDEO\n              : isAudio\n                ? DEFAULT_COMPONENT_TYPES.AUDIO\n                : DEFAULT_COMPONENT_TYPES.FILE;\n\n          let componentId = componentIdMap.get(componentType) ?? -1;\n          const id = componentType + ++componentId;\n          componentIdMap.set(componentType, componentId);\n\n          const attributes = {};\n\n          const inputs = {\n            asset,\n          };\n\n          const command: ComponentRenderCommand = [\n            type,\n            nestingLevel,\n            domPosition,\n            commandIndex++,\n            attributes,\n            component,\n            inputs,\n            id,\n          ];\n\n          rootCommands.push(command);\n\n          domPosition++;\n\n          break;\n        }\n\n        case BLOCKS.EMBEDDED_ENTRY:\n        case INLINES.EMBEDDED_ENTRY: {\n          // Render component\n          const type = RENDER_COMMAND_TYPE.COMPONENT;\n          const entryId = node.data['target']?.sys?.id;\n\n          if (!entryId) {\n            throw richTextRendererError('entry_id_not_found', false, { node });\n          }\n\n          const entry = this.contentIncludesMap().entries[entryId];\n\n          if (!entry) {\n            throw richTextRendererError('entry_not_found', false, { entryId, node });\n          }\n\n          const componentType = entry.sys.contentType.sys.id;\n\n          const component = this._config.customComponents[componentType];\n\n          if (!component) {\n            throw richTextRendererError('custom_component_not_found', false, {\n              componentType,\n              customComponents: this._config.customComponents,\n              entry,\n            });\n          }\n\n          const attributes = {};\n          let componentId = componentIdMap.get(componentType) ?? -1;\n          const id = componentType + ++componentId;\n          componentIdMap.set(componentType, componentId);\n\n          const inputs = {\n            fields: entry.fields,\n            metadata: entry.metadata,\n            sys: entry.sys,\n            includes: this.contentIncludesMap(),\n          };\n\n          const command: ComponentRenderCommand = [\n            type,\n            nestingLevel,\n            domPosition,\n            commandIndex++,\n            attributes,\n            component,\n            inputs,\n            id,\n          ];\n\n          rootCommands.push(command);\n\n          domPosition++;\n\n          break;\n        }\n\n        default: {\n          const type = RENDER_COMMAND_TYPE.HTML_OPEN;\n          const tag = translateContentfulNodeTypeToHtmlTag(node.nodeType);\n          const attributes: Record<string, string> = {};\n          const id = 'e' + elementId++;\n\n          const command: HtmlOpenRenderCommand = [type, nestingLevel, domPosition, commandIndex++, attributes, tag, id];\n\n          rootCommands.push(command);\n\n          const domPositionAtThisLevel = domPosition;\n          // Normal html elements can have children\n          for (const child of node.content) {\n            domPosition = 0;\n            nestingLevel++;\n            traverse(child, command);\n            nestingLevel--;\n            domPosition = domPositionAtThisLevel;\n          }\n\n          const lastCommand = rootCommands[rootCommands.length - 1];\n\n          if (lastCommand?.[RENDER_COMMAND_POSITION.TYPE] === RENDER_COMMAND_TYPE.HTML_OPEN) {\n            // If the last command is an open command, we can remove it since it's empty\n            rootCommands.pop();\n          } else {\n            const closeId = 'e' + elementId++;\n\n            const closeCommand: HtmlCloseRenderCommand = [\n              RENDER_COMMAND_TYPE.HTML_CLOSE,\n              nestingLevel,\n              domPosition,\n              commandIndex++,\n              tag,\n              closeId,\n            ];\n            rootCommands.push(closeCommand);\n\n            domPosition++;\n          }\n\n          if (node.nodeType === INLINES.HYPERLINK) {\n            const uri = node.data['uri'];\n            attributes['href'] = uri;\n\n            const host = this._document.location.host;\n            const isExternal = !uri.includes(host);\n\n            if (isExternal) {\n              attributes['target'] = '_blank';\n            }\n          }\n\n          break;\n        }\n      }\n    };\n\n    for (const node of richTextData.content) {\n      traverse(node, null);\n    }\n\n    return rootCommands;\n  }\n\n  private _execInstructions(instructions: RenderInstruction[]) {\n    for (const instruction of instructions) {\n      const type = instruction[RENDER_INSTRUCTION_POSITION.TYPE];\n      const command = instruction[RENDER_INSTRUCTION_POSITION.COMMAND];\n\n      switch (type) {\n        case RENDER_INSTRUCTION_TYPE.CREATE:\n          this._runCreateInstruction(command);\n          break;\n        case RENDER_INSTRUCTION_TYPE.UPDATE:\n          this._runUpdateInstruction(command);\n          break;\n        case RENDER_INSTRUCTION_TYPE.MOVE:\n          this._runMoveInstruction(command);\n          break;\n        case RENDER_INSTRUCTION_TYPE.DELETE:\n          this._runDeleteInstruction(command);\n          break;\n      }\n    }\n  }\n\n  private _runCreateInstruction(command: RenderCommand) {\n    const id = getRenderCommandId(command);\n    const parentElement = this._findParent(command);\n    const nextElement = this._findFollowingElement(command);\n\n    if (isComponentRenderCommand(command)) {\n      const componentRef = this._viewContainerRef.createComponent(command[COMPONENT_RENDER_COMMAND_POSITION.COMPONENT]);\n\n      this._updateComponentInputs(command, componentRef);\n\n      const rootNode = this._getComponentRootNode(componentRef);\n\n      this._renderInsertOrAppend(rootNode, parentElement, nextElement);\n\n      this._executedCommandsCache.set(id, {\n        command,\n        componentRef,\n        element: rootNode,\n      });\n    } else if (isTextRenderCommand(command)) {\n      const text = command[TEXT_RENDER_COMMAND_POSITION.TEXT];\n      const textNode = this._renderer.createText(text);\n      const span = this._renderer.createElement('span');\n      this._renderer.appendChild(span, textNode);\n\n      this._renderInsertOrAppend(span, parentElement, nextElement);\n\n      this._executedCommandsCache.set(id, {\n        command,\n        element: span,\n        textNode,\n      });\n    } else if (isHtmlOpenRenderCommand(command)) {\n      const tag = command[HTML_OPEN_RENDER_COMMAND_POSITION.TAG_NAME];\n      const attributes = command[HTML_OPEN_RENDER_COMMAND_POSITION.ATTRIBUTES];\n      const element = this._renderer.createElement(tag);\n\n      for (const [key, value] of Object.entries(attributes)) {\n        this._renderer.setAttribute(element, key, value);\n      }\n\n      this._renderInsertOrAppend(element, parentElement, nextElement);\n\n      this._executedCommandsCache.set(id, {\n        command,\n        element,\n      });\n    }\n  }\n\n  private _runUpdateInstruction(command: RenderCommand) {\n    const id = getRenderCommandId(command);\n    const cached = this._executedCommandsCache.get(id);\n\n    if (!cached) {\n      throw new Error('Cached command not found!');\n    }\n\n    if (isComponentRenderCommand(command)) {\n      if (!isExecutedComponentCommandCacheItem(cached)) {\n        throw new Error('Cached command is not a component command!');\n      }\n\n      const componentRef = cached.componentRef;\n\n      if (!componentRef) {\n        throw new Error('Component ref not found!');\n      }\n\n      this._updateComponentInputs(command, componentRef);\n    }\n\n    this._executedCommandsCache.set(id, {\n      ...cached,\n      command: command as any,\n    });\n  }\n\n  private _runMoveInstruction(command: RenderCommand) {\n    const id = getRenderCommandId(command);\n    const cached = this._executedCommandsCache.get(id);\n\n    if (!cached) {\n      throw new Error('Cached command not found!');\n    }\n\n    if (isComponentRenderCommand(command)) {\n      if (!isExecutedComponentCommandCacheItem(cached)) {\n        throw new Error('Cached command is not a component command!');\n      }\n\n      const componentRef = cached.componentRef;\n\n      if (!componentRef) {\n        throw new Error('Component ref not found!');\n      }\n\n      const rootNode = cached.element;\n      const oldParentElement = cached.element.parentElement;\n\n      this._renderer.removeChild(oldParentElement, rootNode);\n\n      const newParentElement = this._findParent(command);\n      const nextElement = this._findFollowingElement(command);\n\n      this._renderInsertOrAppend(rootNode, newParentElement, nextElement);\n\n      this._updateComponentInputs(command, componentRef);\n\n      this._executedCommandsCache.set(id, {\n        ...cached,\n        command: command as any,\n      });\n    }\n  }\n\n  private _runDeleteInstruction(command: RenderCommand) {\n    const id = getRenderCommandId(command);\n    const cached = this._executedCommandsCache.get(id);\n\n    if (!cached) {\n      if (isHtmlCloseRenderCommand(command)) {\n        return;\n      }\n\n      throw new Error('Cached command not found!');\n    }\n\n    if (isComponentRenderCommand(command)) {\n      if (!isExecutedComponentCommandCacheItem(cached)) {\n        throw new Error('Cached command is not a component command!');\n      }\n\n      cached.componentRef?.destroy();\n    } else if (isTextRenderCommand(command)) {\n      this._renderer.removeChild(cached.element?.parentElement, cached.element);\n    } else if (isHtmlOpenRenderCommand(command)) {\n      this._renderer.removeChild(cached.element?.parentElement, cached.element);\n    }\n\n    this._executedCommandsCache.delete(id);\n  }\n\n  private _getComponentRootNode(componentRef: ComponentRef<any>): HTMLElement {\n    return (componentRef.hostView as EmbeddedViewRef<any>).rootNodes[0] as HTMLElement;\n  }\n\n  private _updateComponentInputs(command: ComponentRenderCommand, componentRef: ComponentRef<any>) {\n    for (const [key, value] of Object.entries(command[COMPONENT_RENDER_COMMAND_POSITION.INPUTS])) {\n      if (!componentRef.instance[key]) continue;\n\n      componentRef.setInput(key, value);\n    }\n  }\n\n  private _findParent(command: RenderCommand) {\n    const hostElement = this._elementRef.nativeElement;\n    const nestingLevel = command[RENDER_COMMAND_POSITION.NESTING_LEVEL];\n    let parentElement: HTMLElement | undefined = undefined;\n\n    if (nestingLevel === 0) {\n      parentElement = hostElement;\n    } else {\n      // Reverse search all render commands beginning from the current one using a for loop.\n      // The parent is found when the command's nesting level ist the same as the current nesting level minus 1.\n      // If the parent is not found, throw an error.\n      const allCommands = this.renderCommands();\n      const currentCommandIndex = command[RENDER_COMMAND_POSITION.INDEX];\n\n      let parentCommand: RenderCommand | null = null;\n\n      for (let i = currentCommandIndex - 1; i >= 0; i--) {\n        const cmd = allCommands[i];\n\n        if (!cmd) {\n          throw new Error('Command not found!');\n        }\n\n        if (cmd[RENDER_COMMAND_POSITION.NESTING_LEVEL] === nestingLevel - 1) {\n          parentCommand = cmd;\n          break;\n        }\n      }\n\n      if (!parentCommand) {\n        throw new Error('Parent command not found!');\n      }\n\n      parentElement = this._executedCommandsCache.get(getRenderCommandId(parentCommand))?.element;\n    }\n\n    if (!parentElement) {\n      throw new Error('Parent element not found!');\n    }\n\n    return parentElement;\n  }\n\n  private _findFollowingElement(command: RenderCommand) {\n    const cacheArray = Array.from(this._executedCommandsCache.values());\n    let nextElement: HTMLElement | undefined = undefined;\n\n    const domPosition = command[RENDER_COMMAND_POSITION.DOM_POSITION];\n    const nestingLevel = command[RENDER_COMMAND_POSITION.NESTING_LEVEL];\n    const type = command[RENDER_COMMAND_POSITION.TYPE];\n\n    //  Try to find an already rendered element with a domPosition that is greater than the current domPosition. If there are multiple, use the one with the smallest domPosition.\n    // If it does not exist, use .appendChild to simply append the element to the end of the parent element.\n    // If it does exist, use .insertBefore to insert the element before the found element.\n    for (const cached of cacheArray) {\n      if (\n        cached.command[RENDER_COMMAND_POSITION.DOM_POSITION] > domPosition &&\n        cached.command[RENDER_COMMAND_POSITION.NESTING_LEVEL] === nestingLevel &&\n        // Make sure the element does not find itself\n        cached.command[RENDER_COMMAND_POSITION.TYPE] !== type\n      ) {\n        nextElement = cached.element;\n        break;\n      }\n    }\n\n    return nextElement;\n  }\n\n  private _renderInsertOrAppend(\n    nodeToRender: HTMLElement,\n    parentElement: HTMLElement,\n    nextElement: HTMLElement | undefined,\n  ) {\n    if (nextElement) {\n      this._renderer.insertBefore(parentElement, nodeToRender, nextElement);\n    } else {\n      this._renderer.appendChild(parentElement, nodeToRender);\n    }\n  }\n\n  private _debugVisualizeRenderCommands(commands: RenderCommand[]) {\n    const debug = commands.map((command) => this._stringifyRenderCommand(command)).flat();\n\n    const prettified = formatHTML(debug);\n\n    return prettified;\n  }\n\n  private _stringifyRenderCommand(command: RenderCommand) {\n    const nestAttr = `nest=\"${command[RENDER_COMMAND_POSITION.NESTING_LEVEL]}\"`;\n    const domAttr = `dom=\"${command[RENDER_COMMAND_POSITION.DOM_POSITION]}\"`;\n\n    if (isHtmlOpenRenderCommand(command)) {\n      return `<${command[HTML_OPEN_RENDER_COMMAND_POSITION.TAG_NAME]} ${nestAttr} ${domAttr}>`;\n    } else if (isHtmlCloseRenderCommand(command)) {\n      return `</${command[HTML_CLOSE_RENDER_COMMAND_POSITION.TAG_NAME]} ${nestAttr} ${domAttr}>`;\n    } else if (isTextRenderCommand(command)) {\n      return [`<span ${nestAttr} ${domAttr}>`, command[TEXT_RENDER_COMMAND_POSITION.TEXT], '</span>'];\n    } else if (isComponentRenderCommand(command)) {\n      const selector = command[COMPONENT_RENDER_COMMAND_POSITION.COMPONENT_TYPE];\n      return [`<${selector} ${nestAttr} ${domAttr}>`, `</${selector}>`];\n    } else {\n      return 'UNKNOWN';\n    }\n  }\n\n  private _stringifyRenderInstruction(instruction: RenderInstruction) {\n    const type = instruction[RENDER_INSTRUCTION_POSITION.TYPE];\n    const translatedType = Object.entries(RENDER_INSTRUCTION_TYPE).find(([, value]) => value === type)?.[0];\n\n    const command = this._stringifyRenderCommand(instruction[RENDER_INSTRUCTION_POSITION.COMMAND]);\n\n    return `${translatedType}: ${command}`;\n  }\n}\n\nfunction formatHTML(html: string[]) {\n  const result: string[] = [];\n  let indent = 0;\n\n  for (const tag of html) {\n    if (tag.startsWith('</')) {\n      indent--;\n    }\n\n    result.push(' '.repeat(indent * 2) + tag);\n\n    if (tag.startsWith('<') && !tag.startsWith('</')) {\n      indent++;\n    }\n  }\n\n  return result.join('\\n');\n}\n"]}