new-branch 0.2.0 → 0.3.0

package/dist/pattern/transforms/camel.js

@@ -0,0 +1,25 @@
+import { splitWords, upperFirst } from "./helpers/words.js";
+/**
+ * Transform: camel
+ *
+ * Converts an input string into camelCase. Uses `splitWords` to extract word
+ * boundaries and lower-cases the words before joining. The first word is kept
+ * in lower-case; subsequent words are capitalized using `upperFirst`.
+ *
+ * Examples:
+ * - "My Task" -> "myTask"
+ * - "HTTP Server" -> "httpServer"
+ */
+export const camel = {
+    name: "camel",
+    fn: (value) => {
+        const words = splitWords(value).map((w) => w.toLowerCase());
+        if (!words.length)
+            return "";
+        return words[0] + words.slice(1).map(upperFirst).join("");
+    },
+    doc: {
+        summary: "Converts value to camelCase.",
+        usage: ["{title:camel}"],
+    },
+};

package/dist/pattern/transforms/camel.test.js

@@ -0,0 +1,13 @@
+import { describe, it, expect } from "vitest";
+import { camel } from "./camel.js";
+describe("camel transform", () => {
+    it("converts spaced text to camelCase", () => {
+        expect(camel.fn("My Task", [])).toBe("myTask");
+    });
+    it("handles punctuation and multiple separators", () => {
+        expect(camel.fn("hello-world_test", [])).toBe("helloWorldTest");
+    });
+    it("returns empty string for empty input", () => {
+        expect(camel.fn("", [])).toBe("");
+    });
+});

package/dist/pattern/transforms/helpers/words.js

@@ -0,0 +1,64 @@
+/**
+ * Splits an input string into word-like segments.
+ *
+ * The function attempts to be Unicode-aware and supports the following
+ * heuristics for identifying boundaries:
+ * - Splits on any run of non-letter/number characters (spaces, punctuation).
+ * - Inserts boundaries for camelCase (e.g. `myTask` -> `my Task`).
+ * - Inserts a boundary between an ALL-CAPS acronym and a following
+ *   capitalized word (e.g. `HTTPServer` -> `HTTP Server`).
+ *
+ * Returned words are trimmed and empty segments are discarded.
+ *
+ * @example
+ * splitWords("myTask") // => ["my", "Task"]
+ * splitWords("HTTPServer") // => ["HTTP", "Server"]
+ * splitWords("Título grande") // => ["Título", "grande"]
+ *
+ * @param input - The string to split into words.
+ * @returns An array of word segments (possibly empty).
+ */
+export function splitWords(input) {
+    const cleaned = input.trim();
+    if (!cleaned)
+        return [];
+    const withBoundaries = cleaned
+        // camelCase boundary: myTask -> my Task
+        .replace(/(\p{Ll}|\p{N})(\p{Lu})/gu, "$1 $2")
+        // ALLCAPS followed by lowercase: HTTPServer -> HTTP Server
+        .replace(/(\p{Lu})(\p{Lu}\p{Ll})/gu, "$1 $2");
+    return withBoundaries
+        .split(/[^\p{L}\p{N}]+/u)
+        .map((w) => w.trim())
+        .filter(Boolean);
+}
+/**
+ * Upper-cases the first character of the provided string.
+ *
+ * Does not modify the remainder of the string.
+ *
+ * @example
+ * upperFirst("hello") // => "Hello"
+ * upperFirst("") // => ""
+ *
+ * @param s - Input string.
+ * @returns String with the first character upper-cased (if present).
+ */
+export function upperFirst(s) {
+    return s.length ? s[0].toUpperCase() + s.slice(1) : s;
+}
+/**
+ * Lower-cases the first character of the provided string.
+ *
+ * Does not modify the remainder of the string.
+ *
+ * @example
+ * lowerFirst("Hello") // => "hello"
+ * lowerFirst("") // => ""
+ *
+ * @param s - Input string.
+ * @returns String with the first character lower-cased (if present).
+ */
+export function lowerFirst(s) {
+    return s.length ? s[0].toLowerCase() + s.slice(1) : s;
+}

package/dist/pattern/transforms/helpers/words.test.js

