swagger-typescript-api 13.0.9 → 13.0.11

package/cli/execute.js

@@ -1,180 +0,0 @@
-import didYouMean from "didyoumean";
-import _ from "lodash";
-import { root_command, skip_command } from "./constants.js";
-import { parseArgs } from "./parse-args.js";
-
-didYouMean.threshold = 0.5;
-
-// eslint-disable-next-line no-unused-vars
-const execute = (params, commands, instance) => {
-  const args = parseArgs(params.args, params.from);
-
-  return new Promise((resolve, reject) => {
-    const { command, usageOptions, error } = processArgs(commands, args);
-
-    if (error) {
-      reject(new Error(error));
-      return;
-    }
-
-    if (!usageOptions.length && command.name === root_command) {
-      usageOptions.push(
-        command.options.find((option) => option.flags.name === "help"),
-      );
-    }
-
-    const operationOptions = usageOptions.filter((option) => option.operation);
-    if (operationOptions.length) {
-      operationOptions[0].operation();
-      resolve({
-        command: skip_command,
-        options: {},
-      });
-      return;
-    } else {
-      let error = "";
-
-      const processUserOptionData = (userOption, option) => {
-        if (userOption) {
-          const data = userOption.$data;
-          if (!data.length && !option.flags.value) {
-            return !option.flags.isNoFlag;
-          }
-          if (option.flags.value) {
-            if (option.flags.value.variadic) {
-              return data.reduce((acc, d) => {
-                acc.push(...d.split(",").map(option.flags.value.formatter));
-                return acc;
-              }, []);
-            } else {
-              return option.flags.value.formatter(data[0] || option.default);
-            }
-          }
-        }
-
-        return option.default;
-      };
-
-      const parsedOptionsObject = command.options.reduce((acc, option) => {
-        if (error) return acc;
-
-        const userOption = usageOptions.find(
-          (o) => o.flags.name === option.flags.name,
-        );
-
-        if (!userOption && option.required) {
-          error = `required option '${option.flags.raw}' not specified`;
-          return acc;
-        }
-
-        const flagValue = processUserOptionData(userOption, option);
-        if (!option.operation) {
-          const internal = option.internal || {};
-          acc[internal.name || option.flags.name] = internal.formatter
-            ? internal.formatter(flagValue)
-            : flagValue;
-        }
-
-        return acc;
-      }, {});
-
-      if (error) {
-        reject(new Error(error));
-      } else {
-        resolve({
-          command: command.name === root_command ? null : command.name,
-          options: parsedOptionsObject,
-        });
-      }
-    }
-  });
-};
-
-const processArgs = (commands, args) => {
-  let command = null;
-  let usageOptions = [];
-  let walkingOption = null;
-  let error = "";
-
-  let allFlagKeys = [];
-
-  _.forEach(args, (arg, i) => {
-    if (error) return;
-
-    if (i === 0) {
-      command = commands[arg];
-
-      if (!command && !arg.startsWith("-")) {
-        const tip = didYouMean(arg, _.keys(commands));
-        error = `unknown command ${arg}${
-          tip ? `\n(Did you mean ${tip} ?)` : ""
-        }`;
-      } else if (!command) {
-        command = commands[root_command];
-      }
-
-      if (command) {
-        allFlagKeys = command.options.reduce(
-          (acc, option) => [...acc, ...option.flags.keys],
-          [],
-        );
-      }
-    }
-
-    if (error) return;
-
-    if (arg.startsWith("-")) {
-      const option = command.options.find((option) =>
-        option.flags.keys.includes(arg),
-      );
-
-      if (!option) {
-        const tip = didYouMean(arg, allFlagKeys);
-        error = `unknown option ${arg}${
-          tip ? `\n(Did you mean ${tip} ?)` : ""
-        }`;
-      }
-
-      if (option) {
-        if (walkingOption && walkingOption.flags.name === option.flags.name) {
-          return;
-        }
-        const existedOption = usageOptions.find(
-          (o) => o.flags.name === option.flags.name,
-        );
-        if (existedOption) {
-          walkingOption = existedOption;
-        } else {
-          walkingOption = {
-            ...option,
-            $data: [],
-          };
-          usageOptions.push(walkingOption);
-        }
-      }
-
-      return;
-    }
-
-    if (walkingOption) {
-      walkingOption.$data.push(arg);
-    }
-  });
-  command = command || commands[root_command];
-
-  if (error) {
-    return {
-      command: null,
-      usageOptions: [],
-      error,
-    };
-  }
-
-  return {
-    command,
-    usageOptions,
-    error,
-  };
-};
-
-export { execute };

package/cli/index.js

