@eccenca/gui-elements 6.1.0 → 22.0.0-rc.6

package/dist/components/Workspace/WorkspaceSide.jsx

@@ -0,0 +1,22 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import React from "react";
+import { CLASSPREFIX as eccgui } from "../../configuration/constants";
+// import PropTypes from 'prop-types';
+import GridColumn from "./../Grid/GridColumn";
+function WorkspaceSide(_a) {
+    var children = _a.children, _b = _a.className, className = _b === void 0 ? '' : _b, restProps = __rest(_a, ["children", "className"]);
+    return (<GridColumn {...restProps} className={eccgui + "-workspace__side " + className} sm={4} md={8} lg={5} xlg={5}>
+            {children}
+        </GridColumn>);
+}
+export default WorkspaceSide;

package/dist/components/interfaces.d.ts

@@ -0,0 +1,3 @@
+export interface TestableComponent {
+    "data-test-id"?: string;
+}

package/dist/components/interfaces.js

@@ -0,0 +1 @@
+"use strict";

package/dist/configuration/constants.d.ts

@@ -0,0 +1 @@
+export declare const CLASSPREFIX = "eccgui";

package/dist/configuration/constants.js

@@ -0,0 +1,9 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CLASSPREFIX = void 0;
+// basic vars
+const CLASSPREFIX = 'eccgui';
+exports.CLASSPREFIX = CLASSPREFIX;

package/dist/extensions/react-flow/edges/EdgeDefault.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import { EdgeProps as ReactFlowEdgeProps } from "react-flow-renderer/dist/types";
+export interface EdgeDefaultDataProps {
+    pathGlowWidth?: number;
+}
+export interface EdgeDefaultProps extends ReactFlowEdgeProps {
+    data?: EdgeDefaultDataProps;
+    drawSvgPath?: (edge: ReactFlowEdgeProps) => string;
+}
+export declare const EdgeDefault: React.MemoExoticComponent<(edge: EdgeDefaultProps) => JSX.Element>;

package/dist/extensions/react-flow/edges/EdgeDefault.js

@@ -0,0 +1,62 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.EdgeDefault = void 0;
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _reactFlowRenderer = require("react-flow-renderer");
+
+var _utils = require("./utils");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+const EdgeDefault = /*#__PURE__*/(0, _react.memo)(edge => {
+  const {
+    data = {},
+    drawSvgPath = _utils.drawEdgeStraight,
+    ...edgeOriginalProperties
+  } = edge;
+  const {
+    pathGlowWidth = 10
+  } = data;
+  const pathDisplay = drawSvgPath({ ...edgeOriginalProperties,
+    data
+  });
+  const markerEnd = (0, _reactFlowRenderer.getMarkerEnd)(edgeOriginalProperties.arrowHeadType, edgeOriginalProperties.markerEndId);
+  const edgeCenter = (0, _reactFlowRenderer.getEdgeCenter)({
+    sourceX: edgeOriginalProperties.sourceX,
+    sourceY: edgeOriginalProperties.sourceY,
+    targetX: edgeOriginalProperties.targetX,
+    targetY: edgeOriginalProperties.targetY
+  });
+  const edgeLabel = edgeOriginalProperties.label ? /*#__PURE__*/_react.default.createElement(_reactFlowRenderer.EdgeText, {
+    x: edgeCenter[0],
+    y: edgeCenter[1],
+    label: edgeOriginalProperties.label,
+    labelStyle: edgeOriginalProperties.labelStyle,
+    labelShowBg: edgeOriginalProperties.labelShowBg,
+    labelBgStyle: edgeOriginalProperties.labelBgStyle,
+    labelBgPadding: edgeOriginalProperties.labelBgPadding || [5, 5],
+    labelBgBorderRadius: edgeOriginalProperties.labelBgBorderRadius || 3
+  }) : null;
+  const edgeStyle = edgeOriginalProperties.style ?? {};
+  return /*#__PURE__*/_react.default.createElement("g", {
+    style: { ...edgeStyle,
+      color: edgeStyle.color || edgeStyle.stroke
+    }
+  }, pathGlowWidth && /*#__PURE__*/_react.default.createElement("path", {
+    d: pathDisplay,
+    className: "react-flow__edge-path-glow",
+    strokeWidth: pathGlowWidth
+  }), /*#__PURE__*/_react.default.createElement("path", {
+    d: pathDisplay,
+    className: "react-flow__edge-path",
+    markerEnd: markerEnd
+  }), edgeLabel);
+});
+exports.EdgeDefault = EdgeDefault;

