microboard-temp 0.1.1 → 0.1.3

package/dist/types/Items/Connector/ControlPoint.d.ts

@@ -0,0 +1,67 @@
+import { Point } from "../Point";
+import { Item } from "../Item";
+import { Connector } from "./Connector";
+export interface BoardPointData {
+    pointType: "Board";
+    x: number;
+    y: number;
+}
+interface FloatingPointData {
+    pointType: "Floating";
+    itemId: string;
+    relativeX: number;
+    relativeY: number;
+}
+interface FixedPointData {
+    pointType: "Fixed";
+    itemId: string;
+    relativeX: number;
+    relativeY: number;
+}
+interface FixedConnectorPointData {
+    pointType: "FixedConnector";
+    itemId: string;
+    tangent: number;
+    segment: number;
+}
+export type ControlPointData = BoardPointData | FloatingPointData | FixedPointData | FixedConnectorPointData;
+export declare class BoardPoint extends Point {
+    readonly pointType = "Board";
+    serialize(): BoardPointData;
+    equal(controlPoint: ControlPoint): boolean;
+}
+export declare class FloatingPoint extends Point {
+    item: Item;
+    readonly relativePoint: Point;
+    readonly pointType = "Floating";
+    private edge;
+    constructor(item: Item, relativePoint: Point);
+    recalculatePoint(): void;
+    serialize(): FloatingPointData;
+    equal(controlPoint: ControlPoint): boolean;
+}
+export declare class FixedPoint extends Point {
+    item: Item;
+    readonly relativePoint: Point;
+    readonly pointType = "Fixed";
+    private edge;
+    constructor(item: Item, relativePoint: Point);
+    recalculatePoint(): void;
+    serialize(): FixedPointData;
+    equal(controlPoint: ControlPoint): boolean;
+}
+export declare class FixedConnectorPoint extends Point {
+    item: Connector;
+    tangent: number;
+    segmentIndex: number;
+    readonly pointType = "FixedConnector";
+    constructor(item: Connector, tangent: number, segmentIndex: number);
+    recalculatePoint(): void;
+    serialize(): FixedConnectorPointData;
+    equal(controlPoint: ControlPoint): boolean;
+}
+export type ControlPoint = BoardPoint | FloatingPoint | FixedPoint | FixedConnectorPoint;
+export type FindItemFn = (id: string) => Item | undefined;
+export declare function getControlPoint(data: ControlPointData, findItem: FindItemFn): ControlPoint;
+export declare function toRelativePoint(point: Point, item: Item): Point;
+export {};

package/dist/types/Items/Connector/Pointers/Pointers.d.ts

@@ -0,0 +1,110 @@
+import { Path, Paths } from 'Items/Path';
+import { Point } from 'Items/Point';
+export interface Pointer {
+    name: ConnectorPointerStyle;
+    path: Path | Paths;
+    start: Point;
+    end: Point;
+    middle: Point[];
+}
+export declare function getPointer(style: string): Pointer;
+declare const Pointers: {
+    readonly None: {
+        readonly name: "None";
+        readonly path: Path;
+        readonly start: Point;
+        readonly end: Point;
+    };
+    readonly Angle: {
+        readonly name: "Angle";
+        readonly path: Path;
+        readonly start: Point;
+        readonly end: Point;
+    };
+    readonly ArrowBroad: {
+        readonly name: "ArrowBroad";
+        readonly path: Path;
+        readonly start: Point;
+        readonly end: Point;
+    };
+    readonly ArrowThin: {
+        readonly name: "ArrowThin";
+        readonly path: Path;
+        readonly start: Point;
+        readonly end: Point;
+    };
+    readonly CircleFilled: {
+        readonly name: "CircleFilled";
+        readonly path: Path;
+        readonly start: Point;
+        readonly end: Point;
+    };
+    readonly DiamondEmpty: {
+        readonly name: "DiamondEmpty";
+        readonly path: Path;
+        readonly start: Point;
+        readonly end: Point;
+    };
+    readonly DiamondFilled: {
+        readonly name: "DiamondFilled";
+        readonly path: Path;
+        readonly start: Point;
+        readonly end: Point;
+    };
+    readonly Many: {
+        readonly name: "Many";
+        readonly path: Paths;
+        readonly start: Point;
+        readonly end: Point;
+    };
+    readonly ManyMandatory: {
+        readonly name: "ManyManadatory";
+        readonly path: Paths;
+        readonly start: Point;
+        readonly end: Point;
+    };
+    readonly ManyOptional: {
+        readonly name: "ManyOptional";
+        readonly path: Paths;
+        readonly start: Point;
+        readonly end: Point;
+    };
+    readonly One: {
+        readonly name: "One";
+        readonly path: Paths;
+        readonly start: Point;
+        readonly end: Point;
+    };
+    readonly OneMandatory: {
+        readonly name: "OneMandatory";
+        readonly path: Paths;
+        readonly start: Point;
+        readonly end: Point;
+    };
+    readonly OneOptional: {
+        readonly name: "OneOptional";
+        readonly path: Paths;
+        readonly start: Point;
+        readonly end: Point;
+    };
+    readonly TriangleEmpty: {
+        readonly name: "TriangleEmpty";
+        readonly path: Path;
+        readonly start: Point;
+        readonly end: Point;
+    };
+    readonly TriangleFilled: {
+        readonly name: "TriangleFilled";
+        readonly path: Path;
+        readonly start: Point;
+        readonly end: Point;
+    };
+    readonly Zero: {
+        readonly name: "Zero";
+        readonly path: Path;
+        readonly start: Point;
+        readonly end: Point;
+    };
+};
+export type ConnectorPointerStyle = keyof typeof Pointers;
+export {};