@@ -1,94 +0,0 @@
-import _ from "lodash";
-import { reservedOptions, root_command } from "./constants.js";
-import { execute } from "./execute.js";
-import { displayHelp } from "./operations/display-help.js";
-import { displayVersion } from "./operations/display-version.js";
-import { processOption } from "./process-option.js";
-
-const cli = (input) => {
-  const commands = {};
-
-  const addCommand = (command, { addVersion = false, addHelp = true } = {}) => {
-    commands[command.name] = {
-      name: command.name,
-      description: `${command.description || ""}`,
-      options: _.compact(_.map(command.options, processOption)),
-    };
-
-    if (addVersion) {
-      commands[command.name].options.unshift(
-        processOption({
-          flags: "-v, --version",
-          description: "output the current version",
-          operation: () => displayVersion(instance),
-        }),
-      );
-    }
-
-    if (addHelp) {
-      commands[command.name].options.push(
-        processOption({
-          flags: "-h, --help",
-          description: "display help for command",
-          operation: () =>
-            displayHelp(commands, instance, commands[command.name]),
-        }),
-      );
-    }
-
-    return instance;
-  };
-
-  const instance = {
-    commands,
-    input,
-    addCommand,
-    execute: (params) => execute(params, commands, instance),
-  };
-
-  addCommand(
-    {
-      name: root_command,
-      options: [],
-    },
-    {
-      addVersion: false,
-      addHelp: false,
-    },
-  );
-
-  _.forEach(input.options, (option) => {
-    const processed = processOption(option);
-
-    if (!processed) return;
-
-    if (reservedOptions.includes(processed.name)) {
-      console.warn("reserved option", processed.name);
-      return;
-    }
-
-    commands[root_command].options.push(processed);
-  });
-
-  commands[root_command].options.unshift(
-    processOption({
-      flags: "-v, --version",
-      description: "output the current version",
-      operation: () => displayVersion(instance),
-    }),
-  );
-
-  commands[root_command].options.push(
-    processOption({
-      flags: "-h, --help",
-      description: "display help for command",
-      operation: () => displayHelp(commands, instance, commands[root_command]),
-    }),
-  );
-
-  _.forEach(input.commands, addCommand);
-
-  return instance;
-};
-
-export { cli };

package/cli/operations/display-help.js

@@ -1,177 +0,0 @@
-import _ from "lodash";
-import { root_command } from "../constants.js";
-
-const generateOptionsOutput = (options) =>
-  options.reduce(
-    (acc, option) => {
-      const flags = `${option.flags.keys.join(", ")}${
-        option.flags.value?.raw ? ` ${option.flags.value?.raw}` : ""
-      }`;
-      const description = `${option.description || ""}${
-        option.default === undefined ||
-        (option.flags.isNoFlag && option.default === true)
-          ? ""
-          : ` (default: ${
-              typeof option.default === "string"
-                ? `"${option.default}"`
-                : option.default
-            })`
-      }`;
-
-      if (flags.length > acc.maxLength) {
-        acc.maxLength = flags.length;
-      }
-
-      acc.options.push({
-        flags,
-        description,
-      });
-      return acc;
-    },
-    {
-      options: [],
-      maxLength: 0,
-    },
-  );
-
-const generateOptionsTextOutput = (options, maxLength, spaces) =>
-  options
-    .map((option) => {
-      const spacesText = Array(spaces).fill(" ").join("");
-      const leftStr = `${spacesText}${option.flags.padEnd(maxLength, " ")}  `;
-      const leftStrFiller = Array(leftStr.length).fill(" ").join("");
-      const descriptionLines = option.description.split("\n");
-
-      return (
-        leftStr +
-        descriptionLines
-          .map((line, i) => {
-            if (i === 0) {
-              return line;
-            }
-
-            return `\n${leftStrFiller}${line}`;
-          })
-          .join("")
-      );
-    })
-    .join("\n");
-
-const displayAllHelp = (commands, instance) => {
-  const { options, maxLength: maxOptionLength } = generateOptionsOutput(
-    commands[root_command].options,
-  );
-
-  const { commands: commandLabels, maxLength: maxCommandLength } = _.filter(
-    commands,
-    (command) => command.name !== root_command,
-  ).reduce(
-    (acc, command) => {
-      const options = generateOptionsOutput(command.options);
-      const name = `${command.name}${options.length ? " [options]" : ""}`;
-      const description = command.description;
-
-      const maxLength = Math.max(name.length, options.maxLength);
-      if (maxLength > acc.maxLength) {
-        acc.maxLength = maxLength;
-      }
-
-      acc.commands.push({
-        description,
-        name,
-        options,
-      });
-      return acc;
-    },
-    {
-      commands: [],
-      maxLength: maxOptionLength,
-    },
-  );
-
-  const optionsOutput = generateOptionsTextOutput(options, maxOptionLength, 2);
-
-  const commandsOutput = commandLabels
-    .map((commandLabel) => {
-      const leftStr = `  ${commandLabel.name.padEnd(
-        maxCommandLength,
-        " ",
-      )}    `;
-      const leftStrFiller = Array(leftStr.length).fill(" ").join("");
-      const descriptionLines = commandLabel.description.split("\n");
-      const optionsTextOutput = generateOptionsTextOutput(
-        commandLabel.options.options,
-        maxCommandLength,
-        4,
-      );
-
-      return (
-        leftStr +
-        descriptionLines
-          .map((line, i) => {
-            if (i === 0) {
-              return line;
-            }
-
-            return `\n${leftStrFiller}${line}`;
-          })
-          .join("") +
-        (optionsTextOutput.length ? `\n${optionsTextOutput}` : "")
-      );
-    })
-    .join("\n");
-
-  const outputTest = [
-    optionsOutput &&
-      `Options:
-${optionsOutput}`,
-    commandsOutput &&
-      `Commands:
-${commandsOutput}`,
-  ]
-    .filter(Boolean)
-    .join("\n\n");
-
-  console.log(`Usage: ${[instance.input.name, instance.input.alias]
-    .filter(Boolean)
-    .join("|")}${optionsOutput ? " [options]" : ""}${
-    commandsOutput ? " [command]" : ""
-  }
-${
-  instance.input.description &&
-  `
-${instance.input.description}`
-}
-
-${outputTest}`);
-};
-
-const displayHelp = (commands, instance, command) => {
-  if (command.name === root_command) return displayAllHelp(commands, instance);
-
-  const { options, maxLength: maxOptionLength } = generateOptionsOutput(
-    command.options,
-  );
-  const optionsOutput = generateOptionsTextOutput(options, maxOptionLength, 2);
-
-  const outputTest = [
-    optionsOutput &&
-      `Options:
-${optionsOutput}`,
-  ]
-    .filter(Boolean)
-    .join("\n\n");
-
-  console.log(`Usage: ${instance.input.name} ${command.name}${
-    optionsOutput ? " [options]" : ""
-  }
-${
-  command.description &&
-  `
-${command.description}`
-}
-
-${outputTest}`);
-};
-
-export { displayHelp };

