@kontent-ai/delivery-sdk 12.0.0-0

package/lib/resolvers/rich-text/base/base-async-rich-text-resolver.ts

@@ -0,0 +1,16 @@
+import { IAsyncParser } from '../../../parser';
+import { IRichTextResolverAsync } from '../rich-text-resolver.models';
+
+export abstract class BaseAsyncRichTextResolver<TInput, TOutput> implements IRichTextResolverAsync<TInput, TOutput> {
+    constructor(private defaultParser: IAsyncParser<any>, private parser?: IAsyncParser<any>) {}
+
+    abstract resolveRichTextAsync(input: TInput): Promise<TOutput>;
+
+    protected getAsyncParser(): IAsyncParser<any> {
+        if (this.parser) {
+            return this.parser;
+        }
+
+        return this.defaultParser;
+    }
+}

package/lib/resolvers/rich-text/base/base-rich-text-resolver.ts

@@ -0,0 +1,16 @@
+import { IParser } from '../../../parser';
+import { IRichTextResolver } from '../rich-text-resolver.models';
+
+export abstract class BaseRichTextResolver<TInput, TOutput> implements IRichTextResolver<TInput, TOutput> {
+    constructor(private defaultParser: IParser<any>, private parser?: IParser<any>) {}
+
+    abstract resolveRichText(input: TInput): TOutput;
+
+    protected getParser(): IParser<any> {
+        if (this.parser) {
+            return this.parser;
+        }
+
+        return this.defaultParser;
+    }
+}

package/lib/resolvers/rich-text/rich-text-resolver.models.ts

@@ -0,0 +1,117 @@
+import { Elements } from '../../elements';
+import { IContentItem, ILink, IRichTextImage } from '../../models';
+
+export interface IResolvedRichTextHtmlResult {
+    html: string;
+    linkedItemCodenames: string[];
+    componentCodenames: string[];
+}
+
+export interface IRichTextUrlResult {
+    linkHtml?: string;
+    linkUrl?: string;
+}
+
+export interface IRichTextImageResult {
+    imageUrl?: string;
+    imageHtml?: string;
+}
+
+export interface IRichTextContentItemResult {
+    contentItemHtml?: string;
+}
+
+export type IRichTextUrlResolver = (linkId: string, linkText: string, link?: ILink) => IRichTextUrlResult;
+export type IRichTextImageResolver = (imageId: string, image?: IRichTextImage) => IRichTextImageResult;
+export type IRichTextContentItemResolver = (
+    itemCodename: string,
+    contentItem?: IContentItem
+) => IRichTextContentItemResult;
+
+export type IAsyncRichTextUrlResolver = (linkId: string, linkText: string, link?: ILink) => Promise<IRichTextUrlResult>;
+export type IAsyncRichTextImageResolver = (imageId: string, image?: IRichTextImage) => Promise<IRichTextImageResult>;
+export type IAsyncRichTextContentItemResolver = (
+    itemCodename: string,
+    contentItem?: IContentItem
+) => Promise<IRichTextContentItemResult>;
+
+export interface IRichTextHtmlResolverInput {
+    element: Elements.RichTextElement;
+    urlResolver?: IRichTextUrlResolver;
+    imageResolver?: IRichTextImageResolver;
+    contentItemResolver?: IRichTextContentItemResolver;
+    linkedItems?: IContentItem[];
+    preserveResolvedObjectTags?: boolean;
+}
+
+export interface IAsyncRichTextHtmlResolverInput {
+    element: Elements.RichTextElement;
+    urlResolverAsync?: IAsyncRichTextUrlResolver;
+    imageResolverAsync?: IAsyncRichTextImageResolver;
+    contentItemResolverAsync?: IAsyncRichTextContentItemResolver;
+    linkedItems?: IContentItem[];
+    preserveResolvedObjectTags?: boolean;
+}
+
+export interface IRichTextResolver<TInput, TResult> {
+    resolveRichText(input: TInput): TResult;
+}
+
+export interface IRichTextResolverAsync<TInput, TResult> {
+    resolveRichTextAsync(input: TInput): Promise<TResult>;
+}
+
+export interface IRichTextObjectResolverInput {
+    element: Elements.RichTextElement;
+    linkedItems?: IContentItem[];
+    cleanSdkIds?: boolean;
+
+    /**
+     * Tag that wraps content. Defaults to 'div'
+     */
+    wrapperTag?: string;
+}
+
+export type RichTextObjectDataType = 'linkedItem' | 'link' | 'image' | 'htmlElement' | 'root';
+
+export interface IRichTextObjectContentItemData {
+    item?: IContentItem;
+    codename: string;
+}
+
+export interface IRichTextObjectLinkData {
+    link?: ILink;
+    linkId: string;
+    linkText: string;
+}
+
+export interface IRichTextObjectImageData {
+    image?: IRichTextImage;
+    imageId: string;
+}
+
+export interface IRichTextObjectHtmlElementData {
+    text: string | null;
+    html: string | null;
+}
+
+export interface IRichTextObjectAtribute {
+    name: string;
+    value: string | null;
+}
+
+export interface IRichTextObjectItem {
+    type: RichTextObjectDataType;
+    tag: string;
+    _sdkElemId: string;
+    attributes: IRichTextObjectAtribute[];
+    data: any;
+    children: IRichTextObjectItem[];
+}
+
+export interface IRichTextJsonResult {
+    json: string;
+}
+export interface IRichTextObjectResult {
+    data: IRichTextObjectItem;
+}

