microboard-temp 0.1.0 → 0.1.2

package/dist/types/Items/Mbr/Mbr.d.ts

@@ -0,0 +1,63 @@
+import { Point } from "../Point";
+import { Line } from "../Line";
+import { Matrix } from "../Transformation";
+import { VerticalAlignment } from "Items/Alignment";
+import { DrawingContext } from "Items/DrawingContext";
+import { Geometry } from "../Geometry";
+import { GeometricNormal } from "../GeometricNormal";
+import { BorderStyle } from "../Path";
+import { RichText } from "..";
+/**
+ * The minimum bounding rectangle (MBR), also known as bounding box (BBOX) or envelope.
+ * https://en.wikipedia.org/wiki/Minimum_bounding_rectangle
+ */
+export declare class Mbr implements Geometry {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+    borderColor: string;
+    backgroundColor: string;
+    strokeWidth: number;
+    borderStyle: BorderStyle;
+    static fromDomRect(rect: DOMRect): Mbr;
+    constructor(left?: number, top?: number, right?: number, bottom?: number, borderColor?: string, backgroundColor?: string, strokeWidth?: number, borderStyle?: BorderStyle);
+    getWidth(): number;
+    getHeight(): number;
+    getCenter(): Point;
+    getHypotenuse(): number;
+    getSin(): number;
+    getCos(): number;
+    moveLeftTop(position: Point): void;
+    scaleFromCenter(matrix: Matrix): void;
+    scaleFromLeftTop(matrix: Matrix): void;
+    alignInRectangle(rect: Mbr, alignment: VerticalAlignment): void;
+    addMbr(mbr: Mbr): void;
+    combine(mbrs: Mbr | Mbr[]): Mbr;
+    transform(matrix: Matrix): void;
+    getTransformed(matrix: Matrix): Mbr;
+    copy(): Mbr;
+    getLines(): Line[];
+    getSnapAnchorPoints(): Point[];
+    getNearestPointInside(point: Point): Point;
+    getNearestPointOnPerimeter(point: Point, orCenter: boolean): Point;
+    getClosestEdgeCenterPoint(point: Point): Point;
+    isInside(point: Point): boolean;
+    isAlmostInside(point: Point, diff: number): boolean;
+    isEqual(mbr: Mbr): boolean;
+    isNotCrossedBy(rect: Mbr): boolean;
+    isEnclosedOrCrossedBy(rect: Mbr): boolean;
+    isInView(rect: Mbr): boolean;
+    isEnclosedBy(rect: Mbr): boolean;
+    getIntersectionPoints(segment: Line): Point[];
+    getMbr(): Mbr;
+    isClosed(): boolean;
+    getNearestEdgePointTo(point: Point): Point;
+    getDistanceToPoint(point: Point): number;
+    isUnderPoint(point: Point): boolean;
+    isNearPoint(point: Point, distance: number): boolean;
+    getNormal(point: Point): GeometricNormal;
+    updatePath(): void;
+    getRichText(): RichText | null;
+    render(context: DrawingContext): void;
+}

package/dist/types/Items/Mbr/index.d.ts

@@ -0,0 +1 @@
+export { Mbr } from "./Mbr";

package/dist/types/Items/Mbr/updateRects.d.ts