@@ -0,0 +1,35 @@
+import { describe, it, expect } from "vitest";
+import { splitWords, upperFirst, lowerFirst } from "./words.js";
+describe("splitWords", () => {
+    it("returns empty array for empty or whitespace-only input", () => {
+        expect(splitWords("")).toEqual([]);
+        expect(splitWords("   ")).toEqual([]);
+    });
+    it("splits on separators and trims words", () => {
+        expect(splitWords("hello world-test")).toEqual(["hello", "world", "test"]);
+        expect(splitWords("  leading  and  trailing  ")).toEqual(["leading", "and", "trailing"]);
+    });
+    it("handles camelCase boundaries", () => {
+        expect(splitWords("myTask")).toEqual(["my", "Task"]);
+        expect(splitWords("version2Beta")).toEqual(["version2", "Beta"]);
+    });
+    it("handles ALLCAPS followed by capitalized word", () => {
+        expect(splitWords("HTTPServer")).toEqual(["HTTP", "Server"]);
+        expect(splitWords("XMLHttpRequest")).toEqual(["XML", "Http", "Request"]);
+    });
+    it("keeps Unicode letters and accents", () => {
+        expect(splitWords("Título grande")).toEqual(["Título", "grande"]);
+    });
+});
+describe("upperFirst / lowerFirst", () => {
+    it("upperFirst capitalizes only the first character", () => {
+        expect(upperFirst("hello")).toBe("Hello");
+        expect(upperFirst("")).toBe("");
+        expect(upperFirst("éclair")).toBe("Éclair");
+    });
+    it("lowerFirst lowercases only the first character", () => {
+        expect(lowerFirst("Hello")).toBe("hello");
+        expect(lowerFirst("")).toBe("");
+        expect(lowerFirst("Éclair")).toBe("éclair");
+    });
+});

package/dist/pattern/transforms/kebab.js

@@ -0,0 +1,19 @@
+import { splitWords } from "./helpers/words.js";
+/**
+ * Transform: kebab
+ *
+ * Converts an input string into kebab-case (lowercased words joined with
+ * hyphens). Uses `splitWords` to determine word boundaries.
+ *
+ * Example: "My Task" -> "my-task"
+ */
+export const kebab = {
+    name: "kebab",
+    fn: (value) => splitWords(value)
+        .map((w) => w.toLowerCase())
+        .join("-"),
+    doc: {
+        summary: "Converts value to kebab-case.",
+        usage: ["{title:kebab}"],
+    },
+};

package/dist/pattern/transforms/kebab.test.js

@@ -0,0 +1,13 @@
+import { describe, it, expect } from "vitest";
+import { kebab } from "./kebab.js";
+describe("kebab transform", () => {
+    it("converts spaced text to kebab-case", () => {
+        expect(kebab.fn("My Task", [])).toBe("my-task");
+    });
+    it("handles camelCase and punctuation", () => {
+        expect(kebab.fn("myTaskHTTP Server", [])).toBe("my-task-http-server");
+    });
+    it("returns empty string for empty input", () => {
+        expect(kebab.fn("", [])).toBe("");
+    });
+});

package/dist/pattern/transforms/snake.js

@@ -0,0 +1,19 @@
+import { splitWords } from "./helpers/words.js";
+/**
+ * Transform: snake
+ *
+ * Converts an input string into snake_case (lowercased words joined with
+ * underscores). Uses `splitWords` to determine boundaries.
+ *
+ * Example: "My Task" -> "my_task"
+ */
+export const snake = {
+    name: "snake",
+    fn: (value) => splitWords(value)
+        .map((w) => w.toLowerCase())
+        .join("_"),
+    doc: {
+        summary: "Converts value to snake_case.",
+        usage: ["{title:snake}"],
+    },
+};

package/dist/pattern/transforms/snake.test.js

@@ -0,0 +1,13 @@
+import { describe, it, expect } from "vitest";
+import { snake } from "./snake.js";
+describe("snake transform", () => {
+    it("converts spaced text to snake_case", () => {
+        expect(snake.fn("My Task", [])).toBe("my_task");
+    });
+    it("handles camelCase and punctuation", () => {
+        expect(snake.fn("myTaskHTTP Server", [])).toBe("my_task_http_server");
+    });
+    it("returns empty string for empty input", () => {
+        expect(snake.fn("", [])).toBe("");
+    });
+});

package/dist/pattern/transforms/title.js

@@ -0,0 +1,19 @@
+import { splitWords, upperFirst } from "./helpers/words.js";
+/**
+ * Transform: title
+ *
+ * Converts an input string into Title Case where each word's first
+ * character is upper-cased and the remainder lower-cased. Uses `splitWords`.
+ *
+ * Example: "hello WORLD" -> "Hello World"
+ */
+export const title = {
+    name: "title",
+    fn: (value) => splitWords(value)
+        .map((w) => upperFirst(w.toLowerCase()))
+        .join(" "),
+    doc: {
+        summary: "Converts value to Title Case.",
+        usage: ["{title:title}"],
+    },
+};

