swagger-typescript-api 13.0.9 → 13.0.10

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 };