@@ -0,0 +1,16 @@
+import { Board } from 'Board';
+import { Camera } from 'Camera';
+import { Mbr } from 'Items';
+import { RefObject } from 'react';
+export declare function updateRects(board: Board, ref: RefObject<HTMLElement>, mbr?: Mbr, verticalOffset?: number, horizontalOffset?: number, fit?: 'hyperLink' | 'boardMenu' | 'contextPanel' | 'linkToBtn' | 'comment' | 'threadPanel'): Mbr | null;
+export declare function getContextPanelRect(selectionMbr: Mbr, camera: Camera, panel: HTMLElement, toLeft: boolean, horizontalOffset?: number, verticalOffset?: number): Mbr;
+export declare function fitContextPanelToLeft(selectionMbr: Mbr, view: Mbr, panel: Mbr, verticalOffset?: number, horizontalOffset?: number): Mbr;
+export declare function fitContextPanelToCenter(selectionMbr: Mbr, view: Mbr, panel: Mbr, verticalOffset?: number, horizontalOffset?: number): Mbr;
+export declare function fitContextMenu(button: Mbr, view: Mbr, menu: Mbr, panel: Mbr): Mbr;
+export declare function fitOnLeftOrRightOfItem(item: Mbr, view: Mbr, bounds: Mbr, offset: number): Mbr;
+export declare function fitLinkToBtn(itemMbr: Mbr, view: Mbr, panel: Mbr, verticalOffset?: number, horizontalOffset?: number): Mbr;
+export declare function fitHyperLink(linkMbr: Mbr, panel: Mbr, view: Mbr, offset?: number): Mbr;
+export declare function fitComment(anchor: Mbr, panel: Mbr, verticalOffset?: number, horizontalOffset?: number): Mbr;
+export declare function fitBoardMenu(anchor: Mbr, view: Mbr, panel: Mbr, verticalOffset?: number, horizontalOffset?: number): Mbr;
+export declare function fitThreadPanel(anchor: Mbr, view: Mbr, panel: Mbr, verticalOffset?: number, horizontalOffset?: number): Mbr;
+export declare function fitOnTopOrBottomOfItem(item: Mbr, view: Mbr, bounds: Mbr, offset: number): Mbr;

package/dist/types/Items/Mbr/useDomMbr.d.ts

@@ -0,0 +1,17 @@
+import { type App } from 'App';
+import { type Board } from 'Board';
+import { Mbr } from 'Items';
+import { type RefObject } from 'react';
+import type { SubjectName } from 'App/getSubscriptions';
+type Params = {
+    app: App;
+    board: Board;
+    ref: RefObject<HTMLElement>;
+    subjects?: SubjectName[];
+    targetMbr?: Mbr;
+    verticalOffset?: number;
+    horizontalOffset?: number;
+    fit?: 'contextPanel' | 'linkToBtn' | 'comment' | 'threadPanel' | 'boardMenu' | 'hyperLink';
+};
+export declare function useDomMbr({ app, board, ref, subjects, targetMbr, horizontalOffset, verticalOffset, fit, }: Params): any;
+export {};

package/dist/types/Items/Path/Path.d.ts

