ngx-vflow 0.1.0

package/esm2022/lib/vflow/math/edge-path/bezier-path.mjs

@@ -0,0 +1,77 @@
+import { path as d3Path } from 'd3-path';
+import { getPointOnLineByRatio } from '../point-on-line-by-ratio';
+export function bezierPath(source, target, sourcePosition, targetPosition, usingPoints = [false, false, false]) {
+    const path = d3Path();
+    path.moveTo(source.x, source.y);
+    const distanceVector = { x: source.x - target.x, y: source.y - target.y };
+    const firstControl = calcControlPoint(source, sourcePosition, distanceVector);
+    const secondControl = calcControlPoint(target, targetPosition, distanceVector);
+    path.bezierCurveTo(firstControl.x, firstControl.y, secondControl.x, secondControl.y, target.x, target.y);
+    return getPathData(path, source, target, firstControl, secondControl, usingPoints);
+}
+/**
+ * Calculate control point based on provided point
+ *
+ * @param point relative this point control point is gonna be computed (the source or the target)
+ * @param pointPosition position of {point} on block
+ * @param distanceVector transmits the distance between the source and the target as x and y coordinates
+ */
+function calcControlPoint(point, pointPosition, distanceVector) {
+    const factorPoint = { x: 0, y: 0 };
+    switch (pointPosition) {
+        case 'top':
+            factorPoint.y = 1;
+            break;
+        case 'bottom':
+            factorPoint.y = -1;
+            break;
+        case 'right':
+            factorPoint.x = 1;
+            break;
+        case 'left':
+            factorPoint.x = -1;
+            break;
+    }
+    // TODO: explain name
+    const fullDistanceVector = {
+        x: distanceVector.x * Math.abs(factorPoint.x),
+        y: distanceVector.y * Math.abs(factorPoint.y),
+    };
+    // TODO: probably need to make this configurable
+    const curvature = 0.25;
+    // thanks colleagues from react/svelte world
+    // https://github.com/xyflow/xyflow/blob/f0117939bae934447fa7f232081f937169ee23b5/packages/system/src/utils/edges/bezier-edge.ts#L56
+    const controlOffset = curvature * 25 * Math.sqrt(Math.abs(fullDistanceVector.x + fullDistanceVector.y));
+    return {
+        x: point.x + factorPoint.x * controlOffset,
+        y: point.y - factorPoint.y * controlOffset,
+    };
+}
+function getPathData(path, source, target, firstControl, secondControl, usingPoints) {
+    const [start, center, end] = usingPoints;
+    const nullPoint = { x: 0, y: 0 };
+    return {
+        path: path.toString(),
+        points: {
+            start: start
+                ? getPointOnBezier(source, target, firstControl, secondControl, 0.1)
+                : nullPoint,
+            center: center
+                ? getPointOnBezier(source, target, firstControl, secondControl, 0.5)
+                : nullPoint,
+            end: end
+                ? getPointOnBezier(source, target, firstControl, secondControl, 0.9)
+                : nullPoint,
+        },
+    };
+}
+/**
+ * Get point on bezier curve by ratio
+ */
+function getPointOnBezier(sourcePoint, targetPoint, controlPoint1, controlPoint2, ratio) {
+    const fromSourceToFirstControl = getPointOnLineByRatio(sourcePoint, controlPoint1, ratio);
+    const fromFirstControlToSecond = getPointOnLineByRatio(controlPoint1, controlPoint2, ratio);
+    const fromSecondControlToTarget = getPointOnLineByRatio(controlPoint2, targetPoint, ratio);
+    return getPointOnLineByRatio(getPointOnLineByRatio(fromSourceToFirstControl, fromFirstControlToSecond, ratio), getPointOnLineByRatio(fromFirstControlToSecond, fromSecondControlToTarget, ratio), ratio);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bezier-path.js","sourceRoot":"","sources":["../../../../../../../projects/ngx-vflow-lib/src/lib/vflow/math/edge-path/bezier-path.ts"],"names":[],"mappings":"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","sourcesContent":["import { PathData } from '../../interfaces/path-data.interface';\nimport { Point } from '../../interfaces/point.interface';\nimport { Path, path as d3Path } from 'd3-path';\nimport { UsingPoints } from '../../types/using-points.type';\nimport { Position } from '../../types/position.type';\nimport { getPointOnLineByRatio } from '../point-on-line-by-ratio';\n\nexport function bezierPath(\n  source: Point,\n  target: Point,\n  sourcePosition: Position,\n  targetPosition: Position,\n  usingPoints: UsingPoints = [false, false, false]\n): PathData {\n  const path = d3Path();\n\n  path.moveTo(source.x, source.y);\n\n  const distanceVector = { x: source.x - target.x, y: source.y - target.y };\n\n  const firstControl = calcControlPoint(source, sourcePosition, distanceVector);\n  const secondControl = calcControlPoint(target, targetPosition, distanceVector);\n\n  path.bezierCurveTo(\n    firstControl.x,\n    firstControl.y,\n    secondControl.x,\n    secondControl.y,\n    target.x,\n    target.y\n  );\n\n  return getPathData(\n    path,\n    source,\n    target,\n    firstControl,\n    secondControl,\n    usingPoints\n  );\n}\n\n/**\n * Calculate control point based on provided point\n *\n * @param point relative this point control point is gonna be computed (the source or the target)\n * @param pointPosition position of {point} on block\n * @param distanceVector transmits the distance between the source and the target as x and y coordinates\n */\n\nfunction calcControlPoint(\n  point: Point,\n  pointPosition: Position,\n  distanceVector: Point\n) {\n  const factorPoint = { x: 0, y: 0 };\n\n  switch (pointPosition) {\n    case 'top':\n      factorPoint.y = 1;\n      break;\n    case 'bottom':\n      factorPoint.y = -1;\n      break;\n    case 'right':\n      factorPoint.x = 1;\n      break;\n    case 'left':\n      factorPoint.x = -1;\n      break;\n  }\n\n  // TODO: explain name\n  const fullDistanceVector = {\n    x: distanceVector.x * Math.abs(factorPoint.x),\n    y: distanceVector.y * Math.abs(factorPoint.y),\n  };\n\n  // TODO: probably need to make this configurable\n  const curvature = 0.25;\n  // thanks colleagues from react/svelte world\n  // https://github.com/xyflow/xyflow/blob/f0117939bae934447fa7f232081f937169ee23b5/packages/system/src/utils/edges/bezier-edge.ts#L56\n  const controlOffset =\n    curvature * 25 * Math.sqrt(Math.abs(fullDistanceVector.x + fullDistanceVector.y));\n\n  return {\n    x: point.x + factorPoint.x * controlOffset,\n    y: point.y - factorPoint.y * controlOffset,\n  };\n}\n\nfunction getPathData(\n  path: Path,\n  source: Point,\n  target: Point,\n  firstControl: Point,\n  secondControl: Point,\n  usingPoints: UsingPoints\n): PathData {\n  const [start, center, end] = usingPoints;\n\n  const nullPoint = { x: 0, y: 0 };\n\n  return {\n    path: path.toString(),\n    points: {\n      start: start\n        ? getPointOnBezier(source, target, firstControl, secondControl, 0.1)\n        : nullPoint,\n      center: center\n        ? getPointOnBezier(source, target, firstControl, secondControl, 0.5)\n        : nullPoint,\n      end: end\n        ? getPointOnBezier(source, target, firstControl, secondControl, 0.9)\n        : nullPoint,\n    },\n  };\n}\n\n/**\n * Get point on bezier curve by ratio\n */\nfunction getPointOnBezier(\n  sourcePoint: Point,\n  targetPoint: Point,\n  controlPoint1: Point,\n  controlPoint2: Point,\n  ratio: number\n): Point {\n  const fromSourceToFirstControl: Point = getPointOnLineByRatio(\n    sourcePoint,\n    controlPoint1,\n    ratio\n  );\n  const fromFirstControlToSecond: Point = getPointOnLineByRatio(\n    controlPoint1,\n    controlPoint2,\n    ratio\n  );\n  const fromSecondControlToTarget: Point = getPointOnLineByRatio(\n    controlPoint2,\n    targetPoint,\n    ratio\n  );\n\n  return getPointOnLineByRatio(\n    getPointOnLineByRatio(fromSourceToFirstControl, fromFirstControlToSecond, ratio),\n    getPointOnLineByRatio(fromFirstControlToSecond, fromSecondControlToTarget, ratio),\n    ratio\n  );\n}\n"]}

package/esm2022/lib/vflow/math/edge-path/straigh-path.mjs

@@ -0,0 +1,18 @@
+import { path as d3Path } from 'd3-path';
+import { getPointOnLineByRatio } from "../point-on-line-by-ratio";
+export function straightPath(source, target, usingPoints = [false, false, false]) {
+    const [start, center, end] = usingPoints;
+    const nullPoint = { x: 0, y: 0 };
+    const path = d3Path();
+    path.moveTo(source.x, source.y);
+    path.lineTo(target.x, target.y);
+    return {
+        path: path.toString(),
+        points: {
+            start: start ? getPointOnLineByRatio(source, target, .15) : nullPoint,
+            center: center ? getPointOnLineByRatio(source, target, .50) : nullPoint,
+            end: end ? getPointOnLineByRatio(source, target, .85) : nullPoint,
+        }
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/vflow/math/point-on-line-by-ratio.mjs

@@ -0,0 +1,12 @@
+/**
+ * Get point on line
+ *
+ * https://math.stackexchange.com/questions/563566/how-do-i-find-the-middle1-2-1-3-1-4-etc-of-a-line
+ */
+export function getPointOnLineByRatio(start, end, ratio) {
+    return {
+        x: (1 - ratio) * start.x + ratio * end.x,
+        y: (1 - ratio) * start.y + ratio * end.y,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG9pbnQtb24tbGluZS1ieS1yYXRpby5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25neC12Zmxvdy1saWIvc3JjL2xpYi92Zmxvdy9tYXRoL3BvaW50LW9uLWxpbmUtYnktcmF0aW8udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUE7Ozs7R0FJRztBQUNILE1BQU0sVUFBVSxxQkFBcUIsQ0FBQyxLQUFZLEVBQUUsR0FBVSxFQUFFLEtBQWE7SUFDM0UsT0FBTztRQUNMLENBQUMsRUFBRSxDQUFDLENBQUMsR0FBRyxLQUFLLENBQUMsR0FBRyxLQUFLLENBQUMsQ0FBQyxHQUFHLEtBQUssR0FBRyxHQUFHLENBQUMsQ0FBQztRQUN4QyxDQUFDLEVBQUUsQ0FBQyxDQUFDLEdBQUcsS0FBSyxDQUFDLEdBQUcsS0FBSyxDQUFDLENBQUMsR0FBRyxLQUFLLEdBQUcsR0FBRyxDQUFDLENBQUM7S0FDekMsQ0FBQztBQUNKLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBQb2ludCB9IGZyb20gXCIuLi9pbnRlcmZhY2VzL3BvaW50LmludGVyZmFjZVwiO1xuXG4vKipcbiAqIEdldCBwb2ludCBvbiBsaW5lXG4gKlxuICogaHR0cHM6Ly9tYXRoLnN0YWNrZXhjaGFuZ2UuY29tL3F1ZXN0aW9ucy81NjM1NjYvaG93LWRvLWktZmluZC10aGUtbWlkZGxlMS0yLTEtMy0xLTQtZXRjLW9mLWEtbGluZVxuICovXG5leHBvcnQgZnVuY3Rpb24gZ2V0UG9pbnRPbkxpbmVCeVJhdGlvKHN0YXJ0OiBQb2ludCwgZW5kOiBQb2ludCwgcmF0aW86IG51bWJlcik6IFBvaW50IHtcbiAgcmV0dXJuIHtcbiAgICB4OiAoMSAtIHJhdGlvKSAqIHN0YXJ0LnggKyByYXRpbyAqIGVuZC54LFxuICAgIHk6ICgxIC0gcmF0aW8pICogc3RhcnQueSArIHJhdGlvICogZW5kLnksXG4gIH07XG59XG4iXX0=

package/esm2022/lib/vflow/models/connection.model.mjs

@@ -0,0 +1,9 @@
+export class ConnectionModel {
+    constructor(connection) {
+        this.connection = connection;
+        this.curve = connection.curve ?? 'bezier';
+        this.type = connection.type ?? 'default';
+        this.validator = connection.validator ?? (() => true);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29ubmVjdGlvbi5tb2RlbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25neC12Zmxvdy1saWIvc3JjL2xpYi92Zmxvdy9tb2RlbHMvY29ubmVjdGlvbi5tb2RlbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFHQSxNQUFNLE9BQU8sZUFBZTtJQUsxQixZQUFtQixVQUE4QjtRQUE5QixlQUFVLEdBQVYsVUFBVSxDQUFvQjtRQUMvQyxJQUFJLENBQUMsS0FBSyxHQUFHLFVBQVUsQ0FBQyxLQUFLLElBQUksUUFBUSxDQUFBO1FBQ3pDLElBQUksQ0FBQyxJQUFJLEdBQUcsVUFBVSxDQUFDLElBQUksSUFBSSxTQUFTLENBQUE7UUFDeEMsSUFBSSxDQUFDLFNBQVMsR0FBRyxVQUFVLENBQUMsU0FBUyxJQUFJLENBQUMsR0FBRyxFQUFFLENBQUMsSUFBSSxDQUFDLENBQUE7SUFDdkQsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29ubmVjdGlvblNldHRpbmdzLCBDb25uZWN0aW9uVmFsaWRhdG9yRm4gfSBmcm9tIFwiLi4vaW50ZXJmYWNlcy9jb25uZWN0aW9uLXNldHRpbmdzLmludGVyZmFjZVwiO1xuaW1wb3J0IHsgQ3VydmUsIEVkZ2VUeXBlIH0gZnJvbSBcIi4uL2ludGVyZmFjZXMvZWRnZS5pbnRlcmZhY2VcIjtcblxuZXhwb3J0IGNsYXNzIENvbm5lY3Rpb25Nb2RlbCB7XG4gIHB1YmxpYyBjdXJ2ZTogQ3VydmVcbiAgcHVibGljIHR5cGU6IEVkZ2VUeXBlXG4gIHB1YmxpYyB2YWxpZGF0b3I6IENvbm5lY3Rpb25WYWxpZGF0b3JGblxuXG4gIGNvbnN0cnVjdG9yKHB1YmxpYyBjb25uZWN0aW9uOiBDb25uZWN0aW9uU2V0dGluZ3MpIHtcbiAgICB0aGlzLmN1cnZlID0gY29ubmVjdGlvbi5jdXJ2ZSA/PyAnYmV6aWVyJ1xuICAgIHRoaXMudHlwZSA9IGNvbm5lY3Rpb24udHlwZSA/PyAnZGVmYXVsdCdcbiAgICB0aGlzLnZhbGlkYXRvciA9IGNvbm5lY3Rpb24udmFsaWRhdG9yID8/ICgoKSA9PiB0cnVlKVxuICB9XG59XG4iXX0=

package/esm2022/lib/vflow/models/edge-label.model.mjs

@@ -0,0 +1,8 @@
+import { signal } from "@angular/core";
+export class EdgeLabelModel {
+    constructor(edgeLabel) {
+        this.edgeLabel = edgeLabel;
+        this.size = signal({ width: 0, height: 0 });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZWRnZS1sYWJlbC5tb2RlbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25neC12Zmxvdy1saWIvc3JjL2xpYi92Zmxvdy9tb2RlbHMvZWRnZS1sYWJlbC5tb2RlbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsTUFBTSxFQUFFLE1BQU0sZUFBZSxDQUFBO0FBR3RDLE1BQU0sT0FBTyxjQUFjO0lBR3pCLFlBQW1CLFNBQW9CO1FBQXBCLGNBQVMsR0FBVCxTQUFTLENBQVc7UUFGaEMsU0FBSSxHQUFHLE1BQU0sQ0FBQyxFQUFFLEtBQUssRUFBRSxDQUFDLEVBQUUsTUFBTSxFQUFFLENBQUMsRUFBRSxDQUFDLENBQUE7SUFFRixDQUFDO0NBQzdDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgc2lnbmFsIH0gZnJvbSBcIkBhbmd1bGFyL2NvcmVcIlxuaW1wb3J0IHsgRWRnZUxhYmVsIH0gZnJvbSBcIi4uL2ludGVyZmFjZXMvZWRnZS1sYWJlbC5pbnRlcmZhY2VcIlxuXG5leHBvcnQgY2xhc3MgRWRnZUxhYmVsTW9kZWwge1xuICBwdWJsaWMgc2l6ZSA9IHNpZ25hbCh7IHdpZHRoOiAwLCBoZWlnaHQ6IDAgfSlcblxuICBjb25zdHJ1Y3RvcihwdWJsaWMgZWRnZUxhYmVsOiBFZGdlTGFiZWwpIHsgfVxufVxuIl19

package/esm2022/lib/vflow/models/edge.model.mjs

@@ -0,0 +1,30 @@
+import { computed } from "@angular/core";
+import { EdgeLabelModel } from "./edge-label.model";
+import { straightPath } from "../math/edge-path/straigh-path";
+import { bezierPath } from "../math/edge-path/bezier-path";
+export class EdgeModel {
+    constructor(edge) {
+        this.edge = edge;
+        this.path = computed(() => {
+            const source = this.source.sourcePointAbsolute();
+            const target = this.target.targetPointAbsolute();
+            switch (this.curve) {
+                case 'straight':
+                    return straightPath(source, target, this.usingPoints);
+                case 'bezier':
+                    return bezierPath(source, target, this.source.sourcePosition(), this.target.targetPosition(), this.usingPoints);
+            }
+        });
+        this.edgeLabels = {};
+        this.type = edge.type ?? 'default';
+        this.curve = edge.curve ?? 'bezier';
+        if (edge.edgeLabels?.start)
+            this.edgeLabels.start = new EdgeLabelModel(edge.edgeLabels.start);
+        if (edge.edgeLabels?.center)
+            this.edgeLabels.center = new EdgeLabelModel(edge.edgeLabels.center);
+        if (edge.edgeLabels?.end)
+            this.edgeLabels.end = new EdgeLabelModel(edge.edgeLabels.end);
+        this.usingPoints = [!!this.edgeLabels.start, !!this.edgeLabels.center, !!this.edgeLabels.end];
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/vflow/models/flow.model.mjs

@@ -0,0 +1,16 @@
+import { computed, signal } from "@angular/core";
+export class FlowModel {
+    constructor() {
+        /**
+         * Global setting with handle positions. Nodes derive this value
+         */
+        this.handlePositions = signal({ source: 'right', target: 'left' });
+        /**
+         * @see {VflowComponent.view}
+         */
+        this.view = signal([400, 400]);
+        this.flowWidth = computed(() => this.view() === 'auto' ? '100%' : this.view()[0]);
+        this.flowHeight = computed(() => this.view() === 'auto' ? '100%' : this.view()[1]);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmxvdy5tb2RlbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25neC12Zmxvdy1saWIvc3JjL2xpYi92Zmxvdy9tb2RlbHMvZmxvdy5tb2RlbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQTBCLFFBQVEsRUFBRSxNQUFNLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFHekUsTUFBTSxPQUFPLFNBQVM7SUFBdEI7UUFDRTs7V0FFRztRQUNJLG9CQUFlLEdBQW9DLE1BQU0sQ0FBQyxFQUFFLE1BQU0sRUFBRSxPQUFPLEVBQUUsTUFBTSxFQUFFLE1BQU0sRUFBRSxDQUFDLENBQUE7UUFFckc7O1dBRUc7UUFDSSxTQUFJLEdBQThDLE1BQU0sQ0FBQyxDQUFDLEdBQUcsRUFBRSxHQUFHLENBQUMsQ0FBQyxDQUFBO1FBRXBFLGNBQVMsR0FBRyxRQUFRLENBQUMsR0FBRyxFQUFFLENBQUMsSUFBSSxDQUFDLElBQUksRUFBRSxLQUFLLE1BQU0sQ0FBQyxDQUFDLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsSUFBSSxFQUFFLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQTtRQUU1RSxlQUFVLEdBQUcsUUFBUSxDQUFDLEdBQUcsRUFBRSxDQUFDLElBQUksQ0FBQyxJQUFJLEVBQUUsS0FBSyxNQUFNLENBQUMsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDLElBQUksRUFBRSxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUE7SUFDdEYsQ0FBQztDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgU2lnbmFsLCBXcml0YWJsZVNpZ25hbCwgY29tcHV0ZWQsIHNpZ25hbCB9IGZyb20gXCJAYW5ndWxhci9jb3JlXCI7XG5pbXBvcnQgeyBIYW5kbGVQb3NpdGlvbnMgfSBmcm9tIFwiLi4vaW50ZXJmYWNlcy9oYW5kbGUtcG9zaXRpb25zLmludGVyZmFjZVwiO1xuXG5leHBvcnQgY2xhc3MgRmxvd01vZGVsIHtcbiAgLyoqXG4gICAqIEdsb2JhbCBzZXR0aW5nIHdpdGggaGFuZGxlIHBvc2l0aW9ucy4gTm9kZXMgZGVyaXZlIHRoaXMgdmFsdWVcbiAgICovXG4gIHB1YmxpYyBoYW5kbGVQb3NpdGlvbnM6IFdyaXRhYmxlU2lnbmFsPEhhbmRsZVBvc2l0aW9ucz4gPSBzaWduYWwoeyBzb3VyY2U6ICdyaWdodCcsIHRhcmdldDogJ2xlZnQnIH0pXG5cbiAgLyoqXG4gICAqIEBzZWUge1ZmbG93Q29tcG9uZW50LnZpZXd9XG4gICAqL1xuICBwdWJsaWMgdmlldzogV3JpdGFibGVTaWduYWw8W251bWJlciwgbnVtYmVyXSB8ICdhdXRvJz4gPSBzaWduYWwoWzQwMCwgNDAwXSlcblxuICBwdWJsaWMgZmxvd1dpZHRoID0gY29tcHV0ZWQoKCkgPT4gdGhpcy52aWV3KCkgPT09ICdhdXRvJyA/ICcxMDAlJyA6IHRoaXMudmlldygpWzBdKVxuXG4gIHB1YmxpYyBmbG93SGVpZ2h0ID0gY29tcHV0ZWQoKCkgPT4gdGhpcy52aWV3KCkgPT09ICdhdXRvJyA/ICcxMDAlJyA6IHRoaXMudmlldygpWzFdKVxufVxuIl19

package/esm2022/lib/vflow/models/node.model.mjs

@@ -0,0 +1,90 @@
+import { computed, signal } from '@angular/core';
+import { isDefined } from '../utils/is-defined';
+import { toObservable } from '@angular/core/rxjs-interop';
+export class NodeModel {
+    constructor(node) {
+        this.node = node;
+        this.point = signal({ x: 0, y: 0 });
+        this.point$ = toObservable(this.point);
+        this.size = signal({ width: 0, height: 0 });
+        this.pointTransform = computed(() => `translate(${this.point().x}, ${this.point().y})`);
+        this.sourceOffset = computed(() => {
+            const { width, height } = this.size();
+            switch (this.sourcePosition()) {
+                case 'left': return { x: 0, y: height / 2 };
+                case 'right': return { x: width, y: height / 2 };
+                case 'top': return { x: width / 2, y: 0 };
+                case 'bottom': return { x: width / 2, y: height };
+            }
+        });
+        this.targetOffset = computed(() => {
+            const { width, height } = this.size();
+            switch (this.targetPosition()) {
+                case 'left': return { x: 0, y: (height / 2) };
+                case 'right': return { x: width, y: height / 2 };
+                case 'top': return { x: width / 2, y: 0 };
+                case 'bottom': return { x: width / 2, y: height };
+            }
+        });
+        this.sourcePointAbsolute = computed(() => {
+            return {
+                x: this.point().x + this.sourceOffset().x + this.sourceHandleOffset().x,
+                y: this.point().y + this.sourceOffset().y + this.sourceHandleOffset().y
+            };
+        });
+        this.targetPointAbsolute = computed(() => {
+            return {
+                x: this.point().x + this.targetOffset().x + this.targetHandleOffset().x,
+                y: this.point().y + this.targetOffset().y + this.targetHandleOffset().y
+            };
+        });
+        // Now source and handle positions derived from parent flow
+        this.sourcePosition = computed(() => this.flow.handlePositions().source);
+        this.targetPosition = computed(() => this.flow.handlePositions().target);
+        this.sourceHandleSize = signal({ width: 0, height: 0 });
+        this.targetHandleSize = signal({ width: 0, height: 0 });
+        this.sourceHandleOffset = computed(() => {
+            switch (this.sourcePosition()) {
+                case 'left': return { x: -(this.sourceHandleSize().width / 2), y: 0 };
+                case 'right': return { x: this.sourceHandleSize().width / 2, y: 0 };
+                case 'top': return { x: 0, y: -(this.sourceHandleSize().height / 2) };
+                case 'bottom': return { x: 0, y: this.sourceHandleSize().height / 2 };
+            }
+        });
+        this.targetHandleOffset = computed(() => {
+            switch (this.targetPosition()) {
+                case 'left': return { x: -(this.targetHandleSize().width / 2), y: 0 };
+                case 'right': return { x: this.targetHandleSize().width / 2, y: 0 };
+                case 'top': return { x: 0, y: -(this.targetHandleSize().height / 2) };
+                case 'bottom': return { x: 0, y: this.targetHandleSize().height / 2 };
+            }
+        });
+        this.sourceOffsetAligned = computed(() => {
+            return {
+                x: this.sourceOffset().x - (this.sourceHandleSize().width / 2),
+                y: this.sourceOffset().y - (this.sourceHandleSize().height / 2),
+            };
+        });
+        this.targetOffsetAligned = computed(() => {
+            return {
+                x: this.targetOffset().x - (this.targetHandleSize().width / 2),
+                y: this.targetOffset().y - (this.targetHandleSize().height / 2),
+            };
+        });
+        this.draggable = true;
+        // disabled for configuration for now
+        this.magnetRadius = 20;
+        this.point.set(node.point);
+        if (isDefined(node.draggable))
+            this.draggable = node.draggable;
+    }
+    /**
+     * Bind parent flow model to node
+     *
+     * @param flow parent flow
+     */
+    bindFlow(flow) {
+        this.flow = flow;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"node.model.js","sourceRoot":"","sources":["../../../../../../projects/ngx-vflow-lib/src/lib/vflow/models/node.model.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injector, computed, inject, signal } from '@angular/core'\nimport { Node } from '../interfaces/node.interface'\nimport { FlowModel } from './flow.model'\nimport { isDefined } from '../utils/is-defined'\nimport { toObservable } from '@angular/core/rxjs-interop'\n\nexport class NodeModel<T = unknown> {\n  public point = signal({ x: 0, y: 0 })\n\n  public point$ = toObservable(this.point)\n\n  public size = signal({ width: 0, height: 0 })\n\n  public pointTransform = computed(() => `translate(${this.point().x}, ${this.point().y})`)\n\n  public sourceOffset = computed(() => {\n    const { width, height } = this.size()\n\n    switch (this.sourcePosition()) {\n      case 'left': return { x: 0, y: height / 2 }\n      case 'right': return { x: width, y: height / 2 }\n      case 'top': return { x: width / 2, y: 0 }\n      case 'bottom': return { x: width / 2, y: height }\n    }\n  })\n\n  public targetOffset = computed(() => {\n    const { width, height } = this.size()\n\n    switch (this.targetPosition()) {\n      case 'left': return { x: 0, y: (height / 2) }\n      case 'right': return { x: width, y: height / 2 }\n      case 'top': return { x: width / 2, y: 0 }\n      case 'bottom': return { x: width / 2, y: height }\n    }\n  })\n\n  public sourcePointAbsolute = computed(() => {\n    return {\n      x: this.point().x + this.sourceOffset().x + this.sourceHandleOffset().x,\n      y: this.point().y + this.sourceOffset().y + this.sourceHandleOffset().y\n    }\n  })\n\n  public targetPointAbsolute = computed(() => {\n    return {\n      x: this.point().x + this.targetOffset().x + this.targetHandleOffset().x,\n      y: this.point().y + this.targetOffset().y + this.targetHandleOffset().y\n    }\n  })\n\n  // Now source and handle positions derived from parent flow\n  public sourcePosition = computed(() => this.flow.handlePositions().source)\n  public targetPosition = computed(() => this.flow.handlePositions().target)\n\n  public sourceHandleSize = signal({ width: 0, height: 0 })\n  public targetHandleSize = signal({ width: 0, height: 0 })\n\n  public sourceHandleOffset = computed(() => {\n    switch (this.sourcePosition()) {\n      case 'left': return { x: -(this.sourceHandleSize().width / 2), y: 0 }\n      case 'right': return { x: this.sourceHandleSize().width / 2, y: 0 }\n      case 'top': return { x: 0, y: -(this.sourceHandleSize().height / 2) }\n      case 'bottom': return { x: 0, y: this.sourceHandleSize().height / 2 }\n    }\n  })\n\n  public targetHandleOffset = computed(() => {\n    switch (this.targetPosition()) {\n      case 'left': return { x: -(this.targetHandleSize().width / 2), y: 0 }\n      case 'right': return { x: this.targetHandleSize().width / 2, y: 0 }\n      case 'top': return { x: 0, y: -(this.targetHandleSize().height / 2) }\n      case 'bottom': return { x: 0, y: this.targetHandleSize().height / 2 }\n    }\n  })\n\n  public sourceOffsetAligned = computed(() => {\n    return {\n      x: this.sourceOffset().x - (this.sourceHandleSize().width / 2),\n      y: this.sourceOffset().y - (this.sourceHandleSize().height / 2),\n    }\n  })\n\n  public targetOffsetAligned = computed(() => {\n    return {\n      x: this.targetOffset().x - (this.targetHandleSize().width / 2),\n      y: this.targetOffset().y - (this.targetHandleSize().height / 2),\n    }\n  })\n\n  public draggable = true\n\n  // disabled for configuration for now\n  public readonly magnetRadius = 20\n\n  private flow!: FlowModel\n\n  constructor(\n    public node: Node<T>\n  ) {\n    this.point.set(node.point)\n\n    if (isDefined(node.draggable)) this.draggable = node.draggable\n  }\n\n  /**\n   * Bind parent flow model to node\n   *\n   * @param flow parent flow\n   */\n  public bindFlow(flow: FlowModel) {\n    this.flow = flow\n  }\n}\n"]}

package/esm2022/lib/vflow/services/draggable.service.mjs

@@ -0,0 +1,66 @@
+import { Injectable } from '@angular/core';
+import { select } from 'd3-selection';
+import { drag } from 'd3-drag';
+import { round } from '../utils/round';
+import * as i0 from "@angular/core";
+export class DraggableService {
+    /**
+     * Enable or disable draggable behavior for element.
+     * model contains draggable flag which declares if draggable should be enabled or not
+     *
+     * @param element target element for toggling draggable
+     * @param model model with data for this element
+     */
+    toggleDraggable(element, model) {
+        const d3Element = select(element);
+        const behavior = model.draggable
+            ? this.getDragBehavior(model)
+            : this.getIgnoreDragBehavior();
+        d3Element.call(behavior);
+    }
+    /**
+     * TODO: not shure if this work, need to check
+     *
+     * @param element
+     */
+    destroy(element) {
+        select(element).on('.drag', null);
+    }
+    /**
+     * Node drag behavior. Updated node's coordinate according to dragging
+     *
+     * @param model
+     * @returns
+     */
+    getDragBehavior(model) {
+        let deltaX;
+        let deltaY;
+        return drag()
+            .on('start', (event) => {
+            deltaX = model.point().x - event.x;
+            deltaY = model.point().y - event.y;
+        })
+            .on('drag', (event) => {
+            model.point.set({
+                x: round(event.x + deltaX),
+                y: round(event.y + deltaY)
+            });
+        });
+    }
+    /**
+     * Specify ignoring drag behavior. It's responsible for not moving the map when user tries to drag node
+     * with disabled drag behavior
+     */
+    getIgnoreDragBehavior() {
+        return drag()
+            .on('drag', (event) => {
+            event.sourceEvent.stopPropagation();
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DraggableService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DraggableService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DraggableService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/vflow/services/edge-changes.service.mjs

@@ -0,0 +1,38 @@
+import { Injectable, computed, inject, untracked } from '@angular/core';
+import { FlowEntitiesService } from './flow-entities.service';
+import { asyncScheduler, filter, map, merge, observeOn, pairwise } from 'rxjs';
+import { toObservable } from '@angular/core/rxjs-interop';
+import * as i0 from "@angular/core";
+export class EdgeChangesService {
+    constructor() {
+        this.entitiesService = inject(FlowEntitiesService);
+        this.edgeDetachedChange$ = toObservable(computed(() => {
+            const nodes = this.entitiesService.nodes();
+            const edges = untracked(this.entitiesService.edges);
+            return edges.filter(({ source, target }) => !nodes.includes(source) || !nodes.includes(target));
+        })).pipe(
+        // TODO check why there are 2 emits from single call inside computed
+        filter(edges => !!edges.length), map((edges) => edges.map(({ edge }) => ({ type: 'detached', id: edge.id }))));
+        this.edgeAddChange$ = toObservable(this.entitiesService.edges)
+            .pipe(pairwise(), map(([oldList, newList]) => {
+            return newList.filter(edge => !oldList.includes(edge));
+        }), filter(edges => !!edges.length), map((edges) => edges.map(({ edge }) => ({ type: 'add', id: edge.id }))));
+        this.edgeRemoveChange$ = toObservable(this.entitiesService.edges)
+            .pipe(pairwise(), map(([oldList, newList]) => {
+            return oldList.filter(edge => !newList.includes(edge));
+        }), filter(edges => !!edges.length), map((edges) => edges.map(({ edge }) => ({ type: 'remove', id: edge.id }))));
+        this.changes$ = merge(this.edgeDetachedChange$, this.edgeAddChange$, this.edgeRemoveChange$)
+            .pipe(
+        // this fixes the case when user gets 'deteched' changes
+        // and tries to delete these edges inside stream
+        // angular may ignore this change because [edges] input changed
+        // right after [nodes] input change
+        observeOn(asyncScheduler));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: EdgeChangesService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: EdgeChangesService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: EdgeChangesService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/vflow/services/flow-entities.service.mjs

@@ -0,0 +1,49 @@
+import { Injectable, computed, signal } from '@angular/core';
+import { ConnectionModel } from '../models/connection.model';
+import { hashCode } from '../utils/hash';
+import * as i0 from "@angular/core";
+export class FlowEntitiesService {
+    constructor() {
+        this.nodes = signal([], {
+            // empty arrays considered equal, other arrays may not be equal
+            equal: (a, b) => !a.length && !b.length ? true : a === b
+        });
+        this.edges = signal([], {
+            // empty arrays considered equal, other arrays may not be equal
+            equal: (a, b) => !a.length && !b.length ? true : a === b
+        });
+        this.connection = signal(new ConnectionModel({}));
+        this.markers = computed(() => {
+            const markersMap = new Map();
+            this.validEdges().forEach(e => {
+                if (e.edge.markers?.start) {
+                    const hash = hashCode(JSON.stringify(e.edge.markers.start));
+                    markersMap.set(hash, e.edge.markers.start);
+                }
+                if (e.edge.markers?.end) {
+                    const hash = hashCode(JSON.stringify(e.edge.markers.end));
+                    markersMap.set(hash, e.edge.markers.end);
+                }
+            });
+            const connectionMarker = this.connection().connection.marker;
+            if (connectionMarker) {
+                const hash = hashCode(JSON.stringify(connectionMarker));
+                markersMap.set(hash, connectionMarker);
+            }
+            return markersMap;
+        });
+        this.validEdges = computed(() => {
+            const nodes = this.nodes();
+            return this.edges().filter(e => nodes.includes(e.source) && nodes.includes(e.target));
+        });
+    }
+    getNode(id) {
+        return this.nodes().find(({ node }) => node.id === id);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FlowEntitiesService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FlowEntitiesService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FlowEntitiesService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/vflow/services/flow-status.service.mjs

@@ -0,0 +1,39 @@
+import { Injectable, signal } from '@angular/core';
+import * as i0 from "@angular/core";
+export class FlowStatusService {
+    constructor() {
+        this.status = signal({ state: 'idle', payload: null });
+    }
+    setIdleStatus() {
+        this.status.set({ state: 'idle', payload: null });
+    }
+    setConnectionStartStatus(sourceNode) {
+        this.status.set({ state: 'connection-start', payload: { sourceNode } });
+    }
+    setConnectionValidationStatus(sourceNode, targetNode, valid) {
+        this.status.set({ state: 'connection-validation', payload: { sourceNode, targetNode, valid } });
+    }
+    setConnectionEndStatus(sourceNode, targetNode) {
+        this.status.set({ state: 'connection-end', payload: { sourceNode, targetNode } });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FlowStatusService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FlowStatusService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FlowStatusService, decorators: [{
+            type: Injectable
+        }] });
+/**
+ * Batch status changes together to call them one after another
+ *
+ * @param changes list of set[FlowStatus.state]Status() calls
+ */
+export function batchStatusChanges(...changes) {
+    if (changes.length) {
+        const [firstChange, ...restChanges] = changes;
+        // first change is sync
+        firstChange();
+        // without timer, subscribed effects/comuted signals only get latest value
+        restChanges.forEach(change => setTimeout(() => change()));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/vflow/services/node-changes.service.mjs

@@ -0,0 +1,32 @@
+import { Injectable, inject } from '@angular/core';
+import { FlowEntitiesService } from './flow-entities.service';
+import { toObservable } from '@angular/core/rxjs-interop';
+import { filter, map, merge, pairwise, skip, switchMap } from 'rxjs';
+import * as i0 from "@angular/core";
+export class NodesChangeService {
+    constructor() {
+        this.entitiesService = inject(FlowEntitiesService);
+        this.nodesPositionChange$ = toObservable(this.entitiesService.nodes)
+            .pipe(
+        // Check for nodes list change and watch for specific node from this list change its position
+        switchMap((nodes) => merge(...nodes.map(node => node.point$.pipe(
+        // skip initial position from signal
+        skip(1), map(() => node))))), 
+        // For now it's a single node, later this list will also be filled
+        // with child node position changes
+        map(changedNode => [
+            { type: 'position', id: changedNode.node.id, point: changedNode.point() }
+        ]));
+        this.nodeAddChange$ = toObservable(this.entitiesService.nodes)
+            .pipe(pairwise(), map(([oldList, newList]) => newList.filter(node => !oldList.includes(node))), filter((nodes) => !!nodes.length), map((nodes) => nodes.map(node => ({ type: 'add', id: node.node.id }))));
+        this.nodeRemoveChange$ = toObservable(this.entitiesService.nodes)
+            .pipe(pairwise(), map(([oldList, newList]) => oldList.filter(node => !newList.includes(node))), filter((nodes) => !!nodes.length), map((nodes) => nodes.map(node => ({ type: 'remove', id: node.node.id }))));
+        this.changes$ = merge(this.nodesPositionChange$, this.nodeAddChange$, this.nodeRemoveChange$);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NodesChangeService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NodesChangeService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NodesChangeService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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