@lincle/react-shared 0.0.1 → 0.4.0-next.10

package/dist/Providers/index.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Providers = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const defaultSettings_1 = __importDefault(require("../defaultSettings"));
+const Providers_1 = require("./Providers");
+const Providers = ({ children, edgeFrequency = defaultSettings_1.default.edgeFrequency, grid = defaultSettings_1.default.grid, id, line = defaultSettings_1.default.line, nodeFrequency = defaultSettings_1.default.nodeFrequency, nodeHeight = defaultSettings_1.default.height, nodeWidth = defaultSettings_1.default.width, shape = defaultSettings_1.default.shape }) => {
+    return ((0, jsx_runtime_1.jsx)(Providers_1.GraphProvider, { edgeFrequency: edgeFrequency, grid: grid, id: id, line: line, nodeFrequency: nodeFrequency, nodeHeight: nodeHeight, nodeWidth: nodeWidth, shape: shape, children: (0, jsx_runtime_1.jsx)(Providers_1.EdgesProvider, { children: children }) }));
+};
+exports.Providers = Providers;
+Providers.displayName = 'LincleProviders';

package/dist/defaultSettings.d.ts

@@ -0,0 +1,12 @@
+import { type Line, type Shape } from './types';
+declare const _default: {
+    edgeFrequency: number;
+    grid: [number, number];
+    height: number;
+    line: Line;
+    nodeFrequency: number;
+    shape: Shape;
+    showGrid: boolean;
+    width: number;
+};
+export default _default;

package/dist/defaultSettings.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    edgeFrequency: 16,
+    grid: [
+        16,
+        16
+    ],
+    height: 50,
+    line: 'step',
+    nodeFrequency: 16,
+    shape: 'oval',
+    showGrid: true,
+    width: 50
+};

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { default as defaultSettings } from './defaultSettings';
+export * from './Hooks';
+export * from './Providers';
+export * from './types';
+export { default as generateOrigins } from './utils/Path/generateOrigins';

package/dist/index.js

@@ -0,0 +1,27 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateOrigins = exports.defaultSettings = void 0;
+var defaultSettings_1 = require("./defaultSettings");
+Object.defineProperty(exports, "defaultSettings", { enumerable: true, get: function () { return __importDefault(defaultSettings_1).default; } });
+__exportStar(require("./Hooks"), exports);
+__exportStar(require("./Providers"), exports);
+__exportStar(require("./types"), exports);
+var generateOrigins_1 = require("./utils/Path/generateOrigins");
+Object.defineProperty(exports, "generateOrigins", { enumerable: true, get: function () { return __importDefault(generateOrigins_1).default; } });

package/dist/types.d.ts

@@ -0,0 +1,82 @@
+import { type ProvidersProps } from './Providers';
+import { type PropsWithChildren, type ReactElement, type ReactNode } from 'react';
+export type GridType = [
+    number,
+    number
+];
+export type Line = 'curve' | 'direct' | 'step';
+export type Shape = 'oval' | 'rectangle';
+export type EdgeNodeProps = {
+    height: number;
+    id: number | string;
+    shape: Shape;
+    width: number;
+    x: number;
+    y: number;
+};
+export type Size = {
+    bottom: number;
+    height: number;
+    left: number;
+    right: number;
+    top: number;
+    width: number;
+};
+export type NodesDimensions = {
+    [key: string]: Dimensions;
+};
+export type Dimensions = {
+    height: number;
+    id: number | string;
+    shape: Shape;
+    width: number;
+    x: number;
+    y: number;
+};
+export type GridContextProps = GridType;
+export type EdgeProps = PropsWithChildren<{
+    dash?: boolean;
+    id: number | string;
+    line?: Line;
+    markerEnd?: string;
+    markerStart?: string;
+    path?: (source?: EdgeNodeProps, target?: EdgeNodeProps, children?: ReactNode) => ReactElement;
+    sourceId: number | string;
+    targetId: number | string;
+}>;
+export type EdgesProps = PropsWithChildren<{
+    readonly dash?: boolean;
+    readonly scale?: number;
+    readonly translate?: {
+        x: number;
+        y: number;
+    };
+}>;
+export type PathProps = {
+    center?: boolean;
+    edgeId: string | number;
+    line?: Line;
+    markerEnd?: string;
+    markerStart?: string;
+    source?: EdgeNodeProps;
+    target?: EdgeNodeProps;
+};
+export type NodeProps = PropsWithChildren<{
+    height?: number;
+    id: number | string;
+    ref?: React.MutableRefObject<HTMLDivElement | null> | ((instance: HTMLDivElement | null) => void) | null;
+    shape?: Shape;
+    track?: boolean;
+    width?: number;
+    x?: number;
+    y?: number;
+}>;
+export type NodesProps = PropsWithChildren<{}>;
+export type GridProps = PropsWithChildren<{
+    scale?: number;
+    xOffset?: number;
+    yOffset?: number;
+}>;
+export type GraphProps = ProvidersProps & {
+    showGrid?: boolean;
+};

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/EdgeSubscriber.d.ts