@@ -0,0 +1,114 @@
+import { DrawingContext } from 'Items/DrawingContext';
+import { Geometry } from '../Geometry';
+import { Line } from '../Line';
+import { CubicBezier, QuadraticBezier } from '../Curve';
+import { Point } from '../Point';
+import { Mbr } from '../Mbr';
+import { Arc, Matrix } from '..';
+import { GeometricNormal } from '../GeometricNormal';
+import { DocumentFactory } from 'api/DocumentFactory';
+export type Segment = Line | QuadraticBezier | CubicBezier | Arc;
+export declare const LinePatterns: {
+    solid: number[];
+    dot: number[];
+    dash: number[];
+    longDash: number[];
+    dotDash: number[];
+    tripleDotDash: number[];
+    looseDoubleDotDash: number[];
+};
+export type BorderStyle = keyof typeof LinePatterns;
+export declare const LineStyles: BorderStyle[];
+declare const scaledPatterns: {
+    [key: number]: typeof LinePatterns;
+};
+export declare function scalePatterns(scale: number): typeof LinePatterns;
+export type BorderWidth = keyof typeof scaledPatterns;
+export declare const borderWidths: BorderWidth[];
+export interface PathStylize {
+    setBackgroundColor: (color: string) => void;
+    setBorderColor: (color: string) => void;
+    setBorderStyle: (style: BorderStyle) => void;
+    setBorderWidth: (style: BorderWidth) => void;
+    setBackgroundOpacity: (opacity: number) => void;
+    setBorderOpacity: (opacity: number) => void;
+}
+export declare class Path implements Geometry, PathStylize {
+    private segments;
+    private isClosedValue;
+    private backgroundColor;
+    private borderColor;
+    private borderStyle;
+    private borderWidth;
+    private backgroundOpacity;
+    private borderOpacity;
+    private shadowColor;
+    private shadowBlur;
+    private shadowOffsetX;
+    private shadowOffsetY;
+    private paddingTop;
+    private paddingRight;
+    private paddingBottom;
+    private paddingLeft;
+    private path2d;
+    private x;
+    private y;
+    private width;
+    private height;
+    private maxDimension;
+    private linePattern;
+    connectedItemType: string;
+    constructor(segments?: Segment[], isClosedValue?: boolean, backgroundColor?: string, borderColor?: string, borderStyle?: BorderStyle, borderWidth?: number, backgroundOpacity?: number, borderOpacity?: number, shadowColor?: string, shadowBlur?: number, shadowOffsetX?: number, shadowOffsetY?: number, paddingTop?: number, paddingRight?: number, paddingBottom?: number, paddingLeft?: number);
+    getBackgroundColor(): string;
+    getBorderColor(): string;
+    getBorderStyle(): BorderStyle;
+    getBorderWidth(): BorderWidth;
+    setBackgroundColor(color: string): void;
+    setBorderColor(color: string): void;
+    setBorderStyle(style: BorderStyle): void;
+    setBorderWidth(width: number): void;
+    getShadowColor(): string;
+    setShadowColor(color: string): void;
+    getShadowBlur(): number;
+    setShadowBlur(blur: number): void;
+    getShadowOffsetX(): number;
+    setShadowOffsetX(offsetX: number): void;
+    getShadowOffsetY(): number;
+    setShadowOffsetY(offsetY: number): void;
+    getBackgroundOpacity(): number;
+    setBackgroundOpacity(opacity: number): void;
+    getBorderOpacity(): number;
+    getWidth(): number;
+    getHeight(): number;
+    setBorderOpacity(opacity: number): void;
+    private updateCache;
+    getIntersectionPoints(segment: Line): Point[];
+    getNearestEdgePointTo(point: Point): Point;
+    getNearestEdgeAndPointTo(point: Point): {
+        index: number;
+        segment: Segment;
+        point: Point;
+    };
+    getDistanceToPoint(point: Point): number;
+    isUnderPoint(point: Point): boolean;
+    isPointOverEdges(point: Point, tolerance?: number): boolean;
+    isNearPoint(point: Point, distance: number): boolean;
+    getMbr(): Mbr;
+    isEnclosedOrCrossedBy(bounds: Mbr): boolean;
+    private isOpenEnclosedOrCrossedBy;
+    private isClosedEnclosedOrCrossedBy;
+    isEnclosedBy(rect: Mbr): boolean;
+    isInView(rect: Mbr): boolean;
+    getNormal(point: Point): GeometricNormal;
+    updateMaxDimension(scale?: number): void;
+    render(context: DrawingContext): void;
+    getSvgPath(): string;
+    renderHTML(documentFactory: DocumentFactory): SVGPathElement;
+    transform(matrix: Matrix): void;
+    getTransformed(matrix: Matrix): Path;
+    copy(): Path;
+    getSegments(): Segment[];
+    isClosed(): boolean;
+    addConnectedItemType(name: string): this;
+}
+export {};

package/dist/types/Items/Path/Paths.d.ts