package/dist/extensions/react-flow/edges/EdgeDefault.jsx

@@ -0,0 +1,45 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import React, { memo } from 'react';
+import { getMarkerEnd, getEdgeCenter, EdgeText, } from "react-flow-renderer";
+import { drawEdgeStraight } from "./utils";
+export var EdgeDefault = memo(function (edge) {
+    var _a;
+    var _b = edge.data, data = _b === void 0 ? {} : _b, _c = edge.drawSvgPath, drawSvgPath = _c === void 0 ? drawEdgeStraight : _c, edgeOriginalProperties = __rest(edge, ["data", "drawSvgPath"]);
+    var _d = data.pathGlowWidth, pathGlowWidth = _d === void 0 ? 10 : _d;
+    var pathDisplay = drawSvgPath(__assign(__assign({}, edgeOriginalProperties), { data: data }));
+    var markerEnd = getMarkerEnd(edgeOriginalProperties.arrowHeadType, edgeOriginalProperties.markerEndId);
+    var edgeCenter = getEdgeCenter({
+        sourceX: edgeOriginalProperties.sourceX,
+        sourceY: edgeOriginalProperties.sourceY,
+        targetX: edgeOriginalProperties.targetX,
+        targetY: edgeOriginalProperties.targetY,
+    });
+    var edgeLabel = edgeOriginalProperties.label ? (<EdgeText x={edgeCenter[0]} y={edgeCenter[1]} label={edgeOriginalProperties.label} labelStyle={edgeOriginalProperties.labelStyle} labelShowBg={edgeOriginalProperties.labelShowBg} labelBgStyle={edgeOriginalProperties.labelBgStyle} labelBgPadding={edgeOriginalProperties.labelBgPadding || [5, 5]} labelBgBorderRadius={edgeOriginalProperties.labelBgBorderRadius || 3}/>) : null;
+    var edgeStyle = (_a = edgeOriginalProperties.style) !== null && _a !== void 0 ? _a : {};
+    return (<g style={__assign(__assign({}, edgeStyle), { color: edgeStyle.color || edgeStyle.stroke })}>
+                {pathGlowWidth && (<path d={pathDisplay} className="react-flow__edge-path-glow" strokeWidth={pathGlowWidth}/>)}
+                <path d={pathDisplay} className="react-flow__edge-path" markerEnd={markerEnd}/>
+                {edgeLabel}
+            </g>);
+});

package/dist/extensions/react-flow/edges/EdgeStep.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { EdgeDefaultProps, EdgeDefaultDataProps } from "./EdgeDefault";
+export interface EdgeStepDataProps extends EdgeDefaultDataProps {
+    stepCornerRadius?: number;
+}
+export interface EdgeStepProps extends EdgeDefaultProps {
+    data?: EdgeStepDataProps;
+}
+export declare const EdgeStep: React.MemoExoticComponent<(edge: EdgeStepProps) => JSX.Element>;

package/dist/extensions/react-flow/edges/EdgeStep.js

@@ -0,0 +1,27 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.EdgeStep = void 0;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _EdgeDefault = require("./EdgeDefault");
+
+var _utils = require("./utils");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+const EdgeStep = /*#__PURE__*/(0, _react.memo)(edge => {
+  return /*#__PURE__*/_react.default.createElement(_EdgeDefault.EdgeDefault, (0, _extends2.default)({}, edge, {
+    drawSvgPath: _utils.drawEdgeStep
+  }));
+});
+exports.EdgeStep = EdgeStep;