@@ -0,0 +1,15 @@
+import { type EdgeNodeProps } from '../types';
+declare class EdgeSubscriber {
+    private frequency;
+    constructor(frequency?: number);
+    getFrequency: () => number;
+    setFrequency: (frequency: number) => number;
+    private nodes;
+    private propsCache;
+    register: <T>(edgeId: number | string, nodeId: number | string, updateFn: (update: T) => void) => EdgeNodeProps;
+    unregister: (edgeId: number | string, nodeId: number | string) => void;
+    private readonly updateEdges;
+    private throttleUpdates;
+    update: (props: EdgeNodeProps) => void;
+}
+export default EdgeSubscriber;

package/dist/utils/EdgeSubscriber.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const defaultSettings_1 = __importDefault(require("../defaultSettings"));
+const lodash_throttle_1 = __importDefault(require("lodash.throttle"));
+const FREQUENCY = defaultSettings_1.default.edgeFrequency;
+class EdgeSubscriber {
+    constructor(frequency = FREQUENCY) {
+        this.getFrequency = () => {
+            return this.frequency;
+        };
+        this.setFrequency = (frequency) => {
+            this.frequency = frequency;
+            return this.frequency;
+        };
+        this.nodes = {};
+        this.propsCache = {};
+        this.register = (edgeId, nodeId, updateFn) => {
+            if (!this.nodes[nodeId]) {
+                this.nodes[nodeId] = {};
+            }
+            this.nodes[nodeId][edgeId] = updateFn;
+            return this.propsCache[nodeId];
+        };
+        this.unregister = (edgeId, nodeId) => {
+            delete this.nodes[nodeId][edgeId];
+            delete this.throttleUpdates[nodeId];
+        };
+        this.updateEdges = (props) => {
+            if (this.nodes[props.id]) {
+                for (const [_edgeId, update] of Object.entries(this.nodes[props.id])) {
+                    update(props);
+                }
+            }
+            this.propsCache[props.id] = props;
+        };
+        this.throttleUpdates = {};
+        this.update = (props) => {
+            const { id } = props;
+            if (!this.throttleUpdates[id]) {
+                this.throttleUpdates[id] = (0, lodash_throttle_1.default)(this.updateEdges, this.frequency, {
+                    trailing: true
+                });
+            }
+            this.throttleUpdates[id](props);
+        };
+        this.frequency = frequency;
+    }
+}
+exports.default = EdgeSubscriber;

package/dist/utils/NodePositions.d.ts

