@tbsten/mir-core 0.0.1-alpha04 → 0.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tbsten/mir-core",
-  "version": "0.0.1-alpha04",
+  "version": "0.0.1",
   "description": "スニペット配布・取得ツール mir のコアロジック（テンプレート、スキーマ、i18n）",
   "type": "module",
   "keywords": [

package/src/__tests__/helpers/string-helpers.test.ts

@@ -0,0 +1,100 @@
+import { describe, it, expect } from "vitest";
+import {
+  lowercase,
+  uppercase,
+  capitalize,
+  uncapitalize,
+  replace,
+  camelCase,
+  pascalCase,
+  snakeCase,
+  kebabCase,
+  trim,
+} from "../../helpers/string-helpers.js";
+
+describe("lowercase", () => {
+  it("大文字を小文字に変換", () => expect(lowercase("HELLO")).toBe("hello"));
+  it("空文字", () => expect(lowercase("")).toBe(""));
+  it("undefined は 'undefined' に変換", () =>
+    expect(lowercase(undefined)).toBe("undefined"));
+  it("数値は文字列化", () => expect(lowercase(123)).toBe("123"));
+});
+
+describe("uppercase", () => {
+  it("小文字を大文字に変換", () => expect(uppercase("hello")).toBe("HELLO"));
+  it("空文字", () => expect(uppercase("")).toBe(""));
+});
+
+describe("capitalize", () => {
+  it("先頭を大文字に", () => expect(capitalize("hello")).toBe("Hello"));
+  it("空文字", () => expect(capitalize("")).toBe(""));
+  it("1文字", () => expect(capitalize("a")).toBe("A"));
+});
+
+describe("uncapitalize", () => {
+  it("先頭を小文字に", () => expect(uncapitalize("Hello")).toBe("hello"));
+  it("空文字", () => expect(uncapitalize("")).toBe(""));
+  it("1文字", () => expect(uncapitalize("A")).toBe("a"));
+});
+
+describe("replace", () => {
+  it("リテラル文字列を置換", () =>
+    expect(replace("com/example/app", "/", ".")).toBe("com.example.app"));
+  it("マッチしない場合はそのまま", () =>
+    expect(replace("hello", "x", "y")).toBe("hello"));
+  it("空の search は何もしない", () =>
+    expect(replace("hello", "", "x")).toBe("hello"));
+  it("正規表現メタ文字がリテラルとして扱われる", () =>
+    expect(replace("a.b.c", ".", "-")).toBe("a-b-c"));
+  it("$記号を含む replacement が安全に処理される", () =>
+    expect(replace("hello", "l", "$1")).toBe("he$1$1o"));
+});
+
+describe("camelCase", () => {
+  it("kebab-case → camelCase", () =>
+    expect(camelCase("my-component")).toBe("myComponent"));
+  it("snake_case → camelCase", () =>
+    expect(camelCase("my_component")).toBe("myComponent"));
+  it("PascalCase → camelCase", () =>
+    expect(camelCase("MyComponent")).toBe("myComponent"));
+  it("スペース区切り", () =>
+    expect(camelCase("hello world")).toBe("helloWorld"));
+  it("ドット区切り", () =>
+    expect(camelCase("com.example.app")).toBe("comExampleApp"));
+  it("空文字", () => expect(camelCase("")).toBe(""));
+  it("単一単語", () => expect(camelCase("hello")).toBe("hello"));
+});
+
+describe("pascalCase", () => {
+  it("kebab-case → PascalCase", () =>
+    expect(pascalCase("my-component")).toBe("MyComponent"));
+  it("camelCase → PascalCase", () =>
+    expect(pascalCase("myComponent")).toBe("MyComponent"));
+  it("空文字", () => expect(pascalCase("")).toBe(""));
+});
+
+describe("snakeCase", () => {
+  it("camelCase → snake_case", () =>
+    expect(snakeCase("myComponent")).toBe("my_component"));
+  it("kebab-case → snake_case", () =>
+    expect(snakeCase("my-component")).toBe("my_component"));
+  it("PascalCase → snake_case", () =>
+    expect(snakeCase("MyComponent")).toBe("my_component"));
+  it("空文字", () => expect(snakeCase("")).toBe(""));
+});
+
+describe("kebabCase", () => {
+  it("camelCase → kebab-case", () =>
+    expect(kebabCase("myComponent")).toBe("my-component"));
+  it("PascalCase → kebab-case", () =>
+    expect(kebabCase("MyComponent")).toBe("my-component"));
+  it("snake_case → kebab-case", () =>
+    expect(kebabCase("my_component")).toBe("my-component"));
+  it("空文字", () => expect(kebabCase("")).toBe(""));
+});
+
+describe("trim", () => {
+  it("前後空白を除去", () => expect(trim("  hello  ")).toBe("hello"));
+  it("空文字", () => expect(trim("")).toBe(""));
+  it("改行を除去", () => expect(trim("\nhello\n")).toBe("hello"));
+});

package/src/__tests__/template-engine.test.ts

@@ -100,6 +100,109 @@ describe("extractVariables", () => {
   });
 });
 