@@ -0,0 +1,58 @@
+import { Mbr } from '../Mbr';
+import { DrawingContext } from '../DrawingContext';
+import { Geometry } from '../Geometry';
+import { Line } from '../Line';
+import { Point } from '../Point';
+import { BorderStyle, BorderWidth, Path, PathStylize } from './Path';
+import { Matrix } from '../Transformation';
+import { GeometricNormal } from '../GeometricNormal';
+import { DocumentFactory } from 'api/DocumentFactory';
+export declare class Paths implements Geometry {
+    private paths;
+    private backgroundColor;
+    private borderColor;
+    private borderStyle;
+    private borderWidth;
+    private backgroundOpacity;
+    private borderOpacity;
+    private setterFilter;
+    private x;
+    private y;
+    private width;
+    private height;
+    private maxDimension;
+    constructor(paths: Path[], backgroundColor?: string, borderColor?: string, borderStyle?: BorderStyle, borderWidth?: BorderWidth, backgroundOpacity?: number, borderOpacity?: number, setterFilter?: (m: string, v: any, p: Path, i: number) => boolean);
+    getBackgroundColor(): string;
+    getBorderColor(): string;
+    getBorderStyle(): BorderStyle;
+    getBorderWidth(): BorderWidth;
+    _setter<T extends keyof PathStylize>(p: any, method: T, v: any): void;
+    setBackgroundColor(color: string): void;
+    setBorderColor(color: string): void;
+    setBorderStyle(style: BorderStyle): void;
+    setBorderWidth(width: BorderWidth): void;
+    setBackgroundOpacity(opacity: number): void;
+    setBorderOpacity(opacity: number): void;
+    getBackgroundOpacity(): number;
+    getBorderOpacity(): number;
+    getIntersectionPoints(segment: Line): Point[];
+    getNearestEdgePointTo(point: Point): Point;
+    getDistanceToPoint(point: Point): number;
+    isUnderPoint(point: Point): boolean;
+    isPointOverEdges(point: Point, tolerance?: number): boolean;
+    isNearPoint(point: Point, distance: number): boolean;
+    getMbr(): Mbr;
+    isEnclosedOrCrossedBy(rect: Mbr): boolean;
+    isEnclosedBy(rect: Mbr): boolean;
+    isInView(rect: Mbr): boolean;
+    getNormal(point: Point): GeometricNormal;
+    updateMaxDimension(scale?: number): void;
+    render(context: DrawingContext): void;
+    renderHTML(documentFactory: DocumentFactory): SVGPathElement[];
+    transform(matrix: Matrix): void;
+    getTransformed(matrix: Matrix): Paths;
+    getPaths(): Path[];
+    copy(): Paths;
+    copyPaths(): Path[];
+    isClosed(): boolean;
+}

package/dist/types/Items/Path/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./Path";
+export * from "./Paths";

package/dist/types/Items/Placeholder/Placeholder.d.ts

