@ethlete/contentful 2.1.2 → 3.0.1

package/lib/components/rich-text-renderer/rich-text-renderer.component.d.ts

@@ -1,19 +1,164 @@
-import { RichTextResponse } from '../../types';
+import { ComponentType } from '@angular/cdk/portal';
+import { ComponentRef, ElementRef, Renderer2, ViewContainerRef } from '@angular/core';
+import { Mark } from '@contentful/rich-text-types';
+import { ContentfulAsset, ContentfulCollection, ContentfulEntry, RichTextResponse } from '../../types';
 import * as i0 from "@angular/core";
+export declare const RENDER_COMMAND_TYPE: {
+    readonly HTML_OPEN: 0;
+    readonly HTML_CLOSE: 1;
+    readonly TEXT: 2;
+    readonly COMPONENT: 3;
+};
+export declare const RENDER_COMMAND_POSITION: {
+    readonly TYPE: 0;
+    readonly NESTING_LEVEL: 1;
+    readonly DOM_POSITION: 2;
+    readonly INDEX: 3;
+};
+export declare const HTML_OPEN_RENDER_COMMAND_POSITION: {
+    readonly ATTRIBUTES: 4;
+    readonly TAG_NAME: 5;
+    readonly ELEMENT_ID: 6;
+};
+export declare const HTML_CLOSE_RENDER_COMMAND_POSITION: {
+    readonly TAG_NAME: 4;
+    readonly ELEMENT_ID: 5;
+};
+export declare const TEXT_RENDER_COMMAND_POSITION: {
+    readonly TEXT: 4;
+};
+export declare const COMPONENT_RENDER_COMMAND_POSITION: {
+    readonly ATTRIBUTES: 4;
+    readonly COMPONENT: 5;
+    readonly INPUTS: 6;
+    readonly COMPONENT_TYPE: 7;
+};
+type HtmlOpenRenderCommand = [
+    type: typeof RENDER_COMMAND_TYPE.HTML_OPEN,
+    nestingLevel: number,
+    domPosition: number,
+    index: number,
+    attributes: Record<string, string>,
+    tagName: string,
+    elementId: string
+];
+type HtmlCloseRenderCommand = [
+    type: typeof RENDER_COMMAND_TYPE.HTML_CLOSE,
+    nestingLevel: number,
+    domPosition: number,
+    index: number,
+    tagName: string,
+    elementId: string
+];
+type TextRenderCommand = [
+    type: typeof RENDER_COMMAND_TYPE.TEXT,
+    nestingLevel: number,
+    domPosition: number,
+    index: number,
+    text: string
+];
+type ComponentRenderCommand = [
+    type: typeof RENDER_COMMAND_TYPE.COMPONENT,
+    nestingLevel: number,
+    domPosition: number,
+    index: number,
+    attributes: Record<string, string>,
+    component: ComponentType<unknown>,
+    inputs: Record<string, unknown>,
+    componentType: string
+];
+type RenderCommand = HtmlOpenRenderCommand | HtmlCloseRenderCommand | TextRenderCommand | ComponentRenderCommand;
+export declare const RENDER_INSTRUCTION_POSITION: {
+    readonly TYPE: 0;
+    readonly COMMAND: 1;
+};
+export declare const RENDER_INSTRUCTION_TYPE: {
+    readonly CREATE: 0;
+    readonly UPDATE: 1;
+    readonly DELETE: 2;
+    readonly MOVE: 3;
+};
+type RenderInstructionTypeValue = (typeof RENDER_INSTRUCTION_TYPE)[keyof typeof RENDER_INSTRUCTION_TYPE];
+type RenderInstruction = [RenderInstructionTypeValue, RenderCommand];
+export declare const marksToClass: (marks: Mark[]) => string;
+export declare const isHtmlOpenRenderCommand: (command: RenderCommand) => command is HtmlOpenRenderCommand;
+export declare const isHtmlCloseRenderCommand: (command: RenderCommand) => command is HtmlCloseRenderCommand;
+export declare const isTextRenderCommand: (command: RenderCommand) => command is TextRenderCommand;
+export declare const isComponentRenderCommand: (command: RenderCommand) => command is ComponentRenderCommand;
+export declare const getRenderCommandId: (command: RenderCommand) => string;
+type ExecutedCommandCacheItemBase = {
+    element: HTMLElement;
+};
+type ExecutedComponentCommandCacheItem = {
+    command: ComponentRenderCommand;
+    componentRef: ComponentRef<unknown>;
+} & ExecutedCommandCacheItemBase;
+type ExecutedHtmlCommandCacheItem = {
+    command: HtmlOpenRenderCommand | HtmlCloseRenderCommand;
+} & ExecutedCommandCacheItemBase;
+type ExecutedTextCommandCacheItem = {
+    command: TextRenderCommand;
+    textNode: unknown;
+} & ExecutedCommandCacheItemBase;
+type ExecutedCommandCacheItem = ExecutedComponentCommandCacheItem | ExecutedHtmlCommandCacheItem | ExecutedTextCommandCacheItem;
+export declare const isExecutedComponentCommandCacheItem: (cache: ExecutedCommandCacheItem) => cache is ExecutedComponentCommandCacheItem;
+export declare const isExecutedHtmlOrTextCommandCacheItem: (cache: ExecutedCommandCacheItem) => cache is ExecutedHtmlCommandCacheItem;
+export declare const isExecutedTextCommandCacheItem: (cache: ExecutedCommandCacheItem) => cache is ExecutedTextCommandCacheItem;
+export type ContentfulIncludeMap = {
+    assets: Record<string, ContentfulAsset>;
+    entries: Record<string, ContentfulEntry>;
+};
 export declare class ContentfulRichTextRendererComponent {
-    get richText(): RichTextResponse | null | undefined;
-    set richText(v: RichTextResponse | null | undefined);
-    private _richText;
-    private _renderer;
-    private _elementRef;
-    private _componentFactoryResolver;
-    private _document;
-    private _appRef;
-    private _injector;
-    private _config;
-    resetAndRender(): void;
-    private _render;
-    private _executeCommand;
+    _viewContainerRef: ViewContainerRef;
+    _renderer: Renderer2;
+    _elementRef: ElementRef<HTMLElement>;
+    _document: Document;
+    _config: import("../../types").ContentfulConfig;
+    /**
+     * 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.
+     */
+    _executedCommandsCache: Map<string, ExecutedCommandCacheItem>;
+    /**
+     * The contentful response gotten via their REST api.
+     * @see https://www.contentful.com/developers/docs/references/content-delivery-api/#/reference/entries/entries-collection
+     */
+    content: import("@angular/core").InputSignal<ContentfulCollection | null | undefined>;
+    /**
+     * The path to where the rich text field is inside the contentful response. Dot and array notation is allowed.
+     * @default "items[0].fields.html"
+     */
+    richTextPath: import("@angular/core").InputSignal<string>;
+    /**
+     * 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.
+     */
+    contentIncludesMap: import("@angular/core").Signal<ContentfulIncludeMap>;
+    /**
+     * The rich text data that should be rendered.
+     */
+    richTextData: import("@angular/core").Signal<RichTextResponse | null>;
+    renderCommands: import("@angular/core").Signal<RenderCommand[]>;
+    renderCommandHistory: import("@angular/core").Signal<[RenderCommand[], RenderCommand[]]>;
+    previousRenderCommandMap: import("@angular/core").Signal<Map<string | number, RenderCommand>>;
+    renderInstructions: import("@angular/core").Signal<RenderInstruction[]>;
+    constructor();
+    private _createRenderCommands;
+    private _execInstructions;
+    private _runCreateInstruction;
+    private _runUpdateInstruction;
+    private _runMoveInstruction;
+    private _runDeleteInstruction;
+    private _getComponentRootNode;
+    private _updateComponentInputs;
+    private _findParent;
+    private _findFollowingElement;
+    private _renderInsertOrAppend;
+    private _debugVisualizeRenderCommands;
+    private _stringifyRenderCommand;
+    private _stringifyRenderInstruction;
     static ɵfac: i0.ɵɵFactoryDeclaration<ContentfulRichTextRendererComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<ContentfulRichTextRendererComponent, "et-contentful-rich-text-renderer", never, { "richText": { "alias": "richText"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ContentfulRichTextRendererComponent, "et-contentful-rich-text-renderer", never, { "content": { "alias": "content"; "required": true; "isSignal": true; }; "richTextPath": { "alias": "richTextPath"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
 }
+export {};

package/lib/components/rich-text-renderer/rich-text-renderer.errors.d.ts

@@ -0,0 +1,12 @@
+export declare const RICH_TEXT_RENDERER_ERRORS: {
+    readonly rich_text_undefined: "The property value given at richTextPath is undefined. Use the richTextPath input to specify the path to the rich text object.";
+    readonly rich_text_wrong_type: "The rich text object does not satisfy the RichTextResponse interface. It should contain a property named \"nodeType\" with the value \"document\".";
+    readonly asset_id_not_found: "The asset ID was not found. This node is not supported.";
+    readonly entry_id_not_found: "The entry ID was not found. This node is not supported.";
+    readonly asset_not_found: "The asset was not found. This node is not supported.";
+    readonly entry_not_found: "The entry was not found. This node is not supported.";
+    readonly custom_component_not_found: "No custom component found for entry type. Please provide one for this type.";
+    readonly text_parent_not_found: "The parent node is not found. This structure is not supported.";
+    readonly text_parent_wrong_type: "The parent node neither a html element nor a custom component. This structure is not supported.";
+};
+export declare const richTextRendererError: (code: keyof typeof RICH_TEXT_RENDERER_ERRORS, devOnly: boolean, data?: unknown) => never;

package/lib/components/rich-text-renderer/rich-text-renderer.util.d.ts

@@ -1,17 +1,4 @@
-import { Block, BLOCKS, Inline, INLINES, Mark, Text } from '@contentful/rich-text-types';
-import { ContentfulConfig, ContentfulEntryBase, RichTextResponse } from '../../types';
-import { ContentfulResourceMap, RichTextRenderCommand } from './rich-text-renderer.types';
-export declare const createRenderCommandsFromContentfulRichText: (options: {
-    data: RichTextResponse;
-    config: ContentfulConfig;
-}) => RichTextRenderCommand[];
-export declare const createContentfulRenderCommand: (node: Block | Inline | Text, parent: RichTextRenderCommand, resourceMap: ContentfulResourceMap, config: ContentfulConfig) => RichTextRenderCommand;
-export declare const getContentfulNodeProps: (node: Block | Inline | Text) => {
-    children: (Block | Inline | Text)[] | null;
-    marks: Mark[] | null;
-    value: string | null;
-};
-export declare const transformContentfulMarks: (marks: Mark[], useTailwindClasses: boolean) => string;
-export declare const translateContentfulNodeTypeToHtmlTag: (nodeType: 'text' | BLOCKS | INLINES) => "h1" | "h2" | "h3" | "h4" | "h5" | "h6" | "p" | "ul" | "ol" | "li" | "hr" | "blockquote" | "table" | "tr" | "td" | "th" | "div" | "a" | "span" | "document";
-export declare const createContentfulResourceMap: (links: RichTextResponse['links']) => ContentfulResourceMap;
-export declare const createContentfulMap: <T extends ContentfulEntryBase>(links: Array<T> | null | undefined) => Map<string, T>;
+import { BLOCKS, INLINES } from '@contentful/rich-text-types';
+import { RichTextResponse } from '../../types';
+export declare const isRichTextRootNode: (node: unknown) => node is RichTextResponse;
+export declare const translateContentfulNodeTypeToHtmlTag: (nodeType: 'text' | BLOCKS | INLINES) => "document" | "h1" | "h2" | "h3" | "h4" | "h5" | "h6" | "p" | "ul" | "ol" | "li" | "hr" | "blockquote" | "table" | "tr" | "td" | "th" | "div" | "a" | "span";

package/lib/components/video/contentful-video.component.d.ts

@@ -1,14 +1,9 @@
-import { OnInit } from '@angular/core';
 import { NgClassType } from '@ethlete/core';
 import { ContentfulAsset } from '../../types';
 import * as i0 from "@angular/core";
-export declare class ContentfulVideoComponent implements OnInit {
-    private _richTextData;
-    get data(): ContentfulAsset | null | undefined;
-    set data(v: ContentfulAsset | null | undefined);
-    private _data;
-    videoClass: NgClassType;
-    ngOnInit(): void;
+export declare class ContentfulVideoComponent {
+    asset: import("@angular/core").InputSignal<ContentfulAsset | null | undefined>;
+    videoClass: import("@angular/core").InputSignal<NgClassType>;
     static ɵfac: i0.ɵɵFactoryDeclaration<ContentfulVideoComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<ContentfulVideoComponent, "et-contentful-video", never, { "data": { "alias": "data"; "required": false; }; "videoClass": { "alias": "videoClass"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ContentfulVideoComponent, "et-contentful-video", never, { "asset": { "alias": "asset"; "required": true; "isSignal": true; }; "videoClass": { "alias": "videoClass"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/lib/gql/asset.fragments.d.ts

@@ -1,2 +1 @@
 export declare const GQL_FRAGMENT_CONTENTFUL_ASSET: string;
-export declare const GQL_FRAGMENT_CONTENTFUL_IMAGE: string;

package/lib/types/contentful.types.d.ts

@@ -1,54 +1,17 @@
 import { ComponentType } from '@angular/cdk/portal';
-import { Document as ContentfulDocument } from '@contentful/rich-text-types';
-export interface ContentfulAsset {
-    sys: {
-        id: string;
-    };
-    title: string;
-    contentType: string;
-    url: string;
-    description: string | null;
-    width: number | null;
-    height: number | null;
-    size: number;
-    priority?: boolean;
-    __typename: string;
-}
+import { InputSignal } from '@angular/core';
+import { Block, NodeData } from '@contentful/rich-text-types';
+import { ContentfulIncludeMap } from '../components/rich-text-renderer';
 export type ContentfulImageResizeBehavior = 'pad' | 'crop' | 'fill' | 'scale' | 'thumb' | 'fit';
 export type ContentfulImageFocusArea = 'top' | 'bottom' | 'left' | 'right' | 'center' | 'top_left' | 'top_right' | 'bottom_left' | 'bottom_right' | 'face' | 'faces';
-export interface ContentfulImage {
-    sys: {
-        id: string;
-    };
-    asset: ContentfulAsset;
-    alt: string | null;
-    caption: string | null;
-    resizeBehavior: ContentfulImageResizeBehavior | null;
-    focusArea: ContentfulImageFocusArea | null;
-    quality: number;
-    __typename: string;
-}
-export interface RichTextResponse {
-    json: ContentfulDocument;
-    links: {
-        assets?: {
-            block?: Array<ContentfulAsset>;
-            inline?: Array<ContentfulAsset>;
-        };
-        entries?: {
-            block?: Array<ContentfulEntryBase>;
-            inline?: Array<ContentfulEntryBase>;
-        };
-    };
-}
-export interface ContentfulEntryBase {
-    sys: {
-        id: string;
-    };
-    __typename: string;
-}
 type ComponentLikeWithAsset = ComponentType<{
-    data: ContentfulAsset | ContentfulImage | null | undefined;
+    asset: InputSignal<ContentfulAsset | null | undefined>;
+}>;
+type ComponentLikeWithContentfulRendererInputs = ComponentType<{
+    fields?: InputSignal<any>;
+    includes?: InputSignal<ContentfulIncludeMap>;
+    metadata?: InputSignal<ContentfulMetadata>;
+    sys?: InputSignal<ContentfulSys>;
 }>;
 export interface ContentfulAssetComponents {
     file: ComponentLikeWithAsset;
@@ -64,7 +27,7 @@ export interface ContentfulConfig {
     /**
      * Component for rendering embedded entries
      */
-    customComponents: Record<string, ComponentType<unknown>>;
+    customComponents: Record<string, ComponentLikeWithContentfulRendererInputs>;
     /**
      * Determines if the contentful rich text renderer should render the contentful rich text with tailwind css classes
      */
@@ -95,4 +58,85 @@ export interface ContentfulConfig {
         backgroundColor: string | null;
     };
 }
+export type ContentfulLinkType = 'Space' | 'ContentType' | 'Environment';
+export interface ContentfulLink<T extends ContentfulLinkType> {
+    type: 'Link';
+    linkType: T;
+    id: string;
+}
+export type ContentfulSpaceLink = ContentfulLink<'Space'>;
+export type ContentfulEnvironmentLink = ContentfulLink<'Environment'>;
+export type ContentfulContentTypeLink = ContentfulLink<'ContentType'>;
+export interface ContentfulTagLink {
+    sys: {
+        type: 'Link';
+        linkType: 'Tag';
+        id: string;
+    };
+}
+export interface ContentfulMetadata {
+    tags: ContentfulTagLink[];
+}
+export interface ContentfulSys {
+    type: string;
+    id: string;
+    createdAt: string;
+    updatedAt: string;
+    locale: string;
+    revision?: number;
+    space?: {
+        sys: ContentfulSpaceLink;
+    };
+    environment?: {
+        sys: ContentfulEnvironmentLink;
+    };
+    contentType: {
+        sys: ContentfulContentTypeLink;
+    };
+}
+export interface ContentfulAssetImageData {
+    width: number;
+    height: number;
+}
+export interface ContentfulAssetFileData {
+    url: string;
+    details: {
+        size: number;
+        image?: ContentfulAssetImageData;
+    };
+    fileName: string;
+    contentType: string;
+}
+export interface ContentfulAsset {
+    sys: ContentfulSys;
+    fields: {
+        title: string;
+        description: string;
+        file: ContentfulAssetFileData;
+    };
+    metadata: ContentfulMetadata;
+}
+export interface ContentfulEntry<T = Record<string, unknown>> {
+    sys: ContentfulSys;
+    fields: T;
+    metadata: ContentfulMetadata;
+}
+export interface ContentfulCollection {
+    includes: {
+        Asset: ContentfulAsset[];
+        Entry: ContentfulEntry[];
+    };
+    items: ContentfulEntry[];
+    limit: number;
+    skip: number;
+    total: number;
+    sys: {
+        type: 'Array';
+    };
+}
+export interface RichTextResponse {
+    nodeType: 'document';
+    data: NodeData;
+    content: Block[];
+}
 export {};

package/lib/utils/contentful.util.d.ts

@@ -1,7 +1,5 @@
-import { ContentfulAsset, ContentfulConfig, ContentfulImage } from '../types';
+import { ContentfulConfig } from '../types';
 export declare const provideContentfulConfig: (contentfulConfig?: Partial<ContentfulConfig> | null | undefined) => {
     provide: import("@angular/core").InjectionToken<ContentfulConfig>;
     useValue: ContentfulConfig;
 };
-export declare const isContentfulImage: (v: ContentfulAsset | ContentfulImage | null | undefined) => v is ContentfulImage;
-export declare const isContentfulAsset: (v: ContentfulAsset | ContentfulImage | null | undefined) => v is ContentfulAsset;

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@ethlete/contentful",
-  "version": "2.1.2",
+  "version": "3.0.1",
   "peerDependencies": {
-    "@angular/cdk": "17.2.2",
-    "@angular/common": "17.3.0",
-    "@angular/core": "17.3.0",
+    "@angular/cdk": "17.3.3",
+    "@angular/common": "17.3.3",
+    "@angular/core": "17.3.3",
     "@contentful/rich-text-types": "^16.3.0",
     "@ethlete/cdk": "^4.0.3",
     "@ethlete/core": "^4.0.3",

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

@@ -1,3 +0,0 @@
-import { InjectionToken } from '@angular/core';
-export const RICH_TEXT_RENDERER_COMPONENT_DATA = new InjectionToken('RICH_TEXT_RENDERER_COMPONENT_DATA');
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmljaC10ZXh0LXJlbmRlcmVyLmNvbnN0YW50cy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY29udGVudGZ1bC9zcmMvbGliL2NvbXBvbmVudHMvcmljaC10ZXh0LXJlbmRlcmVyL3JpY2gtdGV4dC1yZW5kZXJlci5jb25zdGFudHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUUvQyxNQUFNLENBQUMsTUFBTSxpQ0FBaUMsR0FBRyxJQUFJLGNBQWMsQ0FBVSxtQ0FBbUMsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0aW9uVG9rZW4gfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuZXhwb3J0IGNvbnN0IFJJQ0hfVEVYVF9SRU5ERVJFUl9DT01QT05FTlRfREFUQSA9IG5ldyBJbmplY3Rpb25Ub2tlbjx1bmtub3duPignUklDSF9URVhUX1JFTkRFUkVSX0NPTVBPTkVOVF9EQVRBJyk7XG4iXX0=

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

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmljaC10ZXh0LXJlbmRlcmVyLnR5cGVzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9jb250ZW50ZnVsL3NyYy9saWIvY29tcG9uZW50cy9yaWNoLXRleHQtcmVuZGVyZXIvcmljaC10ZXh0LXJlbmRlcmVyLnR5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb250ZW50ZnVsQXNzZXQsIENvbnRlbnRmdWxFbnRyeUJhc2UgfSBmcm9tICcuLi8uLi90eXBlcyc7XG5cbmV4cG9ydCBpbnRlcmZhY2UgUmljaFRleHRSZW5kZXJDb21tYW5kIHtcbiAgcGF5bG9hZDogc3RyaW5nIHwgKG5ldyAoKSA9PiB1bmtub3duKTtcbiAgZGF0YT86IHVua25vd247XG4gIGF0dHJpYnV0ZXM/OiBSZWNvcmQ8c3RyaW5nLCBzdHJpbmc+O1xuICBjaGlsZHJlbjogUmljaFRleHRSZW5kZXJDb21tYW5kW107XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgQ29udGVudGZ1bFJlc291cmNlTWFwIHtcbiAgcmVhZG9ubHkgYXNzZXRzQmxvY2s6IE1hcDxzdHJpbmcsIENvbnRlbnRmdWxBc3NldD47XG4gIHJlYWRvbmx5IGVudHJpZXNJbmxpbmU6IE1hcDxzdHJpbmcsIENvbnRlbnRmdWxFbnRyeUJhc2U+O1xuICByZWFkb25seSBlbnRyaWVzQmxvY2s6IE1hcDxzdHJpbmcsIENvbnRlbnRmdWxFbnRyeUJhc2U+O1xufVxuIl19

package/lib/components/rich-text-renderer/rich-text-renderer.constants.d.ts

@@ -1,2 +0,0 @@
-import { InjectionToken } from '@angular/core';
-export declare const RICH_TEXT_RENDERER_COMPONENT_DATA: InjectionToken<unknown>;

package/lib/components/rich-text-renderer/rich-text-renderer.types.d.ts

@@ -1,12 +0,0 @@
-import { ContentfulAsset, ContentfulEntryBase } from '../../types';
-export interface RichTextRenderCommand {
-    payload: string | (new () => unknown);
-    data?: unknown;
-    attributes?: Record<string, string>;
-    children: RichTextRenderCommand[];
-}
-export interface ContentfulResourceMap {
-    readonly assetsBlock: Map<string, ContentfulAsset>;
-    readonly entriesInline: Map<string, ContentfulEntryBase>;
-    readonly entriesBlock: Map<string, ContentfulEntryBase>;
-}