@contrail/documents 1.3.6 → 1.3.8

package/lib/index.d.ts

@@ -6,3 +6,5 @@ export * from './document-action';
 export * from './util/measure-text/measure-text';
 export * from './util/dynamic-text/dynamic-text-util';
 export * from './document-element-constants';
+export * from './util/curved-line/point';
+export * from './util/curved-line/curved-line';

package/lib/index.js

@@ -22,3 +22,5 @@ __exportStar(require("./document-action"), exports);
 __exportStar(require("./util/measure-text/measure-text"), exports);
 __exportStar(require("./util/dynamic-text/dynamic-text-util"), exports);
 __exportStar(require("./document-element-constants"), exports);
+__exportStar(require("./util/curved-line/point"), exports);
+__exportStar(require("./util/curved-line/curved-line"), exports);

package/lib/util/callout.ts/callout.d.ts

@@ -0,0 +1,16 @@
+import { LineDefinition, ViewBox, LinkedEdgeDefinition, PositionDefinition, SizeDefinition } from '../../types';
+export declare class Callout {
+    static getCalloutLocation({ x1, y1, x2, y2 }: LineDefinition): 'auto' | 'left' | 'right' | 'top' | 'bottom';
+    static getCalloutStart({ x, y }: {
+        x: any;
+        y: any;
+    }, elementId?: string, elementDimensions?: ViewBox): LinkedEdgeDefinition;
+    static getCalloutEnd({ x, y }: {
+        x: any;
+        y: any;
+    }, elementId?: string): LinkedEdgeDefinition;
+    static getCalloutLineEndPosition(location: 'auto' | 'left' | 'right' | 'top' | 'bottom', position: PositionDefinition, size: SizeDefinition): PositionDefinition;
+    static getCalloutEndElementPosition(location: 'auto' | 'left' | 'right' | 'top' | 'bottom', position: PositionDefinition, size: SizeDefinition): PositionDefinition;
+    private static rotate;
+    private static roundTo;
+}

package/lib/util/callout.ts/callout.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Callout = void 0;
+class Callout {
+    static getCalloutLocation({ x1, y1, x2, y2 }) {
+        let location;
+        const endCenterRelativeToStart = {
+            x: x2 - x1,
+            y: y2 - y1,
+        };
+        const rotatedPosition = this.rotate(endCenterRelativeToStart, -45);
+        if (rotatedPosition.x >= 0) {
+            if (rotatedPosition.y >= 0)
+                location = 'top';
+            else
+                location = 'left';
+        }
+        else {
+            if (rotatedPosition.y >= 0)
+                location = 'right';
+            else
+                location = 'bottom';
+        }
+        return location;
+    }
+    static getCalloutStart({ x, y }, elementId, elementDimensions) {
+        if (!elementId) {
+            return {
+                id: null,
+                position: {
+                    x,
+                    y,
+                },
+            };
+        }
+        return {
+            id: elementId,
+            position: {
+                x: this.roundTo(((x - elementDimensions.x) * 100) / elementDimensions.width),
+                y: this.roundTo(((y - elementDimensions.y) * 100) / elementDimensions.height),
+            },
+        };
+    }
+    static getCalloutEnd({ x, y }, elementId) {
+        if (!elementId) {
+            return {
+                id: null,
+                position: {
+                    x,
+                    y,
+                },
+            };
+        }
+        return {
+            id: elementId,
+            location: 'auto',
+        };
+    }
+    static getCalloutLineEndPosition(location, position, size) {
+        let x, y;
+        switch (location) {
+            case 'top':
+                x = position.x + size.width * 0.5;
+                y = position.y;
+                break;
+            case 'bottom':
+                x = position.x + size.width * 0.5;
+                y = position.y + size.height;
+                break;
+            case 'right':
+                x = position.x + size.width;
+                y = position.y + size.height * 0.5;
+                break;
+            case 'left':
+            default:
+                x = position.x;
+                y = position.y + size.height * 0.5;
+                break;
+        }
+        return { x, y };
+    }
+    static getCalloutEndElementPosition(location, position, size) {
+        let x, y;
+        switch (location) {
+            case 'top':
+                x = position.x - size.width * 0.5;
+                y = position.y;
+                break;
+            case 'bottom':
+                x = position.x - size.width * 0.5;
+                y = position.y - size.height;
+                break;
+            case 'right':
+                x = position.x - size.width;
+                y = position.y - size.height * 0.5;
+                break;
+            case 'left':
+            default:
+                x = position.x;
+                y = position.y - size.height * 0.5;
+                break;
+        }
+        return { x, y };
+    }
+    static rotate(position, angle, center = { x: 0, y: 0 }) {
+        const theta = (angle * Math.PI) / 180;
+        const dx = position.x - center.x;
+        const dy = position.y - center.y;
+        return {
+            x: dx * Math.cos(theta) - dy * Math.sin(theta) + center.x,
+            y: dx * Math.sin(theta) + dy * Math.cos(theta) + center.y,
+        };
+    }
+    static roundTo(v) {
+        return Math.round(v * 10000) / 10000;
+    }
+}
+exports.Callout = Callout;