@@ -0,0 +1,79 @@
+import { Events, Operation } from "Events";
+import { DrawingContext } from "../DrawingContext";
+import { ResizeType } from "Selection/Transformer/TransformerHelpers/getResizeType";
+import { Subject } from "Subject";
+import { GeometricNormal } from "../GeometricNormal";
+import { Line } from "../Line";
+import { Mbr } from "../Mbr";
+import { Path, Paths } from "../Path";
+import { Point } from "../Point";
+import { Transformation, Matrix, TransformationData } from "../Transformation";
+import { PlaceholderOperation } from "./PlaceholderOperation";
+export interface PlaceholderData {
+    readonly itemType: "Placeholder";
+    backgroundColor: string;
+    icon: string;
+    transformation: TransformationData;
+    miroData?: unknown;
+}
+export declare class Placeholder {
+    private events?;
+    private miroData?;
+    private id;
+    private backgroundColor;
+    private icon;
+    readonly itemType = "Placeholder";
+    shapeType: string;
+    parent: string;
+    readonly transformation: Transformation;
+    private path;
+    private mbr;
+    readonly subject: Subject<Placeholder>;
+    transformationRenderBlock?: boolean;
+    iconImage: any;
+    constructor(events?: Events | undefined, miroData?: unknown | undefined, id?: string, backgroundColor?: string, icon?: string);
+    emit(operation: PlaceholderOperation): void;
+    serialize(): PlaceholderData;
+    deserialize(data: Partial<PlaceholderData>): this;
+    setId(id: string): this;
+    getId(): string;
+    apply(op: Operation): void;
+    private applyPlaceholder;
+    getBackgroundColor(): string;
+    private applyBackgroundColor;
+    setBackgroundColor(backgroundColor: string): void;
+    getIcon(): string;
+    private applyIcon;
+    setIcon(icon: string): void;
+    getMiroData(): unknown;
+    private applyMiroData;
+    setMiroData(miroData: unknown): void;
+    getIntersectionPoints(segment: Line): Point[];
+    updateMbr(): Mbr;
+    getMbr(): Mbr;
+    getNearestEdgePointTo(point: Point): Point;
+    getDistanceToPoint(point: Point): number;
+    isUnderPoint(point: Point): boolean;
+    isNearPoint(point: Point, distance: number): boolean;
+    isEnclosedOrCrossedBy(rect: Mbr): boolean;
+    isEnclosedBy(rect: Mbr): boolean;
+    isInView(rect: Mbr): boolean;
+    getNormal(point: Point): GeometricNormal;
+    getPaths(): Path | Paths;
+    getPath(): Path | Paths;
+    copyPaths(): Path | Paths;
+    isClosed(): boolean;
+    getSnapAnchorPoints(): Point[];
+    doResize(resizeType: ResizeType, pointer: Point, mbr: Mbr, opposite: Point, startMbr: Mbr, timeStamp: number): {
+        matrix: Matrix;
+        mbr: Mbr;
+    };
+    private transformPath;
+    private initPath;
+    private loadIconImage;
+    private renderIcon;
+    private renderShadowShape;
+    render(context: DrawingContext): void;
+    getLinkTo(): undefined;
+    getRichText(): null;
+}

package/dist/types/Items/Placeholder/PlaceholderCommand.d.ts

@@ -0,0 +1,15 @@
+import { Command } from "../../Events";
+import { Placeholder } from "./Placeholder";
+import { PlaceholderOperation } from "./PlaceholderOperation";
+export declare class PlaceholderCommand implements Command {
+    private placeholder;
+    private operation;
+    private reverse;
+    constructor(placeholder: Placeholder[], operation: PlaceholderOperation);
+    apply(): void;
+    revert(): void;
+    getReverse(): {
+        item: Placeholder;
+        operation: PlaceholderOperation;
+    }[];
+}

package/dist/types/Items/Placeholder/PlaceholderOperation.d.ts

@@ -0,0 +1,18 @@
+export type PlaceholderOperation = SetBackgroundColor | SetIcon | SetMiroData;
+interface BasePlaceholderOperation {
+    class: "Placeholder";
+    item: string[];
+}
+interface SetBackgroundColor extends BasePlaceholderOperation {
+    method: "setBackgroundColor";
+    backgroundColor: string;
+}
+interface SetIcon extends BasePlaceholderOperation {
+    method: "setIcon";
+    icon: string;
+}
+interface SetMiroData extends BasePlaceholderOperation {
+    method: "setMiroData";
+    miroData: unknown;
+}
+export {};

package/dist/types/Items/Placeholder/index.d.ts

@@ -0,0 +1 @@
+export * from "./Placeholder";

package/dist/types/Items/Point/Point.d.ts

@@ -0,0 +1,12 @@
+import { Matrix } from '..';
+export declare class Point {
+    x: number;
+    y: number;
+    constructor(x?: number, y?: number);
+    getDistance(point: Point): number;
+    transform(matrix: Matrix): void;
+    getTransformed(matrix: Matrix): Point;
+    copy(): Point;
+    equal(point: Point): boolean;
+    barelyEqual(point: Point): boolean;
+}

package/dist/types/Items/Point/index.d.ts