package/dist/types/Items/Connector/Pointers/index.d.ts

@@ -0,0 +1,10 @@
+import { Path } from 'Items';
+import { ConnectorLineStyle } from '../Connector';
+import { ControlPoint } from '../ControlPoint';
+import { Pointer } from './Pointers';
+export type ConnectedPointerDirection = 'top' | 'bottom' | 'right' | 'left';
+export type ConnectorEdge = 'start' | 'end' | 'middle';
+/** If connected to item returns direction of connection otherwise returns undefined */
+export declare function getPointerDirection(point: ControlPoint): ConnectedPointerDirection | undefined;
+export declare function getStartPointer(point: ControlPoint, pointerStyle: string, lineStyle: ConnectorLineStyle, lines: Path, scale: number): Pointer;
+export declare function getEndPointer(point: ControlPoint, pointerStyle: string, lineStyle: ConnectorLineStyle, lines: Path, scale: number): Pointer;

package/dist/types/Items/Connector/getLine/findOrthogonalPath.d.ts

@@ -0,0 +1,15 @@
+import { Line, Mbr } from 'Items';
+import { Point } from '../../Point';
+import { ControlPoint } from '../ControlPoint';
+type Direction = 'vertical' | 'horizontal';
+export declare function getDirection(from: Point, to?: Point): Direction | null;
+/**
+ * Removes points from centerLine that will probably be visited twice or lengthen the path
+ */
+export declare function removeUnnecessaryPoints(pathToCenterLine: Point[], centerLine: Point[], fromStart: boolean): void;
+export declare function findOrthogonalPath(start: ControlPoint, end: ControlPoint, obstacles: Mbr[], toVisitPoints?: Point[]): {
+    lines: Line[];
+    newStart?: ControlPoint;
+    newEnd?: ControlPoint;
+};
+export {};

package/dist/types/Items/Connector/getLine/getCurvedLine.d.ts

@@ -0,0 +1,3 @@
+import { Path } from "../../Path";
+import { BoardPoint, ControlPoint } from "../ControlPoint";
+export declare function getCurvedLine(start: ControlPoint, end: ControlPoint, middle: BoardPoint | null): Path;

package/dist/types/Items/Connector/getLine/getLine.d.ts

@@ -0,0 +1,4 @@
+import { Path } from "../../Path";
+import { ConnectorLineStyle } from "../Connector";
+import { ControlPoint } from "../ControlPoint";
+export declare function getLine(lineStyle: ConnectorLineStyle, start: ControlPoint, end: ControlPoint, middle: ControlPoint | null): Path;

package/dist/types/Items/Connector/getLine/getOrthogonalLine.d.ts

@@ -0,0 +1,3 @@
+import { Path } from 'Items';
+import { ControlPoint, BoardPoint } from '../ControlPoint';
+export declare function getOrthogonalLine(start: ControlPoint, end: ControlPoint, middle: BoardPoint | null, skipObstacles?: boolean): Path;

package/dist/types/Items/Connector/getLine/getStraightLine.d.ts