+describe("expandTemplate with helpers", () => {
+  it("lowercase ヘルパー", () => {
+    expect(expandTemplate("{{lowercase name}}", { name: "HELLO" })).toBe("hello");
+  });
+
+  it("uppercase ヘルパー", () => {
+    expect(expandTemplate("{{uppercase name}}", { name: "hello" })).toBe("HELLO");
+  });
+
+  it("replace ヘルパー", () => {
+    expect(
+      expandTemplate('{{replace package "/" "."}}', { package: "com/example/app" }),
+    ).toBe("com.example.app");
+  });
+
+  it("camelCase ヘルパー", () => {
+    expect(expandTemplate("{{camelCase name}}", { name: "my-component" })).toBe(
+      "myComponent",
+    );
+  });
+
+  it("pascalCase ヘルパー", () => {
+    expect(expandTemplate("{{pascalCase name}}", { name: "my-component" })).toBe(
+      "MyComponent",
+    );
+  });
+
+  it("snakeCase ヘルパー", () => {
+    expect(expandTemplate("{{snakeCase name}}", { name: "myComponent" })).toBe(
+      "my_component",
+    );
+  });
+
+  it("kebabCase ヘルパー", () => {
+    expect(expandTemplate("{{kebabCase name}}", { name: "MyComponent" })).toBe(
+      "my-component",
+    );
+  });
+
+  it("capitalize ヘルパー", () => {
+    expect(expandTemplate("{{capitalize name}}", { name: "hello" })).toBe("Hello");
+  });
+
+  it("uncapitalize ヘルパー", () => {
+    expect(expandTemplate("{{uncapitalize name}}", { name: "Hello" })).toBe("hello");
+  });
+
+  it("trim ヘルパー", () => {
+    expect(expandTemplate("{{trim name}}", { name: "  hello  " })).toBe("hello");
+  });
+
+  it("サブ式（ネスト）: lowercase(replace(...))", () => {
+    expect(
+      expandTemplate('{{lowercase (replace name "/" ".")}}', {
+        name: "COM/EXAMPLE/APP",
+      }),
+    ).toBe("com.example.app");
+  });
+
+  it("サブ式（ネスト）: pascalCase(replace(...))", () => {
+    expect(
+      expandTemplate('{{pascalCase (replace pkg "/" "-")}}', {
+        pkg: "my/cool/component",
+      }),
+    ).toBe("MyCoolComponent");
+  });
+});
+
+describe("extractVariables with helpers", () => {
+  it("ヘルパー名を変数に含めない", () => {
+    const vars = extractVariables("{{lowercase name}}");
+    expect(vars).toContain("name");
+    expect(vars).not.toContain("lowercase");
+  });
+
+  it("replace ヘルパーで変数のみ抽出", () => {
+    const vars = extractVariables('{{replace package "/" "."}}');
+    expect(vars).toContain("package");
+    expect(vars).not.toContain("replace");
+  });
+
+  it("サブ式でもヘルパー名を除外", () => {
+    const vars = extractVariables('{{lowercase (replace name "/" ".")}}');
+    expect(vars).toContain("name");
+    expect(vars).not.toContain("lowercase");
+    expect(vars).not.toContain("replace");
+  });
+
+  it("ヘルパーと通常変数が混在", () => {
+    const vars = extractVariables("{{name}} {{lowercase title}}");
+    expect(vars).toContain("name");
+    expect(vars).toContain("title");
+    expect(vars).not.toContain("lowercase");
+  });
+
+  it("組み込みヘルパー (if/each) も変数に含めない", () => {
+    const vars = extractVariables("{{#if enabled}}{{name}}{{/if}}");
+    expect(vars).toContain("enabled");
+    expect(vars).toContain("name");
+    expect(vars).not.toContain("if");
+  });
+});
+
 describe("extractVariablesFromDirectory", () => {
   let tmpDir: string;
 

package/src/helpers/index.ts

@@ -0,0 +1,34 @@
+import type Handlebars from "handlebars";
+import * as helpers from "./string-helpers.js";
+
+/** ヘルパー名一覧（extractVariables でフィルタ用） */
+export const HELPER_NAMES: ReadonlySet<string> = new Set([
+  "lowercase",
+  "uppercase",
+  "capitalize",
+  "uncapitalize",
+  "replace",
+  "camelCase",
+  "pascalCase",
+  "snakeCase",
+  "kebabCase",
+  "trim",
+]);
+
+/** Handlebars インスタンスにヘルパーを一括登録 */
+export function registerHelpers(hbs: typeof Handlebars): void {
+  hbs.registerHelper("lowercase", (v: unknown) => helpers.lowercase(v));
+  hbs.registerHelper("uppercase", (v: unknown) => helpers.uppercase(v));
+  hbs.registerHelper("capitalize", (v: unknown) => helpers.capitalize(v));
+  hbs.registerHelper("uncapitalize", (v: unknown) => helpers.uncapitalize(v));
+  hbs.registerHelper(
+    "replace",
+    (v: unknown, search: unknown, replacement: unknown) =>
+      helpers.replace(v, search, replacement),
+  );
+  hbs.registerHelper("camelCase", (v: unknown) => helpers.camelCase(v));
+  hbs.registerHelper("pascalCase", (v: unknown) => helpers.pascalCase(v));
+  hbs.registerHelper("snakeCase", (v: unknown) => helpers.snakeCase(v));
+  hbs.registerHelper("kebabCase", (v: unknown) => helpers.kebabCase(v));
+  hbs.registerHelper("trim", (v: unknown) => helpers.trim(v));
+}

package/src/helpers/string-helpers.ts

@@ -0,0 +1,76 @@
+/**
+ * Handlebars カスタムヘルパー用の純粋関数群
+ * 外部ライブラリ不使用
+ */
+
+/** 単語分割: `-`, `_`, `.`, スペース, camelCase 境界で分割 */
+function splitWords(value: string): string[] {
+  return value
+    .replace(/([a-z0-9])([A-Z])/g, "$1\0$2")
+    .replace(/([A-Z]+)([A-Z][a-z])/g, "$1\0$2")
+    .split(/[-_.\s\0]+/)
+    .filter((w) => w.length > 0);
+}
+
+export function lowercase(value: unknown): string {
+  return String(value).toLowerCase();
+}
+
+export function uppercase(value: unknown): string {
+  return String(value).toUpperCase();
+}
+
+export function capitalize(value: unknown): string {
+  const s = String(value);
+  if (s.length === 0) return s;
+  return s[0].toUpperCase() + s.slice(1);
+}
+
+export function uncapitalize(value: unknown): string {
+  const s = String(value);
+  if (s.length === 0) return s;
+  return s[0].toLowerCase() + s.slice(1);
+}
+
+/** リテラル文字列置換（replaceAll）。正規表現は受け付けない（ReDoS 防止） */
+export function replace(
+  value: unknown,
+  search: unknown,
+  replacement: unknown,
+): string {
+  const s = String(value);
+  const searchStr = String(search);
+  const replaceStr = String(replacement);
+  if (searchStr === "") return s;
+  return s.split(searchStr).join(replaceStr);
+}
+
+export function camelCase(value: unknown): string {
+  const words = splitWords(String(value));
+  return words
+    .map((w, i) =>
+      i === 0 ? w.toLowerCase() : w[0].toUpperCase() + w.slice(1).toLowerCase(),
+    )
+    .join("");
+}
+
+export function pascalCase(value: unknown): string {
+  const words = splitWords(String(value));
+  return words.map((w) => w[0].toUpperCase() + w.slice(1).toLowerCase()).join("");
+}
+
+export function snakeCase(value: unknown): string {
+  return splitWords(String(value))
+    .map((w) => w.toLowerCase())
+    .join("_");
+}
+
+export function kebabCase(value: unknown): string {
+  return splitWords(String(value))
+    .map((w) => w.toLowerCase())
+    .join("-");
+}
+
+export function trim(value: unknown): string {
+  return String(value).trim();
+}

package/src/index.ts

@@ -44,6 +44,9 @@ export {
   expandTemplateDirectory,
 } from "./template-engine.js";
 
+// helpers
+export { HELPER_NAMES } from "./helpers/index.js";
+
 // hooks
 export { ExitHookError, executeHooks } from "./hooks.js";
 export type { HookExecutionOptions } from "./hooks.js";

package/src/template-engine.ts

@@ -5,12 +5,17 @@ import {
   listTemplateFiles,
   readTemplateFile,
 } from "./registry.js";
+import { HELPER_NAMES, registerHelpers } from "./helpers/index.js";
+
+// 隔離インスタンスを作成しヘルパーを登録
+const hbs = Handlebars.create();
+registerHelpers(hbs);
 
 export function expandTemplate(
   template: string,
   variables: Record<string, unknown>,
 ): string {
-  const compiled = Handlebars.compile(template, { noEscape: true });
+  const compiled = hbs.compile(template, { noEscape: true });
   return compiled(variables);
 }
 
@@ -23,30 +28,50 @@ export function expandPath(
   return path.normalize(expanded);
 }
 
+/** Handlebars 組み込みヘルパー名 */
+const BUILTIN_HELPERS = new Set([
+  "if",
+  "unless",
+  "each",
+  "with",
+  "lookup",
+  "log",
+]);
+
 export function extractVariables(template: string): string[] {
   const ast = Handlebars.parse(template);
   const vars = new Set<string>();
 
-  function visitExpression(expr: hbs.AST.Expression): void {
+  function collectVarFromExpression(expr: hbs.AST.Expression): void {
     if (expr.type === "PathExpression") {
       const pathExpr = expr as hbs.AST.PathExpression;
       vars.add(pathExpr.parts[0]);
+    } else if (expr.type === "SubExpression") {
+      // サブ式: {{lowercase (replace name "/" ".")}} 等
+      const sub = expr as hbs.AST.SubExpression;
+      // sub.path はヘルパー名なのでスキップ、params のみ抽出
+      if (sub.params) {
+        for (const param of sub.params) collectVarFromExpression(param);
+      }
     }
   }
 
   function visit(node: hbs.AST.Node): void {
     if (node.type === "MustacheStatement") {
       const stmt = node as hbs.AST.MustacheStatement;
-      if (stmt.path) visitExpression(stmt.path);
-      if (stmt.params) {
-        for (const param of stmt.params) visitExpression(param);
+      if (stmt.params && stmt.params.length > 0) {
+        // ヘルパー呼び出し: path はヘルパー名なのでスキップ、params のみ変数抽出
+        for (const param of stmt.params) collectVarFromExpression(param);
+      } else {
+        // 単純な変数参照: {{name}}
+        if (stmt.path) collectVarFromExpression(stmt.path);
       }
     }
     if (node.type === "BlockStatement") {
       const block = node as hbs.AST.BlockStatement;
       // #if, #unless, #each 等のパラメータから変数を抽出
       if (block.params) {
-        for (const param of block.params) visitExpression(param);
+        for (const param of block.params) collectVarFromExpression(param);
       }
       if (block.program) visit(block.program);
       if (block.inverse) visit(block.inverse);
@@ -59,6 +84,11 @@ export function extractVariables(template: string): string[] {
   }
 
   visit(ast);
+
+  // ヘルパー名・組み込みヘルパー名を除外
+  for (const name of HELPER_NAMES) vars.delete(name);
+  for (const name of BUILTIN_HELPERS) vars.delete(name);
+
   return [...vars];
 }