package/cli/operations/display-version.js

@@ -1,5 +0,0 @@
-const displayVersion = (instance) => {
-  console.log(instance.input.version);
-};
-
-export { displayVersion };

package/cli/parse-args.js

@@ -1,24 +0,0 @@
-const parseArgs = (args, type) => {
-  if (args == null || !Array.isArray(args)) {
-    throw "args should be array";
-  }
-  const argsCopy = args.slice();
-
-  switch (type) {
-    case "electron": {
-      if (process.defaultApp) {
-        return argsCopy.slice(2);
-      }
-
-      return argsCopy.slice(1);
-    }
-    case "user": {
-      return argsCopy;
-    }
-    default: {
-      return argsCopy.slice(2);
-    }
-  }
-};
-
-export { parseArgs };

package/cli/process-option.js

@@ -1,75 +0,0 @@
-import _ from "lodash";
-
-const optionFormatters = {
-  number: (str) => +str,
-  numeric: (str) => +str,
-  str: (str) => `${str}`,
-  string: (str) => `${str}`,
-  bool: (str) => !!str,
-  boolean: (str) => !!str,
-};
-
-const processFlags = (flags) => {
-  let name = null;
-  const keys = [];
-  let value = null;
-  const isNoFlag = flags.includes("--no-");
-
-  _.compact(_.split(flags, " ").map((str) => str.replace(/,/g, ""))).forEach(
-    (str) => {
-      if (str.startsWith("-")) {
-        keys.push(str);
-      } else if (value === null) {
-        if (str.startsWith("{") || str.startsWith("[") || str.startsWith("<")) {
-          const rawValue = str.replace(/[{[<>}\].]/g, "");
-          const variadic = str.includes("...");
-          value = {
-            raw: str,
-            variadic,
-            name: rawValue,
-            formatter: optionFormatters[rawValue] || optionFormatters.string,
-          };
-        }
-      }
-    },
-  );
-
-  const longestKey = keys.slice().sort((a, b) => b.length - a.length)[0];
-
-  if (!_.isEmpty(longestKey)) {
-    name = _.camelCase(
-      (isNoFlag ? longestKey.replace("--no-", "") : longestKey).replace(
-        /(--?)/,
-        "",
-      ),
-    );
-  }
-
-  return {
-    isNoFlag,
-    raw: flags,
-    name,
-    keys,
-    value,
-  };
-};
-
-const processOption = (option) => {
-  const processedFlags = processFlags(option.flags);
-
-  if (!processedFlags.name) {
-    console.warn("invalid option", option);
-    return null;
-  }
-
-  return {
-    required: !!option.required,
-    description: `${option.description || ""}`,
-    default: option.default,
-    flags: processedFlags,
-    operation: option.operation,
-    internal: option.internal,
-  };
-};
-
-export { processOption };