import { Dispatch, SetStateAction, useEffect, useState } from "react"; import { AutomationNode, AutomationNodeTypes } from "types/automations"; import { AutomationNodeSubtype } from "types/automations"; import { getOptionManager } from "./getOptionManager"; import { getNodeSubType, getSubTypeList, validateNode, } from "utils/automations"; import InputYaml from "components/Inputs/Base/InputYaml"; import InputText from "components/Inputs/Base/InputText"; import { getDescriptionFromAutomationNode } from "utils/formatting"; import { useHA } from "services/haService"; import { Generic } from "./Generic"; import { getNodeTypeAndValidate } from "utils/automations"; import { useLang } from "services/lang"; type UseState = (s: S) => [S, Dispatch>]; export const useEditorNodeState = ( originalNode: AutomationNode, allowedTypes: AutomationNodeTypes[], createMode: boolean, uState: UseState = useState ) => { // state const langStore = useLang(); const [allState, setAllState] = uState({ yamlMode: false, isModified: false, ...computeInvalidYaml(originalNode, allowedTypes), }); const ha = useHA(); // aliases const { node: currentNode, isModified, yamlMode, invalidManualYaml, } = allState; // effects useEffect(() => { setAllState({ ...allState, node: originalNode, isModified: false }); // eslint-disable-next-line }, [originalNode]); // function aliases const setState = (node: AutomationNode) => setAllState({ ...allState, node, isModified: JSON.stringify(node) !== JSON.stringify(originalNode), }); const setYamlMode = (yamlMode: boolean) => setAllState({ ...allState, yamlMode }); const setStateForManualYaml = (yaml: any) => { setAllState({ ...allState, ...computeInvalidYaml(yaml, allowedTypes), isModified: true, }); }; // value aliases const { originalNodeType, originalNodeSubType, nodeType, subType, subTypes, optionManager, } = createData(originalNode, currentNode, allowedTypes); // publuc return { nodeType, subType, subTypes, setYamlMode, invalidManualYaml, isModified, isErrored: allState.isErrored, get prettyNodeType() { if (nodeType) { return `${langStore.get(nodeType.toUpperCase())} ${langStore.get( "TYPE" )}`; } else { return "n/a"; } }, get yamlMode() { return allState.isErrored || yamlMode; }, get data() { return currentNode; }, setEnabled(enabled: boolean) { setState({ ...currentNode, enabled, }); }, renderOptionList() { let aliasEditor = <>; if (nodeType === "trigger") { aliasEditor = ( setState({ ...allState.node, id, } as any) } /> ); } if (nodeType === "action") { aliasEditor = ( setState({ ...allState.node, alias, } as any) } /> ); } if (yamlMode || allState.isErrored) { return ( <> {aliasEditor} ); } return ( <> {aliasEditor} {"renderOptionList" in optionManager ? ( optionManager.renderOptionList(currentNode, setState, ha.entities) ) : ( )} ); }, isReady() { return optionManager.isReady(currentNode); }, setNodeType(newType: AutomationNodeTypes) { if (newType === originalNodeType) { setState(originalNode); } else { setState( getOptionManager(newType, getSubTypeList(newType)[0]).defaultState() ); } }, setSubType(newSubType: AutomationNodeSubtype) { if (newSubType === originalNodeSubType) { setState(originalNode); } else { if (nodeType) { setState( getOptionManager(nodeType, newSubType as any).defaultState() ); } else { setState( getOptionManager(allowedTypes[0], newSubType as any).defaultState() ); } } }, }; }; const createData = ( originalNode: AutomationNode, currentNode: AutomationNode, allowedTypes: AutomationNodeTypes[] ) => { let originalNodeType: AutomationNodeTypes = allowedTypes[0]; let originalNodeSubType: AutomationNodeSubtype | null = null; let nodeType: AutomationNodeTypes = originalNodeType; let subType: AutomationNodeSubtype | null = originalNodeSubType; let subTypes: AutomationNodeSubtype[] = getSubTypeList(allowedTypes[0]); let optionManager = Generic; try { originalNodeType = getNodeTypeAndValidate(originalNode, allowedTypes); originalNodeSubType = getNodeSubType(originalNode); } catch (err) { console.error(`ORIGINAL NODE ERROR ${JSON.stringify(originalNode)}`); } try { nodeType = getNodeTypeAndValidate(currentNode, allowedTypes); subType = getNodeSubType(currentNode); subTypes = getSubTypeList(nodeType); optionManager = getOptionManager(nodeType, subType as any); } catch (err) { console.error(`CURRENT NODE ERROR ${JSON.stringify(currentNode)}`); } return { originalNodeType, originalNodeSubType, nodeType, subType, subTypes, optionManager, }; }; const computeInvalidYaml = ( node: AutomationNode, allowedNodeTypes: AutomationNodeTypes[] ) => { const errors = validateNode(node, allowedNodeTypes); if (errors) { console.warn({ errors }); return { node, isErrored: true, invalidManualYaml: (
    {errors.map(({ message, path }, i) => (
  • {path}: {message}
  • ))}
), }; } else { return { node, isErrored: false, invalidManualYaml: <>, }; } };