@@ -0,0 +1,31 @@
+import { type Dimensions, type NodesDimensions, type Size } from '../types';
+declare class NodePositions {
+    private frequency;
+    private subscriptions;
+    getFrequency: () => number;
+    setFrequency: (frequency: number) => number;
+    private nodes;
+    constructor(frequency?: number);
+    subscribe: (id: string, callback: (size?: Size, nodes?: NodesDimensions) => void) => void;
+    unsubscribe: (id: string) => void;
+    register: (node: Dimensions, { maxWait }?: {
+        maxWait?: number | undefined;
+    }) => void;
+    unregister: (id: number | string) => void;
+    private top;
+    private readonly getTop;
+    private right;
+    private readonly getRight;
+    private bottom;
+    private readonly getBottom;
+    private left;
+    private readonly getLeft;
+    private readonly getSize;
+    private readonly privateUpdate;
+    private readonly notify;
+    private debounceUpdates;
+    update: (node: Dimensions) => void;
+    match: (x: number, y: number) => Promise<number | string | undefined>;
+    size: () => Size;
+}
+export default NodePositions;

package/dist/utils/NodePositions.js

@@ -0,0 +1,226 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const defaultSettings_1 = __importDefault(require("../defaultSettings"));
+const lodash_debounce_1 = __importDefault(require("lodash.debounce"));
+const FREQUENCY = defaultSettings_1.default.nodeFrequency;
+const MAX_WAIT = defaultSettings_1.default.nodeFrequency;
+class NodePositions {
+    constructor(frequency = FREQUENCY) {
+        this.subscriptions = {};
+        this.getFrequency = () => {
+            return this.frequency;
+        };
+        this.setFrequency = (frequency) => {
+            this.frequency = frequency;
+            return this.frequency;
+        };
+        this.nodes = {};
+        this.subscribe = (id, callback) => {
+            this.subscriptions[id] = callback;
+            callback(this.size(), this.nodes);
+        };
+        this.unsubscribe = (id) => {
+            delete this.subscriptions[id];
+        };
+        this.register = (node, { maxWait = MAX_WAIT } = {}) => {
+            this.nodes[node.id] = node;
+            this.debounceUpdates[node.id] = (0, lodash_debounce_1.default)(this.privateUpdate, this.frequency, {
+                maxWait,
+                trailing: true
+            });
+        };
+        this.unregister = (id) => {
+            var _a, _b, _c, _d;
+            delete this.nodes[id];
+            delete this.debounceUpdates[id];
+            if (((_a = this.top) === null || _a === void 0 ? void 0 : _a.id) === id) {
+                this.top = undefined;
+                for (const nodeId of Object.keys(this.nodes)) {
+                    if (!this.top ||
+                        this.nodes[nodeId].y < this.top.y) {
+                        this.top = this.nodes[nodeId];
+                    }
+                }
+            }
+            if (((_b = this.right) === null || _b === void 0 ? void 0 : _b.id) === id) {
+                this.right = undefined;
+                for (const nodeId of Object.keys(this.nodes)) {
+                    if (!this.right ||
+                        this.nodes[nodeId].x + this.nodes[nodeId].height > this.right.x + this.right.width) {
+                        this.right = this.nodes[nodeId];
+                    }
+                }
+            }
+            if (((_c = this.bottom) === null || _c === void 0 ? void 0 : _c.id) === id) {
+                this.bottom = undefined;
+                for (const nodeId of Object.keys(this.nodes)) {
+                    if (!this.bottom ||
+                        this.nodes[nodeId].y + this.nodes[nodeId].height > this.bottom.y + this.bottom.height) {
+                        this.bottom = this.nodes[nodeId];
+                    }
+                }
+            }
+            if (((_d = this.left) === null || _d === void 0 ? void 0 : _d.id) === id) {
+                this.left = undefined;
+                for (const nodeId of Object.keys(this.nodes)) {
+                    if (!this.left ||
+                        this.nodes[nodeId].x < this.left.x) {
+                        this.left = this.nodes[nodeId];
+                    }
+                }
+            }
+            this.notify();
+        };
+        this.getTop = (node) => {
+            if (this.top &&
+                this.top.id === node.id) {
+                if (node.y > this.top.y) {
+                    this.top = node;
+                    for (const id of Object.keys(this.nodes)) {
+                        if (this.top && this.nodes[id].y < this.top.y) {
+                            this.top = this.nodes[id];
+                        }
+                    }
+                }
+                else {
+                    this.top = node;
+                }
+            }
+            else if (!this.top ||
+                node.y < this.top.y) {
+                this.top = node;
+            }
+        };
+        this.getRight = (node) => {
+            const nodeX = node.x + node.width;
+            const rightNodeX = this.right ?
+                this.right.x + this.right.width :
+                undefined;
+            if (this.right &&
+                this.right.id === node.id) {
+                if (!rightNodeX ||
+                    nodeX < rightNodeX) {
+                    this.right = node;
+                    for (const id of Object.keys(this.nodes)) {
+                        if (this.nodes[id].x + this.nodes[id].width > this.right.x + this.right.width) {
+                            this.right = this.nodes[id];
+                        }
+                    }
+                }
+                else {
+                    this.right = node;
+                }
+            }
+            else if (!this.right ||
+                rightNodeX &&
+                    nodeX > rightNodeX) {
+                this.right = node;
+            }
+        };
+        this.getBottom = (node) => {
+            const nodeY = node.y + node.height;
+            const bottomNodeY = this.bottom ?
+                this.bottom.y + this.bottom.height :
+                undefined;
+            if (this.bottom &&
+                this.bottom.id === node.id) {
+                if (!bottomNodeY ||
+                    nodeY < bottomNodeY) {
+                    this.bottom = node;
+                    for (const id of Object.keys(this.nodes)) {
+                        if (this.nodes[id].y + this.nodes[id].height > this.bottom.y + this.bottom.height) {
+                            this.bottom = this.nodes[id];
+                        }
+                    }
+                }
+                else {
+                    this.bottom = node;
+                }
+            }
+            else if (!this.bottom ||
+                bottomNodeY &&
+                    nodeY > bottomNodeY) {
+                this.bottom = node;
+            }
+        };
+        this.getLeft = (node) => {
+            if (this.left &&
+                this.left.id === node.id) {
+                if (node.x > this.left.x) {
+                    this.left = node;
+                    for (const id of Object.keys(this.nodes)) {
+                        if (this.nodes[id].x < this.left.x) {
+                            this.left = this.nodes[id];
+                        }
+                    }
+                }
+                else {
+                    this.left = node;
+                }
+            }
+            else if (!this.left ||
+                node.x < this.left.x) {
+                this.left = node;
+            }
+        };
+        this.getSize = (node) => {
+            this.getTop(node);
+            this.getRight(node);
+            this.getBottom(node);
+            this.getLeft(node);
+        };
+        this.privateUpdate = (node) => {
+            this.register(node);
+            this.getSize(node);
+            this.notify();
+        };
+        this.notify = () => {
+            for (const [_id, update] of Object.entries(this.subscriptions)) {
+                update(this.size(), this.nodes);
+            }
+        };
+        this.debounceUpdates = {};
+        this.update = (node) => {
+            this.debounceUpdates[node.id](node);
+        };
+        this.match = (x, y) => __awaiter(this, void 0, void 0, function* () {
+            const ids = yield Promise.resolve(Object.keys(this.nodes).find((id) => {
+                const node = this.nodes[id];
+                return x > node.x &&
+                    x < node.x + node.width &&
+                    y > node.y &&
+                    y < node.y + node.height;
+            }));
+            return ids ?
+                ids :
+                undefined;
+        });
+        this.size = () => {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z;
+            return {
+                bottom: ((_b = (_a = this.bottom) === null || _a === void 0 ? void 0 : _a.y) !== null && _b !== void 0 ? _b : 0) + ((_d = (_c = this.bottom) === null || _c === void 0 ? void 0 : _c.height) !== null && _d !== void 0 ? _d : 0),
+                height: (((_f = (_e = this.bottom) === null || _e === void 0 ? void 0 : _e.y) !== null && _f !== void 0 ? _f : 0) +
+                    ((_h = (_g = this.bottom) === null || _g === void 0 ? void 0 : _g.height) !== null && _h !== void 0 ? _h : 0)) - ((_k = (_j = this.top) === null || _j === void 0 ? void 0 : _j.y) !== null && _k !== void 0 ? _k : 0),
+                left: (_m = (_l = this.left) === null || _l === void 0 ? void 0 : _l.x) !== null && _m !== void 0 ? _m : 0,
+                right: ((_p = (_o = this.right) === null || _o === void 0 ? void 0 : _o.x) !== null && _p !== void 0 ? _p : 0) + ((_r = (_q = this.right) === null || _q === void 0 ? void 0 : _q.width) !== null && _r !== void 0 ? _r : 0),
+                top: (_t = (_s = this.top) === null || _s === void 0 ? void 0 : _s.y) !== null && _t !== void 0 ? _t : 0,
+                width: (((_v = (_u = this.right) === null || _u === void 0 ? void 0 : _u.x) !== null && _v !== void 0 ? _v : 0) +
+                    ((_x = (_w = this.right) === null || _w === void 0 ? void 0 : _w.width) !== null && _x !== void 0 ? _x : 0)) - ((_z = (_y = this.left) === null || _y === void 0 ? void 0 : _y.x) !== null && _z !== void 0 ? _z : 0)
+            };
+        };
+        this.frequency = frequency;
+    }
+}
+exports.default = NodePositions;

