value: convertArgDefaultText()

in src/web/src/views/workspace/WSEditorCommandArgumentsContent.tsx [855:989]
121 lines of code
18 McCabe index (conditional complexity)

            value: convertArgDefaultText(defaultValue!, argType),
          };
        } catch (err: any) {
          setInvalidText(`Field 'Default Value' is invalid: ${err.message}.`);
          return undefined;
        }
        if (props.arg.default !== undefined && props.arg.default.value === argDefault.value) {
          argDefault = undefined;
        }
      }
    }

    let argPrompt = undefined;
    if (hasPrompt === false) {
      if (props.arg.prompt !== undefined) {
        argPrompt = null;
      }
    } else if (hasPrompt === true) {
      if (promptMsg === undefined) {
        setInvalidText(`Field 'Prompt Message' is undefined.`);
        return undefined;
      } else {
        const msg = promptMsg.trim();
        if (msg.length < 1) {
          setInvalidText(`Field 'Prompt Message' is empty.`);
          return undefined;
        }
        if (!msg.endsWith(":")) {
          setInvalidText(`Field 'Prompt Message' must end with a colon.`);
          return undefined;
        }
        argPrompt = {
          msg: msg,
          confirm: promptConfirm,
        };
      }
    }

    return {
      options: names,
      singularOptions: sNames,
      stage: stage,
      group: gName,
      hide: hide,
      help: {
        short: sHelp,
        lines: lines,
      },
      default: argDefault,
      prompt: argPrompt,
      configurationKey: argCfgKey,
      supportEnumExtension: supportEnumExtension,
    };
  };

  const handleModify = async () => {
    const data = verifyModification();
    if (data === undefined) {
      return;
    }

    setUpdating(true);

    const argumentUrl = `${props.commandUrl}/Arguments/${props.arg.var}`;

    try {
      await axios.patch(argumentUrl, {
        ...data,
      });
      setUpdating(false);
      await props.onClose(true);
    } catch (err: any) {
      console.error(err);
      if (err.response?.data?.message) {
        const data = err.response!.data!;
        setInvalidText(`ResponseError: ${data.message!}: ${JSON.stringify(data.details)}`);
      }
      setUpdating(false);
    }
  };

  const handleDisplaySimilar = () => {
    if (verifyModification() === undefined) {
      return;
    }

    setUpdating(true);

    const similarUrl = `${props.commandUrl}/Arguments/${props.arg.var}/FindSimilar`;
    axios
      .post(similarUrl)
      .then((res) => {
        setUpdating(false);
        const { tree, expandedIds } = BuildArgSimilarTree(res);
        setArgSimilarTree(tree);
        setArgSimilarTreeExpandedIds(expandedIds);
        setArgSimilarTreeArgIdsUpdated([]);
      })
      .catch((err) => {
        console.error(err);
        if (err.response?.data?.message) {
          const data = err.response!.data!;
          setInvalidText(`ResponseError: ${data.message!}: ${JSON.stringify(data.details)}`);
        }
        setUpdating(false);
      });
  };

  const handleDisableSimilar = () => {
    setArgSimilarTree(undefined);
    setArgSimilarTreeExpandedIds([]);
  };

  const onSimilarTreeUpdated = (newTree: ArgSimilarTree) => {
    setArgSimilarTree(newTree);
  };

  const onSimilarTreeExpandedIdsUpdated = (expandedIds: string[]) => {
    setArgSimilarTreeExpandedIds(expandedIds);
  };

  const handleModifySimilar = async () => {
    const data = verifyModification();
    if (data === undefined) {
      return;
    }

    setUpdating(true);
    let invalidText = "";
    const updatedIds: string[] = [...argSimilarTreeArgIdsUpdated];
    for (const idx in argSimilarTree!.selectedArgIds) {
      const argId = argSimilarTree!.selectedArgIds[idx];
      if (updatedIds.indexOf(argId) === -1) {
        try {
          await axios.patch(argId, {