refactor of dagflow start

This commit is contained in:
ari committed 2022-07-09 19:22:04 -04:00
1 parent 3cb6070aca
commit d62c484f33
29 files changed
+1463 -16

No files matched your search

@@ -0,0 +1,38 @@
import { FC } from "react";
import { NodeProps, XYPosition, Node } from "react-flow-renderer";
import { DAGDims } from "../elements/types";
export type NodeMaker = ReturnType<typeof makeNodeMaker>;
export const makeNodeMaker = <
NodeType extends string,
PreNodeData extends {},
NodeData extends {}
>(
nodeType: NodeType,
DAGNode: FC<NodeData>,
convert: (pre: PreNodeData, dims: DAGDims) => NodeData
) => {
return {
get nodeType() {
return nodeType;
},
GraphNode: (p: NodeProps<NodeData>) => {
return <DAGNode {...p.data} />;
},
makeElement(
reactFlowProps: {
id: string;
position: XYPosition;
parentNode?: string;
},
dims: DAGDims,
data: PreNodeData
): Node<NodeData> {
return {
...reactFlowProps,
type: nodeType,
data: convert(data, dims),
};
},
};
};
@@ -0,0 +1,27 @@
import { FC } from "react";
import { NodeTypes } from "react-flow-renderer";
import { makeNodeMaker } from "./NodeMaker";
import { DAGDims } from "../elements/types";
export type NodeManager = typeof NodeManager;
export const NodeManager = (() => {
const nodeTypes: NodeTypes = {};
return {
get nodeTypes() {
return nodeTypes;
},
register: <
NodeType extends string,
PreNodeData extends {},
NodeData extends {}
>(
nodeType: NodeType,
DAGNode: FC<NodeData>,
convert: (pre: PreNodeData, dims: DAGDims) => NodeData
) => {
const nodeMaker = makeNodeMaker(nodeType, DAGNode, convert);
nodeTypes[nodeMaker.nodeType] = nodeMaker.GraphNode;
return nodeMaker;
},
};
})();
@@ -0,0 +1,95 @@
.sequence-node {
font-size: 0.9em;
display: flex;
justify-content: center;
align-items: center;
cursor: default;
}
.sequence-node--inner {
position: relative;
display: flex;
flex-direction: row;
justify-content: center;
align-items: center;
padding: 0.25em 0.75em 0.5em 0.75em;
border-style: solid;
border-top-width: 0.25em;
border-left-width: 1px;
border-right-width: 1px;
border-radius: 10px;
}
.sequence-node--label {
flex: 1;
display: flex;
align-items: flex-start;
justify-content: center;
overflow: hidden;
}
.sequence-node--label span {
text-align: center;
white-space: break-word;
overflow: hidden;
text-overflow: ellipsis;
}
.sequence-node--enabled-flag {
position: absolute;
top: -1.5em;
right: -2.5em;
}
.sequence-node--midway-options {
position: absolute;
bottom: -2.5em;
left: calc(50%-0.5em);
z-index: 10;
}
.sequence-node--midway-options button {
padding: 0;
color: var(--mui-primary-main);
background-color: var(--mui-primary-contrastText);
}
.sequence-node--midway-options button:hover {
color: var(--mui-primary-dark);
background-color: var(--mui-primary-contrastText);
}
.sequence-node .sequence-node--inner .speed-dial {
height: 2em;
width: 2em;
min-height: 2em;
max-height: 2em;
position: absolute;
top: -1em;
left: -1em;
background-color: var(--mui-common-black);
border-color: var(--mui-grey-400);
border-style: solid;
border-width: 0.5px;
border-radius: 20px;
}
.open>.sequence-node--actions-btn, .sequence-node--actions-btn:hover {
color: var(--mui-common-black);
background-color: var(--mui-grey-400);
border-radius: 20px;
}
.sequence-node--actions--move.right {
transform: rotate(180deg);
}
.sequence-node--actions--move.up {
transform: rotate(90deg);
}
.sequence-node--actions--move.down {
transform: rotate(270deg);
}
@@ -0,0 +1,94 @@
import React from "react";
import { ComponentMeta, ComponentStory } from "@storybook/react";
import * as dgconst from "components/DAGFlow/constants";
import { Page } from "components/Page";
import { SequenceNode } from "./SequenceNode";
import { DAGGraphBoard } from "components/DAGGraph/board";
import { SequenceNodeMaker } from "./index";
import { DEFAULT_DIMS } from "components/DAGGraph/elements/constants";
export default {
title: "DAGGraph/Nodes/Sequence",
component: SequenceNode,
parameters: { actions: { argTypesRegex: "^on.*" } },
args: {
color: "lblue",
height: dgconst.NODE_HEIGHT,
width: dgconst.NODE_WIDTH,
label: "test",
hasInput: true,
},
} as ComponentMeta<typeof SequenceNode>;
const Template: ComponentStory<typeof SequenceNode> = (args) => {
return (
<Page>
<DAGGraphBoard
closeModal={() => {}}
state={{
ready: true,
data: {
elements: {
edges: [],
nodes: [
SequenceNodeMaker.makeElement(
{
id: "test",
position: {
x: 50,
y: 50,
},
},
DEFAULT_DIMS,
args
),
],
},
},
}}
/>
</Page>
);
};
export const Colors: ComponentStory<typeof SequenceNode> = (args) => {
return (
<Page>
<DAGGraphBoard
closeModal={() => {}}
state={{
ready: true,
data: {
elements: {
edges: [],
nodes: ["blue", "red", "green", "lblue"].map((color: any, i) =>
SequenceNodeMaker.makeElement(
{
id: color,
position: {
x: 50 + dgconst.NODE_HEIGHT * dgconst.DISTANCE_FACTOR * i,
y: 50 + dgconst.NODE_HEIGHT * dgconst.DISTANCE_FACTOR * i,
},
},
DEFAULT_DIMS,
{ ...args, color }
)
),
},
},
}}
/>
</Page>
);
};
export const OnMoveAllDirections = Template.bind({});
OnMoveAllDirections.args = {
...OnMoveAllDirections.args,
onMove: {
up: console.log,
down: console.log,
left: console.log,
right: console.log,
},
};
@@ -0,0 +1,24 @@
import { FC } from "react";
import { Handle, Position } from "react-flow-renderer";
import { SequenceNodeProps } from "./types";
import { SequenceNodeElement } from "./SequenceNodeElement";
export const SequenceNode: FC<SequenceNodeProps> = ({
hasInput = false,
...props
}) => {
return (
<SequenceNodeElement {...props}>
{hasInput && (
<Handle
type="target"
position={props.flipped ? Position.Top : Position.Left}
/>
)}
<Handle
type="source"
position={props.flipped ? Position.Bottom : Position.Right}
/>
</SequenceNodeElement>
);
};
@@ -0,0 +1,148 @@
import "./SequenceNode.css";
import { FC, PropsWithChildren } from "react";
import { useConfirm } from "material-ui-confirm";
import { useSnackbar } from "notistack";
import { useTheme } from "@mui/material/styles";
import IconButton from "@mui/material/IconButton";
import DeleteForeverIcon from "@mui/icons-material/DeleteForever";
import ArrowBackIcon from "@mui/icons-material/ArrowBack";
import SettingsOutlinedIcon from "@mui/icons-material/SettingsOutlined";
import Edit from "@mui/icons-material/Edit";
import Add from "@mui/icons-material/Add";
import InputBoolean from "components/Inputs/InputBoolean";
import { ButtonIcon } from "components/Icons/ButtonIcons";
import { SpeedDial } from "components/SpeedDial";
import { SequenceNodeElementProps } from "./types";
export const SequenceNodeElement: FC<
PropsWithChildren<SequenceNodeElementProps>
> = ({
label,
height,
width,
onXClick,
onEditClick = () => {},
onAddNode,
onMove = {},
color,
flipped,
enabled,
onSetEnabled,
children,
}) => {
const theme = useTheme();
const confirm = useConfirm();
const snackbr = useSnackbar();
const nodeColor =
color === "blue"
? theme.palette.info.main
: color === "green"
? theme.palette.success.light
: color === "lblue"
? theme.palette.info.light
: color === "red"
? theme.palette.error.dark
: "none";
return (
<>
<div
className={[
"sequence-node",
flipped ? "flipped" : "",
enabled ? "enabled" : "disabled",
].join(" ")}
style={{
height,
width,
}}
>
<div
className="sequence-node--inner"
style={{
maxHeight: `calc(${height}px - 1em)`,
maxWidth: `calc(${width}px - 1em)`,
minWidth: Math.max(width / 2, height / 2),
borderBottomColor: theme.palette.grey[500],
borderLeftColor: theme.palette.grey[700],
borderRightColor: theme.palette.grey[700],
borderTopColor: nodeColor,
backgroundColor: enabled
? theme.palette.background.default
: theme.palette.grey[600],
}}
>
<SpeedDial
icon={
<SettingsOutlinedIcon className="sequence-node--actions-btn" />
}
>
<IconButton onClick={onEditClick} size="small">
<Edit color="success" fontSize="inherit" />
</IconButton>
{Object.entries(onMove).map(([key, action]) => (
<IconButton
key={key}
onClick={action}
size="small"
className={["sequence-node--actions--move", key].join(" ")}
>
<ArrowBackIcon fontSize="inherit" />
</IconButton>
))}
{onXClick && (
<IconButton
onClick={() => {
confirm({
description: "Are you sure you want to delete this node?",
})
.then(() => {
onXClick();
snackbr.enqueueSnackbar("Deleted.", {
variant: "info",
});
})
.catch(() =>
snackbr.enqueueSnackbar("Did not delete node.", {
variant: "info",
})
);
}}
size="small"
>
<DeleteForeverIcon fontSize="inherit" color="error" />
</IconButton>
)}
</SpeedDial>
{!!onSetEnabled && (
<InputBoolean
key="enabled-flag"
className="sequence-node--enabled-flag"
label=""
value={enabled}
onChange={onSetEnabled}
/>
)}
{children}
<div
className="sequence-node--label"
style={{
maxHeight: `calc(${height}px - 1em)`,
maxWidth: `calc(${width}px - 1em)`,
minHeight: `1em`,
}}
>
{typeof label === "string" ? <span>{label}</span> : label}
</div>
</div>
{onAddNode && (
<div className="sequence-node--midway-options">
<ButtonIcon icon={<Add />} onClick={onAddNode} />
</div>
)}
</div>
</>
);
};
@@ -0,0 +1,13 @@
import { NodeManager } from "components/DAGGraph/nodes/NodeManager";
import { SequenceNode } from "./SequenceNode";
import { SequenceNodeDataProps } from "./types";
export const SequenceNodeMaker = NodeManager.register(
"SequenceNode",
SequenceNode,
(pre: SequenceNodeDataProps, { node, flipped }) => ({
...node,
...pre,
flipped,
})
);
@@ -0,0 +1,35 @@
import { ReactNode } from "react";
export type SequenceNodeColor = "red" | "blue" | "green" | "lblue";
export type SequenceNodeOnMove<Direction extends string> = Record<
Direction,
() => void
>;
export type SequenceNodeActions = {
onXClick: () => void;
onEditClick: () => void;
onSetEnabled: () => void;
onAddNode: () => void;
onMove: SequenceNodeOnMoveEvents;
};
export type SequenceNodeOnMoveEvents = Partial<
SequenceNodeOnMove<"up" | "down" | "left" | "right">
>;
export type SequenceNodeBaseProps = Partial<SequenceNodeActions> & {
color: SequenceNodeColor;
label: ReactNode;
enabled: boolean;
};
export type SequenceNodeElementProps = SequenceNodeBaseProps & {
height: number;
width: number;
flipped: boolean;
};
export type SequenceNodeDataProps = SequenceNodeBaseProps & {
hasInput?: boolean;
};
export interface SequenceNodeProps extends SequenceNodeDataProps {
height: number;
width: number;
flipped: boolean;
}
@@ -0,0 +1,35 @@
import Add from "@mui/icons-material/Add";
import { ButtonIcon } from "components/Icons/ButtonIcons";
import { FC } from "react";
import { SequenceNodeElement } from "../SequenceNode/SequenceNodeElement";
import { TriggerNodeProps } from "./types";
export const TriggerNodes: FC<TriggerNodeProps> = ({
onAddNode,
nodes,
sequenceNode,
height,
width,
flipped,
}) => {
return (
<div
className="trigger-nodes"
style={{
maxHeight: height,
maxWidth: width,
}}
>
{nodes.map((n, i) => (
<SequenceNodeElement
{...n}
{...sequenceNode}
key={i}
color="red"
flipped={flipped}
/>
))}
<ButtonIcon icon={<Add />} onClick={onAddNode} />
</div>
);
};
@@ -0,0 +1,14 @@
import { NodeManager } from "components/DAGGraph/nodes/NodeManager";
import { TriggerNodes } from "./TriggerNodes";
import { TriggerNodeDataProps } from "./types";
export const TriggerNodesMaker = NodeManager.register(
"TriggerNodes",
TriggerNodes,
(pre: TriggerNodeDataProps, { node, trigger, flipped }) => ({
...pre,
...trigger,
sequenceNode: node,
flipped,
})
);
@@ -0,0 +1,18 @@
import { Size } from "components/DAGGraph/elements/types";
import { ReactNode } from "react";
import { SequenceNodeActions } from "../SequenceNode/types";
export type TriggerNodeChildProps = Partial<SequenceNodeActions> & {
enabled: boolean;
label: ReactNode;
};
export type TriggerNodeDataProps = {
nodes: TriggerNodeChildProps[];
onAddNode: () => void;
};
export type TriggerNodeProps = TriggerNodeDataProps &
Size & {
sequenceNode: Size;
flipped: boolean;
};
@@ -0,0 +1,5 @@
import { Node, NodeTypes } from "react-flow-renderer";
import { NodeManager } from "./NodeManager";
export const nodeTypes: NodeTypes = NodeManager.nodeTypes;
export type DAGAutomationFlowNode = Node<any>;