@reltio/components 1.4.1843 → 1.4.1845

package/esm/EmptyState/EmptyState.d.ts

@@ -9,6 +9,7 @@ export declare const EMPTY_STATE_ICONS: {
     SELECT_ATTRIBUTES: React.FC<React.SVGProps<SVGSVGElement>>;
     NO_DATA: React.FC<React.SVGProps<SVGSVGElement>>;
     ERROR: React.FC<React.SVGProps<SVGSVGElement>>;
+    LOADING: React.FC<React.SVGProps<SVGSVGElement>>;
 };
 type Props = {
     variant?: EMPTY_STATE_VARIANTS;

package/esm/EmptyState/EmptyState.js

@@ -8,6 +8,7 @@ import SelectAttributesIcon from '../icons/SelectAttributes';
 import NoData from '../icons/NoData';
 import Error from '../icons/Error';
 import { useStyles } from './styles';
+import EmptyLoadingIcon from '../icons/EmptyLoading';
 export var EMPTY_STATE_VARIANTS;
 (function (EMPTY_STATE_VARIANTS) {
     EMPTY_STATE_VARIANTS["full"] = "full";
@@ -18,7 +19,8 @@ export var EMPTY_STATE_ICONS = {
     SEARCH_RESULTS: EmptySearchResultsIcon,
     SELECT_ATTRIBUTES: SelectAttributesIcon,
     NO_DATA: NoData,
-    ERROR: Error
+    ERROR: Error,
+    LOADING: EmptyLoadingIcon
 };
 export var EmptyState = function (_a) {
     var _b = _a.variant, variant = _b === void 0 ? EMPTY_STATE_VARIANTS.full : _b, _c = _a.LogoRenderer, LogoRenderer = _c === void 0 ? EMPTY_STATE_ICONS.SEARCH_RESULTS : _c, text = _a.text, secondaryText = _a.secondaryText, buttonTitle = _a.buttonTitle, _d = _a.onClick, onClick = _d === void 0 ? identity : _d, access = _a.access;

package/esm/features/graph/DataModelGraph/DataModelGraph.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import Graph from 'graphology';
+type Props = {
+    graph?: Graph;
+    children?: React.ReactNode;
+    selectedNode?: string;
+    onNodeClick: (nodeId: string) => void;
+    selectedEdge: string;
+    onEdgeLabelClick: (edgeId: string, event: MouseEvent) => void;
+};
+export declare const DataModelGraph: ({ graph, children, selectedNode, onNodeClick, selectedEdge, onEdgeLabelClick }: Props) => JSX.Element;
+export default DataModelGraph;

package/esm/features/graph/DataModelGraph/DataModelGraph.js

@@ -0,0 +1,21 @@
+import React from 'react';
+import { SigmaGraphContainer } from '../SigmaGraphContainer/SigmaGraphContainer';
+import { DataModelCircleLayuot } from './components/DataModelCircleLayout/DataModelCircleLayuot';
+import { ZoomSlider } from '../ZoomSlider';
+import { useStyles } from './styles';
+var settings = {
+    labelRenderedSizeThreshold: 11,
+    zIndex: true
+};
+export var DataModelGraph = function (_a) {
+    var graph = _a.graph, children = _a.children, selectedNode = _a.selectedNode, onNodeClick = _a.onNodeClick, selectedEdge = _a.selectedEdge, onEdgeLabelClick = _a.onEdgeLabelClick;
+    var styles = useStyles();
+    return (React.createElement("div", { className: styles.wrapper },
+        React.createElement("div", { className: styles.graph }, graph && (React.createElement(SigmaGraphContainer, { initialSettings: settings },
+            React.createElement(React.Fragment, null,
+                React.createElement(DataModelCircleLayuot, { graph: graph, selectedNode: selectedNode, onNodeClick: onNodeClick, selectedEdge: selectedEdge, onEdgeLabelClick: onEdgeLabelClick }),
+                React.createElement("div", { className: styles.rightBottomControls },
+                    React.createElement(ZoomSlider, { className: styles.zoomSlider, min: 30, max: 300 })))))),
+        children));
+};
+export default DataModelGraph;

package/esm/features/graph/DataModelGraph/DataModelGraph.test.d.ts

@@ -0,0 +1 @@
+export {};

package/esm/features/graph/DataModelGraph/DataModelGraph.test.js

@@ -0,0 +1,58 @@
+import React from 'react';
+import Graph from 'graphology';
+import { render, screen } from '@testing-library/react';
+import { DataModelGraph } from '../DataModelGraph';
+import { useDataModelGraphAppearance } from './hooks/useDataModelGraphAppearance';
+import { useFakeCenterNode } from './hooks/useFakeCenterNode';
+import { useCircleLayout } from '../hooks/useCircleLayout';
+jest.mock('@react-sigma/core', function () { return ({
+    SigmaContainer: function (_a) {
+        var children = _a.children;
+        return React.createElement("div", null, children);
+    },
+    useSigma: jest.fn().mockReturnValue({
+        refresh: jest.fn()
+    }),
+    useLoadGraph: jest.fn().mockReturnValue(jest.fn())
+}); });
+jest.mock('../hooks/useCircleLayout', function () { return ({
+    useCircleLayout: jest.fn()
+}); });
+jest.mock('../hooks/useSigmaCustomRenderers', function () { return ({
+    useSigmaCustomRenderers: jest.fn().mockReturnValue({ addRenderers: jest.fn() })
+}); });
+jest.mock('./hooks/useDataModelGraphAppearance', function () { return ({
+    useDataModelGraphAppearance: jest.fn()
+}); });
+jest.mock('./hooks/useFakeCenterNode', function () { return ({
+    useFakeCenterNode: jest.fn()
+}); });
+jest.mock('../ZoomSlider', function () { return ({
+    ZoomSlider: function () { return React.createElement("div", null, "ZoomSlider"); }
+}); });
+describe('DataModelGraph tests', function () {
+    var graph = new Graph();
+    var selectedNode = 'node1';
+    var onNodeClick = jest.fn();
+    var selectedEdge = 'edge1';
+    var onEdgeLabelClick = jest.fn();
+    var setUp = function () {
+        render(React.createElement(DataModelGraph, { graph: graph, selectedNode: selectedNode, onNodeClick: onNodeClick, selectedEdge: selectedEdge, onEdgeLabelClick: onEdgeLabelClick }));
+    };
+    afterEach(function () {
+        jest.clearAllMocks();
+    });
+    it('renders call hooks with correct props', function () {
+        setUp();
+        expect(useDataModelGraphAppearance).toHaveBeenCalledWith(expect.objectContaining({
+            graph: graph,
+            selectedNode: selectedNode,
+            selectedEdge: selectedEdge,
+            onNodeClick: onNodeClick,
+            onEdgeLabelClick: onEdgeLabelClick
+        }));
+        expect(useFakeCenterNode).toHaveBeenCalledWith(expect.objectContaining({ graph: graph, timeout: 3100 }));
+        expect(useCircleLayout).toHaveBeenCalledWith(expect.objectContaining({ graph: graph, animationDuration: 3000 }));
+        expect(screen.getByText('ZoomSlider')).toBeInTheDocument();
+    });
+});

package/esm/features/graph/DataModelGraph/components/DataModelCircleLayout/DataModelCircleLayuot.d.ts

@@ -0,0 +1,11 @@
+import Graph from 'graphology';
+type Props = {
+    graph: Graph;
+    selectedNode?: string;
+    onNodeClick: (nodeId: string) => void;
+    selectedEdge: string;
+    onEdgeLabelClick: (edgeId: string, event: MouseEvent) => void;
+};
+export declare const LAYOUT_ANIMATION_DURATION = 3000;
+export declare const DataModelCircleLayuot: ({ graph, selectedNode, onNodeClick, selectedEdge, onEdgeLabelClick }: Props) => any;
+export {};

package/esm/features/graph/DataModelGraph/components/DataModelCircleLayout/DataModelCircleLayuot.js

@@ -0,0 +1,17 @@
+import { useCircleLayout } from '../../../hooks/useCircleLayout';
+import { useFakeCenterNode } from '../../hooks/useFakeCenterNode';
+import { useDataModelGraphAppearance } from '../../hooks/useDataModelGraphAppearance';
+export var LAYOUT_ANIMATION_DURATION = 3000;
+export var DataModelCircleLayuot = function (_a) {
+    var graph = _a.graph, selectedNode = _a.selectedNode, onNodeClick = _a.onNodeClick, selectedEdge = _a.selectedEdge, onEdgeLabelClick = _a.onEdgeLabelClick;
+    useFakeCenterNode({ graph: graph, timeout: LAYOUT_ANIMATION_DURATION + 100 });
+    useCircleLayout({ graph: graph, animationDuration: LAYOUT_ANIMATION_DURATION });
+    useDataModelGraphAppearance({
+        graph: graph,
+        selectedNode: selectedNode,
+        selectedEdge: selectedEdge,
+        onNodeClick: onNodeClick,
+        onEdgeLabelClick: onEdgeLabelClick
+    });
+    return null;
+};

package/esm/features/graph/DataModelGraph/helpers/edgeLabelHelpers.d.ts

@@ -0,0 +1,9 @@
+import Sigma from 'sigma/sigma';
+export declare const getBezierCenter: (x1: number, y1: number, x2: number, y2: number, cx1: number, cy1: number, cx2: number, cy2: number) => {
+    x: number;
+    y: number;
+};
+export declare const getEdgeCenter: (edgeId: string, sourceId: string, targetId: string, sigma: Sigma) => {
+    x: any;
+    y: any;
+};

package/esm/features/graph/DataModelGraph/helpers/edgeLabelHelpers.js

@@ -0,0 +1,33 @@
+import { LOOP_SCALE, getSelfLoopControlPoints } from '../../rendering/canvas/selfRelationLoop';
+export var getBezierCenter = function (x1, y1, x2, y2, cx1, cy1, cx2, cy2) {
+    var t = 0.5;
+    var Bt = (1 - t) * (1 - t) * (1 - t);
+    var Ct = 3 * ((1 - t) * (1 - t)) * t;
+    var Dt = 3 * (1 - t) * (t * t);
+    var Et = t * t * t;
+    var x = Bt * x1 + Ct * cx1 + Dt * cx2 + Et * x2;
+    var y = Bt * y1 + Ct * cy1 + Dt * cy2 + Et * y2;
+    return { x: x, y: y };
+};
+export var getEdgeCenter = function (edgeId, sourceId, targetId, sigma) {
+    var edgeDisplayData = sigma.getEdgeDisplayData(edgeId);
+    var sourceDisplayData = sigma.getNodeDisplayData(sourceId);
+    var targetDisplayData = sigma.getNodeDisplayData(targetId);
+    var sourceCenter = sigma.framedGraphToViewport({
+        x: sourceDisplayData.x,
+        y: sourceDisplayData.y
+    });
+    var targetCenter = sigma.framedGraphToViewport({
+        x: targetDisplayData.x,
+        y: targetDisplayData.y
+    });
+    var getLoopCenter = function () {
+        var _a = getSelfLoopControlPoints(sourceCenter.x, sourceCenter.y, sigma.scaleSize(sourceDisplayData.size) * LOOP_SCALE), x1 = _a.x1, y1 = _a.y1, x2 = _a.x2, y2 = _a.y2;
+        return getBezierCenter(sourceCenter.x, sourceCenter.y, sourceCenter.x, sourceCenter.y, x1, y1, x2, y2);
+    };
+    var loopCenter = edgeDisplayData.loop && getLoopCenter();
+    var getEdgeCenter = function (coord) { return sourceCenter[coord] + (targetCenter[coord] - sourceCenter[coord]) / 2; };
+    var x = edgeDisplayData.loop ? loopCenter.x : getEdgeCenter('x');
+    var y = edgeDisplayData.loop ? loopCenter.y : getEdgeCenter('y');
+    return { x: x, y: y };
+};

package/esm/features/graph/DataModelGraph/helpers/edgeLabelHelpers.test.d.ts

@@ -0,0 +1 @@
+export {};

package/esm/features/graph/DataModelGraph/helpers/edgeLabelHelpers.test.js

@@ -0,0 +1,72 @@
+import { getEdgeCenter } from './edgeLabelHelpers';
+describe('getEdgeCenter tests', function () {
+    var edgeId = 'edge1';
+    var sourceId = 'source1';
+    var targetId = 'target1';
+    var sigma = {
+        getEdgeDisplayData: jest.fn(),
+        getNodeDisplayData: jest.fn(),
+        framedGraphToViewport: jest.fn(),
+        scaleSize: jest.fn(function (x) { return x; })
+    };
+    afterEach(function () {
+        jest.clearAllMocks();
+    });
+    it('should calculate the regular edge center', function () {
+        var edgeDisplayData = {
+            loop: false
+        };
+        var sourceDisplayData = {
+            x: 1,
+            y: 2,
+            size: 10
+        };
+        var targetDisplayData = {
+            x: 3,
+            y: 4
+        };
+        var expectedX = 2;
+        var expectedY = 3;
+        sigma.getEdgeDisplayData.mockReturnValue(edgeDisplayData);
+        sigma.getNodeDisplayData.mockReturnValueOnce(sourceDisplayData);
+        sigma.getNodeDisplayData.mockReturnValueOnce(targetDisplayData);
+        sigma.framedGraphToViewport.mockImplementation(function (_a) {
+            var x = _a.x, y = _a.y;
+            return ({ x: x, y: y });
+        });
+        var result = getEdgeCenter(edgeId, sourceId, targetId, sigma);
+        expect(result.x).toBe(expectedX);
+        expect(result.y).toBe(expectedY);
+        expect(sigma.getEdgeDisplayData).toHaveBeenCalledWith(edgeId);
+        expect(sigma.getNodeDisplayData).toHaveBeenCalledWith(sourceId);
+        expect(sigma.getNodeDisplayData).toHaveBeenCalledWith(targetId);
+        expect(sigma.framedGraphToViewport).toHaveBeenCalledWith({ x: 1, y: 2 });
+        expect(sigma.framedGraphToViewport).toHaveBeenCalledWith({ x: 3, y: 4 });
+    });
+    it('should calculate the edge center with loop', function () {
+        var edgeDisplayData = {
+            loop: true
+        };
+        var sourceDisplayData = {
+            x: 100,
+            y: 100,
+            size: 10
+        };
+        var expectedX = 84.25;
+        var expectedY = 115.75;
+        sigma.getEdgeDisplayData.mockReturnValue(edgeDisplayData);
+        sigma.getNodeDisplayData.mockReturnValueOnce(sourceDisplayData);
+        sigma.getNodeDisplayData.mockReturnValueOnce(sourceDisplayData);
+        sigma.framedGraphToViewport.mockImplementation(function (_a) {
+            var x = _a.x, y = _a.y;
+            return ({ x: x, y: y });
+        });
+        var result = getEdgeCenter(edgeId, sourceId, sourceId, sigma);
+        expect(result.x).toBe(expectedX);
+        expect(result.y).toBe(expectedY);
+        expect(sigma.getEdgeDisplayData).toHaveBeenCalledWith(edgeId);
+        expect(sigma.getNodeDisplayData).toHaveBeenCalledWith(sourceId);
+        expect(sigma.framedGraphToViewport).toHaveBeenCalledWith({ x: 100, y: 100 });
+        expect(sigma.scaleSize).toHaveBeenCalledWith(sourceDisplayData.size);
+    });
+});

package/esm/features/graph/DataModelGraph/hooks/defaultGraph.test-data.d.ts

@@ -0,0 +1,2 @@
+import Graph from 'graphology';
+export declare const createDefaultGraph: () => Graph<import("graphology-types").Attributes, import("graphology-types").Attributes, import("graphology-types").Attributes>;

package/esm/features/graph/DataModelGraph/hooks/defaultGraph.test-data.js

@@ -0,0 +1,45 @@
+import Graph from 'graphology';
+import { DataModelGraphNodeType } from '../../types/graphDataTypes';
+export var createDefaultGraph = function () {
+    var graph = new Graph();
+    graph.addNode('hcp', {
+        nodeType: DataModelGraphNodeType.entityType,
+        label: 'HCP',
+        secondaryLabel: '12 attributes',
+        image: 'HCP.svg',
+        x: 100,
+        y: 100
+    });
+    graph.addNode('hca', {
+        nodeType: DataModelGraphNodeType.entityType,
+        label: 'HCA',
+        secondaryLabel: '10 attributes',
+        image: 'HCA.svg',
+        x: 200,
+        y: 100
+    });
+    graph.addNode('gpo', {
+        nodeType: DataModelGraphNodeType.entityType,
+        label: 'GPO',
+        secondaryLabel: '1 attribute',
+        x: 300,
+        y: 100
+    });
+    graph.addNode('prescriptions', {
+        nodeType: DataModelGraphNodeType.interactionType,
+        label: 'Prescriptions',
+        secondaryLabel: '2 attributes',
+        x: 100,
+        y: 200
+    });
+    graph.addEdgeWithKey('hcp->hca', 'hcp', 'hca', {
+        label: '1'
+    });
+    graph.addEdgeWithKey('hca->gpo', 'hca', 'gpo', {
+        label: '2'
+    });
+    graph.addEdgeWithKey('hcp->prescriptions', 'hcp', 'prescriptions', {
+        type: 'dashed'
+    });
+    return graph;
+};

package/esm/features/graph/DataModelGraph/hooks/useDataModelGraphAppearance.d.ts

@@ -0,0 +1,17 @@
+import Graph from 'graphology';
+export declare const EDGE_COLOR = "rgba(130, 130, 130, 1)";
+export declare const DASHED_EDGE_COLOR = "rgba(189, 189, 189, 1)";
+export declare const INACTIVE_EDGE_COLOR = "rgba(224, 224, 224, 1)";
+export declare const SELECTED_EDGE_COLOR = "rgba(79, 79, 79, 1)";
+export declare const RELATED_EDGE_COLOR = "rgba(130, 130, 130, 1)";
+export declare const RELATED_DASHED_EDGE_COLOR = "rgba(79, 79, 79, 1)";
+export declare const INACTIVE_LABEL_COLOR = "rgba(0, 0, 0, 0.38)";
+type Props = {
+    graph: Graph;
+    selectedNode: string;
+    selectedEdge: string;
+    onNodeClick: (node: string) => void;
+    onEdgeLabelClick: (edgeId: string, event: MouseEvent) => void;
+};
+export declare const useDataModelGraphAppearance: ({ graph, selectedNode, selectedEdge, onNodeClick, onEdgeLabelClick }: Props) => void;
+export {};

package/esm/features/graph/DataModelGraph/hooks/useDataModelGraphAppearance.js

@@ -0,0 +1,135 @@
+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 __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+import { useEffect, useState } from 'react';
+import { useSigmaContext } from '@react-sigma/core';
+import { useRegisterEvents, useSetSettings, useSigma } from '@react-sigma/core';
+import { svg2Url } from '@reltio/mdm-sdk';
+import { DataModelGraphNodeType } from '../../types/graphDataTypes';
+import { useLoopRenderer } from '../../hooks/useLoopRenderer';
+import { useEdgeLabelsRenderer } from './useEdgeLabelsRenderer';
+import { useSelectedNodeRenderer } from './useSelectedNodeRenderer';
+import { interactionIcon } from '../icons/interaction.inline.svg';
+var DEFAULT_NODE_STYLE = {
+    type: 'image',
+    size: 28,
+    color: 'rgba(55, 71, 79, 1)'
+};
+var DEFAULT_EDGE_STYLE = {
+    size: 2
+};
+export var EDGE_COLOR = 'rgba(130, 130, 130, 1)';
+export var DASHED_EDGE_COLOR = 'rgba(189, 189, 189, 1)';
+export var INACTIVE_EDGE_COLOR = 'rgba(224, 224, 224, 1)';
+export var SELECTED_EDGE_COLOR = 'rgba(79, 79, 79, 1)';
+export var RELATED_EDGE_COLOR = 'rgba(130, 130, 130, 1)';
+export var RELATED_DASHED_EDGE_COLOR = 'rgba(79, 79, 79, 1)';
+export var INACTIVE_LABEL_COLOR = 'rgba(0, 0, 0, 0.38)';
+export var useDataModelGraphAppearance = function (_a) {
+    var graph = _a.graph, selectedNode = _a.selectedNode, selectedEdge = _a.selectedEdge, onNodeClick = _a.onNodeClick, onEdgeLabelClick = _a.onEdgeLabelClick;
+    var sigma = useSigma();
+    var container = useSigmaContext().container;
+    var _b = useState(null), hoveredNode = _b[0], setHoveredNode = _b[1];
+    var registerEvents = useRegisterEvents();
+    var setSettings = useSetSettings();
+    useLoopRenderer(graph);
+    var hoveredEdge = useEdgeLabelsRenderer({ graph: graph, onEdgeLabelClick: onEdgeLabelClick });
+    useSelectedNodeRenderer(graph);
+    useEffect(function () {
+        registerEvents({
+            enterNode: function (_a) {
+                var node = _a.node;
+                setHoveredNode(node);
+            },
+            leaveNode: function () {
+                setHoveredNode(null);
+            },
+            clickNode: function (_a) {
+                var node = _a.node;
+                onNodeClick(node);
+            }
+        });
+    }, [sigma, registerEvents, onNodeClick]);
+    useEffect(function () {
+        container.style.cursor = hoveredNode || hoveredEdge ? 'pointer' : 'default';
+    }, [container, hoveredNode, hoveredEdge]);
+    useEffect(function () {
+        var graph = sigma.getGraph();
+        var selectedNodeNeighbours;
+        try {
+            selectedNodeNeighbours = graph.neighbors(selectedNode);
+        }
+        catch (e) {
+            //do nothing
+        }
+        setSettings({
+            nodeReducer: function (node, data) {
+                var isSelectedNode = node === selectedNode;
+                var isInactiveNode = (selectedNode &&
+                    selectedNodeNeighbours &&
+                    __spreadArray(__spreadArray([], selectedNodeNeighbours, true), [selectedNode], false).every(function (n) { return n !== node; })) ||
+                    (selectedEdge && !graph.hasExtremity(selectedEdge, node)) ||
+                    false;
+                var newData = __assign(__assign({}, DEFAULT_NODE_STYLE), data);
+                if (data.nodeType === DataModelGraphNodeType.interactionType) {
+                    newData.hasBorder = true;
+                    newData.image = svg2Url(interactionIcon);
+                }
+                if (isInactiveNode) {
+                    newData.inactive = true;
+                    newData.labelColor = INACTIVE_LABEL_COLOR;
+                    newData.secondaryLabelColor = INACTIVE_LABEL_COLOR;
+                }
+                if (isSelectedNode) {
+                    newData.selected = true;
+                    newData.zIndex = 100;
+                }
+                if (hoveredNode !== node && !isSelectedNode) {
+                    delete newData.secondaryLabel;
+                }
+                return newData;
+            },
+            edgeReducer: function (edge, data) {
+                var isDashedLine = data.type === 'dashed';
+                var newData = __assign(__assign({}, DEFAULT_EDGE_STYLE), data);
+                if (selectedEdge === edge) {
+                    newData.selected = true;
+                }
+                if (selectedNode) {
+                    if (graph.hasExtremity(edge, selectedNode)) {
+                        newData.color = isDashedLine ? RELATED_DASHED_EDGE_COLOR : RELATED_EDGE_COLOR;
+                    }
+                    else {
+                        newData.color = INACTIVE_EDGE_COLOR;
+                        newData.labelColor = INACTIVE_LABEL_COLOR;
+                    }
+                }
+                else if (selectedEdge) {
+                    newData.color = edge === selectedEdge ? SELECTED_EDGE_COLOR : INACTIVE_EDGE_COLOR;
+                    newData.labelColor = edge === selectedEdge ? undefined : INACTIVE_LABEL_COLOR;
+                }
+                else {
+                    newData.color = isDashedLine ? DASHED_EDGE_COLOR : EDGE_COLOR;
+                }
+                return newData;
+            }
+        });
+    }, [sigma, setSettings, selectedNode, selectedEdge, hoveredEdge, hoveredNode]);
+};

package/esm/features/graph/DataModelGraph/hooks/useDataModelGraphAppearance.test.d.ts

@@ -0,0 +1 @@
+export {};