package/dist/extensions/react-flow/edges/EdgeStep.jsx

@@ -0,0 +1,6 @@
+import React, { memo } from 'react';
+import { EdgeDefault } from "./EdgeDefault";
+import { drawEdgeStep } from "./utils";
+export var EdgeStep = memo(function (edge) {
+    return (<EdgeDefault {...edge} drawSvgPath={drawEdgeStep}/>);
+});

package/dist/extensions/react-flow/edges/EdgeTools.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import { IPopoverProps as IBlueprintPopoverProps } from "@blueprintjs/core";
+interface PosOffset {
+    left: number;
+    top: number;
+}
+export interface EdgeToolsProps extends IBlueprintPopoverProps {
+    posOffset: PosOffset;
+    children: string | JSX.Element | JSX.Element[];
+}
+export declare const EdgeTools: React.MemoExoticComponent<({ posOffset, children, ...otherProps }: EdgeToolsProps) => JSX.Element>;
+export {};

package/dist/extensions/react-flow/edges/EdgeTools.js

@@ -0,0 +1,48 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.EdgeTools = void 0;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _index = require("../../../index");
+
+var _constants = require("../../../configuration/constants");
+
+var _core = require("@blueprintjs/core");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+const EdgeTools = /*#__PURE__*/(0, _react.memo)(({
+  posOffset,
+  children,
+  ...otherProps
+}) => {
+  return /*#__PURE__*/_react.default.createElement("div", {
+    className: `${_constants.CLASSPREFIX}-graphviz__edgetools-target`,
+    style: { ...posOffset
+    }
+  }, /*#__PURE__*/_react.default.createElement(_index.ContextOverlay, (0, _extends2.default)({}, otherProps, {
+    defaultIsOpen: true,
+    autoFocus: true,
+    interactionKind: _core.PopoverInteractionKind.HOVER,
+    content: /*#__PURE__*/_react.default.createElement("div", {
+      className: `${_constants.CLASSPREFIX}-graphviz__edgetools-content`
+    }, children),
+    target: /*#__PURE__*/_react.default.createElement("div", {
+      className: `${_constants.CLASSPREFIX}-graphviz__edgetools-target`,
+      style: { ...posOffset
+      }
+    }),
+    popoverClassName: `${_constants.CLASSPREFIX}-graphviz__edgetools-overlay`
+  })));
+});
+exports.EdgeTools = EdgeTools;

package/dist/extensions/react-flow/edges/EdgeTools.jsx

@@ -0,0 +1,32 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import React, { memo } from 'react';
+import { ContextOverlay } from "../../../index";
+import { CLASSPREFIX as eccgui } from "../../../configuration/constants";
+import { PopoverInteractionKind as BlueprintPopoverInteractionKind, } from "@blueprintjs/core";
+export var EdgeTools = memo(function (_a) {
+    var posOffset = _a.posOffset, children = _a.children, otherProps = __rest(_a, ["posOffset", "children"]);
+    return (<div className={eccgui + "-graphviz__edgetools-target"} style={__assign({}, posOffset)}>
+                <ContextOverlay {...otherProps} defaultIsOpen={true} autoFocus={true} interactionKind={BlueprintPopoverInteractionKind.HOVER} content={<div className={eccgui + "-graphviz__edgetools-content"}>{children}</div>} target={<div className={eccgui + "-graphviz__edgetools-target"} style={__assign({}, posOffset)}/>} popoverClassName={eccgui + "-graphviz__edgetools-overlay"}/>
+            </div>);
+});