@@ -0,0 +1,3 @@
+import { Path } from 'Items';
+import { ControlPoint } from '../ControlPoint';
+export declare function getStraightLine(start: ControlPoint, end: ControlPoint, middle: ControlPoint | null): Path;

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

@@ -0,0 +1,6 @@
+export { Connector } from "./Connector";
+export { ConnectorData } from "./ConnectorOperations";
+export type { ConnectorLineStyle } from "./Connector";
+export type { ConnectorOperation } from "./ConnectorOperations";
+export { BoardPoint, FloatingPoint, FixedPoint, FixedConnectorPoint, } from "./ControlPoint";
+export type { ControlPoint } from "./ControlPoint";

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

@@ -0,0 +1 @@
+export type ConnectorAnchorColors = Record<"snapBorder" | "snapBackgroundHighlight" | "snapBackground" | "anchorBorder" | "anchorBackground" | "anchorHighlight" | "pointBorder" | "pointBackground", string>;

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

@@ -0,0 +1,55 @@
+import { Bezier } from 'bezier-js';
+import { Mbr } from '../Mbr';
+import { Line } from '../Line';
+import { Point } from '../Point';
+import { Matrix } from '../Transformation';
+import { GeometricNormal } from '../GeometricNormal';
+export declare class BaseCurve {
+    curve: Bezier;
+    constructor(curve: Bezier);
+    protected updateCache(curve: Bezier): void;
+    getIntersectionPoints(segment: Line): Point[];
+    getNearestEdgePointTo(point: Point): Point;
+    getDistance(point: Point): number;
+    private getIntersectionCurveRectangle;
+    getMbr(): Mbr;
+    isEnclosedOrCrossedBy(bounds: Mbr): boolean;
+    getNormal(point: Point): GeometricNormal;
+    getNewThatIntersectsPoints(pointA: Point, pointB: Point, pointC: Point): CubicBezier;
+    getCenterPoint(): Point;
+    getPoint(parameter: number): Point;
+    getParameter(point: Point): number;
+    getLength(): number;
+}
+export declare class QuadraticBezier extends BaseCurve {
+    start: Point;
+    control: Point;
+    end: Point;
+    type: "QuadBezier";
+    static getCache(start?: Point, control?: Point, end?: Point): Bezier;
+    constructor(start?: Point, control?: Point, end?: Point);
+    protected updateCache(): void;
+    getStartPoint(): Point;
+    moveToStart(ctx: Path2D | CanvasRenderingContext2D): void;
+    render(ctx: Path2D | CanvasRenderingContext2D): void;
+    transform(matrix: Matrix): void;
+    getTransformed(matrix: Matrix): QuadraticBezier;
+    copy(): QuadraticBezier;
+}
+export declare class CubicBezier extends BaseCurve {
+    start: Point;
+    startControl: Point;
+    end: Point;
+    endControl: Point;
+    type: "CubicBezier";
+    static getCache(start?: Point, startControl?: Point, end?: Point, endControl?: Point): Bezier;
+    constructor(start?: Point, startControl?: Point, end?: Point, endControl?: Point);
+    protected updateCache(): void;
+    getStartPoint(): Point;
+    moveToStart(ctx: Path2D | CanvasRenderingContext2D): void;
+    render(ctx: Path2D | CanvasRenderingContext2D): void;
+    transform(matrix: Matrix): void;
+    getTransformed(matrix: Matrix): CubicBezier;
+    copy(): CubicBezier;
+    getMiddle(): Point;
+}

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

@@ -0,0 +1 @@
+export { QuadraticBezier, CubicBezier } from "./Curve";

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