@@ -0,0 +1 @@
+export { Point } from "./Point";

package/dist/types/Items/RichText/CanvasText/DropflowRender.d.ts

@@ -0,0 +1,7 @@
+import { BlockNode } from '../Editor/BlockNode';
+import { LayoutBlockNodes } from './LayoutBlockNodes';
+import { Descendant } from 'slate';
+export declare function getBlockNodes(data: BlockNode[], maxWidth: number, shrink?: boolean, isFrame?: boolean): LayoutBlockNodes;
+export declare function getOneCharacterMaxWidth(data: Descendant[]): number;
+export declare function measureText(fontSize: any, fontFamily: any, text: any): TextMetrics;
+export declare function findMinimumWidthForSingleLineHeight(data: BlockNode[], singleLineHeight: number, maxWidth: number): number;

package/dist/types/Items/RichText/CanvasText/LayoutBlockNodes.d.ts

@@ -0,0 +1,17 @@
+export interface LayoutBlockNodes {
+    nodes: [];
+    maxWidth: number;
+    width: number;
+    height: number;
+    didBreakWords: boolean;
+    render: (ctx: CanvasRenderingContext2D, scale?: number) => void;
+    realign: (newMaxWidht: number) => void;
+    recoordinate: (newMaxWidth?: number) => void;
+    linkPositions: {
+        link: string;
+        left: number;
+        top: number;
+        right: number;
+        bottom: number;
+    }[];
+}

package/dist/types/Items/RichText/CanvasText/Render.d.ts

@@ -0,0 +1,3 @@
+import { BlockNode } from '../Editor/BlockNode';
+import { LayoutBlockNodes } from './LayoutBlockNodes';
+export declare function getBlockNodes(data: BlockNode[], maxWidth?: number, shrink?: boolean, isFrame?: boolean): LayoutBlockNodes;

package/dist/types/Items/RichText/CanvasText/convertLinkNodeToTextNode.d.ts

@@ -0,0 +1,2 @@
+import { LinkNode, TextNode } from '../Editor/TextNode';
+export declare const convertLinkNodeToTextNode: (node: LinkNode | TextNode) => TextNode;

package/dist/types/Items/RichText/Editor/BlockNode.d.ts