package/dist/extensions/react-flow/edges/edgeTypes.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="react" />
+export declare const edgeTypes: {
+    default: import("react").MemoExoticComponent<(edge: import("./EdgeDefault").EdgeDefaultProps) => JSX.Element>;
+    straight: import("react").MemoExoticComponent<(edge: import("./EdgeDefault").EdgeDefaultProps) => JSX.Element>;
+    step: import("react").MemoExoticComponent<(edge: import("./EdgeStep").EdgeStepProps) => JSX.Element>;
+    smoothstep: import("react").MemoExoticComponent<(edge: import("./EdgeStep").EdgeStepProps) => JSX.Element>;
+    implicitEdge: import("react").MemoExoticComponent<(edge: import("./EdgeDefault").EdgeDefaultProps) => JSX.Element>;
+    importEdge: import("react").MemoExoticComponent<(edge: import("./EdgeDefault").EdgeDefaultProps) => JSX.Element>;
+    subclassEdge: import("react").MemoExoticComponent<(edge: import("./EdgeDefault").EdgeDefaultProps) => JSX.Element>;
+    subpropertyEdge: import("react").MemoExoticComponent<(edge: import("./EdgeDefault").EdgeDefaultProps) => JSX.Element>;
+    rdftypeEdge: import("react").MemoExoticComponent<(edge: import("./EdgeDefault").EdgeDefaultProps) => JSX.Element>;
+    successStep: import("react").MemoExoticComponent<(edge: import("./EdgeStep").EdgeStepProps) => JSX.Element>;
+    warningStep: import("react").MemoExoticComponent<(edge: import("./EdgeStep").EdgeStepProps) => JSX.Element>;
+    dangerStep: import("react").MemoExoticComponent<(edge: import("./EdgeStep").EdgeStepProps) => JSX.Element>;
+};

package/dist/extensions/react-flow/edges/edgeTypes.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.edgeTypes = void 0;
+
+var _EdgeDefault = require("./EdgeDefault");
+
+var _EdgeStep = require("./EdgeStep");
+
+/*
+    We need to replicate some elements from react flow because they
+
+    1. do not export all sub elements, e.g. edges
+    2. we need to add additional features for better usage
+*/
+const edgeTypes = {
+  default: _EdgeDefault.EdgeDefault,
+  straight: _EdgeDefault.EdgeDefault,
+  step: _EdgeStep.EdgeStep,
+  smoothstep: _EdgeStep.EdgeStep,
+  implicitEdge: _EdgeDefault.EdgeDefault,
+  importEdge: _EdgeDefault.EdgeDefault,
+  subclassEdge: _EdgeDefault.EdgeDefault,
+  subpropertyEdge: _EdgeDefault.EdgeDefault,
+  rdftypeEdge: _EdgeDefault.EdgeDefault,
+  successStep: _EdgeStep.EdgeStep,
+  warningStep: _EdgeStep.EdgeStep,
+  dangerStep: _EdgeStep.EdgeStep
+};
+exports.edgeTypes = edgeTypes;

package/dist/extensions/react-flow/edges/utils.d.ts

@@ -0,0 +1,4 @@
+import { EdgeDefaultProps } from "./EdgeDefault";
+import { EdgeStepProps } from "./EdgeStep";
+export declare const drawEdgeStraight: ({ sourceX, sourceY, targetX, targetY, }: EdgeDefaultProps) => string;
+export declare const drawEdgeStep: ({ sourceX, sourceY, sourcePosition, targetX, targetY, targetPosition, data, }: EdgeStepProps) => string;

package/dist/extensions/react-flow/edges/utils.js

@@ -0,0 +1,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.drawEdgeStraight = exports.drawEdgeStep = void 0;
+
+var _reactFlowRenderer = require("react-flow-renderer");
+
+const drawEdgeStraight = ({
+  sourceX,
+  sourceY,
+  targetX,
+  targetY
+}) => {
+  return `M ${sourceX},${sourceY}L ${targetX},${targetY}`;
+};
+
+exports.drawEdgeStraight = drawEdgeStraight;
+
+const drawEdgeStep = ({
+  sourceX,
+  sourceY,
+  sourcePosition,
+  targetX,
+  targetY,
+  targetPosition,
+  data = {}
+}) => {
+  return (0, _reactFlowRenderer.getSmoothStepPath)({
+    sourceX,
+    sourceY,
+    sourcePosition,
+    targetX,
+    targetY,
+    targetPosition,
+    borderRadius: data.stepCornerRadius || 10
+  });
+};
+
+exports.drawEdgeStep = drawEdgeStep;