package/lib/resolvers/rich-text/sync/rich-text-html-resolver.ts

@@ -0,0 +1,87 @@
+import { IResolvedRichTextHtmlResult, IRichTextHtmlResolverInput } from '../rich-text-resolver.models';
+import { browserParser, IParser, parserConfiguration, parserHelper } from '../../../parser';
+import { BaseRichTextResolver } from '../base/base-rich-text-resolver';
+
+export class RichTextHtmlResolver extends BaseRichTextResolver<
+    IRichTextHtmlResolverInput,
+    IResolvedRichTextHtmlResult
+> {
+    constructor(parser?: IParser<string>) {
+        super(browserParser, parser);
+    }
+
+    resolveRichText(input: IRichTextHtmlResolverInput): IResolvedRichTextHtmlResult {
+        return this.resolveRichTextInternal(input.element.value, input);
+    }
+
+    private resolveRichTextInternal(html: string, input: IRichTextHtmlResolverInput): IResolvedRichTextHtmlResult {
+        const parsedResult = super.getParser().parse(
+            html,
+            input.element,
+            {
+                elementResolver: (element) => {},
+                contentItemResolver: (element, itemCodename, linkedItemIndex, linkedItem) => {
+                    const parentElement = element.parentElement;
+
+                    if (parentElement) {
+                        const resolvedItemHtml = input.contentItemResolver
+                            ? input.contentItemResolver(itemCodename, linkedItem).contentItemHtml ?? ''
+                            : '';
+
+                        // resursively resolve HTML
+                        const innerHtml = this.resolveRichTextInternal(resolvedItemHtml, input).html;
+
+                        // set resolved html
+                        if (input.preserveResolvedObjectTags === true) {
+                            element.setInnerHtml(innerHtml);
+                        } else {
+                            element.setOuterHtml(innerHtml);
+                        }
+
+                        // set resolved attribute
+                        element.setAttribute(parserHelper.sdkResolvedAttributeName, '1');
+                    }
+                },
+                genericElementResolver: (element) => {
+                    // do nothing to generic elements
+                },
+                imageResolver: (element, imageId, image) => {
+                    // get image result
+                    const imageResult = input.imageResolver ? input.imageResolver(imageId, image) : undefined;
+
+                    // html has priority over url resolver
+                    if (imageResult?.imageHtml) {
+                        // replace link html
+                        element.setOuterHtml(imageResult.imageHtml);
+                    } else if (imageResult?.imageUrl) {
+                        // set link url only
+                        element.setAttribute(parserConfiguration.imageElementData.srcAttribute, imageResult.imageUrl);
+                    }
+                },
+                urlResolver: (element, linkId, linkText, link) => {
+                    if (input.urlResolver) {
+                        const urlResult = input.urlResolver(linkId, linkText, link);
+
+                        // html has priority over url resolver
+                        if (urlResult?.linkHtml) {
+                            // replace link html
+                            element.setOuterHtml(urlResult.linkHtml);
+                        } else if (urlResult?.linkUrl) {
+                            // set link url only
+                            element.setAttribute('href', urlResult.linkUrl);
+                        }
+                    }
+                }
+            },
+            input.linkedItems ?? []
+        );
+
+        return {
+            componentCodenames: parsedResult.componentCodenames,
+            linkedItemCodenames: parsedResult.linkedItemCodenames,
+            html: parsedResult.result
+        };
+    }
+}
+
+export const createRichTextHtmlResolver = (parser?: IParser<string>) => new RichTextHtmlResolver(parser);