@@ -0,0 +1,76 @@
+import { Events, Operation } from 'Events';
+import { Subject } from 'Subject';
+import { DrawingContext } from '../DrawingContext';
+import { Line } from '../Line';
+import { Mbr } from '../Mbr';
+import { BorderStyle, BorderWidth, Path } from '../Path';
+import { Point } from '../Point';
+import { Transformation } from '../Transformation';
+import { DrawingOperation } from './DrawingOperation';
+import { TransformationData } from '../Transformation/TransformationData';
+import { Geometry } from '../Geometry';
+import { LinkTo } from '../LinkTo/LinkTo';
+import { DocumentFactory } from 'api/DocumentFactory';
+import { Board } from 'Board';
+export interface DrawingData {
+    itemType: 'Drawing';
+    points: {
+        x: number;
+        y: number;
+    }[];
+    transformation: TransformationData;
+    strokeStyle: string;
+    strokeWidth: number;
+    linkTo?: string;
+}
+export declare class Drawing extends Mbr implements Geometry {
+    private board;
+    points: Point[];
+    private events?;
+    private id;
+    readonly itemType = "Drawing";
+    parent: string;
+    readonly transformation: Transformation;
+    private path2d;
+    readonly subject: Subject<Drawing>;
+    untransformedMbr: Mbr;
+    private lines;
+    readonly linkTo: LinkTo;
+    strokeWidth: BorderWidth;
+    borderStyle: BorderStyle;
+    private linePattern;
+    private borderOpacity;
+    transformationRenderBlock?: boolean;
+    constructor(board: Board, points: Point[], events?: Events | undefined, id?: string);
+    serialize(): DrawingData;
+    deserialize(data: DrawingData): this;
+    updateGeometry(): void;
+    updateMbr(): void;
+    updatePath2d(): void;
+    updateLines(): void;
+    optimizePoints(): void;
+    addPoint(point: Point): void;
+    setId(id: string): this;
+    getId(): string;
+    render(context: DrawingContext): void;
+    renderHTML(documentFactory: DocumentFactory): HTMLElement;
+    private getPathData;
+    getPath(): Path;
+    getSnapAnchorPoints(): Point[];
+    getLines(): Line[];
+    isClosed(): boolean;
+    isEnclosedOrCrossedBy(rect: Mbr): boolean;
+    emit(operation: DrawingOperation): void;
+    apply(op: Operation): void;
+    setStrokeOpacity(opacity: number): this;
+    getStrokeOpacity(): number;
+    setBorderStyle(style: BorderStyle): this;
+    getBorderStyle(): BorderStyle;
+    setStrokeColor(color: string): this;
+    getStrokeColor(): string;
+    setStrokeWidth(width: number): this;
+    getLinkTo(): string | undefined;
+    getStrokeWidth(): number;
+    getRichText(): null;
+    isPointNearLine(point: Point, threshold?: number | undefined): boolean;
+}

package/dist/types/Items/Drawing/DrawingCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command } from 'Events';
+import { Drawing } from './Drawing';
+import { DrawingOperation } from './DrawingOperation';
+export declare class DrawingCommand implements Command {
+    private item;
+    private operation;
+    private reverse;
+    constructor(item: Drawing[], operation: DrawingOperation);
+    merge(op: DrawingOperation): this;
+    apply(): void;
+    revert(): void;
+    getReverse(): {
+        item: Drawing;
+        operation: DrawingOperation;
+    }[];
+    getReverseOperation(item: Drawing): DrawingOperation;
+}

package/dist/types/Items/Drawing/DrawingOperation.d.ts

@@ -0,0 +1,28 @@
+import { BorderStyle } from "../Path";
+interface DrawingSetStrokeColorOp {
+    class: "Drawing";
+    method: "setStrokeColor";
+    item: string[];
+    color: string;
+}
+interface DrawingSetStrokeWidthOp {
+    class: "Drawing";
+    method: "setStrokeWidth";
+    item: string[];
+    width: number;
+    prevWidth: number;
+}
+interface DrawingSetStrokeOpacityOp {
+    class: "Drawing";
+    method: "setStrokeOpacity";
+    item: string[];
+    opacity: number;
+}
+interface DrawingSetStrokeStyleOp {
+    class: "Drawing";
+    method: "setStrokeStyle";
+    item: string[];
+    style: BorderStyle;
+}
+export type DrawingOperation = DrawingSetStrokeColorOp | DrawingSetStrokeWidthOp | DrawingSetStrokeOpacityOp | DrawingSetStrokeStyleOp;
+export {};

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

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

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

@@ -0,0 +1,20 @@
+import { Camera } from 'Camera';
+import { Matrix } from './Transformation';
+/** A container for a CanvasRenderingContext2D, to extend it with more data. */
+export declare class DrawingContext {
+    camera: Camera;
+    ctx: CanvasRenderingContext2D;
+    cursorCtx?: CanvasRenderingContext2D | undefined;
+    matrix: Matrix;
+    isBorderInvisible: boolean;
+    shapeVisibilityTreshold: number;
+    rectangleVisibilyTreshold: number;
+    constructor(camera: Camera, ctx: CanvasRenderingContext2D, // fix here
+    cursorCtx?: CanvasRenderingContext2D | undefined, matrix?: Matrix);
+    dpi(): number;
+    setCamera(camera: Camera): void;
+    clear(): void;
+    clearCursor(): void;
+    applyChanges(): void;
+    getCameraScale(): number;
+}

