@vonage/vivid 5.8.0 → 5.10.0

package/lib/popover/popover.template.d.ts

@@ -0,0 +1,3 @@
+import type { VividElementDefinitionContext } from '../../shared/design-system/defineVividComponent';
+import { Popover } from './popover';
+export declare const popoverTemplate: (context: VividElementDefinitionContext) => import("@microsoft/fast-element").ViewTemplate<Popover, any>;

package/lib/rich-text-editor/locale.d.ts

@@ -32,4 +32,6 @@ export interface RichTextEditorLocale {
         fit: string;
         original: string;
     };
+    suggestLoading: string;
+    suggestNoResults: string;
 }

package/lib/rich-text-editor/popover.d.ts

@@ -2,6 +2,7 @@ import { VividElement } from '../../shared/foundation/vivid-element/vivid-elemen
 export declare class Popover extends VividElement {
     #private;
     static setBlockPopover(onElement: HTMLElement, block: boolean): void;
+    kind: 'default' | 'autocomplete';
     offset?: number;
     anchorBlocksPopover: boolean;
     onAnchorBlockPopoverChanged: () => void;

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

@@ -4,15 +4,19 @@ import { RteInstance, type RteInstanceOptions } from './instance';
 import { RteFeature, RteFeatureImpl } from './feature';
 import { TextblockAttrs } from './utils/textblock-attrs';
 import { TextblockMarks } from './utils/textblock-marks';
+import type { RteDocument } from './document';
+import { type RteView, type RteViewOptions } from './view';
 export declare class RteConfig {
     constructor(features: RteFeature[]);
     instantiateEditor(options?: RteInstanceOptions): RteInstance;
+    instantiateView(document: RteDocument, options?: RteViewOptions): RteView;
 }
 export declare class RteConfigImpl {
     schema: Schema;
     textblockAttrs: TextblockAttrs;
     textblockMarks: TextblockMarks;
-    featureMap: Map<Constructor<RteFeatureImpl>, RteFeatureImpl>;
+    featureFacadesMap: Map<Constructor<RteFeature>, RteFeatureImpl[]>;
+    featureMap: Map<string, RteFeatureImpl>;
     features: RteFeatureImpl[];
     constructor(featuresFacades: RteFeature[]);
 }

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

@@ -21,6 +21,8 @@ type RegularNode = {
     marks?: Mark[];
     content?: Array<RteNode>;
 };
+export type RteTextNode = TextNode;
+export type RteRegularNode = RegularNode;
 export type RteNode = TextNode | RegularNode;
 export type RteMark = Mark;
 export type RteDocument = Doc;

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

@@ -17,7 +17,12 @@ export { RteLinkFeature } from './features/link';
 export { RteInlineImageFeature } from './features/inline-image';
 export { RteFileHandlerFeature } from './features/file-handler';
 export { RteDropHandlerFeature } from './features/drop-handler';
+export { RteToolbarButtonFeature } from './features/toolbar-button';
+export { RteAtomFeature } from './features/atom';
+export { RteInputRuleFeature } from './features/input-rule';
+export { RteSuggestFeature } from './features/suggest';
 export { RteHtmlParser } from './html-parser';
 export { RteHtmlSerializer } from './html-serializer';
 export type { RteInstance } from './instance';
 export type { RteDocument, RteFragment, RteNode, RteMark } from './document';
+export type { RteView, RteViewOptions } from './view';

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

@@ -6,6 +6,7 @@ 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';
 type Contribution<T> = {
     priority: number;
     featureName: string;
@@ -25,10 +26,12 @@ export type TextblockAttrContribution = Contribution<TextblockAttrSpec>;
 export type TextblockMarkContribution = Contribution<TextblockMarkSpec>;
 export type PluginContribution = Contribution<Plugin>;
 export type ToolbarItemContribution = Contribution<ToolbarItemSpec>;
+export type InputRuleContribution = Contribution<InputRuleSpec>;
 export declare abstract class RteFeature {
 }
 export declare abstract class RteFeatureImpl {
-    protected abstract name: string;
+    abstract name: string;
+    featureId?: string;
     protected contribution<T>(value: T, order?: number): Contribution<T>;
     getStyles(): StyleContribution[];
     getSchema(textblockAttrs: TextblockAttrs, textblockMarks: TextblockMarks): SchemaContribution[];
@@ -36,11 +39,14 @@ export declare abstract class RteFeatureImpl {
     getTextblockMarks(): TextblockMarkContribution[];
     getPlugins(rte: RteInstanceImpl): PluginContribution[];
     getToolbarItems(rte: RteInstanceImpl): ToolbarItemContribution[];
+    getInputRules(rte: RteInstanceImpl): InputRuleContribution[];
     getFeatures(): RteFeatureImpl[];
+    getPublicInterface(rte: RteInstanceImpl): any;
 }
 export declare const featureFacade: <T extends RteFeatureImpl, C extends Constructor<T>>(FeatureImpl: C) => {
     new (...args: ConstructorParameters<C>): {
         [impl]: T;
     };
 };
+export declare function getPublicInterface(facade: Constructor<RteFeature>): unknown;
 export {};

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

@@ -12,7 +12,7 @@ type EnabledBlocks = {
 };
 export declare class RteBasicTextBlocksImpl extends RteFeatureImpl {
     protected enabledBlocks: EnabledBlocks;
-    protected name: string;
+    name: string;
     constructor(enabledBlocks: EnabledBlocks);
     getStyles(): {
         priority: number;

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

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

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

@@ -1,6 +1,6 @@
 import { RteFeatureImpl, type ToolbarItemContribution } from '../../feature';
 export declare class RteHistoryFeatureImpl extends RteFeatureImpl {
-    protected name: string;
+    name: string;
     getPlugins(): {
         priority: number;
         featureName: string;

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

@@ -0,0 +1,15 @@
+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';
+export interface InputRuleSpec {
+    rule: InputRule;
+    enterHandler?: {
+        regex: RegExp;
+        handler: (state: EditorState, match: RegExpMatchArray, start: number, end: number) => Transaction | null;
+    };
+}
+export declare class RteInputRulesFeatureImpl extends RteFeatureImpl {
+    name: string;
+    getPlugins(rte: RteInstanceImpl): PluginContribution[];
+}

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

@@ -6,7 +6,7 @@ import type { Constructor } from '../../../shared/utils/mixins';
 import type { Locale } from '../../../shared/localization/Locale';
 import { RteConfig, RteConfigImpl } from './config';
 import { type HostState } from './features/internal/core';
-import { RteFeatureImpl } from './feature';
+import { type getPublicInterface, type RteFeature, type RteFeatureImpl } from './feature';
 import type { RteDocument, RteFragment } from './document';
 import type { TextblockAttrs } from './utils/textblock-attrs';
 import { RteHtmlParser } from './html-parser';
@@ -30,6 +30,7 @@ export declare class RteInstance {
         cursorPlacement?: 'start' | 'end';
         selectContent?: boolean;
     }): void;
+    feature: typeof getPublicInterface;
 }
 export declare class RteInstanceImpl {
     readonly options?: RteInstanceOptions | undefined;
@@ -41,7 +42,8 @@ export declare class RteInstanceImpl {
     readonly styles: ElementStyles;
     readonly foreignHtmlParser: RteHtmlParser;
     readonly foreignHtmlSerializer: RteHtmlSerializer;
-    getFeature<T extends RteFeatureImpl>(constr: Constructor<T>): T;
+    getFeature<T extends RteFeatureImpl>(name: string): T;
+    getPublicInterface(Feature: Constructor<RteFeature>, featureId?: string): any;
     constructor(configFacade: RteConfig, options?: RteInstanceOptions | undefined);
     protected initState(initialDoc?: RteDocument): void;
     reset(initialDocument?: RteDocument): void;

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

@@ -0,0 +1,8 @@
+import { Plugin } from 'prosemirror-state';
+import type { RteInstanceImpl } from '../instance';
+export declare class FeatureState<T> {
+    plugin: Plugin<T>;
+    constructor(initialValue: T);
+    getValue(rte: RteInstanceImpl): T;
+    setValue(rte: RteInstanceImpl, newValue: T): void;
+}

package/lib/rich-text-editor/rte/utils/text-before-cursor.d.ts

@@ -0,0 +1,2 @@
+import type { ResolvedPos } from 'prosemirror-model';
+export declare const textBeforeCursor: ($cursor: ResolvedPos) => string;

package/lib/rich-text-editor/rte/utils/ui.d.ts

@@ -16,6 +16,8 @@ type EventBinding = [
 ];
 type CtxProps = {
     popupPlacement: 'top' | 'bottom';
+    menuOffset?: number;
+    disabled?: boolean;
 };
 export declare class UiCtx {
     readonly view: EditorView;

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

@@ -0,0 +1,30 @@
+import type { RteConfig } from './config';
+import type { RteDocument, RteMark, RteNode } from './document';
+import { impl } from './utils/impl';
+export type RteView = ({
+    type: 'node';
+    node: RteNode;
+    children: RteView;
+} | {
+    type: 'mark';
+    mark: RteMark;
+    children: RteView;
+} | {
+    type: 'fragment';
+    content: RteView[];
+}) & {
+    [impl]: RteViewCtx;
+};
+export type RteViewCtx = {
+    config: RteConfig;
+    options: RteViewOptions;
+};
+export type RteViewOptions = {
+    renderChildView?: (view: RteView & {
+        type: 'node' | 'mark';
+    }) => {
+        dom: HTMLElement;
+        contentDom?: HTMLElement;
+    } | true | false;
+};
+export declare const convertToView: (doc: RteDocument, ctx: RteViewCtx) => RteView;

package/lib/rich-text-view/definition.d.ts

@@ -0,0 +1,5 @@
+import { RichTextView } from './rich-text-view';
+export declare const richTextViewDefinition: import("../../shared/design-system/defineVividComponent").VividComponentDefinition;
+export declare const registerRichTextView: (prefix?: string) => void;
+export { RichTextView as VwcRichTextViewElement };
+export type { RteChildSlotProps } from './rich-text-view';

package/lib/rich-text-view/rich-text-view.d.ts

@@ -0,0 +1,19 @@
+import { VividElement } from '../../shared/foundation/vivid-element/vivid-element';
+import type { RteView } from '../rich-text-editor/rte/view';
+export type RteChildSlotProps = {
+    view: RteView;
+};
+export declare class RichTextView extends VividElement {
+    view?: RteView;
+    private _styles?;
+    private _addStyles;
+    private _removeStyles;
+    private _slotCounter;
+    private _slottedChildren;
+    private _slotRequests;
+    private _cleanupLightDom;
+    private _updateView;
+    private _renderView;
+    private _handleCustomRender;
+    private _renderDefault;
+}

package/lib/rich-text-view/rich-text-view.template.d.ts

@@ -0,0 +1,3 @@
+import type { ViewTemplate } from '@microsoft/fast-element';
+import type { RichTextView } from './rich-text-view';
+export declare const RichTextViewTemplate: () => ViewTemplate<RichTextView>;

package/lib/selectable-box/selectable-box.d.ts

@@ -387,5 +387,6 @@ export declare class SelectableBox extends SelectableBox_base {
     controlType?: SelectableBoxControlType;
     controlPlacement: SelectableBoxControlPlacement;
     tight: boolean;
+    disabled: boolean;
 }
 export {};

package/lib/status/definition.d.ts

@@ -0,0 +1,4 @@
+import { Status } from './status';
+export type { StatusConnotation } from './status';
+export declare const registerStatus: (prefix?: string) => void;
+export { Status as VwcStatusElement };