added condition editor for device

This commit is contained in:
ari committed 2022-06-17 17:45:14 -04:00
1 parent 1ce934fd54
commit 618a62affe
9 files changed
+387 -256

No files matched your search

@@ -1,5 +1,5 @@
import { Classes } from "jss"; import { Classes } from "jss";
import { FC, useState, useEffect } from 'react'; import { FC, useState, useEffect } from "react";
import { getConditionDefaultValues } from "utils/defaults"; import { getConditionDefaultValues } from "utils/defaults";
import { AutomationCondition } from "types/automations/conditions"; import { AutomationCondition } from "types/automations/conditions";
import { CheckMarkIcon, PencilIcon } from "components/Icons"; import { CheckMarkIcon, PencilIcon } from "components/Icons";
@@ -10,126 +10,151 @@ import { useStyles } from "./style";
import { getViewer } from "./viewRender"; import { getViewer } from "./viewRender";
import useWindowSize from "utils/useWindowSize"; import useWindowSize from "utils/useWindowSize";
import { useHA } from "haService"; import { useHA } from "haService";
import { getSubTypeList } from "utils/automations";
export const ConditionNode: FC<{ export const ConditionNode: FC<{
condition: AutomationCondition; condition: AutomationCondition;
displayMode: boolean; displayMode: boolean;
showDelete?: boolean; showDelete?: boolean;
onDelete?: (which: 'root' | number) => void; onDelete?: (which: "root" | number) => void;
onUpdate?: (data: AutomationCondition) => void; onUpdate?: (data: AutomationCondition) => void;
children?: (props: { children?: (props: { classes: Classes<string> }) => JSX.Element;
classes: Classes<string>
}) => JSX.Element,
}> = ({ }> = ({
condition, condition,
showDelete = false, showDelete = false,
displayMode = true, displayMode = true,
onDelete = () => { }, onDelete = () => {},
onUpdate = () => { }, onUpdate = () => {},
children = () => { }, children = () => {},
}) => { }) => {
// state // state
const [internalDisplayMode, setInternalDisplayMode] = useState(displayMode); const [internalDisplayMode, setInternalDisplayMode] = useState(displayMode);
const [yamlMode, setYamlMode] = useState(false); const [yamlMode, setYamlMode] = useState(false);
const { isMobile } = useWindowSize(); const { isMobile } = useWindowSize();
const { namer } = useHA(); const ha = useHA();
// alias // alias
const effectiveDM = internalDisplayMode || yamlMode; const effectiveDM = internalDisplayMode || yamlMode;
// effect // effect
useEffect(() => { useEffect(() => {
setInternalDisplayMode(displayMode); setInternalDisplayMode(displayMode);
}, [displayMode]) }, [displayMode]);
useEffect(() => { useEffect(() => {
if (yamlMode) { if (yamlMode) {
setInternalDisplayMode(true); setInternalDisplayMode(true);
}
}, [yamlMode])
// alias
const onAddChild = () => {
if (
(condition.condition === 'and') ||
(condition.condition === 'or') ||
(condition.condition === 'not')
) {
onUpdate({
...condition,
conditions: condition.conditions.concat({
condition: 'or',
conditions: []
})
})
}
} }
// children }, [yamlMode]);
let childrenConditions: JSX.Element; // alias
if (effectiveDM) { const onAddChild = () => {
const Viewer = getViewer(condition); if (
childrenConditions = <Viewer condition={condition} onChange={onUpdate} namer={namer} /> condition.condition === "and" ||
} else { condition.condition === "or" ||
const Editor = getEditor(condition); condition.condition === "not"
childrenConditions = <Editor condition={condition} onChange={onUpdate} /> ) {
onUpdate({
...condition,
conditions: condition.conditions.concat({
condition: "or",
conditions: [],
}),
});
} }
// styles };
let hasChildren = false; // children
if (condition.condition === "not") { let childrenConditions: JSX.Element;
hasChildren = true if (effectiveDM) {
} else if (condition.condition === 'and') { const Viewer = getViewer(condition);
hasChildren = true childrenConditions = (
} else if (condition.condition === 'or') { <Viewer condition={condition} onChange={onUpdate} namer={ha.namer} />
hasChildren = true );
} } else {
const { classes } = useStyles({ hasChildren, isMobile }); const Editor = getEditor(condition);
childrenConditions = (
<Editor condition={condition} onChange={onUpdate} ha={ha} />
);
}
// styles
let hasChildren = false;
if (condition.condition === "not") {
hasChildren = true;
} else if (condition.condition === "and") {
hasChildren = true;
} else if (condition.condition === "or") {
hasChildren = true;
}
const { classes } = useStyles({ hasChildren, isMobile });
// components // components
const DeleteButton = (p: { onClick?: () => void, isRoot?: boolean }) => const DeleteButton = (p: { onClick?: () => void; isRoot?: boolean }) => (
<button className={p.isRoot ? classes.deleteBtnRoot : classes.deleteBtn} onClick={p?.onClick}>X</button> <button
className={p.isRoot ? classes.deleteBtnRoot : classes.deleteBtn}
onClick={p?.onClick}
>
X
</button>
);
return <div className={classes.root}> return (
<div className={classes.root}>
<> <>
{(showDelete && !effectiveDM) && <DeleteButton isRoot onClick={() => onDelete('root')} />} {showDelete && !effectiveDM && (
<DeleteButton isRoot onClick={() => onDelete("root")} />
)}
<div className={classes.title}> <div className={classes.title}>
<InputList <InputList
label="" label=""
className={classes.titleText} className={classes.titleText}
current={condition.condition} current={condition.condition}
options={[ options={getSubTypeList("condition")}
'or', 'not', 'and', onChange={(n: any) =>
'template', onUpdate({
'numeric_state', ...getConditionDefaultValues(n),
'state', ...condition,
'time', condition: n,
'trigger', } as any)
'zone', }
]}
onChange={(n: any) => onUpdate({
...getConditionDefaultValues(n),
...condition,
condition: n,
} as any)}
/> />
{effectiveDM && <button className={classes.yamlBtn} onClick={() => setYamlMode(!yamlMode)}> {effectiveDM && (
{yamlMode ? 'visual' : 'yaml'} <button
</button>} className={classes.yamlBtn}
{!yamlMode && <button className={classes.modifyBtn} onClick={() => setInternalDisplayMode(!effectiveDM)}> onClick={() => setYamlMode(!yamlMode)}
{effectiveDM ? <PencilIcon className={classes.icon} /> : <CheckMarkIcon className={classes.icon} />} >
</button>} {yamlMode ? "visual" : "yaml"}
</button>
)}
{!yamlMode && (
<button
className={classes.modifyBtn}
onClick={() => setInternalDisplayMode(!effectiveDM)}
>
{effectiveDM ? (
<PencilIcon className={classes.icon} />
) : (
<CheckMarkIcon className={classes.icon} />
)}
</button>
)}
</div> </div>
<div className={classes.children}> <div className={classes.children}>
{yamlMode && <InputYaml {yamlMode && (
label="" <InputYaml
value={condition} label=""
onChange={update => onUpdate(update as any)} value={condition}
/>} onChange={(update) => onUpdate(update as any)}
/>
)}
<div className={classes.conditionWrap}> <div className={classes.conditionWrap}>
{!yamlMode && childrenConditions} {!yamlMode && childrenConditions}
</div> </div>
{!yamlMode && hasChildren && <div className={classes.addBtnContainer}> {!yamlMode && hasChildren && (
<button className={classes.addBtn} onClick={() => onAddChild()}>Add</button> <div className={classes.addBtnContainer}>
</div>} <button className={classes.addBtn} onClick={() => onAddChild()}>
Add
</button>
</div>
)}
</div> </div>
{children({ classes })} {children({ classes })}
</> </>
</div> </div>
} );
};
@@ -1,6 +1,7 @@
import { FC } from "react"; import { FC } from "react";
import { import {
AutomationCondition, AutomationCondition,
DeviceCondition,
LogicCondition, LogicCondition,
NumericCondition, NumericCondition,
StateCondition, StateCondition,
@@ -16,11 +17,14 @@ import { ConditionNode } from "./ConditionNode";
import { genUpdateMethods } from "./nestedUpdater"; import { genUpdateMethods } from "./nestedUpdater";
import { InputTime } from "components/Inputs/InputTime"; import { InputTime } from "components/Inputs/InputTime";
import InputYaml from "components/Inputs/InputYaml"; import InputYaml from "components/Inputs/InputYaml";
import { HAService } from "haService";
import { DeviceEditor } from "components/DeviceEditor";
interface Editor<C extends AutomationCondition> interface Editor<C extends AutomationCondition>
extends FC<{ extends FC<{
condition: C; condition: C;
onChange: (condition: C) => void; onChange: (condition: C) => void;
ha: HAService;
}> {} }> {}
export const getEditor = (condition: AutomationCondition): Editor<any> => { export const getEditor = (condition: AutomationCondition): Editor<any> => {
@@ -33,6 +37,8 @@ export const getEditor = (condition: AutomationCondition): Editor<any> => {
return LogicViewer; return LogicViewer;
case "not": case "not":
return LogicViewer; return LogicViewer;
case "device":
return DeviceConditionEditor;
case "numeric_state": case "numeric_state":
return NumericStateEditor; return NumericStateEditor;
case "state": case "state":
@@ -68,6 +74,35 @@ export const TemplateEditor: Editor<TemplateCondition> = ({
); );
}; };
export const DeviceConditionEditor: Editor<DeviceCondition> = ({
onChange,
condition,
ha: {
deviceExtras: { useDeviceConditionCapalities, useDeviceConditions },
},
}) => {
return (
<DeviceEditor
type="condition"
state={condition}
setState={(data) =>
onChange({
condition: "device",
...data,
} as any)
}
options={useDeviceConditions(
condition.device_id
? {
deviceId: condition.device_id,
}
: undefined
)}
caps={useDeviceConditionCapalities(condition as any)}
/>
);
};
export const NumericStateEditor: Editor<NumericCondition> = ({ export const NumericStateEditor: Editor<NumericCondition> = ({
onChange, onChange,
condition, condition,
+25
View File
@@ -3,6 +3,7 @@ import { MessageBase } from "home-assistant-js-websocket";
import { useEffect, useRef, useState } from "react"; import { useEffect, useRef, useState } from "react";
import { prettyName } from "utils/formatting"; import { prettyName } from "utils/formatting";
import { import {
DeviceConditionType,
DeviceTriggerType, DeviceTriggerType,
DeviceTypeAction, DeviceTypeAction,
DeviceTypeCapability, DeviceTypeCapability,
@@ -114,5 +115,29 @@ export const getDeviceExtraWsCalls = (callHA: HASendMessage) => {
reduceDeviceThings, reduceDeviceThings,
{} {}
), ),
useDeviceConditionCapalities: createUseThing<
DeviceTypeAction,
DeviceTypeCapability,
Partial<DeviceTypeCapability>
>(
(condition) => ({
type: "device_automation/condition/capabilities",
condition,
}),
(data) => data,
{}
),
useDeviceConditions: createUseThing<
{ deviceId: string },
DeviceConditionType[],
Record<string, BaseOption<{ data: DeviceConditionType[] }>>
>(
({ deviceId }) => ({
type: "device_automation/condition/list",
device_id: deviceId,
}),
reduceDeviceThings,
{}
),
}; };
}; };
+4 -1
View File
@@ -33,7 +33,10 @@ export type DeviceBaseType = AutomationDeviceState & {
} & Record<string, any>; } & Record<string, any>;
export type DeviceTypeAction = DeviceBaseType; export type DeviceTypeAction = DeviceBaseType;
export type DeviceTriggerType = DeviceBaseType & { export type DeviceTriggerType = DeviceBaseType & {
platform: string; platform: "device";
};
export type DeviceConditionType = DeviceBaseType & {
condition: "device";
}; };
export type DeviceTypeCapability = { export type DeviceTypeCapability = {
extra_fields: Array<{ extra_fields: Array<{
+18 -15
View File
@@ -1,26 +1,29 @@
import { AutomationTime } from "./common"; import * as st from "superstruct";
import * as st from 'superstruct';
import * as v from "types/validators/conditions"; import * as v from "types/validators/conditions";
type AutomationConditionNodeBase<Name extends String, Data extends Object> = { type AutomationConditionNodeBase<Name extends String, Data extends Object> = {
condition: Name; condition: Name;
enabled?: boolean; enabled?: boolean;
} & Data; } & Data;
export type LogicCondition = AutomationConditionNodeBase<'and' | 'or' | 'not', { export type LogicCondition = AutomationConditionNodeBase<
"and" | "or" | "not",
{
conditions: AutomationCondition[]; conditions: AutomationCondition[];
}>; }
>;
export type NumericCondition = st.Infer<typeof v.NumericCondition>; export type NumericCondition = st.Infer<typeof v.NumericCondition>;
export type DeviceCondition = st.Infer<typeof v.DeviceCondition>;
export type StateCondition = st.Infer<typeof v.StateCondition>; export type StateCondition = st.Infer<typeof v.StateCondition>;
export type TemplateCondition = st.Infer<typeof v.TemplateCondition>; export type TemplateCondition = st.Infer<typeof v.TemplateCondition>;
export type TimeCondition = st.Infer<typeof v.TimeCondition>; export type TimeCondition = st.Infer<typeof v.TimeCondition>;
export type TriggerCondition = st.Infer<typeof v.TriggerCondition>; export type TriggerCondition = st.Infer<typeof v.TriggerCondition>;
export type ZoneCondition = st.Infer<typeof v.ZoneCondition>; export type ZoneCondition = st.Infer<typeof v.ZoneCondition>;
export type AutomationCondition = export type AutomationCondition =
| LogicCondition | LogicCondition
| NumericCondition | DeviceCondition
| StateCondition | NumericCondition
| TemplateCondition | StateCondition
| TimeCondition | TemplateCondition
| TriggerCondition | TimeCondition
| ZoneCondition | TriggerCondition
; | ZoneCondition;
export type ConditionType = AutomationCondition['condition']; export type ConditionType = AutomationCondition["condition"];
+72 -68
View File
@@ -1,71 +1,75 @@
import * as st from 'superstruct' import * as st from "superstruct";
import { AutomationTime, EntityId } from './common'; import { AutomationDeviceState, AutomationTime, EntityId } from "./common";
export const AutomationConditionNodeBase = st.type({ export const AutomationConditionNodeBase = st.type({
enabled: st.optional(st.boolean()) enabled: st.optional(st.boolean()),
}); });
export const LogicCondition = st.intersection([ export const LogicCondition = st.assign(
AutomationConditionNodeBase, AutomationConditionNodeBase,
st.type({ st.type({
condition: st.enums(['and', 'or', 'not']), condition: st.enums(["and", "or", "not"]),
conditions: st.array(st.object()) conditions: st.array(st.object()),
}) })
]) );
export const NumericCondition = st.intersection([ export const NumericCondition = st.assign(
AutomationConditionNodeBase, AutomationConditionNodeBase,
st.type({ st.type({
condition: st.literal('numeric_state'), condition: st.literal("numeric_state"),
entity_id: EntityId, entity_id: EntityId,
above: st.optional(st.string()), above: st.optional(st.string()),
below: st.optional(st.string()), below: st.optional(st.string()),
attribute: st.optional(st.string()), attribute: st.optional(st.string()),
value_template: st.optional(st.string()), value_template: st.optional(st.string()),
}) })
]); );
export const StateCondition = st.intersection([ export const StateCondition = st.assign(
AutomationConditionNodeBase, AutomationConditionNodeBase,
st.type({ st.type({
condition: st.literal('state'), condition: st.literal("state"),
entity_id: EntityId, entity_id: EntityId,
state: st.union([st.array(st.string()), st.string()]), state: st.union([st.array(st.string()), st.string()]),
for: st.optional(AutomationTime), for: st.optional(AutomationTime),
attribute: st.optional(st.string()), attribute: st.optional(st.string()),
}) })
]); );
export const TemplateCondition = st.intersection([ export const DeviceCondition = st.assign(
AutomationConditionNodeBase, AutomationConditionNodeBase,
st.type({ st.type({
condition: st.literal('template'), condition: st.literal("device"),
value_template: st.string(), }),
}) AutomationDeviceState
]); );
export const TriggerCondition = st.intersection([ export const TemplateCondition = st.assign(
AutomationConditionNodeBase, AutomationConditionNodeBase,
st.type({ st.type({
condition: st.literal('trigger'), condition: st.literal("template"),
id: st.string(), value_template: st.string(),
}) })
]); );
export const TimeCondition = st.intersection([ export const TriggerCondition = st.assign(
AutomationConditionNodeBase, AutomationConditionNodeBase,
st.type({ st.type({
condition: st.literal('time'), condition: st.literal("trigger"),
after: st.optional(AutomationTime), id: st.string(),
before: st.optional(AutomationTime), })
weekday: st.optional(st.enums([ );
'mon', 'tue', 'wed', export const TimeCondition = st.assign(
'thu', 'fri', 'sat', AutomationConditionNodeBase,
'sun', st.type({
])) condition: st.literal("time"),
}) after: st.optional(AutomationTime),
]); before: st.optional(AutomationTime),
export const ZoneCondition = st.intersection([ weekday: st.optional(
AutomationConditionNodeBase, st.enums(["mon", "tue", "wed", "thu", "fri", "sat", "sun"])
st.type({ ),
condition: st.literal('zone'), })
zone: st.string(), );
entity_id: EntityId, export const ZoneCondition = st.assign(
state: st.union([st.array(st.string()), st.string()]), AutomationConditionNodeBase,
}) st.type({
]); condition: st.literal("zone"),
zone: st.string(),
entity_id: EntityId,
state: st.union([st.array(st.string()), st.string()]),
})
);
+7 -5
View File
@@ -46,8 +46,9 @@ export const getSubTypeList = <T extends AutomationNodeTypes>(
"or", "or",
"and", "and",
"not", "not",
"numeric_state",
"state", "state",
"device",
"numeric_state",
"template", "template",
"time", "time",
"trigger", "trigger",
@@ -125,7 +126,7 @@ export const getNodeSubType = <T extends AutomationNodeTypes>(
} }
}; };
const TriggerValidators: Record<TriggerType, any> = { export const TriggerValidators: Record<TriggerType, any> = {
homeassistant: v.triggers.AutomationTriggerHA, homeassistant: v.triggers.AutomationTriggerHA,
device: v.triggers.AutomationTriggerDevice, device: v.triggers.AutomationTriggerDevice,
event: v.triggers.AutomationTriggerEvent, event: v.triggers.AutomationTriggerEvent,
@@ -140,7 +141,7 @@ const TriggerValidators: Record<TriggerType, any> = {
zone: v.triggers.AutomationTriggerZone, zone: v.triggers.AutomationTriggerZone,
}; };
const ActionValidators: Record<ActionType, any> = { export const ActionValidators: Record<ActionType, any> = {
choose: v.actions.ChooseAction, choose: v.actions.ChooseAction,
device: v.actions.DeviceAction, device: v.actions.DeviceAction,
event: v.actions.FireEventAction, event: v.actions.FireEventAction,
@@ -149,10 +150,11 @@ const ActionValidators: Record<ActionType, any> = {
wait: st.union([v.actions.DelayAction, v.actions.WaitAction]), wait: st.union([v.actions.DelayAction, v.actions.WaitAction]),
}; };
const ConditionValidators: Record<ConditionType, any> = { export const ConditionValidators: Record<ConditionType, any> = {
and: v.conditions.LogicCondition, and: v.conditions.LogicCondition,
or: v.conditions.LogicCondition, or: v.conditions.LogicCondition,
not: v.conditions.LogicCondition, not: v.conditions.LogicCondition,
device: v.conditions.DeviceCondition,
numeric_state: v.conditions.NumericCondition, numeric_state: v.conditions.NumericCondition,
state: v.conditions.StateCondition, state: v.conditions.StateCondition,
template: v.conditions.TemplateCondition, template: v.conditions.TemplateCondition,
@@ -161,7 +163,7 @@ const ConditionValidators: Record<ConditionType, any> = {
zone: v.conditions.ZoneCondition, zone: v.conditions.ZoneCondition,
}; };
const AllValidators: Record<AutomationNodeTypes, any> = { export const AllValidators: Record<AutomationNodeTypes, any> = {
action: ActionValidators, action: ActionValidators,
condition: ConditionValidators, condition: ConditionValidators,
trigger: TriggerValidators, trigger: TriggerValidators,
+74 -59
View File
@@ -1,62 +1,77 @@
import { AutomationCondition, LogicCondition, NumericCondition, StateCondition, TemplateCondition, TimeCondition, TriggerCondition, ZoneCondition } from "types/automations/conditions"; import {
import { AutomationData } from 'types/automations'; AutomationCondition,
LogicCondition,
NumericCondition,
StateCondition,
TemplateCondition,
TimeCondition,
TriggerCondition,
ZoneCondition,
} from "types/automations/conditions";
import { AutomationData } from "types/automations";
export const getConditionDefaultValues = (
export const getConditionDefaultValues = (condition: AutomationCondition['condition']): AutomationCondition => { condition: AutomationCondition["condition"]
if ( ): AutomationCondition => {
(condition === 'or') || if (condition === "or" || condition === "and" || condition === "not") {
(condition === 'and') || return {
(condition === 'not') condition,
) { conditions: [],
return { } as LogicCondition;
condition, } else if (condition === "template") {
conditions: [] return {
} as LogicCondition condition,
} else if (condition === 'template') { value_template: "",
return { } as TemplateCondition;
condition, } else if (condition === "numeric_state") {
value_template: "" return {
} as TemplateCondition condition,
} else if (condition === 'numeric_state') { entity_id: [],
return { } as NumericCondition;
condition, } else if (condition === "state") {
entity_id: [] return {
} as NumericCondition condition,
} else if (condition === 'state') { entity_id: [],
return { state: [],
condition, } as StateCondition;
entity_id: [], } else if (condition === "time") {
state: [], return {
} as StateCondition condition,
} else if (condition === 'time') { } as TimeCondition;
return { } else if (condition === "trigger") {
condition, return {
} as TimeCondition condition,
} else if (condition === 'trigger') { id: "",
return { } as TriggerCondition;
condition, } else if (condition === "zone") {
id: "" return {
} as TriggerCondition condition,
} else if (condition === 'zone') { zone: "",
return { entity_id: [],
condition, state: [],
zone: "", } as ZoneCondition;
entity_id: [], } else if (condition === "device") {
state: [], return {
} as ZoneCondition condition,
} device_id: "",
throw new Error("NOT IMPLEMENTED!") domain: "",
} type: "",
};
}
return {
condition,
} as any;
};
export const defaultAutomation = (id: string): AutomationData => ({ export const defaultAutomation = (id: string): AutomationData => ({
metadata: { metadata: {
id, id,
alias: "New Automation", alias: "New Automation",
description: "", description: "",
mode: "single", mode: "single",
}, },
tags: {}, tags: {},
trigger: [], trigger: [],
sequence: [], sequence: [],
condition: [], condition: [],
}) });
+34 -15
View File
@@ -1,5 +1,8 @@
import { AutomationNode, AutomationNodeTypes } from "types/automations"; import { AutomationNode, AutomationNodeTypes } from "types/automations";
import { AutomationTime } from "types/automations/common"; import {
AutomationDeviceState,
AutomationTime,
} from "types/automations/common";
export interface Namer { export interface Namer {
getEntityName(entity_id: string | string[], maxEntities?: number): string; getEntityName(entity_id: string | string[], maxEntities?: number): string;
@@ -106,8 +109,10 @@ export const getDescriptionFromAutomationNode = <N extends AutomationNodeTypes>(
return `${namer.getEntityName(node.entity_id)} is '${node.state}'`; return `${namer.getEntityName(node.entity_id)} is '${node.state}'`;
case "template": case "template":
return node.value_template; return node.value_template;
case "device":
return getDescriptionForDeviceType(node, namer, true);
default: default:
return "n/a"; return JSON.stringify(node);
} }
} }
} }
@@ -131,19 +136,7 @@ export const getDescriptionFromAutomationNode = <N extends AutomationNodeTypes>(
return `Trigger ${node.event}`; return `Trigger ${node.event}`;
} }
if ("device_id" in node) { if ("device_id" in node) {
let out = ""; return getDescriptionForDeviceType(node, namer);
if (node.type) {
out += `${prettyName(node.type ?? "")} `;
}
if (node.subtype) {
out += node.subtype + " ";
}
if (node.entity_id) {
out += namer.getEntityName(node.entity_id);
} else if (node.device_id) {
out += namer.getDeviceName(node.device_id);
}
return out;
} }
if ("choose" in node) { if ("choose" in node) {
return "Choose"; return "Choose";
@@ -151,6 +144,32 @@ export const getDescriptionFromAutomationNode = <N extends AutomationNodeTypes>(
return "n/a"; return "n/a";
}; };
const getDescriptionForDeviceType = (
node: AutomationDeviceState,
namer: Namer,
actionToEnd: boolean = false
) => {
let out = "";
let actionPort = "";
if (node.type) {
actionPort += `${prettyName(node.type ?? "")} `;
}
if (node.subtype) {
actionPort += node.subtype;
}
actionPort = actionPort.trim();
if (node.entity_id) {
out += namer.getEntityName(node.entity_id);
} else if (node.device_id) {
out += namer.getDeviceName(node.device_id);
}
out = out.trim();
if (actionToEnd) {
return out + " " + actionPort;
}
return actionPort + " " + out;
};
export const prettyName = (n: string) => { export const prettyName = (n: string) => {
const clean = n.replaceAll(/[.\-_]/g, " "); const clean = n.replaceAll(/[.\-_]/g, " ");
return clean return clean