package/dist/pattern/transforms/title.test.js

@@ -0,0 +1,13 @@
+import { describe, it, expect } from "vitest";
+import { title } from "./title.js";
+describe("title transform", () => {
+    it("converts text to Title Case", () => {
+        expect(title.fn("hello WORLD", [])).toBe("Hello World");
+    });
+    it("handles punctuation and multiple separators", () => {
+        expect(title.fn("my-task_HTTP server", [])).toBe("My Task Http Server");
+    });
+    it("returns empty string for empty input", () => {
+        expect(title.fn("", [])).toBe("");
+    });
+});

package/dist/pattern/transforms/words.js

@@ -0,0 +1,27 @@
+import { splitWords } from "./helpers/words.js";
+/**
+ * Transform: words
+ *
+ * Limits the input to at most `n` words. The transform expects a single
+ * numeric argument that indicates the maximum number of words to keep. The
+ * returned value is the first `n` words joined by a single space.
+ *
+ * Examples:
+ * - `{title:words:2}` applied to "My big title" -> "My big"
+ *
+ * @throws If the provided argument is missing or not a non-negative number.
+ */
+export const words = {
+    name: "words",
+    fn: (value, [n]) => {
+        const count = Number(n);
+        if (!Number.isFinite(count) || count < 0) {
+            throw new Error(`words expects a non-negative number, got "${n ?? ""}"`);
+        }
+        return splitWords(value).slice(0, count).join(" ");
+    },
+    doc: {
+        summary: "Limits value to a maximum number of words.",
+        usage: ["{title:words:3}"],
+    },
+};

package/dist/pattern/transforms/words.test.js

@@ -0,0 +1,16 @@
+import { describe, it, expect } from "vitest";
+import { words } from "./words.js";
+describe("words transform", () => {
+    it("limits the number of words when a positive number is provided", () => {
+        expect(words.fn("one two three four", ["2"]).trim()).toBe("one two");
+        expect(words.fn("hello world", ["5"]).trim()).toBe("hello world");
+    });
+    it("returns empty string when 0 is provided", () => {
+        expect(words.fn("some text here", ["0"]).trim()).toBe("");
+    });
+    it("throws when argument is missing or invalid", () => {
+        expect(() => words.fn("a b c", [])).toThrow();
+        expect(() => words.fn("a b c", ["-1"])).toThrow();
+        expect(() => words.fn("a b c", ["not-a-number"])).toThrow();
+    });
+});

package/dist/runtime/resolveMissingValues.js