package/dist/utils/Path/generateOrigins.d.ts

@@ -0,0 +1,4 @@
+import { type EdgeNodeProps, type Line } from '../../types';
+import { type Coordinates } from './lines';
+declare const generateOrigins: (target: EdgeNodeProps, source: EdgeNodeProps, line: Line, center?: boolean) => Coordinates;
+export default generateOrigins;

package/dist/utils/Path/generateOrigins.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const lines_1 = require("./lines");
+const generateOrigins = (target, source, line, center) => {
+    switch (line) {
+        case 'curve': {
+            return (0, lines_1.generateCurve)(source, target, center);
+        }
+        case 'direct': {
+            return (0, lines_1.generateDirect)(source, target, center);
+        }
+        case 'step':
+        default: {
+            return (0, lines_1.generateStep)(source, target, center);
+        }
+    }
+};
+exports.default = generateOrigins;

package/dist/utils/Path/lines/generateCurve.d.ts

@@ -0,0 +1,17 @@
+import { type Coordinates, type Line } from './types';
+export declare const curveHorizontal: (rx1: number, ry1: number, rx2: number, ry2: number, center?: boolean) => Line;
+export declare const curveVertical: (rx1: number, ry1: number, rx2: number, ry2: number, center?: boolean) => Line;
+declare const _default: (source: {
+    height: number;
+    shape: "oval" | "rectangle";
+    width: number;
+    x: number;
+    y: number;
+}, target: {
+    height: number;
+    shape: "oval" | "rectangle";
+    width: number;
+    x: number;
+    y: number;
+}, center?: boolean) => Coordinates;
+export default _default;

