@vonage/vivid 5.12.0 → 5.15.0

package/lib/rich-text-editor/rte/feature.d.ts

@@ -1,12 +1,11 @@
-import type { SchemaSpec } from 'prosemirror-model';
-import type { Plugin } from 'prosemirror-state';
-import type { Constructor } from '../../../shared/utils/mixins';
-import type { RteInstanceImpl } from './instance';
-import { TextblockAttrs, type TextblockAttrSpec } from './utils/textblock-attrs';
-import { impl } from './utils/impl';
-import type { ToolbarItemSpec } from './features/toolbar';
-import { TextblockMarks, type TextblockMarkSpec } from './utils/textblock-marks';
-import type { InputRuleSpec } from './features/internal/input-rules';
+import { SchemaSpec } from 'prosemirror-model';
+import { Plugin } from 'prosemirror-state';
+import { Constructor } from '../../../shared/utils/mixins';
+import { RteInstanceImpl } from './instance';
+import { TextblockAttrs, TextblockAttrSpec } from './utils/textblock-attrs';
+import { ToolbarItemSpec } from './features/toolbar';
+import { TextblockMarks, TextblockMarkSpec } from './utils/textblock-marks';
+import { InputRuleSpec } from './features/internal/input-rules';
 type Contribution<T> = {
     priority: number;
     featureName: string;
@@ -43,10 +42,9 @@ export declare abstract class RteFeatureImpl {
     getFeatures(): RteFeatureImpl[];
     getPublicInterface(rte: RteInstanceImpl): any;
 }
+export declare const getFeatureImpl: (facade: RteFeature) => RteFeatureImpl;
 export declare const featureFacade: <T extends RteFeatureImpl, C extends Constructor<T>>(FeatureImpl: C) => {
-    new (...args: ConstructorParameters<C>): {
-        [impl]: T;
-    };
+    new (...args: ConstructorParameters<C>): {};
 };
 export declare function getPublicInterface(facade: Constructor<RteFeature>): unknown;
 export {};

package/lib/rich-text-editor/rte/features/alignment.d.ts

@@ -0,0 +1,19 @@
+import { Command, EditorState } from 'prosemirror-state';
+import { RteFeatureImpl, TextblockAttrContribution, ToolbarItemContribution } from '../feature';
+type Alignment = 'left' | 'center' | 'right';
+export declare class RteAlignmentFeatureImpl extends RteFeatureImpl {
+    name: string;
+    getTextblockAttrs(): TextblockAttrContribution[];
+    getPlugins(): {
+        priority: number;
+        featureName: string;
+        value: import('prosemirror-state').Plugin<any>;
+    }[];
+    getToolbarItems(): ToolbarItemContribution[];
+    getAlignmentFromSelection(state: EditorState): Alignment | 'mixed' | null;
+    setAlignment(align: Alignment): Command;
+}
+export declare const RteAlignmentFeature: {
+    new (): {};
+};
+export {};

package/lib/rich-text-editor/rte/features/atom.d.ts

@@ -0,0 +1,9 @@
+export type ResolvedAtomValue = string | null;
+export type ResolvedAtomValueGenerator = AsyncGenerator<ResolvedAtomValue, ResolvedAtomValue>;
+export interface RteAtomConfig {
+    resolveValue?: (value: string) => ResolvedAtomValue | ResolvedAtomValueGenerator;
+    serializeValueToHtml?: (value: string) => string | null;
+}
+export declare const RteAtomFeature: {
+    new (atomName: string, config?: RteAtomConfig | undefined): {};
+};

package/lib/rich-text-editor/rte/features/base.d.ts

@@ -0,0 +1,33 @@
+import { RteFeatureImpl } from '../feature';
+import { RteInstanceImpl } from '../instance';
+import { RteBasePublicInterface } from '../public-interface';
+export type RteBaseConfig = {
+    heading1?: boolean;
+    heading2?: boolean;
+    heading3?: boolean;
+    paragraph?: boolean;
+};
+export declare class RteBaseImpl extends RteFeatureImpl {
+    protected config?: RteBaseConfig | undefined;
+    name: string;
+    constructor(config?: RteBaseConfig | undefined);
+    getSchema(): {
+        priority: number;
+        featureName: string;
+        value: {
+            nodes: {
+                doc: {
+                    content: string;
+                };
+                text: {
+                    group: string;
+                };
+            };
+        };
+    }[];
+    getFeatures(): RteFeatureImpl[];
+    getPublicInterface(rte: RteInstanceImpl): RteBasePublicInterface;
+}
+export declare const RteBase: {
+    new (config?: RteBaseConfig | undefined): {};
+};

package/lib/rich-text-editor/rte/features/bold.d.ts

@@ -0,0 +1,17 @@
+import { RteInstanceImpl } from '../instance';
+import { SchemaContribution, ToolbarItemContribution } from '../feature';
+import { RteTextStyleFeatureImpl } from './internal/text-style';
+export declare class RteBoldFeatureImpl extends RteTextStyleFeatureImpl {
+    name: string;
+    protected markName: string;
+    getSchema(): SchemaContribution[];
+    getPlugins(rte: RteInstanceImpl): {
+        priority: number;
+        featureName: string;
+        value: import('prosemirror-state').Plugin<any>;
+    }[];
+    getToolbarItems(rte: RteInstanceImpl): ToolbarItemContribution[];
+}
+export declare const RteBoldFeature: {
+    new (config?: import('./internal/text-style').RteTextStyleConfig | undefined): {};
+};

package/lib/rich-text-editor/rte/features/drop-handler.d.ts

@@ -0,0 +1,21 @@
+import { Plugin } from 'prosemirror-state';
+import { RteFeatureImpl } from '../feature';
+import { RteInstanceImpl } from '../instance';
+export interface RteDropHandlerConfig {
+    onViewportDragOver?: (event: DragEvent) => boolean;
+    onViewportDrop?: (event: DragEvent) => void;
+    onViewportDragFinish?: () => void;
+}
+export declare class RteDropHandlerFeatureImpl extends RteFeatureImpl {
+    readonly config: RteDropHandlerConfig;
+    name: string;
+    constructor(config: RteDropHandlerConfig);
+    getPlugins(rte: RteInstanceImpl): {
+        priority: number;
+        featureName: string;
+        value: Plugin<any>;
+    }[];
+}
+export declare const RteDropHandlerFeature: {
+    new (config: RteDropHandlerConfig): {};
+};

package/lib/rich-text-editor/rte/features/file-handler.d.ts

@@ -0,0 +1,25 @@
+import { Plugin } from 'prosemirror-state';
+import { DecorationSet } from 'prosemirror-view';
+import { RteFeatureImpl } from '../feature';
+import { RteInstanceImpl } from '../instance';
+import { RteFragment } from '../document';
+export interface RteFileHandlerConfig {
+    handleFiles: (files: File[]) => RteFragment | Promise<RteFragment> | null;
+}
+export declare class RteFileHandlerFeatureImpl extends RteFeatureImpl {
+    readonly config: RteFileHandlerConfig;
+    name: string;
+    constructor(config: RteFileHandlerConfig);
+    getPlugins(rte: RteInstanceImpl): ({
+        priority: number;
+        featureName: string;
+        value: Plugin<any>;
+    } | {
+        priority: number;
+        featureName: string;
+        value: Plugin<DecorationSet>;
+    })[];
+}
+export declare const RteFileHandlerFeature: {
+    new (config: RteFileHandlerConfig): {};
+};

package/lib/rich-text-editor/rte/features/font-size-picker.d.ts

@@ -0,0 +1,46 @@
+import { Command, EditorState } from 'prosemirror-state';
+import { RteInstanceImpl } from '../instance';
+import { RteFeatureImpl, SchemaContribution, ToolbarItemContribution } from '../feature';
+export interface FontSizeOption {
+    size: string;
+    label: string;
+}
+export interface FontSizeOnBlock {
+    node: string;
+    defaultSize?: string;
+}
+export type RteFontSizePickerConfig = {
+    options: FontSizeOption[];
+    onBlocks?: FontSizeOnBlock[];
+};
+declare const mixedFontSize: unique symbol;
+type MixedFontSize = typeof mixedFontSize;
+type SelectionFontSize = string | MixedFontSize | null;
+export declare class RteFontSizePickerFeatureImpl extends RteFeatureImpl {
+    protected config: RteFontSizePickerConfig;
+    name: string;
+    fontSizes: FontSizeOption[];
+    defaultFontSizeForNode?: Record<string, string | null>;
+    constructor(config: RteFontSizePickerConfig);
+    getTextblockMarks(): {
+        priority: number;
+        featureName: string;
+        value: {
+            markName: string;
+        };
+    }[];
+    getSchema(): SchemaContribution[];
+    getPlugins(): {
+        priority: number;
+        featureName: string;
+        value: import('prosemirror-state').Plugin<any>;
+    }[];
+    getToolbarItems(rte: RteInstanceImpl): ToolbarItemContribution[];
+    getFontSizeFromSelection(state: EditorState): SelectionFontSize;
+    setFontSize(size: string): Command;
+    adjustFontSize(adjustment: -1 | 1): Command;
+}
+export declare const RteFontSizePickerFeature: {
+    new (config: RteFontSizePickerConfig): {};
+};
+export {};

package/lib/rich-text-editor/rte/features/hard-break.d.ts

@@ -0,0 +1,10 @@
+import { PluginContribution, RteFeatureImpl, SchemaContribution } from '../feature';
+import { RteInstanceImpl } from '../instance';
+export declare class RteHardBreakFeatureImpl extends RteFeatureImpl {
+    name: string;
+    getSchema(): SchemaContribution[];
+    getPlugins(_rte: RteInstanceImpl): PluginContribution[];
+}
+export declare const RteHardBreakFeature: {
+    new (): {};
+};

package/lib/rich-text-editor/rte/features/inline-image.d.ts

@@ -0,0 +1,43 @@
+import { Node } from 'prosemirror-model';
+import { Command, EditorState, Plugin } from 'prosemirror-state';
+import { RteFeatureImpl, SchemaContribution } from '../feature';
+import { RteInstanceImpl } from '../instance';
+type SizeOption = 'small' | 'fit' | 'original';
+type ContentDestroyedHandler = () => unknown;
+export type ResolvedUrl = string | null | {
+    type: 'placeholder';
+    create?: (slotName: string) => ContentDestroyedHandler | undefined;
+};
+type ResolvedUrlGenerator = AsyncGenerator<ResolvedUrl, ResolvedUrl>;
+export interface RteInlineImageConfig {
+    resolveUrl?: (imageUrl: string) => ResolvedUrl | ResolvedUrlGenerator;
+    serializeUrlToHtml?: (imageUrl: string) => string | null;
+    parseUrlFromHtml?: (src: string) => string | null;
+}
+export declare class RteInlineImageFeatureImpl extends RteFeatureImpl {
+    protected readonly config: RteInlineImageConfig;
+    name: string;
+    constructor(config?: RteInlineImageConfig);
+    getStyles(): {
+        priority: number;
+        featureName: string;
+        value: string;
+    }[];
+    getSchema(): SchemaContribution[];
+    getPlugins(rte: RteInstanceImpl): {
+        priority: number;
+        featureName: string;
+        value: Plugin<any>;
+    }[];
+    calculateSmallWidth(naturalWidth: number): string;
+    getSelectedInlineImage(state: EditorState): {
+        pos: number;
+        node: Node;
+    } | null;
+    setSelectedImageSize(size: SizeOption): Command;
+    getSelectedImageSize(state: EditorState): SizeOption | null;
+}
+export declare const RteInlineImageFeature: {
+    new (config?: RteInlineImageConfig | undefined): {};
+};
+export {};

package/lib/rich-text-editor/rte/features/input-rule.d.ts

@@ -0,0 +1,10 @@
+import { RteFragment } from '../document';
+export type InputRuleHandler = (match: RegExpMatchArray) => RteFragment | null;
+export interface RteInputRuleFeatureOptions {
+    pattern: RegExp;
+    handler: InputRuleHandler;
+    matchAfterWhitespace?: boolean;
+}
+export declare const RteInputRuleFeature: {
+    new (featureId: string, options: RteInputRuleFeatureOptions): {};
+};

package/lib/rich-text-editor/rte/features/internal/basic-text-blocks.d.ts

@@ -1,9 +1,9 @@
-import type { NodeSpec } from 'prosemirror-model';
-import { type Command, EditorState } from 'prosemirror-state';
-import { type PluginContribution, RteFeatureImpl } from '../../feature';
-import type { RteInstanceImpl } from '../../instance';
-import type { TextblockAttrs } from '../../utils/textblock-attrs';
-import type { TextblockMarks } from '../../utils/textblock-marks';
+import { NodeSpec } from 'prosemirror-model';
+import { Command, EditorState } from 'prosemirror-state';
+import { PluginContribution, RteFeatureImpl } from '../../feature';
+import { RteInstanceImpl } from '../../instance';
+import { TextblockAttrs } from '../../utils/textblock-attrs';
+import { TextblockMarks } from '../../utils/textblock-marks';
 type EnabledBlocks = {
     heading1: boolean;
     heading2: boolean;

package/lib/rich-text-editor/rte/features/internal/core.d.ts

@@ -0,0 +1,37 @@
+import { Plugin } from 'prosemirror-state';
+import { RteFeatureImpl } from '../../feature';
+import { Locale } from '../../../../../shared/localization/Locale';
+import { VividElementDefinitionContext } from '../../../../../shared/design-system/defineVividComponent';
+import { RteInstanceImpl } from '../../instance';
+import { FeatureState } from '../../utils/feature-state';
+export interface HostState {
+    ctx: VividElementDefinitionContext;
+    locale: Locale;
+}
+export declare const hostBridgePlugin: Plugin<HostState | null>;
+export declare class RteCoreImpl extends RteFeatureImpl {
+    name: string;
+    disabled: FeatureState<boolean>;
+    getStyles(): {
+        priority: number;
+        featureName: string;
+        value: string;
+    }[];
+    getPlugins(rte: RteInstanceImpl): ({
+        priority: number;
+        featureName: string;
+        value: Plugin<any>;
+    } | {
+        priority: number;
+        featureName: string;
+        value: Plugin<boolean>;
+    } | {
+        priority: number;
+        featureName: string;
+        value: Plugin<HostState | null>;
+    })[];
+    getFeatures(): RteFeatureImpl[];
+}
+export declare const RteCore: {
+    new (): {};
+};

package/lib/rich-text-editor/rte/features/internal/cursor-fix.d.ts

@@ -0,0 +1,16 @@
+import { MarkSpec, ResolvedPos } from 'prosemirror-model';
+import { EditorState } from 'prosemirror-state';
+import { PluginContribution, RteFeatureImpl } from '../../feature';
+import { RteInstanceImpl } from '../../instance';
+export type CursorFix = Record<string, string>;
+export type CursorFixFn = ($cursor: ResolvedPos, state: EditorState) => CursorFix | null;
+export interface CursorFixMarkSpec extends MarkSpec {
+    cursorFix?: CursorFixFn;
+}
+export declare class RteCursorFixFeatureImpl extends RteFeatureImpl {
+    name: string;
+    getPlugins(rte: RteInstanceImpl): PluginContribution[];
+}
+export declare const RteCursorFixFeature: {
+    new (): {};
+};

package/lib/rich-text-editor/rte/features/internal/foreign-html.d.ts

@@ -1,6 +1,6 @@
 import { Plugin } from 'prosemirror-state';
 import { RteFeatureImpl } from '../../feature';
-import type { RteInstanceImpl } from '../../instance';
+import { RteInstanceImpl } from '../../instance';
 export declare class RteForeignHtmlFeatureImpl extends RteFeatureImpl {
     name: string;
     getPlugins(rte: RteInstanceImpl): {

package/lib/rich-text-editor/rte/features/internal/history.d.ts

@@ -1,10 +1,10 @@
-import { RteFeatureImpl, type ToolbarItemContribution } from '../../feature';
+import { RteFeatureImpl, ToolbarItemContribution } from '../../feature';
 export declare class RteHistoryFeatureImpl extends RteFeatureImpl {
     name: string;
     getPlugins(): {
         priority: number;
         featureName: string;
-        value: import("prosemirror-state").Plugin<any>;
+        value: import('prosemirror-state').Plugin<any>;
     }[];
     getToolbarItems(): ToolbarItemContribution[];
 }

package/lib/rich-text-editor/rte/features/internal/input-rules.d.ts

@@ -1,7 +1,7 @@
-import { type InputRule } from 'prosemirror-inputrules';
-import { type EditorState, type Transaction } from 'prosemirror-state';
-import { type PluginContribution, RteFeatureImpl } from '../../feature';
-import type { RteInstanceImpl } from '../../instance';
+import { InputRule } from 'prosemirror-inputrules';
+import { EditorState, Transaction } from 'prosemirror-state';
+import { PluginContribution, RteFeatureImpl } from '../../feature';
+import { RteInstanceImpl } from '../../instance';
 export interface InputRuleSpec {
     rule: InputRule;
     enterHandler?: {

package/lib/rich-text-editor/rte/features/italic.d.ts

@@ -0,0 +1,17 @@
+import { RteInstanceImpl } from '../instance';
+import { SchemaContribution, ToolbarItemContribution } from '../feature';
+import { RteTextStyleFeatureImpl } from './internal/text-style';
+export declare class RteItalicFeatureImpl extends RteTextStyleFeatureImpl {
+    name: string;
+    protected markName: string;
+    getSchema(): SchemaContribution[];
+    getPlugins(rte: RteInstanceImpl): {
+        priority: number;
+        featureName: string;
+        value: import('prosemirror-state').Plugin<any>;
+    }[];
+    getToolbarItems(rte: RteInstanceImpl): ToolbarItemContribution[];
+}
+export declare const RteItalicFeature: {
+    new (config?: import('./internal/text-style').RteTextStyleConfig | undefined): {};
+};

package/lib/rich-text-editor/rte/features/keyboard-shortcuts.d.ts

@@ -0,0 +1,16 @@
+import { PluginContribution, RteFeatureImpl } from '../feature';
+import { RteInstance, RteInstanceImpl } from '../instance';
+export type KeyboardShortcutHandler = (rteInstance: RteInstance) => boolean;
+export interface RteKeyboardShortcutsFeatureOptions {
+    shortcuts: Record<string, KeyboardShortcutHandler>;
+}
+export declare class RteKeyboardShortcutsFeatureImpl extends RteFeatureImpl {
+    featureId: string;
+    protected readonly options: RteKeyboardShortcutsFeatureOptions;
+    name: string;
+    constructor(featureId: string, options: RteKeyboardShortcutsFeatureOptions);
+    getPlugins(rte: RteInstanceImpl): PluginContribution[];
+}
+export declare const RteKeyboardShortcutsFeature: {
+    new (featureId: string, options: RteKeyboardShortcutsFeatureOptions): {};
+};

package/lib/rich-text-editor/rte/features/link.d.ts

@@ -0,0 +1,33 @@
+import { Command, EditorState } from 'prosemirror-state';
+import { RteInstanceImpl } from '../instance';
+import { InputRuleContribution, PluginContribution, RteFeatureImpl, SchemaContribution, StyleContribution, ToolbarItemContribution } from '../feature';
+import { Menu } from '../../../menu/menu';
+type Link = {
+    text: string;
+    href: string;
+    start: number;
+    end: number;
+};
+export declare class RteLinkFeatureImpl extends RteFeatureImpl {
+    name: string;
+    getStyles(): StyleContribution[];
+    getSchema(): SchemaContribution[];
+    getTextblockMarks(): {
+        priority: number;
+        featureName: string;
+        value: {
+            markName: string;
+        };
+    }[];
+    getInputRules(): InputRuleContribution[];
+    getPlugins(rte: RteInstanceImpl): PluginContribution[];
+    protected toolbarMenu?: Menu;
+    getToolbarItems(rte: RteInstanceImpl): ToolbarItemContribution[];
+    getCurrentLink(state: EditorState): Link | null;
+    removeLink: Command;
+    insertLink(rte: RteInstanceImpl, href: string, text: string): Command;
+}
+export declare const RteLinkFeature: {
+    new (): {};
+};
+export {};

package/lib/rich-text-editor/rte/features/list.d.ts

@@ -0,0 +1,24 @@
+import { NodeType } from 'prosemirror-model';
+import { Command, EditorState } from 'prosemirror-state';
+import { PluginContribution, RteFeatureImpl, SchemaContribution, StyleContribution, ToolbarItemContribution } from '../feature';
+import { RteInstanceImpl } from '../instance';
+import { TextblockAttrs } from '../utils/textblock-attrs';
+export type RteListConfig = {
+    bulletList?: boolean;
+    numberedList?: boolean;
+};
+export declare class RteListFeatureImpl extends RteFeatureImpl {
+    protected config: RteListConfig;
+    name: string;
+    constructor(config: RteListConfig);
+    getStyles(): StyleContribution[];
+    getSchema(textblockAttrs: TextblockAttrs): SchemaContribution[];
+    protected rte: RteInstanceImpl;
+    getPlugins(rte: RteInstanceImpl): PluginContribution[];
+    getToolbarItems(rte: RteInstanceImpl): ToolbarItemContribution[];
+    toggleList(type: NodeType): Command;
+    isSelectionInList(type: NodeType, state: EditorState): boolean;
+}
+export declare const RteListFeature: {
+    new (config: RteListConfig): {};
+};

package/lib/rich-text-editor/rte/features/monospace.d.ts

@@ -0,0 +1,22 @@
+import { RteInstanceImpl } from '../instance';
+import { SchemaContribution, ToolbarItemContribution } from '../feature';
+import { RteTextStyleFeatureImpl } from './internal/text-style';
+export declare class RteMonospaceFeatureImpl extends RteTextStyleFeatureImpl {
+    name: string;
+    protected markName: string;
+    getStyles(): {
+        priority: number;
+        featureName: string;
+        value: string;
+    }[];
+    getSchema(): SchemaContribution[];
+    getPlugins(rte: RteInstanceImpl): {
+        priority: number;
+        featureName: string;
+        value: import('prosemirror-state').Plugin<any>;
+    }[];
+    getToolbarItems(rte: RteInstanceImpl): ToolbarItemContribution[];
+}
+export declare const RteMonospaceFeature: {
+    new (config?: import('./internal/text-style').RteTextStyleConfig | undefined): {};
+};

package/lib/rich-text-editor/rte/features/placeholder.d.ts

@@ -0,0 +1,23 @@
+import { Plugin } from 'prosemirror-state';
+import { RteFeatureImpl } from '../feature';
+export type RtePlaceholderConfig = {
+    text: string;
+};
+export declare class RtePlaceholderFeatureImpl extends RteFeatureImpl {
+    protected config: RtePlaceholderConfig;
+    name: string;
+    constructor(config: RtePlaceholderConfig);
+    getStyles(): {
+        priority: number;
+        featureName: string;
+        value: string;
+    }[];
+    getPlugins(): {
+        priority: number;
+        featureName: string;
+        value: Plugin<any>;
+    }[];
+}
+export declare const RtePlaceholderFeature: {
+    new (config: RtePlaceholderConfig): {};
+};

package/lib/rich-text-editor/rte/features/strikethrough.d.ts

@@ -0,0 +1,17 @@
+import { RteInstanceImpl } from '../instance';
+import { SchemaContribution, ToolbarItemContribution } from '../feature';
+import { RteTextStyleFeatureImpl } from './internal/text-style';
+export declare class RteStrikethroughFeatureImpl extends RteTextStyleFeatureImpl {
+    name: string;
+    protected markName: string;
+    getSchema(): SchemaContribution[];
+    getPlugins(rte: RteInstanceImpl): {
+        priority: number;
+        featureName: string;
+        value: import('prosemirror-state').Plugin<any>;
+    }[];
+    getToolbarItems(rte: RteInstanceImpl): ToolbarItemContribution[];
+}
+export declare const RteStrikethroughFeature: {
+    new (config?: import('./internal/text-style').RteTextStyleConfig | undefined): {};
+};

package/lib/rich-text-editor/rte/features/suggest.d.ts

@@ -0,0 +1,14 @@
+import { RteFragment } from '../document';
+export interface Suggestion {
+    text: string;
+    textSecondary?: string;
+    data?: unknown;
+}
+export interface RteSuggestFeatureOptions {
+    pattern: RegExp;
+    load: (match: string[]) => Suggestion[] | Promise<Suggestion[]>;
+    select: (suggestion: Suggestion) => RteFragment;
+}
+export declare const RteSuggestFeature: {
+    new (featureId: string, options: RteSuggestFeatureOptions): {};
+};

package/lib/rich-text-editor/rte/features/text-block-picker.d.ts

@@ -0,0 +1,18 @@
+import { RteFeatureImpl, ToolbarItemContribution } from '../feature';
+import { RteInstanceImpl } from '../instance';
+export interface TextBlockOption {
+    node: string;
+    label: string;
+}
+export type RteTextBlockPickerConfig = {
+    options: TextBlockOption[];
+};
+export declare class RteTextBlockPickerFeatureImpl extends RteFeatureImpl {
+    protected config: RteTextBlockPickerConfig;
+    name: string;
+    constructor(config: RteTextBlockPickerConfig);
+    getToolbarItems(rte: RteInstanceImpl): ToolbarItemContribution[];
+}
+export declare const RteTextBlockPickerFeature: {
+    new (config: RteTextBlockPickerConfig): {};
+};

package/lib/rich-text-editor/rte/features/text-color-picker.d.ts

@@ -0,0 +1,31 @@
+import { Command, EditorState } from 'prosemirror-state';
+import { RteFeatureImpl, SchemaContribution, ToolbarItemContribution } from '../feature';
+export interface TextColorOnBlock {
+    node: string;
+    defaultColor?: string;
+}
+export interface RteTextColorPickerConfig {
+    onBlocks?: TextColorOnBlock[];
+}
+type SelectionColor = string | null;
+export declare class RteTextColorPickerFeatureImpl extends RteFeatureImpl {
+    protected readonly config?: RteTextColorPickerConfig | undefined;
+    name: string;
+    defaultColorForNode?: Record<string, string | null>;
+    constructor(config?: RteTextColorPickerConfig | undefined);
+    getTextblockMarks(): {
+        priority: number;
+        featureName: string;
+        value: {
+            markName: string;
+        };
+    }[];
+    getSchema(): SchemaContribution[];
+    getToolbarItems(): ToolbarItemContribution[];
+    getSelectionColor(state: EditorState): SelectionColor;
+    setColor(color: string): Command;
+}
+export declare const RteTextColorPickerFeature: {
+    new (config?: RteTextColorPickerConfig | undefined): {};
+};
+export {};

package/lib/rich-text-editor/rte/features/toolbar-button.d.ts

@@ -0,0 +1,13 @@
+export type RteToolbarButtonAction = {
+    type: 'insert-text';
+    text: string;
+};
+export interface RteToolbarButtonFeatureOptions {
+    label: string;
+    icon: string;
+    action: RteToolbarButtonAction;
+    order?: number;
+}
+export declare const RteToolbarButtonFeature: {
+    new (featureId: string, options: RteToolbarButtonFeatureOptions): {};
+};