@@ -1,11 +1,34 @@
 import { input, select } from "@inquirer/prompts";
 import { TYPE_CHOICES } from "../runtime/enums.js";
 /**
- * Resolves missing variable values required by the pattern.
+ * Resolves missing variable values required by a parsed pattern.
  *
- * Rule (v1):
- * - Any variable used in the pattern is considered required.
- * - The "type" variable is resolved using a select menu with predefined choices.
+ * The function inspects `parsed.variablesUsed` and ensures each required
+ * variable has a non-empty value in the returned object. If a variable is
+ * missing or contains only whitespace and `opts.prompt` is `true`, the
+ * function will prompt the user for the value. The special variable name
+ * `type` is resolved with a select prompt pre-populated with
+ * {@link TYPE_CHOICES}.
+ *
+ * Behavior summary:
+ * - Any variable present in `parsed.variablesUsed` is considered required.
+ * - If a value exists and is non-empty (after trimming) it is preserved.
+ * - If a value is missing or blank and `opts.prompt` is `false`, an error is
+ *   thrown listing the missing variable.
+ * - If `opts.prompt` is `true`, the function will:
+ *   - use a select prompt for the variable named `type` (choices from
+ *     {@link TYPE_CHOICES});
+ *   - use a text input prompt for any other variable.
+ *
+ * @param parsed - Parsed pattern containing `variablesUsed`.
+ * @param initialValues - Existing values that may satisfy requirements.
+ * @param opts - Options controlling prompting behavior.
+ * @returns A promise resolving to a `RenderValues` object containing all
+ * required variables (original values preserved when present).
+ * @throws When a required variable is missing and `opts.prompt` is false.
+ * @example
+ * const parsed = parsePattern('{type}/{title}');
+ * await resolveMissingValues(parsed, { title: 'Hello' }, { prompt: true });
  */
 export async function resolveMissingValues(parsed, initialValues, opts) {
     const requiredVars = parsed.variablesUsed;

package/dist/runtime/resolveMissingValues.test.js

@@ -0,0 +1,64 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { resolveMissingValues } from "./resolveMissingValues.js";
+import { parsePattern } from "../pattern/parsePattern.js";
+// Mock prompts module so tests can control interactive behavior
+vi.mock("@inquirer/prompts", () => {
+    return {
+        input: vi.fn(),
+        select: vi.fn(),
+    };
+});
+// Provide a lightweight mock for the runtime enums so module resolution
+// does not fail in the test environment (we only need the shape used
+// by the code under test).
+vi.mock("@/runtime/enums.js", () => ({
+    TYPE_CHOICES: [
+        { name: "Feature", value: "feat" },
+        { name: "Fix", value: "fix" },
+    ],
+}));
+import { input, select } from "@inquirer/prompts";
+beforeEach(() => {
+    // resetAllMocks clears implementations and mock queues (e.g. mockResolvedValueOnce)
+    // which prevents cross-test leakage of one-off mock return values.
+    vi.resetAllMocks();
+});
+describe("resolveMissingValues", () => {
+    it("returns values unchanged when all required vars are present", async () => {
+        const parsed = parsePattern("{type}/{title}-{id}");
+        const initial = { type: "feat", title: "My Task", id: "123" };
+        const out = await resolveMissingValues(parsed, initial, { prompt: true });
+        expect(out).toEqual(initial);
+        expect(input).not.toHaveBeenCalled();
+        expect(select).not.toHaveBeenCalled();
+    });
+    it("prompts for a missing non-type variable using input", async () => {
+        const parsed = parsePattern("{type}/{title}");
+        // input should be used for `title`
+        input.mockResolvedValueOnce("Provided Title");
+        // Type is present so select should not be called
+        const out = await resolveMissingValues(parsed, { type: "fix" }, { prompt: true });
+        expect(input).toHaveBeenCalled();
+        expect(select).not.toHaveBeenCalled();
+        expect(out.title).toBe("Provided Title");
+    });
+    it("uses select for the `type` variable", async () => {
+        const parsed = parsePattern("{type}/{title}");
+        select.mockResolvedValueOnce("feat");
+        input.mockResolvedValueOnce("Some title");
+        const out = await resolveMissingValues(parsed, { title: "Some title" }, { prompt: true });
+        expect(select).toHaveBeenCalled();
+        expect(out.type).toBe("feat");
+    });
+    it("throws when prompt is false and a required variable is missing", async () => {
+        const parsed = parsePattern("{id}");
+        await expect(resolveMissingValues(parsed, {}, { prompt: false })).rejects.toThrow(/Missing required value/i);
+    });
+    it("treats whitespace-only values as missing and prompts", async () => {
+        const parsed = parsePattern("{title}");
+        input.mockResolvedValueOnce("Trimmed");
+        const out = await resolveMissingValues(parsed, { title: "   " }, { prompt: true });
+        expect(input).toHaveBeenCalled();
+        expect(out.title).toBe("Trimmed");
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "new-branch",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Generate and create standardized git branch names from a pattern.",
   "keywords": [
     "git",
@@ -20,6 +20,7 @@
     "prepack": "pnpm build && pnpm test:run",
     "test": "vitest --dir src --exclude **/dist/**",
     "test:run": "vitest run --dir src --exclude **/dist/**",
+    "test:coverage": "vitest run --coverage --dir src --exclude **/dist/**",
     "format": "prettier . --write",
     "format:check": "prettier . --check",
     "lint": "eslint src --ext .ts"
@@ -41,13 +42,14 @@
     "url": "https://github.com/teles/new-branch/issues"
   },
   "new-branch": {
-    "pattern": "{type}/{title}-{id}"
+    "pattern": "{type}/{title:lower}-{id}"
   },
   "homepage": "https://github.com/teles/new-branch#readme",
   "packageManager": "pnpm@10.22.0",
   "devDependencies": {
     "@eslint/js": "10.0.1",
     "@types/node": "25.2.3",
+    "@vitest/coverage-v8": "4.0.18",
     "eslint": "10.0.0",
     "prettier": "3.8.1",
     "tsc-alias": "1.8.16",