@plait/graph-viz 0.62.0-next.10

package/esm2022/force-atlas/with-force-atlas.mjs

@@ -0,0 +1,71 @@
+import { RectangleClient, setSelectionOptions } from '@plait/core';
+import { ForceAtlasFlavour } from './force-atlas.flavour';
+import { ForceAtlasNodeFlavour } from './node.flavour';
+import { ForceAtlasEdgeFlavour } from './edge.flavour';
+import { ForceAtlasElement } from '../interfaces';
+import { isHitNode } from './utils/node';
+import { withNodeIcon } from './with-node-icon';
+export const withForceAtlas = (board) => {
+    const { drawElement, getRectangle, isRectangleHit, isHit, isInsidePoint, isMovable, isAlign, getRelatedFragment } = board;
+    board.drawElement = (context) => {
+        if (ForceAtlasElement.isForceAtlas(context.element)) {
+            return ForceAtlasFlavour;
+        }
+        else if (ForceAtlasElement.isForceAtlasNodeElement(context.element)) {
+            return ForceAtlasNodeFlavour;
+        }
+        else if (ForceAtlasElement.isForceAtlasEdgeElement(context.element)) {
+            return ForceAtlasEdgeFlavour;
+        }
+        return drawElement(context);
+    };
+    board.getRectangle = (element) => {
+        if (element.type === 'force-atlas') {
+            return {
+                width: 0,
+                height: 0,
+                x: 0,
+                y: 0
+            };
+        }
+        else if (ForceAtlasElement.isForceAtlasNodeElement(element)) {
+            return RectangleClient.getRectangleByPoints(element.points || []);
+        }
+        else if (ForceAtlasElement.isForceAtlasEdgeElement(element)) {
+            return {
+                width: 0,
+                height: 0,
+                x: 0,
+                y: 0
+            };
+        }
+        return getRectangle(element);
+    };
+    board.isRectangleHit = (element, selection) => {
+        return isRectangleHit(element, selection);
+    };
+    board.isRectangleHit = (element, range) => {
+        if (ForceAtlasElement.isForceAtlasNodeElement(element)) {
+            return isHitNode(element, [range.anchor, range.focus]);
+        }
+        return isRectangleHit(element, range);
+    };
+    board.isHit = (element, point) => {
+        if (ForceAtlasElement.isForceAtlasNodeElement(element)) {
+            return isHitNode(element, [point, point]);
+        }
+        return isHit(element, point);
+    };
+    board.isInsidePoint = (element, point) => {
+        return isInsidePoint(element, point);
+    };
+    board.isMovable = element => {
+        if (ForceAtlasElement.isForceAtlasNodeElement(element)) {
+            return true;
+        }
+        return isMovable(element);
+    };
+    setSelectionOptions(board, { isMultipleSelection: false });
+    return withNodeIcon(board);
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/force-atlas/with-node-icon.mjs

@@ -0,0 +1,8 @@
+export const withNodeIcon = (board) => {
+    const newBoard = board;
+    newBoard.renderNodeIcon = (container, props) => {
+        throw new Error('No implementation for renderLabeIcon method.');
+    };
+    return newBoard;
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2l0aC1ub2RlLWljb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wYWNrYWdlcy9ncmFwaC12aXovc3JjL2ZvcmNlLWF0bGFzL3dpdGgtbm9kZS1pY29uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQVNBLE1BQU0sQ0FBQyxNQUFNLFlBQVksR0FBRyxDQUFvQyxLQUFRLEVBQUUsRUFBRTtJQUN4RSxNQUFNLFFBQVEsR0FBRyxLQUFvQyxDQUFDO0lBRXRELFFBQVEsQ0FBQyxjQUFjLEdBQUcsQ0FBQyxTQUFxQyxFQUFFLEtBQW9CLEVBQUUsRUFBRTtRQUN0RixNQUFNLElBQUksS0FBSyxDQUFDLDhDQUE4QyxDQUFDLENBQUM7SUFDcEUsQ0FBQyxDQUFDO0lBQ0YsT0FBTyxRQUFRLENBQUM7QUFDcEIsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUGxhaXRCb2FyZCB9IGZyb20gJ0BwbGFpdC9jb3JlJztcbmltcG9ydCB7IEZvcmNlQXRsYXNOb2RlRWxlbWVudCB9IGZyb20gJy4uL2ludGVyZmFjZXMvZWxlbWVudCc7XG5pbXBvcnQgeyBSZW5kZXJDb21wb25lbnRSZWYgfSBmcm9tICdAcGxhaXQvY29tbW9uJztcbmltcG9ydCB7IE5vZGVJY29uSXRlbSB9IGZyb20gJy4vdHlwZXMnO1xuXG5leHBvcnQgaW50ZXJmYWNlIEZvcmNlQXRsYXNOb2RlSWNvbkJvYXJkIHtcbiAgICByZW5kZXJOb2RlSWNvbjogKGNvbnRhaW5lcjogRWxlbWVudCB8IERvY3VtZW50RnJhZ21lbnQsIHByb3BzOiBOb2RlSWNvblByb3BzKSA9PiBSZW5kZXJDb21wb25lbnRSZWY8Tm9kZUljb25Qcm9wcz47XG59XG5cbmV4cG9ydCBjb25zdCB3aXRoTm9kZUljb24gPSA8VCBleHRlbmRzIFBsYWl0Qm9hcmQgPSBQbGFpdEJvYXJkPihib2FyZDogVCkgPT4ge1xuICAgIGNvbnN0IG5ld0JvYXJkID0gYm9hcmQgYXMgVCAmIEZvcmNlQXRsYXNOb2RlSWNvbkJvYXJkO1xuXG4gICAgbmV3Qm9hcmQucmVuZGVyTm9kZUljb24gPSAoY29udGFpbmVyOiBFbGVtZW50IHwgRG9jdW1lbnRGcmFnbWVudCwgcHJvcHM6IE5vZGVJY29uUHJvcHMpID0+IHtcbiAgICAgICAgdGhyb3cgbmV3IEVycm9yKCdObyBpbXBsZW1lbnRhdGlvbiBmb3IgcmVuZGVyTGFiZUljb24gbWV0aG9kLicpO1xuICAgIH07XG4gICAgcmV0dXJuIG5ld0JvYXJkO1xufTtcblxuZXhwb3J0IGludGVyZmFjZSBOb2RlSWNvblByb3BzIHtcbiAgICBib2FyZDogUGxhaXRCb2FyZDtcbiAgICBpY29uSXRlbTogTm9kZUljb25JdGVtO1xuICAgIGVsZW1lbnQ6IEZvcmNlQXRsYXNOb2RlRWxlbWVudDtcbn1cbiJdfQ==

package/esm2022/interfaces/element.mjs

@@ -0,0 +1,12 @@
+export const ForceAtlasElement = {
+    isForceAtlas: (value) => {
+        return value?.type === 'force-atlas';
+    },
+    isForceAtlasNodeElement: (value) => {
+        return value && value.label && value.icon;
+    },
+    isForceAtlasEdgeElement: (value) => {
+        return value && value.source && value.target;
+    }
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZWxlbWVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3BhY2thZ2VzL2dyYXBoLXZpei9zcmMvaW50ZXJmYWNlcy9lbGVtZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQWtCQSxNQUFNLENBQUMsTUFBTSxpQkFBaUIsR0FBRztJQUM3QixZQUFZLEVBQUUsQ0FBQyxLQUFVLEVBQUUsRUFBRTtRQUN6QixPQUFPLEtBQUssRUFBRSxJQUFJLEtBQUssYUFBYSxDQUFDO0lBQ3pDLENBQUM7SUFDRCx1QkFBdUIsRUFBRSxDQUFDLEtBQVUsRUFBa0MsRUFBRTtRQUNwRSxPQUFPLEtBQUssSUFBSSxLQUFLLENBQUMsS0FBSyxJQUFJLEtBQUssQ0FBQyxJQUFJLENBQUM7SUFDOUMsQ0FBQztJQUNELHVCQUF1QixFQUFFLENBQUMsS0FBVSxFQUFrQyxFQUFFO1FBQ3BFLE9BQU8sS0FBSyxJQUFJLEtBQUssQ0FBQyxNQUFNLElBQUksS0FBSyxDQUFDLE1BQU0sQ0FBQztJQUNqRCxDQUFDO0NBQ0osQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFBsYWl0RWxlbWVudCB9IGZyb20gJ0BwbGFpdC9jb3JlJztcbmltcG9ydCB7IE5vZGVJY29uSXRlbSB9IGZyb20gJy4uL2ZvcmNlLWF0bGFzL3R5cGVzJztcbmV4cG9ydCBpbnRlcmZhY2UgRm9yY2VBdGxhc05vZGVFbGVtZW50IGV4dGVuZHMgUGxhaXRFbGVtZW50IHtcbiAgICBsYWJlbDogc3RyaW5nO1xuICAgIGljb246IHN0cmluZyB8IE5vZGVJY29uSXRlbTtcbiAgICBzaXplPzogbnVtYmVyO1xuICAgIGlzQWN0aXZlPzogYm9vbGVhbjtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBGb3JjZUF0bGFzRWRnZUVsZW1lbnQgZXh0ZW5kcyBQbGFpdEVsZW1lbnQge1xuICAgIHNvdXJjZTogc3RyaW5nO1xuICAgIHRhcmdldDogc3RyaW5nO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIEZvcmNlQXRsYXNFbGVtZW50IGV4dGVuZHMgUGxhaXRFbGVtZW50IHtcbiAgICBjaGlsZHJlbjogKEZvcmNlQXRsYXNOb2RlRWxlbWVudCB8IEZvcmNlQXRsYXNFZGdlRWxlbWVudClbXTtcbn1cblxuZXhwb3J0IGNvbnN0IEZvcmNlQXRsYXNFbGVtZW50ID0ge1xuICAgIGlzRm9yY2VBdGxhczogKHZhbHVlOiBhbnkpID0+IHtcbiAgICAgICAgcmV0dXJuIHZhbHVlPy50eXBlID09PSAnZm9yY2UtYXRsYXMnO1xuICAgIH0sXG4gICAgaXNGb3JjZUF0bGFzTm9kZUVsZW1lbnQ6ICh2YWx1ZTogYW55KTogdmFsdWUgaXMgRm9yY2VBdGxhc05vZGVFbGVtZW50ID0+IHtcbiAgICAgICAgcmV0dXJuIHZhbHVlICYmIHZhbHVlLmxhYmVsICYmIHZhbHVlLmljb247XG4gICAgfSxcbiAgICBpc0ZvcmNlQXRsYXNFZGdlRWxlbWVudDogKHZhbHVlOiBhbnkpOiB2YWx1ZSBpcyBGb3JjZUF0bGFzRWRnZUVsZW1lbnQgPT4ge1xuICAgICAgICByZXR1cm4gdmFsdWUgJiYgdmFsdWUuc291cmNlICYmIHZhbHVlLnRhcmdldDtcbiAgICB9XG59O1xuIl19

package/esm2022/interfaces/index.mjs

@@ -0,0 +1,2 @@
+export * from './element';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wYWNrYWdlcy9ncmFwaC12aXovc3JjL2ludGVyZmFjZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxXQUFXLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2VsZW1lbnQnO1xuIl19

package/esm2022/perfect-arrows/get-arrow.mjs

@@ -0,0 +1,91 @@
+// Credits to perfect-arrows
+// https://github.com/steveruizok/perfect-arrows/blob/master/src/lib/getArrow.ts
+import { getAngle, getDistance, getAngliness, projectPoint, getPointBetween, getSector, rotatePoint, modulate } from './utils';
+/**
+   * getArrow
+   * Get the points for a linking line between two points.
+   * @description Draw an arrow between two points.
+   * @param x0 The x position of the "from" point.
+   * @param y0 The y position of the "from" point.
+   * @param x1 The x position of the "to" point.
+   * @param y1 The y position of the "to" point.
+   * @param options Additional options for computing the line.
+   * @returns [sx, sy, cx, cy, e1, e2, ae, as, ac]
+   * @example
+   * const arrow = getArrow(0, 0, 100, 200, {
+      bow: 0
+      stretch: .5
+      stretchMin: 0
+      stretchMax: 420
+      padStart: 0
+      padEnd: 0
+      flip: false
+      straights: true
+   * })
+   *
+   * const [
+   *  startX, startY,
+   *  controlX, controlY,
+   *  endX, endY,
+   *  endAngle,
+   *  startAngle,
+   *  controlAngle
+   *  ] = arrow
+   */
+export default function getArrow(x0, y0, x1, y1, options = {}) {
+    const { bow = 0, stretch = 0.5, stretchMin = 0, stretchMax = 420, padStart = 0, padEnd = 0, flip = false, straights = true } = options;
+    const angle = getAngle(x0, y0, x1, y1);
+    const dist = getDistance(x0, y0, x1, y1);
+    const angliness = getAngliness(x0, y0, x1, y1);
+    // Step 0 ⤜⤏ Should the arrow be straight?
+    if (dist < (padStart + padEnd) * 2 || // Too short
+        (bow === 0 && stretch === 0) || // No bow, no stretch
+        (straights && [0, 1, Infinity].includes(angliness)) // 45 degree angle
+    ) {
+        // ⤜⤏ Arrow is straight! Just pad start and end points.
+        // Padding distances
+        const ps = Math.max(0, Math.min(dist - padStart, padStart));
+        const pe = Math.max(0, Math.min(dist - ps, padEnd));
+        // Move start point toward end point
+        let [px0, py0] = projectPoint(x0, y0, angle, ps);
+        // Move end point toward start point
+        let [px1, py1] = projectPoint(x1, y1, angle + Math.PI, pe);
+        // Get midpoint between new points
+        const [mx, my] = getPointBetween(px0, py0, px1, py1, 0.5);
+        return [px0, py0, mx, my, px1, py1, angle, angle, angle];
+    }
+    // ⤜⤏ Arrow is an arc!
+    // Is the arc clockwise or counterclockwise?
+    let rot = (getSector(angle) % 2 === 0 ? 1 : -1) * (flip ? -1 : 1);
+    // Calculate how much the line should "bow" away from center
+    const arc = bow + modulate(dist, [stretchMin, stretchMax], [1, 0], true) * stretch;
+    // Step 1 ⤜⤏ Find padded points.
+    // Get midpoint.
+    const [mx, my] = getPointBetween(x0, y0, x1, y1, 0.5);
+    // Get control point.
+    let [cx, cy] = getPointBetween(x0, y0, x1, y1, 0.5 - arc);
+    // Rotate control point (clockwise or counterclockwise).
+    [cx, cy] = rotatePoint(cx, cy, mx, my, (Math.PI / 2) * rot);
+    // Get padded start point.
+    const a0 = getAngle(x0, y0, cx, cy);
+    const [px0, py0] = projectPoint(x0, y0, a0, padStart);
+    // Get padded end point.
+    const a1 = getAngle(x1, y1, cx, cy);
+    const [px1, py1] = projectPoint(x1, y1, a1, padEnd);
+    // Step 2  ⤜⤏ Find start and end angles.
+    // Start angle
+    const as = getAngle(cx, cy, x0, y0);
+    // End angle
+    const ae = getAngle(cx, cy, x1, y1);
+    // Step 3 ⤜⤏ Find control point for padded points.
+    // Get midpoint between padded start / end points.
+    const [mx1, my1] = getPointBetween(px0, py0, px1, py1, 0.5);
+    // Get control point for padded start / end points.
+    let [cx1, cy1] = getPointBetween(px0, py0, px1, py1, 0.5 - arc);
+    // Rotate control point (clockwise or counterclockwise).
+    [cx1, cy1] = rotatePoint(cx1, cy1, mx1, my1, (Math.PI / 2) * rot);
+    // Finally, average the two control points.
+    let [cx2, cy2] = getPointBetween(cx, cy, cx1, cy1, 0.5);
+    return [px0, py0, cx2, cy2, px1, py1, ae, as, angle];
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"get-arrow.js","sourceRoot":"","sources":["../../../../packages/graph-viz/src/perfect-arrows/get-arrow.ts"],"names":[],"mappings":"AAAA,4BAA4B;AAC5B,gFAAgF;AAEhF,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,YAAY,EAAE,YAAY,EAAE,eAAe,EAAE,SAAS,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAa/H;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA8BK;AACL,MAAM,CAAC,OAAO,UAAU,QAAQ,CAAC,EAAU,EAAE,EAAU,EAAE,EAAU,EAAE,EAAU,EAAE,UAAwB,EAAkB;IACvH,MAAM,EAAE,GAAG,GAAG,CAAC,EAAE,OAAO,GAAG,GAAG,EAAE,UAAU,GAAG,CAAC,EAAE,UAAU,GAAG,GAAG,EAAE,QAAQ,GAAG,CAAC,EAAE,MAAM,GAAG,CAAC,EAAE,IAAI,GAAG,KAAK,EAAE,SAAS,GAAG,IAAI,EAAE,GAAG,OAAO,CAAC;IAEvI,MAAM,KAAK,GAAG,QAAQ,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;IACvC,MAAM,IAAI,GAAG,WAAW,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;IACzC,MAAM,SAAS,GAAG,YAAY,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;IAE/C,0CAA0C;IAE1C,IACI,IAAI,GAAG,CAAC,QAAQ,GAAG,MAAM,CAAC,GAAG,CAAC,IAAI,YAAY;QAC9C,CAAC,GAAG,KAAK,CAAC,IAAI,OAAO,KAAK,CAAC,CAAC,IAAI,qBAAqB;QACrD,CAAC,SAAS,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,QAAQ,CAAC,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC,CAAC,kBAAkB;MACxE,CAAC;QACC,uDAAuD;QAEvD,oBAAoB;QACpB,MAAM,EAAE,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,IAAI,GAAG,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC;QAC5D,MAAM,EAAE,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,IAAI,GAAG,EAAE,EAAE,MAAM,CAAC,CAAC,CAAC;QAEpD,oCAAoC;QACpC,IAAI,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,YAAY,CAAC,EAAE,EAAE,EAAE,EAAE,KAAK,EAAE,EAAE,CAAC,CAAC;QAEjD,oCAAoC;QACpC,IAAI,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,YAAY,CAAC,EAAE,EAAE,EAAE,EAAE,KAAK,GAAG,IAAI,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;QAE3D,kCAAkC;QAClC,MAAM,CAAC,EAAE,EAAE,EAAE,CAAC,GAAG,eAAe,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC;QAE1D,OAAO,CAAC,GAAG,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE,GAAG,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC;IAC7D,CAAC;IAED,sBAAsB;IAEtB,4CAA4C;IAC5C,IAAI,GAAG,GAAG,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAElE,4DAA4D;IAC5D,MAAM,GAAG,GAAG,GAAG,GAAG,QAAQ,CAAC,IAAI,EAAE,CAAC,UAAU,EAAE,UAAU,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,OAAO,CAAC;IAEnF,gCAAgC;IAEhC,gBAAgB;IAChB,MAAM,CAAC,EAAE,EAAE,EAAE,CAAC,GAAG,eAAe,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,CAAC,CAAC;IAEtD,qBAAqB;IACrB,IAAI,CAAC,EAAE,EAAE,EAAE,CAAC,GAAG,eAAe,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,GAAG,GAAG,CAAC,CAAC;IAE1D,wDAAwD;IACxD,CAAC,EAAE,EAAE,EAAE,CAAC,GAAG,WAAW,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,EAAE,GAAG,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC;IAE5D,0BAA0B;IAC1B,MAAM,EAAE,GAAG,QAAQ,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;IACpC,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,YAAY,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,QAAQ,CAAC,CAAC;IAEtD,wBAAwB;IACxB,MAAM,EAAE,GAAG,QAAQ,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;IACpC,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,YAAY,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,MAAM,CAAC,CAAC;IAEpD,wCAAwC;IAExC,cAAc;IACd,MAAM,EAAE,GAAG,QAAQ,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;IAEpC,YAAY;IACZ,MAAM,EAAE,GAAG,QAAQ,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;IAEpC,kDAAkD;IAElD,kDAAkD;IAClD,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,eAAe,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC;IAE5D,mDAAmD;IACnD,IAAI,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,eAAe,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,GAAG,GAAG,CAAC,CAAC;IAEhE,wDAAwD;IACxD,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,WAAW,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,EAAE,GAAG,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC;IAElE,2CAA2C;IAC3C,IAAI,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,eAAe,CAAC,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC;IAExD,OAAO,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,EAAE,KAAK,CAAC,CAAC;AACzD,CAAC","sourcesContent":["// Credits to perfect-arrows\n// https://github.com/steveruizok/perfect-arrows/blob/master/src/lib/getArrow.ts\n\nimport { getAngle, getDistance, getAngliness, projectPoint, getPointBetween, getSector, rotatePoint, modulate } from './utils';\n\nexport type ArrowOptions = {\n    bow?: number;\n    stretchMin?: number;\n    stretchMax?: number;\n    stretch?: number;\n    padStart?: number;\n    padEnd?: number;\n    flip?: boolean;\n    straights?: boolean;\n};\n\n/**\n   * getArrow\n   * Get the points for a linking line between two points.\n   * @description Draw an arrow between two points.\n   * @param x0 The x position of the \"from\" point.\n   * @param y0 The y position of the \"from\" point.\n   * @param x1 The x position of the \"to\" point.\n   * @param y1 The y position of the \"to\" point.\n   * @param options Additional options for computing the line.\n   * @returns [sx, sy, cx, cy, e1, e2, ae, as, ac]\n   * @example\n   * const arrow = getArrow(0, 0, 100, 200, {\n      bow: 0\n      stretch: .5\n      stretchMin: 0\n      stretchMax: 420\n      padStart: 0\n      padEnd: 0\n      flip: false\n      straights: true\n   * })\n   * \n   * const [\n   *  startX, startY, \n   *  controlX, controlY, \n   *  endX, endY, \n   *  endAngle, \n   *  startAngle,\n   *  controlAngle\n   *  ] = arrow\n   */\nexport default function getArrow(x0: number, y0: number, x1: number, y1: number, options: ArrowOptions = {} as ArrowOptions): number[] {\n    const { bow = 0, stretch = 0.5, stretchMin = 0, stretchMax = 420, padStart = 0, padEnd = 0, flip = false, straights = true } = options;\n\n    const angle = getAngle(x0, y0, x1, y1);\n    const dist = getDistance(x0, y0, x1, y1);\n    const angliness = getAngliness(x0, y0, x1, y1);\n\n    // Step 0 ⤜⤏ Should the arrow be straight?\n\n    if (\n        dist < (padStart + padEnd) * 2 || // Too short\n        (bow === 0 && stretch === 0) || // No bow, no stretch\n        (straights && [0, 1, Infinity].includes(angliness)) // 45 degree angle\n    ) {\n        // ⤜⤏ Arrow is straight! Just pad start and end points.\n\n        // Padding distances\n        const ps = Math.max(0, Math.min(dist - padStart, padStart));\n        const pe = Math.max(0, Math.min(dist - ps, padEnd));\n\n        // Move start point toward end point\n        let [px0, py0] = projectPoint(x0, y0, angle, ps);\n\n        // Move end point toward start point\n        let [px1, py1] = projectPoint(x1, y1, angle + Math.PI, pe);\n\n        // Get midpoint between new points\n        const [mx, my] = getPointBetween(px0, py0, px1, py1, 0.5);\n\n        return [px0, py0, mx, my, px1, py1, angle, angle, angle];\n    }\n\n    // ⤜⤏ Arrow is an arc!\n\n    // Is the arc clockwise or counterclockwise?\n    let rot = (getSector(angle) % 2 === 0 ? 1 : -1) * (flip ? -1 : 1);\n\n    // Calculate how much the line should \"bow\" away from center\n    const arc = bow + modulate(dist, [stretchMin, stretchMax], [1, 0], true) * stretch;\n\n    // Step 1 ⤜⤏ Find padded points.\n\n    // Get midpoint.\n    const [mx, my] = getPointBetween(x0, y0, x1, y1, 0.5);\n\n    // Get control point.\n    let [cx, cy] = getPointBetween(x0, y0, x1, y1, 0.5 - arc);\n\n    // Rotate control point (clockwise or counterclockwise).\n    [cx, cy] = rotatePoint(cx, cy, mx, my, (Math.PI / 2) * rot);\n\n    // Get padded start point.\n    const a0 = getAngle(x0, y0, cx, cy);\n    const [px0, py0] = projectPoint(x0, y0, a0, padStart);\n\n    // Get padded end point.\n    const a1 = getAngle(x1, y1, cx, cy);\n    const [px1, py1] = projectPoint(x1, y1, a1, padEnd);\n\n    // Step 2  ⤜⤏ Find start and end angles.\n\n    // Start angle\n    const as = getAngle(cx, cy, x0, y0);\n\n    // End angle\n    const ae = getAngle(cx, cy, x1, y1);\n\n    // Step 3 ⤜⤏ Find control point for padded points.\n\n    // Get midpoint between padded start / end points.\n    const [mx1, my1] = getPointBetween(px0, py0, px1, py1, 0.5);\n\n    // Get control point for padded start / end points.\n    let [cx1, cy1] = getPointBetween(px0, py0, px1, py1, 0.5 - arc);\n\n    // Rotate control point (clockwise or counterclockwise).\n    [cx1, cy1] = rotatePoint(cx1, cy1, mx1, my1, (Math.PI / 2) * rot);\n\n    // Finally, average the two control points.\n    let [cx2, cy2] = getPointBetween(cx, cy, cx1, cy1, 0.5);\n\n    return [px0, py0, cx2, cy2, px1, py1, ae, as, angle];\n}\n"]}

package/esm2022/perfect-arrows/utils.mjs

@@ -0,0 +1,111 @@
+// Credits to perfect-arrows
+// https://github.com/steveruizok/perfect-arrows/blob/master/src/lib/utils.ts
+const PI = Math.PI;
+/**
+ * Modulate a value between two ranges.
+ * @param value
+ * @param rangeA from [low, high]
+ * @param rangeB to [low, high]
+ * @param clamp
+ */
+export function modulate(value, rangeA, rangeB, clamp = false) {
+    const [fromLow, fromHigh] = rangeA;
+    const [toLow, toHigh] = rangeB;
+    const result = toLow + ((value - fromLow) / (fromHigh - fromLow)) * (toHigh - toLow);
+    if (clamp === true) {
+        if (toLow < toHigh) {
+            if (result < toLow) {
+                return toLow;
+            }
+            if (result > toHigh) {
+                return toHigh;
+            }
+        }
+        else {
+            if (result > toLow) {
+                return toLow;
+            }
+            if (result < toHigh) {
+                return toHigh;
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Rotate a point around a center.
+ * @param x The x-axis coordinate of the point.
+ * @param y The y-axis coordinate of the point.
+ * @param cx The x-axis coordinate of the point to rotate round.
+ * @param cy The y-axis coordinate of the point to rotate round.
+ * @param angle The distance (in radians) to rotate.
+ */
+export function rotatePoint(x, y, cx, cy, angle) {
+    const s = Math.sin(angle);
+    const c = Math.cos(angle);
+    const px = x - cx;
+    const py = y - cy;
+    const nx = px * c - py * s;
+    const ny = px * s + py * c;
+    return [nx + cx, ny + cy];
+}
+/**
+ * Get the distance between two points.
+ * @param x0 The x-axis coordinate of the first point.
+ * @param y0 The y-axis coordinate of the first point.
+ * @param x1 The x-axis coordinate of the second point.
+ * @param y1 The y-axis coordinate of the second point.
+ */
+export function getDistance(x0, y0, x1, y1) {
+    return Math.hypot(y1 - y0, x1 - x0);
+}
+/**
+ * Get an angle (radians) between two points.
+ * @param x0 The x-axis coordinate of the first point.
+ * @param y0 The y-axis coordinate of the first point.
+ * @param x1 The x-axis coordinate of the second point.
+ * @param y1 The y-axis coordinate of the second point.
+ */
+export function getAngle(x0, y0, x1, y1) {
+    return Math.atan2(y1 - y0, x1 - x0);
+}
+/**
+ * Move a point in an angle by a distance.
+ * @param x0
+ * @param y0
+ * @param a angle (radians)
+ * @param d distance
+ */
+export function projectPoint(x0, y0, a, d) {
+    return [Math.cos(a) * d + x0, Math.sin(a) * d + y0];
+}
+/**
+ * Get a point between two points.
+ * @param x0 The x-axis coordinate of the first point.
+ * @param y0 The y-axis coordinate of the first point.
+ * @param x1 The x-axis coordinate of the second point.
+ * @param y1 The y-axis coordinate of the second point.
+ * @param d Normalized
+ */
+export function getPointBetween(x0, y0, x1, y1, d = 0.5) {
+    return [x0 + (x1 - x0) * d, y0 + (y1 - y0) * d];
+}
+/**
+ * Get the sector of an angle (e.g. quadrant, octant)
+ * @param a The angle to check.
+ * @param s The number of sectors to check.
+ */
+export function getSector(a, s = 8) {
+    return Math.floor(s * (0.5 + ((a / (PI * 2)) % s)));
+}
+/**
+ * Get a normal value representing how close two points are from being at a 45 degree angle.
+ * @param x0 The x-axis coordinate of the first point.
+ * @param y0 The y-axis coordinate of the first point.
+ * @param x1 The x-axis coordinate of the second point.
+ * @param y1 The y-axis coordinate of the second point.
+ */
+export function getAngliness(x0, y0, x1, y1) {
+    return Math.abs((x1 - x0) / 2 / ((y1 - y0) / 2));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../packages/graph-viz/src/perfect-arrows/utils.ts"],"names":[],"mappings":"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","sourcesContent":["// Credits to perfect-arrows\n// https://github.com/steveruizok/perfect-arrows/blob/master/src/lib/utils.ts\n\nconst PI = Math.PI;\n\n/**\n * Modulate a value between two ranges.\n * @param value\n * @param rangeA from [low, high]\n * @param rangeB to [low, high]\n * @param clamp\n */\nexport function modulate(value: number, rangeA: number[], rangeB: number[], clamp = false) {\n    const [fromLow, fromHigh] = rangeA;\n    const [toLow, toHigh] = rangeB;\n    const result = toLow + ((value - fromLow) / (fromHigh - fromLow)) * (toHigh - toLow);\n    if (clamp === true) {\n        if (toLow < toHigh) {\n            if (result < toLow) {\n                return toLow;\n            }\n            if (result > toHigh) {\n                return toHigh;\n            }\n        } else {\n            if (result > toLow) {\n                return toLow;\n            }\n            if (result < toHigh) {\n                return toHigh;\n            }\n        }\n    }\n    return result;\n}\n\n/**\n * Rotate a point around a center.\n * @param x The x-axis coordinate of the point.\n * @param y The y-axis coordinate of the point.\n * @param cx The x-axis coordinate of the point to rotate round.\n * @param cy The y-axis coordinate of the point to rotate round.\n * @param angle The distance (in radians) to rotate.\n */\nexport function rotatePoint(x: number, y: number, cx: number, cy: number, angle: number) {\n    const s = Math.sin(angle);\n    const c = Math.cos(angle);\n\n    const px = x - cx;\n    const py = y - cy;\n\n    const nx = px * c - py * s;\n    const ny = px * s + py * c;\n\n    return [nx + cx, ny + cy];\n}\n\n/**\n * Get the distance between two points.\n * @param x0 The x-axis coordinate of the first point.\n * @param y0 The y-axis coordinate of the first point.\n * @param x1 The x-axis coordinate of the second point.\n * @param y1 The y-axis coordinate of the second point.\n */\nexport function getDistance(x0: number, y0: number, x1: number, y1: number) {\n    return Math.hypot(y1 - y0, x1 - x0);\n}\n\n/**\n * Get an angle (radians) between two points.\n * @param x0 The x-axis coordinate of the first point.\n * @param y0 The y-axis coordinate of the first point.\n * @param x1 The x-axis coordinate of the second point.\n * @param y1 The y-axis coordinate of the second point.\n */\nexport function getAngle(x0: number, y0: number, x1: number, y1: number) {\n    return Math.atan2(y1 - y0, x1 - x0);\n}\n\n/**\n * Move a point in an angle by a distance.\n * @param x0\n * @param y0\n * @param a angle (radians)\n * @param d distance\n */\nexport function projectPoint(x0: number, y0: number, a: number, d: number) {\n    return [Math.cos(a) * d + x0, Math.sin(a) * d + y0];\n}\n\n/**\n * Get a point between two points.\n * @param x0 The x-axis coordinate of the first point.\n * @param y0 The y-axis coordinate of the first point.\n * @param x1 The x-axis coordinate of the second point.\n * @param y1 The y-axis coordinate of the second point.\n * @param d Normalized\n */\nexport function getPointBetween(x0: number, y0: number, x1: number, y1: number, d = 0.5) {\n    return [x0 + (x1 - x0) * d, y0 + (y1 - y0) * d];\n}\n\n/**\n * Get the sector of an angle (e.g. quadrant, octant)\n * @param a The angle to check.\n * @param s The number of sectors to check.\n */\nexport function getSector(a: number, s = 8) {\n    return Math.floor(s * (0.5 + ((a / (PI * 2)) % s)));\n}\n\n/**\n * Get a normal value representing how close two points are from being at a 45 degree angle.\n * @param x0 The x-axis coordinate of the first point.\n * @param y0 The y-axis coordinate of the first point.\n * @param x1 The x-axis coordinate of the second point.\n * @param y1 The y-axis coordinate of the second point.\n */\nexport function getAngliness(x0: number, y0: number, x1: number, y1: number) {\n    return Math.abs((x1 - x0) / 2 / ((y1 - y0) / 2));\n}\n"]}

package/esm2022/plait-graph-viz.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGxhaXQtZ3JhcGgtdml6LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vcGFja2FnZXMvZ3JhcGgtdml6L3NyYy9wbGFpdC1ncmFwaC12aXoudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==

package/esm2022/public-api.mjs

@@ -0,0 +1,10 @@
+/*
+ * Public API Surface of utils
+ */
+export * from './force-atlas/constants';
+export * from './force-atlas/types';
+export * from './force-atlas/with-force-atlas';
+export * from './force-atlas/with-node-icon';
+export * from './interfaces/index';
+export * from './force-atlas/core/node-icon-base.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3BhY2thZ2VzL2dyYXBoLXZpei9zcmMvcHVibGljLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLGdDQUFnQyxDQUFDO0FBQy9DLGNBQWMsOEJBQThCLENBQUM7QUFDN0MsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLDZDQUE2QyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLypcbiAqIFB1YmxpYyBBUEkgU3VyZmFjZSBvZiB1dGlsc1xuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vZm9yY2UtYXRsYXMvY29uc3RhbnRzJztcbmV4cG9ydCAqIGZyb20gJy4vZm9yY2UtYXRsYXMvdHlwZXMnO1xuZXhwb3J0ICogZnJvbSAnLi9mb3JjZS1hdGxhcy93aXRoLWZvcmNlLWF0bGFzJztcbmV4cG9ydCAqIGZyb20gJy4vZm9yY2UtYXRsYXMvd2l0aC1ub2RlLWljb24nO1xuZXhwb3J0ICogZnJvbSAnLi9pbnRlcmZhY2VzL2luZGV4JztcbmV4cG9ydCAqIGZyb20gJy4vZm9yY2UtYXRsYXMvY29yZS9ub2RlLWljb24tYmFzZS5jb21wb25lbnQnO1xuIl19