package/lib/resolvers/rich-text/sync/rich-text-json-resolver.ts

@@ -0,0 +1,23 @@
+import { browserParser, IParser } from '../../../parser';
+import { BaseRichTextResolver } from '../base/base-rich-text-resolver';
+import { IRichTextObjectResolverInput, IRichTextJsonResult } from '../rich-text-resolver.models';
+import { createRichTextObjectResolver } from './rich-text-object-resolver';
+
+export class RichTextJsonResolver extends BaseRichTextResolver<
+    IRichTextObjectResolverInput,
+    IRichTextJsonResult
+> {
+    constructor(parser?: IParser<string>) {
+        super(browserParser, parser);
+    }
+
+    resolveRichText(input: IRichTextObjectResolverInput): IRichTextJsonResult {
+        const objectResult = createRichTextObjectResolver(this.getParser()).resolveRichText(input).data;
+
+        return {
+            json: JSON.stringify(objectResult)
+        };
+    }
+}
+
+export const createRichTextJsonResolver = (parser?: IParser<any>) => new RichTextJsonResolver(parser);

package/lib/resolvers/rich-text/sync/rich-text-object-resolver.ts

@@ -0,0 +1,181 @@
+import {
+    IRichTextObjectResolverInput,
+    IRichTextObjectContentItemData,
+    IRichTextObjectLinkData,
+    IRichTextObjectImageData,
+    IRichTextObjectHtmlElementData,
+    IRichTextObjectItem,
+    IRichTextObjectAtribute,
+    IRichTextObjectResult
+} from '../rich-text-resolver.models';
+import { browserParser, IParser, IParserElement } from '../../../parser';
+import { guidHelper } from '../../../utilities';
+import { BaseRichTextResolver } from '../base/base-rich-text-resolver';
+
+export class RichTextObjectResolver extends BaseRichTextResolver<IRichTextObjectResolverInput, IRichTextObjectResult> {
+    private readonly sdkIdAttributeName: string = 'sdk-elem-id';
+    private readonly rootId: string = 'root';
+    private readonly defaultWrapTag: string = 'div';
+
+    constructor(parser?: IParser<string>) {
+        super(browserParser, parser);
+    }
+
+    resolveRichText(input: IRichTextObjectResolverInput): IRichTextObjectResult {
+        const result = this.resolveRichTextInternal(input.element.value, input, {
+            type: 'root',
+            attributes: [],
+            children: [],
+            data: {},
+            tag: input.wrapperTag ?? this.defaultWrapTag,
+            _sdkElemId: this.rootId
+        });
+
+        if (input.cleanSdkIds === true) {
+            this.cleanSdkIds(result);
+        }
+
+        return {
+            data: result
+        };
+    }
+
+    private resolveRichTextInternal(
+        html: string,
+        input: IRichTextObjectResolverInput,
+        result: IRichTextObjectItem
+    ): IRichTextObjectItem {
+        super.getParser().parse(
+            html,
+            input.element,
+            {
+                elementResolver: (element) => {
+                    // generate guid for each element
+                    element.setAttribute(this.sdkIdAttributeName, guidHelper.genereateGuid());
+                },
+                contentItemResolver: (element, itemCodename, linkedItemIndex, linkedItem) => {
+                    const data: IRichTextObjectContentItemData = {
+                        codename: itemCodename,
+                        item: linkedItem
+                    };
+
+                    const parentSdkId = this.getSdkIdFromElement(element.parentElement);
+                    const parentItem = this.findItemWithSdkId(parentSdkId, result);
+
+                    if (parentItem) {
+                        parentItem.children.push({
+                            type: 'linkedItem',
+                            attributes: this.getAttributes(element),
+                            tag: element.tag.toLowerCase(),
+                            data: data,
+                            children: [],
+                            _sdkElemId: this.getSdkIdFromElement(element)
+                        });
+                    }
+                },
+                genericElementResolver: (element) => {
+                    const data: IRichTextObjectHtmlElementData = {
+                        text: element.text ?? '',
+                        html: element.html ?? ''
+                    };
+
+                    const parentSdkId = this.getSdkIdFromElement(element.parentElement);
+                    const parentItem = this.findItemWithSdkId(parentSdkId, result);
+
+                    if (parentItem) {
+                        parentItem.children.push({
+                            type: 'htmlElement',
+                            attributes: this.getAttributes(element),
+                            tag: element.tag.toLowerCase(),
+                            data: data,
+                            children: [],
+                            _sdkElemId: this.getSdkIdFromElement(element)
+                        });
+                    }
+                },
+                imageResolver: (element, imageId, image) => {
+                    const data: IRichTextObjectImageData = {
+                        imageId: imageId,
+                        image: image
+                    };
+
+                    const parentSdkId = this.getSdkIdFromElement(element.parentElement);
+                    const parentItem = this.findItemWithSdkId(parentSdkId, result);
+
+                    if (parentItem) {
+                        parentItem.children.push({
+                            type: 'image',
+                            attributes: this.getAttributes(element),
+                            tag: element.tag.toLowerCase(),
+                            data: data,
+                            children: [],
+                            _sdkElemId: this.getSdkIdFromElement(element)
+                        });
+                    }
+                },
+                urlResolver: (element, linkId, linkText, link) => {
+                    const data: IRichTextObjectLinkData = {
+                        linkId: linkId,
+                        linkText: linkText,
+                        link: link
+                    };
+
+                    const parentSdkId = this.getSdkIdFromElement(element.parentElement);
+                    const parentItem = this.findItemWithSdkId(parentSdkId, result);
+
+                    if (parentItem) {
+                        parentItem.children.push({
+                            type: 'link',
+                            attributes: this.getAttributes(element),
+                            tag: element.tag.toLowerCase(),
+                            data: data,
+                            children: [],
+                            _sdkElemId: this.getSdkIdFromElement(element)
+                        });
+                    }
+                }
+            },
+            input.linkedItems ?? []
+        );
+
+        return result;
+    }
+
+    private findItemWithSdkId(sdkId: string, item: IRichTextObjectItem): IRichTextObjectItem | undefined {
+        if (item._sdkElemId === sdkId) {
+            return item;
+        }
+
+        for (const child of item.children) {
+            const foundItem = this.findItemWithSdkId(sdkId, child);
+            if (foundItem) {
+                return foundItem;
+            }
+        }
+
+        return undefined;
+    }
+
+    private getAttributes(element: IParserElement | undefined): IRichTextObjectAtribute[] {
+        return element?.attributes ?? [];
+    }
+
+    private getSdkIdFromElement(element: IParserElement | undefined): string {
+        if (!element) {
+            return this.rootId;
+        }
+        const value = element.attributes.find((m) => m.name === this.sdkIdAttributeName)?.value ?? this.rootId;
+        return value;
+    }
+
+    private cleanSdkIds(item: IRichTextObjectItem): void {
+        item.attributes = item.attributes.filter((m) => m.name !== this.sdkIdAttributeName);
+        item._sdkElemId = '';
+
+        for (const child of item.children) {
+            this.cleanSdkIds(child);
+        }
+    }
+}
+
+export const createRichTextObjectResolver = (parser?: IParser<any>) => new RichTextObjectResolver(parser);

package/lib/sdk-info.generated.ts

@@ -0,0 +1,7 @@
+
+import { ISDKInfo } from '@kontent-ai/core-sdk';
+export const sdkInfo: ISDKInfo = {
+    host: 'npmjs.com',
+    version: '12.0.0-0',
+    name: '@kontent-ai/delivery-sdk'
+};