package/dist/extensions/react-flow/handles/HandleContent.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+export interface HandleContentProps {
+    children?: JSX.Element | string;
+    extendedTooltip?: JSX.Element | string;
+}
+export declare const HandleContent: React.MemoExoticComponent<({ children, extendedTooltip }: HandleContentProps) => JSX.Element>;

package/dist/extensions/react-flow/handles/HandleContent.js

@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.HandleContent = void 0;
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _constants = require("../../../configuration/constants");
+
+var _index = require("../../../index");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+const HandleContent = /*#__PURE__*/(0, _react.memo)(({
+  children,
+  extendedTooltip
+}) => {
+  const handleContent = !!children ? /*#__PURE__*/_react.default.createElement("div", {
+    className: `${_constants.CLASSPREFIX}-graphviz__handle__content`
+  }, children) : !!extendedTooltip ? /*#__PURE__*/_react.default.createElement("div", {
+    className: `${_constants.CLASSPREFIX}-graphviz__handle__content`
+  }) : /*#__PURE__*/_react.default.createElement(_react.default.Fragment, null);
+
+  if (!!extendedTooltip) {
+    return /*#__PURE__*/_react.default.createElement(_index.Tooltip, {
+      content: extendedTooltip,
+      wrapperTagName: "div",
+      autoFocus: false,
+      enforceFocus: false,
+      openOnTargetFocus: false
+    }, handleContent);
+  }
+
+  return handleContent;
+});
+exports.HandleContent = HandleContent;

package/dist/extensions/react-flow/handles/HandleContent.jsx

@@ -0,0 +1,15 @@
+import React, { memo } from 'react';
+import { CLASSPREFIX as eccgui } from "../../../configuration/constants";
+import { Tooltip } from "../../../index";
+export var HandleContent = memo(function (_a) {
+    var children = _a.children, extendedTooltip = _a.extendedTooltip;
+    var handleContent = !!children ? (<div className={eccgui + "-graphviz__handle__content"}>
+            {children}
+        </div>) : !!extendedTooltip ? (<div className={eccgui + "-graphviz__handle__content"}/>) : (<></>);
+    if (!!extendedTooltip) {
+        return (<Tooltip content={extendedTooltip} wrapperTagName="div" autoFocus={false} enforceFocus={false} openOnTargetFocus={false}>
+                {handleContent}
+            </Tooltip>);
+    }
+    return handleContent;
+});

package/dist/extensions/react-flow/handles/HandleDefault.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { HandleProps as ReactFlowHandleProps } from "react-flow-renderer";
+import { HandleContentProps } from "./HandleContent";
+export interface HandleProps extends ReactFlowHandleProps {
+    data?: HandleContentProps;
+    tooltip?: string;
+    children?: JSX.Element | string;
+}
+export declare const HandleDefault: React.MemoExoticComponent<({ data, tooltip, children, ...handleProps }: HandleProps) => JSX.Element>;

package/dist/extensions/react-flow/handles/HandleDefault.js

@@ -0,0 +1,33 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.HandleDefault = void 0;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _reactFlowRenderer = require("react-flow-renderer");
+
+var _HandleContent = require("./HandleContent");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+const HandleDefault = /*#__PURE__*/(0, _react.memo)(({
+  data,
+  tooltip,
+  children,
+  ...handleProps
+}) => {
+  const tooltipTitle = !!tooltip ? {
+    title: tooltip
+  } : {};
+  return /*#__PURE__*/_react.default.createElement(_reactFlowRenderer.Handle, (0, _extends2.default)({}, handleProps, tooltipTitle), /*#__PURE__*/_react.default.createElement(_HandleContent.HandleContent, data, children));
+});
+exports.HandleDefault = HandleDefault;