@@ -0,0 +1,90 @@
+import { HorisontalAlignment } from "../../Alignment";
+import { LinkNode, TextNode } from "./TextNode";
+export declare const ListTypes: readonly ["ol_list", "ul_list"];
+export type ListType = (typeof ListTypes)[number];
+export declare const BlockTypes: readonly ["paragraph", "ul_list", "ol_list", "list_item", "code_block", "heading_one", "heading_two", "heading_three", "heading_four", "heading_five", "block-quote"];
+export type BlockType = (typeof BlockTypes)[number];
+export type ParagraphNode = {
+    type: "paragraph";
+    children: TextNode[] | LinkNode[];
+    horisontalAlignment?: HorisontalAlignment;
+    paddingTop?: number;
+    paddingBottom?: number;
+    lineHeight?: number;
+};
+export type CodeBlockNode = {
+    type: "code_block";
+    children: TextNode[];
+    horisontalAlignment?: HorisontalAlignment;
+    paddingTop?: number;
+    paddingBottom?: number;
+    language: string | null;
+};
+export type HeadingOneNode = {
+    type: "heading_one";
+    children: TextNode[];
+    horisontalAlignment?: HorisontalAlignment;
+    paddingTop?: number;
+    paddingBottom?: number;
+};
+export type HeadingTwoNode = {
+    type: "heading_two";
+    children: TextNode[];
+    horisontalAlignment?: HorisontalAlignment;
+    paddingTop?: number;
+    paddingBottom?: number;
+};
+export type HeadingThreeNode = {
+    type: "heading_three";
+    children: TextNode[];
+    horisontalAlignment?: HorisontalAlignment;
+    paddingTop?: number;
+    paddingBottom?: number;
+};
+export type HeadingFourNode = {
+    type: "heading_four";
+    children: TextNode[];
+    horisontalAlignment?: HorisontalAlignment;
+    paddingTop?: number;
+    paddingBottom?: number;
+};
+export type HeadingFiveNode = {
+    type: "heading_five";
+    children: TextNode[];
+    horisontalAlignment?: HorisontalAlignment;
+    paddingTop?: number;
+    paddingBottom?: number;
+};
+export type BlockQuoteNode = {
+    type: "block-quote";
+    children: TextNode[];
+    horisontalAlignment?: HorisontalAlignment;
+    paddingTop?: number;
+    paddingBottom?: number;
+};
+export type BulletedListNode = {
+    type: "ul_list";
+    children: ListItemNode[];
+    listLevel: number;
+    horisontalAlignment?: HorisontalAlignment;
+    paddingTop?: number;
+    paddingBottom?: number;
+};
+export type NumberedListNode = {
+    type: "ol_list";
+    children: ListItemNode[];
+    listLevel: number;
+    horisontalAlignment?: HorisontalAlignment;
+    paddingTop?: number;
+    paddingBottom?: number;
+};
+export type HeadingNode = HeadingOneNode | HeadingTwoNode | HeadingThreeNode | HeadingFourNode | HeadingFiveNode;
+export type ListItemChild = NumberedListNode | BulletedListNode | TextNode;
+export type ListItemNode = {
+    type: "list_item";
+    children: BlockNode[];
+    horisontalAlignment?: HorisontalAlignment;
+    paddingTop?: number;
+    paddingBottom?: number;
+};
+export type BlockNode = ParagraphNode | CodeBlockNode | HeadingOneNode | HeadingTwoNode | HeadingThreeNode | HeadingFourNode | HeadingFiveNode | BlockQuoteNode | BulletedListNode | NumberedListNode | ListItemNode;

package/dist/types/Items/RichText/Editor/TextNode.d.ts

@@ -0,0 +1,31 @@
+import { HorisontalAlignment } from "../../Alignment";
+export declare const TextStyles: string[];
+export type TextStyle = (typeof TextStyles)[number];
+export type TextNode = {
+    type: "text";
+    text: string;
+    link?: string;
+    styles?: TextStyle[];
+    bold: boolean;
+    italic: boolean;
+    underline: boolean;
+    overline: boolean;
+    "line-through": boolean;
+    subscript: boolean;
+    superscript: boolean;
+    fontFamily?: string;
+    fontColor?: string;
+    fontSize?: number | "auto";
+    fontHighlight?: string;
+    enableAuto?: boolean;
+    paddingTop?: number;
+    paddingBottom?: number;
+    horisontalAlignment?: HorisontalAlignment;
+};
+export type LinkNode = {
+    type: "link";
+    link: string;
+    children: TextNode[];
+    paddingTop?: number;
+    paddingBottom?: number;
+};

package/dist/types/Items/RichText/EditorContainer.d.ts

