@qodalis/cli-string 0.0.2 → 2.0.0-beta.1

package/public-api.js

@@ -0,0 +1,775 @@
+'use strict';
+
+var cliCore = require('@qodalis/cli-core');
+var _ = require('lodash');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var ___namespace = /*#__PURE__*/_interopNamespace(_);
+
+// src/lib/processors/cli-string-command-processor.ts
+
+// src/lib/version.ts
+var LIBRARY_VERSION = "2.0.0-beta.1";
+var API_VERSION = 2;
+
+// src/lib/processors/cli-string-command-processor.ts
+var lodash = ___namespace.default || ___namespace;
+function stringTransform(command, description, transform, options) {
+  return {
+    command,
+    aliases: options?.aliases,
+    description,
+    acceptsRawInput: true,
+    valueRequired: true,
+    processCommand: async (cmd, context) => {
+      const text = cmd.value || cmd.data || "";
+      const result = transform(text);
+      context.writer.writeln(
+        `${context.writer.wrapInColor("Result: ", cliCore.CliForegroundColor.Yellow)}${result}`
+      );
+      context.process.output(result);
+    },
+    writeDescription: (context) => {
+      const { writer } = context;
+      writer.writeln(description);
+      writer.writeln();
+      writer.writeln("\u{1F4CB} Usage:");
+      writer.writeln(
+        `  ${writer.wrapInColor(`string ${command} <text>`, cliCore.CliForegroundColor.Cyan)}`
+      );
+      if (options?.example) {
+        writer.writeln();
+        writer.writeln("\u{1F4DD} Examples:");
+        writer.writeln(
+          `  string ${command} ${options.example.input.padEnd(20)} ${writer.wrapInColor(`# \u2192 ${options.example.output}`, cliCore.CliForegroundColor.Green)}`
+        );
+      }
+    }
+  };
+}
+var CliStringCommandProcessor = class {
+  constructor() {
+    this.command = "string";
+    this.aliases = ["str"];
+    this.description = "String manipulation commands";
+    this.author = cliCore.DefaultLibraryAuthor;
+    this.version = LIBRARY_VERSION;
+    this.processors = [];
+    this.metadata = {
+      icon: "\u{1F524}",
+      requiredCoreVersion: ">=2.0.0 <3.0.0",
+      requiredCliVersion: ">=2.0.0 <3.0.0"
+    };
+    this.processors = [
+      // -- Case conversions --
+      stringTransform(
+        "upper",
+        "Convert to UPPERCASE",
+        (t) => t.toUpperCase(),
+        {
+          aliases: ["uppercase", "toUpper"],
+          example: { input: "hello world", output: "HELLO WORLD" }
+        }
+      ),
+      stringTransform(
+        "lower",
+        "Convert to lowercase",
+        (t) => t.toLowerCase(),
+        {
+          aliases: ["lowercase", "toLower"],
+          example: { input: "HELLO WORLD", output: "hello world" }
+        }
+      ),
+      stringTransform(
+        "capitalize",
+        "Capitalize the first letter",
+        (t) => lodash.capitalize(t),
+        {
+          aliases: ["cap"],
+          example: { input: "hello world", output: "Hello world" }
+        }
+      ),
+      stringTransform(
+        "camelCase",
+        "Convert to camelCase",
+        (t) => lodash.camelCase(t),
+        {
+          aliases: ["camel"],
+          example: { input: "hello world", output: "helloWorld" }
+        }
+      ),
+      stringTransform(
+        "kebabCase",
+        "Convert to kebab-case",
+        (t) => lodash.kebabCase(t),
+        {
+          aliases: ["kebab"],
+          example: { input: "Hello World", output: "hello-world" }
+        }
+      ),
+      stringTransform(
+        "snakeCase",
+        "Convert to snake_case",
+        (t) => lodash.snakeCase(t),
+        {
+          aliases: ["snake"],
+          example: { input: "Hello World", output: "hello_world" }
+        }
+      ),
+      stringTransform(
+        "startCase",
+        "Convert to Start Case",
+        (t) => lodash.startCase(t),
+        {
+          aliases: ["title", "titleCase"],
+          example: { input: "hello-world", output: "Hello World" }
+        }
+      ),
+      // -- Trimming --
+      stringTransform(
+        "trim",
+        "Remove whitespace from both ends",
+        (t) => t.trim(),
+        {
+          example: { input: '"  hello  "', output: "hello" }
+        }
+      ),
+      stringTransform(
+        "trimStart",
+        "Remove whitespace from the start",
+        (t) => t.trimStart(),
+        {
+          aliases: ["ltrim"],
+          example: { input: '"  hello"', output: "hello" }
+        }
+      ),
+      stringTransform(
+        "trimEnd",
+        "Remove whitespace from the end",
+        (t) => t.trimEnd(),
+        {
+          aliases: ["rtrim"],
+          example: { input: '"hello  "', output: "hello" }
+        }
+      ),
+      // -- Transform --
+      stringTransform(
+        "reverse",
+        "Reverse a string",
+        (t) => [...t].reverse().join(""),
+        {
+          aliases: ["rev"],
+          example: { input: "Hello", output: "olleH" }
+        }
+      ),
+      stringTransform(
+        "slug",
+        "Convert to URL-friendly slug",
+        (t) => t.toLowerCase().normalize("NFD").replace(/[\u0300-\u036f]/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, ""),
+        {
+          aliases: ["slugify"],
+          example: { input: '"Hello World!"', output: "hello-world" }
+        }
+      ),
+      stringTransform(
+        "escape",
+        "Escape HTML entities",
+        (t) => lodash.escape(t),
+        {
+          aliases: ["escapeHtml"],
+          example: {
+            input: '"<b>hi</b>"',
+            output: "&lt;b&gt;hi&lt;/b&gt;"
+          }
+        }
+      ),
+      stringTransform(
+        "unescape",
+        "Unescape HTML entities",
+        (t) => lodash.unescape(t),
+        {
+          aliases: ["unescapeHtml"],
+          example: { input: '"&lt;b&gt;"', output: "<b>" }
+        }
+      ),
+      // -- Repeat --
+      {
+        command: "repeat",
+        description: "Repeat a string N times",
+        acceptsRawInput: true,
+        valueRequired: true,
+        parameters: [
+          {
+            name: "count",
+            aliases: ["n"],
+            description: "Number of repetitions (default: 2)",
+            type: "number",
+            required: false
+          },
+          {
+            name: "separator",
+            aliases: ["sep"],
+            description: "Separator between repetitions (default: none)",
+            type: "string",
+            required: false
+          }
+        ],
+        processCommand: async (command, context) => {
+          const text = command.value || command.data || "";
+          const count = Math.min(
+            parseInt(command.args["count"] || command.args["n"]) || 2,
+            1e3
+          );
+          const sep = command.args["separator"] || command.args["sep"] || "";
+          const result = Array(count).fill(text).join(sep);
+          context.writer.writeln(
+            `${context.writer.wrapInColor("Result: ", cliCore.CliForegroundColor.Yellow)}${result}`
+          );
+          context.process.output(result);
+        },
+        writeDescription: (context) => {
+          const { writer } = context;
+          writer.writeln("Repeat a string multiple times");
+          writer.writeln();
+          writer.writeln("\u{1F4CB} Usage:");
+          writer.writeln(
+            `  ${writer.wrapInColor("string repeat <text> [--count=N] [--sep=S]", cliCore.CliForegroundColor.Cyan)}`
+          );
+          writer.writeln();
+          writer.writeln("\u{1F4DD} Examples:");
+          writer.writeln(
+            `  string repeat ha --count=3        ${writer.wrapInColor("# \u2192 hahaha", cliCore.CliForegroundColor.Green)}`
+          );
+          writer.writeln(
+            `  string repeat ab --n=3 --sep=-    ${writer.wrapInColor("# \u2192 ab-ab-ab", cliCore.CliForegroundColor.Green)}`
+          );
+        }
+      },
+      // -- Replace --
+      {
+        command: "replace",
+        description: "Replace occurrences in a string",
+        acceptsRawInput: true,
+        valueRequired: true,
+        parameters: [
+          {
+            name: "find",
+            aliases: ["f"],
+            description: "Text to find",
+            type: "string",
+            required: true
+          },
+          {
+            name: "with",
+            aliases: ["w"],
+            description: "Replacement text",
+            type: "string",
+            required: true
+          }
+        ],
+        processCommand: async (command, context) => {
+          const text = command.value || command.data || "";
+          const find = command.args["find"] || command.args["f"] || "";
+          const replacement = command.args["with"] || command.args["w"] || "";
+          if (!find) {
+            context.writer.writeError("--find is required");
+            context.process.exit(-1);
+            return;
+          }
+          const result = text.split(find).join(replacement);
+          context.writer.writeln(
+            `${context.writer.wrapInColor("Result: ", cliCore.CliForegroundColor.Yellow)}${result}`
+          );
+          context.process.output(result);
+        },
+        writeDescription: (context) => {
+          const { writer } = context;
+          writer.writeln("Replace all occurrences of a substring");
+          writer.writeln();
+          writer.writeln("\u{1F4CB} Usage:");
+          writer.writeln(
+            `  ${writer.wrapInColor("string replace <text> --find=<search> --with=<replacement>", cliCore.CliForegroundColor.Cyan)}`
+          );
+          writer.writeln();
+          writer.writeln("\u{1F4DD} Examples:");
+          writer.writeln(
+            `  string replace "hello world" --find=world --with=there`
+          );
+          writer.writeln(
+            `  ${writer.wrapInColor("# \u2192 hello there", cliCore.CliForegroundColor.Green)}`
+          );
+        }
+      },
+      // -- Truncate --
+      {
+        command: "truncate",
+        aliases: ["trunc"],
+        description: "Truncate a string to a max length",
+        acceptsRawInput: true,
+        valueRequired: true,
+        parameters: [
+          {
+            name: "length",
+            aliases: ["l"],
+            description: "Maximum length (default: 30)",
+            type: "number",
+            required: false
+          },
+          {
+            name: "suffix",
+            description: "Omission suffix (default: ...)",
+            type: "string",
+            required: false
+          }
+        ],
+        processCommand: async (command, context) => {
+          const text = command.value || command.data || "";
+          const length = parseInt(command.args["length"] || command.args["l"]) || 30;
+          const suffix = command.args["suffix"] ?? "...";
+          const result = text.length > length ? text.substring(0, length - suffix.length) + suffix : text;
+          context.writer.writeln(
+            `${context.writer.wrapInColor("Result: ", cliCore.CliForegroundColor.Yellow)}${result}`
+          );
+          context.process.output(result);
+        },
+        writeDescription: (context) => {
+          const { writer } = context;
+          writer.writeln(
+            "Truncate a string to a maximum length with an ellipsis"
+          );
+          writer.writeln();
+          writer.writeln("\u{1F4CB} Usage:");
+          writer.writeln(
+            `  ${writer.wrapInColor("string truncate <text> [--length=N] [--suffix=S]", cliCore.CliForegroundColor.Cyan)}`
+          );
+        }
+      },
+      // -- Pad --
+      {
+        command: "pad",
+        description: "Pad a string to a target length",
+        acceptsRawInput: true,
+        valueRequired: true,
+        parameters: [
+          {
+            name: "length",
+            aliases: ["l"],
+            description: "Target length",
+            type: "number",
+            required: true
+          },
+          {
+            name: "char",
+            aliases: ["c"],
+            description: "Padding character (default: space)",
+            type: "string",
+            required: false
+          },
+          {
+            name: "side",
+            description: "Pad side: left, right, both (default: both)",
+            type: "string",
+            required: false
+          }
+        ],
+        processCommand: async (command, context) => {
+          const text = command.value || command.data || "";
+          const length = parseInt(
+            command.args["length"] || command.args["l"]
+          );
+          const char = command.args["char"] || command.args["c"] || " ";
+          const side = command.args["side"] || "both";
+          if (isNaN(length)) {
+            context.writer.writeError("--length is required");
+            context.process.exit(-1);
+            return;
+          }
+          let result;
+          switch (side) {
+            case "left":
+            case "start":
+              result = text.padStart(length, char);
+              break;
+            case "right":
+            case "end":
+              result = text.padEnd(length, char);
+              break;
+            default:
+              result = lodash.pad(text, length, char);
+              break;
+          }
+          context.writer.writeln(
+            `${context.writer.wrapInColor("Result: ", cliCore.CliForegroundColor.Yellow)}"${result}"`
+          );
+          context.process.output(result);
+        },
+        writeDescription: (context) => {
+          const { writer } = context;
+          writer.writeln("Pad a string to a target length");
+          writer.writeln();
+          writer.writeln("\u{1F4CB} Usage:");
+          writer.writeln(
+            `  ${writer.wrapInColor("string pad <text> --length=N [--char=C] [--side=left|right|both]", cliCore.CliForegroundColor.Cyan)}`
+          );
+          writer.writeln();
+          writer.writeln("\u{1F4DD} Examples:");
+          writer.writeln(
+            `  string pad hello --length=10 --char=. --side=right`
+          );
+          writer.writeln(
+            `  ${writer.wrapInColor('# \u2192 "hello....."', cliCore.CliForegroundColor.Green)}`
+          );
+        }
+      },
+      // -- Split --
+      {
+        command: "split",
+        description: "Split a string by a delimiter",
+        acceptsRawInput: true,
+        valueRequired: true,
+        parameters: [
+          {
+            name: "by",
+            aliases: ["d", "delimiter"],
+            description: "Delimiter to split by (default: space)",
+            type: "string",
+            required: false
+          }
+        ],
+        processCommand: async (command, context) => {
+          const text = command.value || command.data || "";
+          const delimiter = command.args["by"] || command.args["d"] || command.args["delimiter"] || " ";
+          const parts = text.split(delimiter);
+          const { writer } = context;
+          parts.forEach((part, i) => {
+            writer.writeln(
+              `  ${writer.wrapInColor(String(i).padStart(3), cliCore.CliForegroundColor.Yellow)}  ${part}`
+            );
+          });
+          context.process.output(parts);
+        },
+        writeDescription: (context) => {
+          const { writer } = context;
+          writer.writeln("Split a string into parts by a delimiter");
+          writer.writeln();
+          writer.writeln("\u{1F4CB} Usage:");
+          writer.writeln(
+            `  ${writer.wrapInColor("string split <text> [--by=<delimiter>]", cliCore.CliForegroundColor.Cyan)}`
+          );
+          writer.writeln();
+          writer.writeln("\u{1F4DD} Examples:");
+          writer.writeln(
+            `  string split "a,b,c" --by=,      ${writer.wrapInColor("# \u2192 a  b  c", cliCore.CliForegroundColor.Green)}`
+          );
+        }
+      },
+      // -- Words --
+      {
+        command: "words",
+        description: "Split a string into words",
+        acceptsRawInput: true,
+        valueRequired: true,
+        processCommand: async (command, context) => {
+          const text = command.value || command.data || "";
+          const words = lodash.words(text);
+          const { writer } = context;
+          writer.writeln(
+            `${writer.wrapInColor(`${words.length} words:`, cliCore.CliForegroundColor.Yellow)} ${words.join(", ")}`
+          );
+          context.process.output(words);
+        },
+        writeDescription: (context) => {
+          const { writer } = context;
+          writer.writeln("Split a string into its component words");
+          writer.writeln();
+          writer.writeln("\u{1F4CB} Usage:");
+          writer.writeln(
+            `  ${writer.wrapInColor("string words <text>", cliCore.CliForegroundColor.Cyan)}`
+          );
+          writer.writeln();
+          writer.writeln("\u{1F4DD} Examples:");
+          writer.writeln(
+            `  string words "helloWorld"         ${writer.wrapInColor("# \u2192 hello, World", cliCore.CliForegroundColor.Green)}`
+          );
+          writer.writeln(
+            `  string words "foo-bar_baz"        ${writer.wrapInColor("# \u2192 foo, bar, baz", cliCore.CliForegroundColor.Green)}`
+          );
+        }
+      },
+      // -- Analysis --
+      {
+        command: "length",
+        aliases: ["len"],
+        description: "Get the length of a string",
+        acceptsRawInput: true,
+        valueRequired: true,
+        processCommand: async (command, context) => {
+          const text = command.value || command.data || "";
+          context.writer.writeln(
+            `${context.writer.wrapInColor("Result: ", cliCore.CliForegroundColor.Yellow)}${text.length}`
+          );
+          context.process.output(text.length);
+        },
+        writeDescription: (context) => {
+          const { writer } = context;
+          writer.writeln("Get the character count of a string");
+          writer.writeln();
+          writer.writeln("\u{1F4CB} Usage:");
+          writer.writeln(
+            `  ${writer.wrapInColor("string length <text>", cliCore.CliForegroundColor.Cyan)}`
+          );
+        }
+      },
+      {
+        command: "wc",
+        aliases: ["wordcount", "count"],
+        description: "Count lines, words, characters, and bytes",
+        acceptsRawInput: true,
+        valueRequired: true,
+        processCommand: async (command, context) => {
+          const text = command.value || command.data || "";
+          const { writer } = context;
+          const lines = text.split(/\r?\n/).length;
+          const wordCount = text.trim() ? text.trim().split(/\s+/).length : 0;
+          const chars = text.length;
+          const bytes = new TextEncoder().encode(text).length;
+          writer.writeln(
+            `  ${writer.wrapInColor("Lines:", cliCore.CliForegroundColor.Cyan)}       ${lines}`
+          );
+          writer.writeln(
+            `  ${writer.wrapInColor("Words:", cliCore.CliForegroundColor.Cyan)}       ${wordCount}`
+          );
+          writer.writeln(
+            `  ${writer.wrapInColor("Characters:", cliCore.CliForegroundColor.Cyan)}  ${chars}`
+          );
+          writer.writeln(
+            `  ${writer.wrapInColor("Bytes:", cliCore.CliForegroundColor.Cyan)}       ${bytes}`
+          );
+          context.process.output({
+            lines,
+            words: wordCount,
+            chars,
+            bytes
+          });
+        },
+        writeDescription: (context) => {
+          const { writer } = context;
+          writer.writeln(
+            "Count lines, words, characters, and bytes in text"
+          );
+          writer.writeln();
+          writer.writeln("\u{1F4CB} Usage:");
+          writer.writeln(
+            `  ${writer.wrapInColor("string wc <text>", cliCore.CliForegroundColor.Cyan)}`
+          );
+        }
+      },
+      {
+        command: "includes",
+        aliases: ["contains", "has"],
+        description: "Check if a string contains a substring",
+        acceptsRawInput: true,
+        valueRequired: true,
+        parameters: [
+          {
+            name: "find",
+            aliases: ["f"],
+            description: "Substring to search for",
+            type: "string",
+            required: true
+          }
+        ],
+        processCommand: async (command, context) => {
+          const text = command.value || command.data || "";
+          const find = command.args["find"] || command.args["f"] || "";
+          const result = text.includes(find);
+          const { writer } = context;
+          if (result) {
+            writer.writeSuccess(`"${find}" found in string`);
+          } else {
+            writer.writeError(`"${find}" not found in string`);
+          }
+          context.process.output(result);
+        },
+        writeDescription: (context) => {
+          const { writer } = context;
+          writer.writeln(
+            "Check if a string contains a given substring"
+          );
+          writer.writeln();
+          writer.writeln("\u{1F4CB} Usage:");
+          writer.writeln(
+            `  ${writer.wrapInColor("string includes <text> --find=<substring>", cliCore.CliForegroundColor.Cyan)}`
+          );
+        }
+      },
+      {
+        command: "startsWith",
+        description: "Check if a string starts with a prefix",
+        acceptsRawInput: true,
+        valueRequired: true,
+        parameters: [
+          {
+            name: "find",
+            aliases: ["f"],
+            description: "Prefix to check",
+            type: "string",
+            required: true
+          }
+        ],
+        processCommand: async (command, context) => {
+          const text = command.value || command.data || "";
+          const find = command.args["find"] || command.args["f"] || "";
+          const result = text.startsWith(find);
+          const { writer } = context;
+          writer.writeln(
+            `${writer.wrapInColor("Result: ", cliCore.CliForegroundColor.Yellow)}${result}`
+          );
+          context.process.output(result);
+        },
+        writeDescription: (context) => {
+          const { writer } = context;
+          writer.writeln(
+            "Check if a string starts with a given prefix"
+          );
+          writer.writeln();
+          writer.writeln("\u{1F4CB} Usage:");
+          writer.writeln(
+            `  ${writer.wrapInColor("string startsWith <text> --find=<prefix>", cliCore.CliForegroundColor.Cyan)}`
+          );
+        }
+      },
+      {
+        command: "endsWith",
+        description: "Check if a string ends with a suffix",
+        acceptsRawInput: true,
+        valueRequired: true,
+        parameters: [
+          {
+            name: "find",
+            aliases: ["f"],
+            description: "Suffix to check",
+            type: "string",
+            required: true
+          }
+        ],
+        processCommand: async (command, context) => {
+          const text = command.value || command.data || "";
+          const find = command.args["find"] || command.args["f"] || "";
+          const result = text.endsWith(find);
+          const { writer } = context;
+          writer.writeln(
+            `${writer.wrapInColor("Result: ", cliCore.CliForegroundColor.Yellow)}${result}`
+          );
+          context.process.output(result);
+        },
+        writeDescription: (context) => {
+          const { writer } = context;
+          writer.writeln(
+            "Check if a string ends with a given suffix"
+          );
+          writer.writeln();
+          writer.writeln("\u{1F4CB} Usage:");
+          writer.writeln(
+            `  ${writer.wrapInColor("string endsWith <text> --find=<suffix>", cliCore.CliForegroundColor.Cyan)}`
+          );
+        }
+      }
+    ];
+  }
+  async processCommand(command, context) {
+    context.executor.showHelp(command, context);
+  }
+  writeDescription(context) {
+    const { writer } = context;
+    writer.writeln("String manipulation and analysis commands");
+    writer.writeln();
+    writer.writeln(
+      writer.wrapInColor(
+        "\u{1F520} Case Conversions:",
+        cliCore.CliForegroundColor.Yellow
+      )
+    );
+    writer.writeln(
+      `  ${writer.wrapInColor("string upper", cliCore.CliForegroundColor.Cyan)} / ${writer.wrapInColor("lower", cliCore.CliForegroundColor.Cyan)} / ${writer.wrapInColor("capitalize", cliCore.CliForegroundColor.Cyan)}`
+    );
+    writer.writeln(
+      `  ${writer.wrapInColor("string camelCase", cliCore.CliForegroundColor.Cyan)} / ${writer.wrapInColor("kebabCase", cliCore.CliForegroundColor.Cyan)} / ${writer.wrapInColor("snakeCase", cliCore.CliForegroundColor.Cyan)} / ${writer.wrapInColor("startCase", cliCore.CliForegroundColor.Cyan)}`
+    );
+    writer.writeln();
+    writer.writeln(
+      writer.wrapInColor("\u{1F527} Transform:", cliCore.CliForegroundColor.Yellow)
+    );
+    writer.writeln(
+      `  ${writer.wrapInColor("string reverse", cliCore.CliForegroundColor.Cyan)} / ${writer.wrapInColor("trim", cliCore.CliForegroundColor.Cyan)} / ${writer.wrapInColor("slug", cliCore.CliForegroundColor.Cyan)} / ${writer.wrapInColor("repeat", cliCore.CliForegroundColor.Cyan)} / ${writer.wrapInColor("replace", cliCore.CliForegroundColor.Cyan)} / ${writer.wrapInColor("truncate", cliCore.CliForegroundColor.Cyan)}`
+    );
+    writer.writeln(
+      `  ${writer.wrapInColor("string pad", cliCore.CliForegroundColor.Cyan)} / ${writer.wrapInColor("escape", cliCore.CliForegroundColor.Cyan)} / ${writer.wrapInColor("unescape", cliCore.CliForegroundColor.Cyan)}`
+    );
+    writer.writeln();
+    writer.writeln(
+      writer.wrapInColor("\u{1F50D} Analysis:", cliCore.CliForegroundColor.Yellow)
+    );
+    writer.writeln(
+      `  ${writer.wrapInColor("string length", cliCore.CliForegroundColor.Cyan)} / ${writer.wrapInColor("wc", cliCore.CliForegroundColor.Cyan)} / ${writer.wrapInColor("includes", cliCore.CliForegroundColor.Cyan)} / ${writer.wrapInColor("startsWith", cliCore.CliForegroundColor.Cyan)} / ${writer.wrapInColor("endsWith", cliCore.CliForegroundColor.Cyan)}`
+    );
+    writer.writeln(
+      `  ${writer.wrapInColor("string split", cliCore.CliForegroundColor.Cyan)} / ${writer.wrapInColor("words", cliCore.CliForegroundColor.Cyan)}`
+    );
+    writer.writeln();
+    writer.writeln("\u{1F4DD} Examples:");
+    writer.writeln(
+      `  string camelCase "hello world"       ${writer.wrapInColor("# \u2192 helloWorld", cliCore.CliForegroundColor.Green)}`
+    );
+    writer.writeln(
+      `  string reverse Hello                 ${writer.wrapInColor("# \u2192 olleH", cliCore.CliForegroundColor.Green)}`
+    );
+    writer.writeln(
+      `  string slug "Hello World!"           ${writer.wrapInColor("# \u2192 hello-world", cliCore.CliForegroundColor.Green)}`
+    );
+    writer.writeln(
+      `  string wc "some text here"           ${writer.wrapInColor("# word/char counts", cliCore.CliForegroundColor.Green)}`
+    );
+  }
+};
+
+// src/public-api.ts
+var stringModule = {
+  apiVersion: API_VERSION,
+  name: "@qodalis/cli-string",
+  processors: [new CliStringCommandProcessor()],
+  translations: {
+    es: { "cli.string.description": "Utilidades de transformaci\xF3n de cadenas" },
+    fr: { "cli.string.description": "Utilitaires de transformation de cha\xEEnes" },
+    de: { "cli.string.description": "Zeichenketten-Transformationswerkzeuge" },
+    pt: { "cli.string.description": "Utilit\xE1rios de transforma\xE7\xE3o de strings" },
+    it: { "cli.string.description": "Utilit\xE0 di trasformazione stringhe" },
+    ja: { "cli.string.description": "\u6587\u5B57\u5217\u5909\u63DB\u30E6\u30FC\u30C6\u30A3\u30EA\u30C6\u30A3" },
+    ko: { "cli.string.description": "\uBB38\uC790\uC5F4 \uBCC0\uD658 \uC720\uD2F8\uB9AC\uD2F0" },
+    zh: { "cli.string.description": "\u5B57\u7B26\u4E32\u8F6C\u6362\u5DE5\u5177" },
+    ru: { "cli.string.description": "\u0423\u0442\u0438\u043B\u0438\u0442\u044B \u043F\u0440\u0435\u043E\u0431\u0440\u0430\u0437\u043E\u0432\u0430\u043D\u0438\u044F \u0441\u0442\u0440\u043E\u043A" },
+    ro: { "cli.string.description": "Utilitare de transformare a \u0219irurilor de caractere" }
+  }
+};
+
+exports.CliStringCommandProcessor = CliStringCommandProcessor;
+exports.stringModule = stringModule;
+//# sourceMappingURL=public-api.js.map
+//# sourceMappingURL=public-api.js.map