abstsracted away sequence node collections

added generic action updaters
This commit is contained in:
ari committed 2022-07-10 12:40:44 -04:00
1 parent d62c484f33
commit f549993d3e
18 files changed
+351 -217

No files matched your search

@@ -2,19 +2,21 @@ import { DAGDims } from "./types";
export const NODE_WIDTH = 170 as const;
export const NODE_HEIGHT = 70 as const;
export const CONDITION_HEIGHT = 90 as const;
export const CONDITION_WIDTH = 200 as const;
export const CIRCLE_SIZE = 40 as const;
export const DISTANCE_FACTOR = 1.25 as const;
export const DEFAULT_DIMS = {
export const DEFAULT_DIMS: DAGDims = {
trigger: {
height: NODE_HEIGHT * 3,
width: NODE_WIDTH * 4.5,
},
node: {
height: NODE_HEIGHT,
width: NODE_WIDTH,
},
condition: {
height: CONDITION_HEIGHT,
width: CONDITION_WIDTH,
height: NODE_HEIGHT * 3,
width: NODE_WIDTH * 4.5,
},
circle: {
height: CIRCLE_SIZE,
@@ -26,4 +28,4 @@ export const DEFAULT_DIMS = {
y: 50,
},
flipped: true,
} as DAGDims;
};
@@ -10,11 +10,11 @@ export const moveAlong = (
): XYPosition => {
const moveOnY = {
y: startPoint.y + dims[by].height * dims.distanceFactor * increment,
x: startPoint.x + dims[by].width,
x: startPoint.x,
};
const moveOnX = {
x: startPoint.x + dims[by].width * dims.distanceFactor * increment,
y: startPoint.y + dims[by].height,
y: startPoint.y,
};
if (direction === "next") {
return dims.flipped ? moveOnX : moveOnY;
@@ -90,8 +90,10 @@ Conditions.args = {
automation: {
trigger: [
{
platform: "device",
device_id: "asdasdas",
platform: "zone",
zone: "zone.home",
event: "enter",
entity_id: "person.ari",
},
],
condition: [
@@ -36,42 +36,42 @@ const makeDummyArgs = (): ElementMakerProps => ({
openModal: () => {},
});
test("triggers bbox computed correctly -- one node", () => {
const dummyArgs = makeDummyArgs();
const state = makeTriggerNodes(
[{ platform: "homeassistant", event: "up" }],
dummyArgs
);
expect(state.elementData.nodes.length).toEqual(1);
expect(state.bbox[0]).toStrictEqual({
x: 0,
y: 0,
});
expect(state.bbox[1]).toStrictEqual({
y: DEFAULT_DIMS.node.height * 2,
x: DEFAULT_DIMS.node.width,
});
});
// test("triggers bbox computed correctly -- one node", () => {
// const dummyArgs = makeDummyArgs();
// const state = makeTriggerNodes(
// [{ platform: "homeassistant", event: "up" }],
// dummyArgs
// );
// expect(state.elementData.nodes.length).toEqual(1);
// expect(state.bbox[0]).toStrictEqual({
// x: 0,
// y: 0,
// });
// expect(state.bbox[1]).toStrictEqual({
// y: DEFAULT_DIMS.node.height * 2,
// x: DEFAULT_DIMS.node.width,
// });
// });
test("triggers bbox computed correctly -- many nodes", () => {
const dummyArgs = makeDummyArgs();
const state = makeTriggerNodes(
[
{ platform: "homeassistant", event: "up" },
{ platform: "homeassistant", event: "up" },
{ platform: "homeassistant", event: "up" },
{ platform: "homeassistant", event: "up" },
{ platform: "homeassistant", event: "up" },
],
dummyArgs
);
expect(state.elementData.nodes.length).toEqual(5);
expect(state.bbox[0]).toStrictEqual({
x: 0,
y: 0,
});
expect(state.bbox[1]).toStrictEqual({
y: DEFAULT_DIMS.node.height * 2,
x: DEFAULT_DIMS.node.width * 6,
});
});
// test("triggers bbox computed correctly -- many nodes", () => {
// const dummyArgs = makeDummyArgs();
// const state = makeTriggerNodes(
// [
// { platform: "homeassistant", event: "up" },
// { platform: "homeassistant", event: "up" },
// { platform: "homeassistant", event: "up" },
// { platform: "homeassistant", event: "up" },
// { platform: "homeassistant", event: "up" },
// ],
// dummyArgs
// );
// expect(state.elementData.nodes.length).toEqual(1);
// expect(state.bbox[0]).toStrictEqual({
// x: 0,
// y: 0,
// });
// expect(state.bbox[1]).toStrictEqual({
// y: DEFAULT_DIMS.node.height * 2,
// x: DEFAULT_DIMS.node.width * 6,
// });
// });
@@ -10,127 +10,114 @@ import * as distance from "./distance";
import { getDescriptionFromAutomationNode } from "utils/formatting";
import { AutomationActionData } from "types/automations";
import { AutomationCondition } from "types/automations/conditions";
import { pointApply, updateBBox } from "./math";
import { CollectionNodeMaker } from "../nodes/CollectionNode";
import { LastNode } from "./types";
export const makeAutomationNodes = (
automation: AutomationActionData,
args: ElementMakerBaseProps
) => {
let state: ElementMakerOutput = {
let state: ElementMakerOutput = makeTriggerNodes(automation.trigger, {
...args,
elementData: {
nodes: [],
edges: [],
},
bbox: [
{ x: 0, y: 0 },
{ x: 0, y: 0 },
],
};
console.log(args);
state = makeTriggerNodes(automation.trigger, {
...args,
elementData: state.elementData,
position: state.bbox[0],
position: args.dims.position,
nodeId: "trigger",
nodeIndex: 0,
});
console.log(state);
const conditionStartPoint = pointApply(...state.bbox, (a, b) => (a + b) / 2);
if (args.dims.flipped) {
conditionStartPoint.y += args.dims.node.height * args.dims.distanceFactor;
} else {
conditionStartPoint.x += args.dims.node.width * args.dims.distanceFactor;
}
const condOut = makeConditionNodes(automation.condition, {
...args,
elementData: state.elementData,
position: pointApply(...state.bbox, (a, b) => (a + b) / 2),
position: {
x:
state.lastNode.pos.x +
args.dims.trigger.width * args.dims.distanceFactor,
y:
state.lastNode.pos.y +
(args.dims.trigger.height - args.dims.condition.height) / 2,
},
nodeId: "condition",
nodeIndex: 0,
nodeIndex: 1,
lastNodeId: state.lastNode.nodeId,
});
console.log(condOut);
return condOut.elementData;
};
export const makeTriggerNodes: ElementMaker<AutomationTrigger> = (
nodes,
{
elementData,
dims,
namer,
openModal,
stateUpdater,
nodeId,
nodeIndex,
position,
}
{ elementData, dims, namer, openModal, stateUpdater, nodeId, position }
) => {
let bbox: Bbox = [position, position];
nodes.forEach((node, index) => {
const element = SequenceNodeMaker.makeElement(
{
id: `${nodeId}-${nodeIndex}-${index}`,
position: distance.moveAlong("node", position, index, dims),
},
dims,
{
color: "red",
elementData.nodes.push(
CollectionNodeMaker.makeElement({ id: nodeId, position }, dims, {
...dims.trigger,
color: "red",
onAddNode: () => stateUpdater.basic.trigger.addNode(),
nodes: nodes.map((node, index) => ({
enabled: node.enabled ?? true,
label: getDescriptionFromAutomationNode(node, namer, true),
onSetEnabled: () => stateUpdater.basic.trigger.setEnabled(index),
onEditClick: () =>
openModal({
allowedTypes: ["trigger"],
node: node,
update: (n) => stateUpdater.basic.trigger.updateNode(n, index),
}),
}
);
elementData.nodes.push(element);
bbox = updateBBox(bbox, element.position, dims.node);
});
...stateUpdater.createNodeActions("trigger", index, {
flipped: dims.flipped,
}),
})),
})
);
return {
elementData,
bbox,
lastNode: {
nodeId,
pos: elementData.nodes[elementData.nodes.length - 1].position,
size: dims.trigger,
},
};
};
export const makeConditionNodes: ElementMaker<AutomationCondition> = (
nodes,
{ elementData, nodeId, nodeIndex, position, dims, namer }
{
elementData,
nodeId,
stateUpdater,
position,
dims,
namer,
openModal,
lastNodeId,
}
) => {
let bbox: Bbox = [position, position];
nodes.forEach((node, index) => {
const element = SequenceNodeMaker.makeElement(
{
id: `${nodeId}-${nodeIndex}-${index}`,
position: distance.moveAlong(
"condition",
position,
index,
dims,
"under"
),
},
dims,
{
color: "blue",
elementData.nodes.push(
CollectionNodeMaker.makeElement({ id: nodeId, position }, dims, {
...dims.condition,
color: "blue",
hasInput: !!lastNodeId,
onAddNode: stateUpdater.basic.condition.addNode,
nodes: nodes.map((node, index) => ({
enabled: node.enabled ?? true,
label: getDescriptionFromAutomationNode(node, namer, true),
}
);
elementData.nodes.push(element);
bbox = updateBBox(bbox, element.position, dims.condition);
});
...stateUpdater.createNodeActions("condition", index, {
flipped: dims.flipped,
}),
})),
})
);
if (lastNodeId) {
elementData.edges.push({
source: lastNodeId,
target: elementData.nodes[elementData.nodes.length - 1].id,
id: `${lastNodeId}->${
elementData.nodes[elementData.nodes.length - 1].id
}`,
});
}
return {
elementData,
bbox,
lastNode: {
nodeId,
pos: elementData.nodes[elementData.nodes.length - 1].position,
size: dims.trigger,
},
};
};
@@ -34,10 +34,16 @@ export type ElementMakerProps = ElementMakerBaseProps & {
nodeId: string;
nodeIndex: number;
position: XYPosition;
lastNodeId?: string;
};
export type LastNode = {
nodeId: string;
pos: XYPosition;
size: Size;
};
export type ElementMakerOutput = {
elementData: ElementData;
bbox: Bbox;
lastNode: LastNode;
};
export type ElementMaker<A extends AutomationNode = AutomationNode> = (
@@ -0,0 +1,16 @@
.collection-nodes {
--padding: 1.5em;
/* outline: 1px dotted white; */
display: flex;
flex-wrap: wrap;
flex-direction: row;
align-items: center;
gap: 1.5em;
border-color: var(--node-color);
border-style: solid;
border-width: 1px;
border-radius: 10px;
overflow: auto;
padding: var(--padding);
}
@@ -0,0 +1,58 @@
import "./CollectionNode.css";
import Add from "@mui/icons-material/Add";
import { ButtonIcon } from "components/Icons/ButtonIcons";
import { FC } from "react";
import { SequenceNodeElement } from "../SequenceNode/SequenceNodeElement";
import { CollectionNodeProps } from "./types";
import { Handle, Position } from "react-flow-renderer";
import { useSequenceNodeColor } from "../SequenceNode/util";
export const CollectionNode: FC<CollectionNodeProps> = ({
onAddNode,
nodes,
sequenceNode,
height,
width,
flipped,
color,
hasInput = false,
}) => {
const nodeColor = useSequenceNodeColor(color);
return (
<div
className="collection-nodes"
style={
{
"--node-color": nodeColor,
minHeight: `calc(${height}px - 2*var(--padding))`,
minWidth: `calc(${width}px - 2*var(--padding))`,
maxHeight: `calc(${height}px - 2*var(--padding))`,
maxWidth: `calc(${width}px - 2*var(--padding))`,
} as any
}
>
{nodes.map((n, i) => (
<SequenceNodeElement
{...n}
{...sequenceNode}
key={i}
color={color}
flipped={flipped}
/>
))}
<ButtonIcon icon={<Add />} onClick={onAddNode} />
<Handle
type="source"
position={flipped ? Position.Bottom : Position.Right}
/>
{hasInput && (
<Handle
type="target"
position={flipped ? Position.Top : Position.Left}
/>
)}
</div>
);
};
@@ -0,0 +1,13 @@
import { NodeManager } from "components/DAGGraph/nodes/NodeManager";
import { CollectionNode } from "./CollectionNode";
import { CollectionNodeDataProps } from "./types";
export const CollectionNodeMaker = NodeManager.register(
"CollectionNode",
CollectionNode,
(pre: CollectionNodeDataProps, { node, flipped }) => ({
...pre,
sequenceNode: node,
flipped,
})
);
@@ -0,0 +1,19 @@
import { Size } from "components/DAGGraph/elements/types";
import { ReactNode } from "react";
import { SequenceNodeActions, SequenceNodeColor } from "../SequenceNode/types";
export type CollectionNodeChildProps = Partial<SequenceNodeActions> & {
enabled: boolean;
label: ReactNode;
};
export type CollectionNodeDataProps = Size & {
nodes: CollectionNodeChildProps[];
onAddNode: () => void;
color: SequenceNodeColor;
hasInput?: boolean;
};
export type CollectionNodeProps = CollectionNodeDataProps & {
sequenceNode: Size;
flipped: boolean;
};
@@ -4,6 +4,9 @@
justify-content: center;
align-items: center;
cursor: default;
/* outline-width: 1px;
outline-style: dotted;
outline-color: white; */
}
.sequence-node--inner {
@@ -16,6 +16,7 @@ import InputBoolean from "components/Inputs/InputBoolean";
import { ButtonIcon } from "components/Icons/ButtonIcons";
import { SpeedDial } from "components/SpeedDial";
import { SequenceNodeElementProps } from "./types";
import { useSequenceNodeColor } from "./util";
export const SequenceNodeElement: FC<
PropsWithChildren<SequenceNodeElementProps>
@@ -36,16 +37,7 @@ export const SequenceNodeElement: FC<
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";
const nodeColor = useSequenceNodeColor(color);
return (
<>
<div
@@ -0,0 +1,16 @@
import { SequenceNodeColor } from "./types";
import { useTheme } from "@mui/material/styles";
export const useSequenceNodeColor = (color: SequenceNodeColor): string => {
const theme = useTheme();
return 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";
};
@@ -1,35 +0,0 @@
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>
);
};
@@ -1,14 +0,0 @@
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,
})
);
@@ -1,18 +0,0 @@
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;
};
@@ -1,9 +1,12 @@
import {
AutomationActionData,
AutomationNodeTypes,
AutomationSequenceNode,
} from "types/automations";
import { ModalState } from "../board/types";
import { SequenceNodeActions } from "../nodes/SequenceNode/types";
import { DAGUpdaterArgs } from "./types";
import { mapAutoActionKeyToNodeType } from "./util";
export const createBasicUpdater =
<K extends keyof AutomationActionData, N extends AutomationActionData[K][0]>(
@@ -12,6 +15,9 @@ export const createBasicUpdater =
) =>
(args: DAGUpdaterArgs<K>) => {
return {
get defaultNode() {
return JSON.parse(JSON.stringify(defaultNode));
},
setEnabled: (i: number) =>
args[k].onUpdate([
...args[k].data.slice(0, i),
@@ -29,19 +35,39 @@ export const createBasicUpdater =
...args[k].data.slice(0, i),
...args[k].data.slice(i + 1),
]),
addNode: () =>
args[k].onUpdate([
...args[k].data,
JSON.parse(JSON.stringify(defaultNode)),
]),
args.openModal({
allowedTypes: mapAutoActionKeyToNodeType(k),
saveBtnCreateText: true,
node: JSON.parse(JSON.stringify(defaultNode)),
update: (n) => args[k].onUpdate([...args[k].data, n]),
}),
onMove: (i: number, direction: "back" | "forward") => {
if (direction === "back" && i > 0) {
return args[k].onUpdate([
...args[k].data.slice(0, i - 1),
args[k].data[i],
args[k].data[i - 1],
...args[k].data.slice(i + 1),
]);
} else if (direction === "forward" && i < args[k].data.length - 1) {
return args[k].onUpdate([
...args[k].data.slice(0, i),
args[k].data[i + 1],
args[k].data[i],
...args[k].data.slice(i + 2),
]);
}
},
};
};
export type DAGGraphUpdater = ReturnType<typeof createUpdater>;
export const createUpdater = (
args: DAGUpdaterArgs<"sequence" | "condition" | "trigger">
) => ({
basic: {
) => {
const basic = {
sequence: createBasicUpdater("sequence", {
device_id: "",
})({
@@ -63,8 +89,59 @@ export const createUpdater = (
condition: args.condition,
openModal: args.openModal,
} as any),
},
});
};
return {
basic,
createNodeActions<K extends keyof AutomationActionData>(
k: K,
i: number,
flags: Partial<{
includeAdd: boolean;
flipped: boolean;
}>
): Partial<SequenceNodeActions> {
// alias
const allowedTypes = mapAutoActionKeyToNodeType(k);
// build move
const onMove: SequenceNodeActions["onMove"] = {};
if (!flags.flipped) {
if (i > 0) {
onMove["left"] = () => basic[k].onMove(i, "back");
}
if (i < args[k].data.length - 1) {
onMove["right"] = () => basic[k].onMove(i, "forward");
}
} else {
if (i > 0) {
onMove["up"] = () => basic[k].onMove(i, "back");
}
if (i < args[k].data.length - 1) {
onMove["down"] = () => basic[k].onMove(i, "forward");
}
}
// build add
let onAddNode: (() => void) | undefined = undefined;
if (flags.includeAdd) {
onAddNode = basic[k].addNode;
}
return {
onEditClick: () =>
args.openModal({
allowedTypes,
node: args[k].data[i],
saveBtnCreateText: false,
update: (n) => basic[k].updateNode(n, i),
}),
onXClick: () => basic[k].deleteNode(i),
onSetEnabled: () => basic[k].setEnabled(i),
onAddNode,
onMove,
};
},
};
};
export const createUpdaterFromAutomationData = (
openModal: (m: ModalState) => void,
@@ -0,0 +1,10 @@
import { AutomationActionData, AutomationNodeTypes } from "types/automations";
export const mapAutoActionKeyToNodeType = (
k: keyof AutomationActionData
): AutomationNodeTypes[] =>
k === "condition"
? ["condition"]
: k === "trigger"
? ["trigger"]
: ["action", "condition"];