package/dist/types/Items/Frame/Basic/1-1/index.d.ts

@@ -0,0 +1,7 @@
+import { Mbr, Path, Point } from 'Items';
+export declare const Frame1x1: {
+    name: string;
+    textBounds: Mbr;
+    path: Path;
+    anchorPoints: Point[];
+};

package/dist/types/Items/Frame/Basic/16-9/index.d.ts

@@ -0,0 +1,7 @@
+import { Mbr, Path, Point } from 'Items';
+export declare const Frame16x9: {
+    name: string;
+    textBounds: Mbr;
+    path: Path;
+    anchorPoints: Point[];
+};

package/dist/types/Items/Frame/Basic/3-2/index.d.ts

@@ -0,0 +1,7 @@
+import { Mbr, Path, Point } from 'Items';
+export declare const Frame3x2: {
+    name: string;
+    textBounds: Mbr;
+    path: Path;
+    anchorPoints: Point[];
+};

package/dist/types/Items/Frame/Basic/4-3/index.d.ts

@@ -0,0 +1,7 @@
+import { Mbr, Path, Point } from 'Items';
+export declare const Frame4x3: {
+    name: string;
+    textBounds: Mbr;
+    path: Path;
+    anchorPoints: Point[];
+};

package/dist/types/Items/Frame/Basic/9-18/index.d.ts

@@ -0,0 +1,7 @@
+import { Mbr, Path, Point } from 'Items';
+export declare const Frame9x18: {
+    name: string;
+    textBounds: Mbr;
+    path: Path;
+    anchorPoints: Point[];
+};

package/dist/types/Items/Frame/Basic/A4/index.d.ts

@@ -0,0 +1,7 @@
+import { Mbr, Path, Point } from 'Items';
+export declare const A4: {
+    name: string;
+    textBounds: Mbr;
+    path: Path;
+    anchorPoints: Point[];
+};

package/dist/types/Items/Frame/Basic/Custom/index.d.ts

@@ -0,0 +1,7 @@
+import { Mbr, Path, Point } from 'Items';
+export declare const Custom: {
+    name: string;
+    textBounds: Mbr;
+    path: Path;
+    anchorPoints: Point[];
+};

package/dist/types/Items/Frame/Basic/Letter/index.d.ts

@@ -0,0 +1,7 @@
+import { Mbr, Path, Point } from 'Items';
+export declare const Letter: {
+    name: string;
+    textBounds: Mbr;
+    path: Path;
+    anchorPoints: Point[];
+};

package/dist/types/Items/Frame/Basic/index.d.ts

@@ -0,0 +1,51 @@
+export declare const Frames: {
+    readonly Custom: {
+        name: string;
+        textBounds: import("../..").Mbr;
+        path: import("../..").Path;
+        anchorPoints: import("../..").Point[];
+    };
+    readonly Frame16x9: {
+        name: string;
+        textBounds: import("../..").Mbr;
+        path: import("../..").Path;
+        anchorPoints: import("../..").Point[];
+    };
+    readonly Frame4x3: {
+        name: string;
+        textBounds: import("../..").Mbr;
+        path: import("../..").Path;
+        anchorPoints: import("../..").Point[];
+    };
+    readonly A4: {
+        name: string;
+        textBounds: import("../..").Mbr;
+        path: import("../..").Path;
+        anchorPoints: import("../..").Point[];
+    };
+    readonly Letter: {
+        name: string;
+        textBounds: import("../..").Mbr;
+        path: import("../..").Path;
+        anchorPoints: import("../..").Point[];
+    };
+    readonly Frame1x1: {
+        name: string;
+        textBounds: import("../..").Mbr;
+        path: import("../..").Path;
+        anchorPoints: import("../..").Point[];
+    };
+    readonly Frame3x2: {
+        name: string;
+        textBounds: import("../..").Mbr;
+        path: import("../..").Path;
+        anchorPoints: import("../..").Point[];
+    };
+    readonly Frame9x18: {
+        name: string;
+        textBounds: import("../..").Mbr;
+        path: import("../..").Path;
+        anchorPoints: import("../..").Point[];
+    };
+};
+export type FrameType = keyof typeof Frames;