package/dist/utils/Path/lines/generateCurve.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.curveVertical = exports.curveHorizontal = void 0;
+const generatePoints_1 = __importDefault(require("./generatePoints"));
+const bezier_js_1 = require("bezier-js");
+const curveHorizontal = (rx1, ry1, rx2, ry2, center) => {
+    const x1 = Math.round(rx1);
+    const y1 = Math.round(ry1);
+    const x2 = Math.round(rx2);
+    const y2 = Math.round(ry2);
+    const d = [];
+    const mx = Math.round(x1 + (x2 - x1) / 2);
+    const c = center ?
+        new bezier_js_1.Bezier(x1, y1, mx, y1, mx, y2, x2, y2).compute(0.5) :
+        undefined;
+    d.push('M', x1, y1);
+    d.push('C', mx, y1, mx, y2, x2, y2);
+    return {
+        center: c,
+        path: d.join(' ')
+    };
+};
+exports.curveHorizontal = curveHorizontal;
+const curveVertical = (rx1, ry1, rx2, ry2, center) => {
+    const x1 = Math.round(rx1);
+    const y1 = Math.round(ry1);
+    const x2 = Math.round(rx2);
+    const y2 = Math.round(ry2);
+    const d = [];
+    const my = Math.round(y1 + (y2 - y1) / 2);
+    const c = center ?
+        new bezier_js_1.Bezier(x1, y1, x1, my, x2, my, x2, y2).compute(0.5) :
+        undefined;
+    d.push('M', x1, y1);
+    d.push('C', x1, my, x2, my, x2, y2);
+    return {
+        center: c,
+        path: d.join(' ')
+    };
+};
+exports.curveVertical = curveVertical;
+exports.default = (source, target, center) => {
+    const { orientation, source: sourcePoints, target: targetPoints } = (0, generatePoints_1.default)(source, target);
+    return Object.assign(Object.assign({}, (orientation === 'horizontal' ?
+        (0, exports.curveHorizontal)(sourcePoints.x, sourcePoints.y, targetPoints.x, targetPoints.y, center) :
+        (0, exports.curveVertical)(sourcePoints.x, sourcePoints.y, targetPoints.x, targetPoints.y, center))), { source: sourcePoints, target: targetPoints });
+};