@@ -0,0 +1,85 @@
+import { DefaultTextStyles } from 'Settings';
+import { Subject } from 'Subject';
+import { BaseEditor, BaseSelection, Descendant, Operation as SlateOp, Operation } from 'slate';
+import { HistoryEditor } from 'slate-history';
+import { ReactEditor } from 'slate-react';
+import { HorisontalAlignment, VerticalAlignment } from '../Alignment';
+import { BlockNode, ListType, ParagraphNode } from './Editor/BlockNode';
+import { TextNode, TextStyle } from './Editor/TextNode';
+import { RichTextOperation } from './RichTextOperations';
+import { MarkdownProcessor } from 'Items/RichText/editorHelpers/markdown/markdownProcessor';
+export declare class EditorContainer {
+    private id;
+    private emit;
+    private emitWithoutApplying;
+    private getScale;
+    horisontalAlignment: HorisontalAlignment;
+    private initialTextStyles;
+    private getAutosize;
+    private autosizeEnable;
+    private autosizeDisable;
+    private getFontSize;
+    private getMatrixScale;
+    private getOnLimitReached;
+    private calcAutoSize;
+    private applyAutoSizeScale;
+    private updateElement;
+    readonly editor: BaseEditor & ReactEditor & HistoryEditor;
+    maxWidth: number | undefined;
+    textScale: number;
+    verticalAlignment: VerticalAlignment;
+    textLength: number;
+    markdownProcessor: MarkdownProcessor;
+    private decorated;
+    shouldEmit: boolean;
+    private recordedOps;
+    readonly subject: Subject<EditorContainer>;
+    isCommandApplication: boolean;
+    constructor(id: string, emit: (op: RichTextOperation) => void, emitWithoutApplying: (op: RichTextOperation) => void, undo: () => void, redo: () => void, getScale: () => number, horisontalAlignment: HorisontalAlignment, initialTextStyles: DefaultTextStyles, fontSize: number, getAutosize: () => boolean, autosizeEnable: () => void, autosizeDisable: () => void, getFontSize: () => number, getMatrixScale: () => number, getOnLimitReached: () => () => void, calcAutoSize: (textNodes?: BlockNode[]) => number, applyAutoSizeScale: (textScale: number, blockNodes?: BlockNode[]) => void, updateElement: () => void);
+    setId(id: string): this;
+    startOpRecording(op?: SlateOp): void;
+    getTextFromNode(node: BlockNode): string;
+    getEndNodePath(node: BlockNode, nodePath: number[]): {
+        path: number[];
+        offset: number;
+    } | null;
+    stopOpRecordingAndGetOps(): SlateOp[];
+    applyRichTextOp(op: RichTextOperation): void;
+    private applySelectionEdit;
+    private applySelectionOp;
+    private applyWholeTextOp;
+    applyMaxWidth(maxWidth: number): void;
+    setMaxWidth(maxWidth: number): void;
+    setSelectionFontColor(format: string, selectionContext?: string): SlateOp[];
+    setSelectionLink(link: string | undefined, selection: BaseSelection): Operation[];
+    setSelectionFontStyle(style: TextStyle | TextStyle[]): SlateOp[];
+    setSelectionFontSize(fontSize: number | 'auto', selectionContext?: string): SlateOp[];
+    setSelectionFontHighlight(format: string, selectionContext?: string): SlateOp[];
+    setSelectionHorisontalAlignment(horisontalAlignment: HorisontalAlignment, selectionContext?: string): SlateOp[];
+    getSelectionMarks(): Omit<TextNode, 'text'> | null;
+    handleListMerge(): boolean;
+    getListTypeAtSelectionStart(): ListType | null;
+    handleSplitListItem(): boolean;
+    includesListNode(): boolean;
+    toggleListType(targetListType: ListType, shouldWrap?: boolean): boolean;
+    withAutoList(): boolean;
+    handleWrapIntoNestedList(): boolean;
+    getFirstSelectionLink(selection: BaseSelection): string | undefined;
+    getText(): Descendant[];
+    getTextParagraphs(lines: string[]): ParagraphNode[];
+    private getValidText;
+    private createParagraphNode;
+    insertCopiedText(text: string): boolean;
+    checkIsAutoSizeTextScaleAllowed(nodes: BlockNode[]): boolean;
+    isLimitReached(nodes: BlockNode[]): boolean;
+    insertCopiedNodes(nodes: BlockNode[]): boolean;
+    hasTextInSelection(): boolean;
+    getSelection(): BaseSelection;
+    splitNode(): void;
+    getBlockNodes(): BlockNode[];
+    isEmpty(): boolean;
+    clearText(): void;
+    addText(text: string): void;
+    selectWholeText(): void;
+    moveCursorToEndOfTheText(delay?: number): void;
+}