package/lib/util/curved-line/curved-line.d.ts

@@ -0,0 +1,12 @@
+import { LineDefinition } from '../../types';
+import { Point } from './point';
+export interface BezierCurvePointDefinition {
+    cp1: Point;
+    cp2: Point;
+    p1: Point;
+    p2: Point;
+}
+export declare class CurvedLine {
+    static getCurvePoints(lineDefinition: LineDefinition, points: [number, number][]): BezierCurvePointDefinition[];
+    static lerp(a: number, b: number, t: number): number;
+}

package/lib/util/curved-line/curved-line.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CurvedLine = void 0;
+const point_1 = require("./point");
+class CurvedLine {
+    static getCurvePoints(lineDefinition, points) {
+        const curves = [];
+        for (let i = 0; i <= points.length; i++) {
+            const p0 = points[i - 1];
+            const p1 = points[i];
+            const prevPoint = p0 ? new point_1.Point(p0[0], p0[1]) : new point_1.Point(lineDefinition.x1, lineDefinition.y1);
+            const point = p1 ? new point_1.Point(p1[0], p1[1]) : new point_1.Point(lineDefinition.x2, lineDefinition.y2);
+            curves.push({
+                p1: prevPoint,
+                p2: point,
+                cp1: prevPoint,
+                cp2: point,
+            });
+        }
+        const interpolation = [];
+        const distance = [];
+        const r = 0.4;
+        for (let i = 0; i < curves.length; i++) {
+            const c0 = curves[i - 1];
+            const { p1, p2 } = curves[i];
+            interpolation.push(r * p1.distance(p2));
+            if (c0) {
+                const diff0 = c0.p2.clone().subtract(c0.p1).normalize();
+                const diff1 = p2.clone().subtract(p1).normalize();
+                const d = diff0.add(diff1).normalize();
+                distance.push(d);
+            }
+        }
+        distance.unshift(new point_1.Point());
+        distance.push(new point_1.Point());
+        const interpolated = [];
+        for (let i = 0; i < curves.length; i++) {
+            const d0 = interpolation[i - 1];
+            const d1 = interpolation[i];
+            const d2 = interpolation[i + 1];
+            const i0 = d0 && d0 < d1 ? CurvedLine.lerp(d0, d1, 0.5) : d1;
+            const i1 = d2 && d2 < d1 ? CurvedLine.lerp(d1, d2, 0.5) : d1;
+            interpolated.push(i0, i1);
+        }
+        for (let i = 0; i < curves.length; i++) {
+            const i1 = interpolated[2 * i];
+            const i2 = interpolated[2 * i + 1];
+            const d1 = distance[i].clone();
+            const d2 = distance[i + 1].clone().invert();
+            const c = curves[i];
+            c.cp1 = c.p1.clone().add(d1.clone().normalize(i1));
+            c.cp2 = c.p2.clone().add(d2.clone().normalize(i2));
+        }
+        return curves;
+    }
+    static lerp(a, b, t) {
+        return a + (b - a) * t;
+    }
+}
+exports.CurvedLine = CurvedLine;

package/lib/util/curved-line/point.d.ts

@@ -0,0 +1,13 @@
+export declare class Point {
+    x: number;
+    y: number;
+    constructor(x?: number, y?: number);
+    clone(): Point;
+    magnitude(): number;
+    multiply(a: number): Point;
+    invert(): Point;
+    add(p: Point): Point;
+    subtract(p: Point): Point;
+    normalize(n?: number): Point;
+    distance(p: Point): number;
+}

package/lib/util/curved-line/point.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Point = void 0;
+class Point {
+    constructor(x = 0, y = 0) {
+        this.x = x;
+        this.y = y;
+    }
+    clone() {
+        return new Point(this.x, this.y);
+    }
+    magnitude() {
+        return Math.hypot(this.x, this.y);
+    }
+    multiply(a) {
+        this.x *= a;
+        this.y *= a;
+        return this;
+    }
+    invert() {
+        this.x = -this.x;
+        this.y = -this.y;
+        return this;
+    }
+    add(p) {
+        this.x += p.x;
+        this.y += p.y;
+        return this;
+    }
+    subtract(p) {
+        this.x -= p.x;
+        this.y -= p.y;
+        return this;
+    }
+    normalize(n) {
+        if (this.x !== 0 || this.y !== 0) {
+            const e = (n !== null && n !== void 0 ? n : 1) / this.magnitude();
+            this.x *= e;
+            this.y *= e;
+        }
+        return this;
+    }
+    distance(p) {
+        return Math.hypot(this.x - p.x, this.y - p.y);
+    }
+}
+exports.Point = Point;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contrail/documents",
-  "version": "1.3.6",
+  "version": "1.3.8",
   "description": "Documents library for contrail platform",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",