package/dist/extensions/react-flow/handles/HandleDefault.jsx

@@ -0,0 +1,23 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import React, { memo } from 'react';
+import { Handle, } from "react-flow-renderer";
+import { HandleContent } from "./HandleContent";
+export var HandleDefault = memo(function (_a) {
+    var data = _a.data, tooltip = _a.tooltip, children = _a.children, handleProps = __rest(_a, ["data", "tooltip", "children"]);
+    var tooltipTitle = !!tooltip ? { title: tooltip } : {};
+    return (<Handle {...handleProps} {...tooltipTitle}>
+            <HandleContent {...data}>
+                {children}
+            </HandleContent>
+        </Handle>);
+});

package/dist/extensions/react-flow/index.d.ts

@@ -0,0 +1,14 @@
+export { NodeDefault } from "./nodes/NodeDefault";
+export { NodeTools } from "./nodes/NodeTools";
+export { nodeTypes } from "./nodes/nodeTypes";
+export { EdgeDefault } from "./edges/EdgeDefault";
+export { EdgeStep } from "./edges/EdgeStep";
+export { EdgeTools } from "./edges/EdgeTools";
+export { edgeTypes } from "./edges/edgeTypes";
+export { MiniMap } from "./minimap/MiniMap";
+export { minimapNodeClassName, minimapNodeColor } from "./minimap/utils";
+export type { NodeProps } from "./nodes/NodeDefault";
+export type { NodeToolsProps } from "./nodes/NodeTools";
+export type { EdgeDefaultProps } from "./edges/EdgeDefault";
+export type { EdgeStepProps } from "./edges/EdgeStep";
+export type { MiniMapProps } from "./minimap/MiniMap";

package/dist/extensions/react-flow/index.js

@@ -0,0 +1,83 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "EdgeDefault", {
+  enumerable: true,
+  get: function () {
+    return _EdgeDefault.EdgeDefault;
+  }
+});
+Object.defineProperty(exports, "EdgeStep", {
+  enumerable: true,
+  get: function () {
+    return _EdgeStep.EdgeStep;
+  }
+});
+Object.defineProperty(exports, "EdgeTools", {
+  enumerable: true,
+  get: function () {
+    return _EdgeTools.EdgeTools;
+  }
+});
+Object.defineProperty(exports, "MiniMap", {
+  enumerable: true,
+  get: function () {
+    return _MiniMap.MiniMap;
+  }
+});
+Object.defineProperty(exports, "NodeDefault", {
+  enumerable: true,
+  get: function () {
+    return _NodeDefault.NodeDefault;
+  }
+});
+Object.defineProperty(exports, "NodeTools", {
+  enumerable: true,
+  get: function () {
+    return _NodeTools.NodeTools;
+  }
+});
+Object.defineProperty(exports, "edgeTypes", {
+  enumerable: true,
+  get: function () {
+    return _edgeTypes.edgeTypes;
+  }
+});
+Object.defineProperty(exports, "minimapNodeClassName", {
+  enumerable: true,
+  get: function () {
+    return _utils.minimapNodeClassName;
+  }
+});
+Object.defineProperty(exports, "minimapNodeColor", {
+  enumerable: true,
+  get: function () {
+    return _utils.minimapNodeColor;
+  }
+});
+Object.defineProperty(exports, "nodeTypes", {
+  enumerable: true,
+  get: function () {
+    return _nodeTypes.nodeTypes;
+  }
+});
+
+var _NodeDefault = require("./nodes/NodeDefault");
+
+var _NodeTools = require("./nodes/NodeTools");
+
+var _nodeTypes = require("./nodes/nodeTypes");
+
+var _EdgeDefault = require("./edges/EdgeDefault");
+
+var _EdgeStep = require("./edges/EdgeStep");
+
+var _EdgeTools = require("./edges/EdgeTools");
+
+var _edgeTypes = require("./edges/edgeTypes");
+
+var _MiniMap = require("./minimap/MiniMap");
+
+var _utils = require("./minimap/utils");