package/dist/utils/Path/lines/generateDirect.d.ts

@@ -0,0 +1,16 @@
+import { type Coordinates, type Line } from './types';
+export declare const direct: (rx1: number, ry1: number, rx2: number, ry2: number, center?: boolean) => Line;
+declare const _default: (source: {
+    height: number;
+    shape: "oval" | "rectangle";
+    width: number;
+    x: number;
+    y: number;
+}, target: {
+    height: number;
+    shape: "oval" | "rectangle";
+    width: number;
+    x: number;
+    y: number;
+}, center?: boolean) => Coordinates;
+export default _default;

package/dist/utils/Path/lines/generateDirect.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.direct = void 0;
+const generatePoints_1 = __importDefault(require("./generatePoints"));
+const direct = (rx1, ry1, rx2, ry2, center) => {
+    const x1 = Math.round(rx1);
+    const y1 = Math.round(ry1);
+    const x2 = Math.round(rx2);
+    const y2 = Math.round(ry2);
+    const cx = Math.round((x2 + x1) / 2);
+    const cy = Math.round((y2 + y1) / 2);
+    const d = [];
+    d.push('M', x1, y1);
+    d.push('L', x2, y2);
+    return {
+        center: center ?
+            {
+                x: cx,
+                y: cy
+            } :
+            undefined,
+        path: d.join(' ')
+    };
+};
+exports.direct = direct;
+exports.default = (source, target, center) => {
+    const { source: sourcePoints, target: targetPoints } = (0, generatePoints_1.default)(source, target);
+    return Object.assign(Object.assign({}, (0, exports.direct)(sourcePoints.x, sourcePoints.y, targetPoints.x, targetPoints.y, center)), { source: sourcePoints, target: targetPoints });
+};

package/dist/utils/Path/lines/generatePoints.d.ts

@@ -0,0 +1,15 @@
+import { type Points } from './types';
+declare const _default: (source: {
+    height: number;
+    shape: "oval" | "rectangle";
+    width: number;
+    x: number;
+    y: number;
+}, target: {
+    height: number;
+    shape: "oval" | "rectangle";
+    width: number;
+    x: number;
+    y: number;
+}) => Points;
+export default _default;