vite-plugin-css-module-types 1.0.0

package/dist/index.js

@@ -0,0 +1,583 @@
+// src/plugin.ts
+import { mkdir, readFile, writeFile, readdir, stat } from "node:fs/promises";
+import { mkdirSync } from "node:fs";
+import path from "node:path";
+
+// src/lib/path-filter.ts
+function normalizeFolderPath(value) {
+  return value.replaceAll("\\", "/").replace(/^\.?\//, "").replace(/\/+$/, "");
+}
+function normalizeFolderList(folders) {
+  if (!folders)
+    return [];
+  const list = Array.isArray(folders) ? folders : [folders];
+  return list.map(normalizeFolderPath).filter(Boolean);
+}
+function isInFolders(relativeFilePath, folders) {
+  if (folders.length === 0)
+    return false;
+  const normalizedPath = normalizeFolderPath(relativeFilePath);
+  return folders.some((folder) => {
+    return normalizedPath === folder || normalizedPath.startsWith(`${folder}/`);
+  });
+}
+function shouldProcessFile(relativeFilePath, includeFolders, excludeFolders) {
+  const isIncluded = includeFolders.length === 0 || isInFolders(relativeFilePath, includeFolders);
+  if (!isIncluded)
+    return false;
+  return !isInFolders(relativeFilePath, excludeFolders);
+}
+// src/lib/css-comments.ts
+function buildNewlineIndex(content) {
+  const offsets = [];
+  for (let i = 0;i < content.length; i++) {
+    if (content.charCodeAt(i) === 10) {
+      offsets.push(i);
+    }
+  }
+  return offsets;
+}
+function getLineAtOffset(newlineIndex, offset) {
+  let lo = 0;
+  let hi = newlineIndex.length;
+  while (lo < hi) {
+    const mid = lo + hi >> 1;
+    if ((newlineIndex[mid] ?? 0) < offset) {
+      lo = mid + 1;
+    } else {
+      hi = mid;
+    }
+  }
+  return lo + 1;
+}
+function extractCssComments(cssContent) {
+  const newlineIndex = buildNewlineIndex(cssContent);
+  const regex = /\/\*\*([\s\S]*?)\*\//g;
+  const comments = [];
+  for (const match of cssContent.matchAll(regex)) {
+    const content = (match[1] ?? "").trim();
+    if (match.index === undefined) {
+      continue;
+    }
+    const endOffset = match.index + match[0].length;
+    const endLine = getLineAtOffset(newlineIndex, endOffset);
+    comments[endLine] = {
+      content,
+      endLine
+    };
+  }
+  return comments;
+}
+// src/lib/transform.ts
+import { Buffer } from "buffer";
+function patchViteModuleCode(code) {
+  return code.replaceAll("import {", "// import {").replaceAll("__vite__updateStyle", "// __vite__updateStyle").replace(/if\s*\(import\.meta\.hot\)\s*\{[\s\S]*?\n\}/g, "").replaceAll("import.meta.hot", "// import.meta.hot").replaceAll("const __vite__css", "export const __vite__css");
+}
+async function evaluateModuleExports(patchedCode) {
+  const base64 = Buffer.from(patchedCode, "utf-8").toString("base64");
+  const mod = await import(`data:text/javascript;base64,${base64}`);
+  return {
+    classMapping: mod.default ?? {},
+    cssText: mod.__vite__css ?? ""
+  };
+}
+// src/lib/camel-case.ts
+function toCamelCase(name) {
+  return name.replace(/-([a-zA-Z\d])/g, (_, char) => char.toUpperCase());
+}
+
+// src/lib/class-index.ts
+function buildClassNameIndex(lineMappings) {
+  const index = new Map;
+  const classRegex = /\.([a-zA-Z_][\w-]*)/g;
+  for (const mapping of lineMappings) {
+    if (!mapping.originalLine)
+      continue;
+    for (const match of mapping.generatedContent.matchAll(classRegex)) {
+      const className = match[1];
+      if (className && !index.has(className)) {
+        index.set(className, mapping);
+      }
+    }
+  }
+  return index;
+}
+function buildOriginalClassLineMap(cssSource) {
+  const map = new Map;
+  const lines = cssSource.split(`
+`);
+  const classRegex = /\.([a-zA-Z_][\w-]*)/g;
+  for (let i = 0;i < lines.length; i++) {
+    const line = lines[i];
+    if (!line)
+      continue;
+    for (const match of line.matchAll(classRegex)) {
+      const name = match[1];
+      if (name && !map.has(name)) {
+        const lineNum = i + 1;
+        map.set(name, lineNum);
+        const camelName = toCamelCase(name);
+        if (camelName !== name && !map.has(camelName)) {
+          map.set(camelName, lineNum);
+        }
+      }
+    }
+  }
+  return map;
+}
+function extractCssRuleBodies(cssSource) {
+  const map = new Map;
+  const lines = cssSource.split(`
+`);
+  const classRegex = /\.([a-zA-Z_][\w-]*)/g;
+  const lineOffsets = [0];
+  for (let i = 0;i < lines.length - 1; i++) {
+    const prevOffset = lineOffsets[i] ?? 0;
+    const lineLen = lines[i]?.length ?? 0;
+    lineOffsets.push(prevOffset + lineLen + 1);
+  }
+  for (let i = 0;i < lines.length; i++) {
+    const line = lines[i];
+    if (!line)
+      continue;
+    for (const match of line.matchAll(classRegex)) {
+      const name = match[1];
+      if (!name || map.has(name))
+        continue;
+      const lineStartOffset = lineOffsets[i] ?? 0;
+      const braceIdx = cssSource.indexOf("{", lineStartOffset);
+      if (braceIdx === -1)
+        continue;
+      let depth = 1;
+      let pos = braceIdx + 1;
+      while (pos < cssSource.length && depth > 0) {
+        const ch = cssSource[pos];
+        if (ch === "{")
+          depth++;
+        else if (ch === "}")
+          depth--;
+        pos++;
+      }
+      if (depth !== 0)
+        continue;
+      const ruleBlock = cssSource.slice(lineStartOffset, pos).trim();
+      map.set(name, ruleBlock);
+      const camelName = toCamelCase(name);
+      if (camelName !== name && !map.has(camelName)) {
+        map.set(camelName, ruleBlock);
+      }
+    }
+  }
+  return map;
+}
+function resolveClassEntries(classMapping, classIndex, comments, originalClassLines = null, cssRuleBodies = null) {
+  const entries = [];
+  for (const key in classMapping) {
+    const hashKey = classMapping[key] ?? "";
+    let line = originalClassLines?.get(key);
+    if (!line) {
+      line = classIndex?.get(hashKey)?.originalLine;
+    }
+    const comment = line != null ? comments?.[line - 1]?.content ?? "" : "";
+    const cssBlock = cssRuleBodies?.get(key) ?? "";
+    entries.push({ rule: key, value: hashKey, line, comment, cssBlock });
+  }
+  const lineByValue = new Map;
+  const cssBlockByValue = new Map;
+  for (const entry of entries) {
+    if (entry.line != null && !lineByValue.has(entry.value)) {
+      lineByValue.set(entry.value, entry.line);
+    }
+    if (entry.cssBlock && !cssBlockByValue.has(entry.value)) {
+      cssBlockByValue.set(entry.value, entry.cssBlock);
+    }
+  }
+  for (const entry of entries) {
+    if (entry.line == null) {
+      const propagatedLine = lineByValue.get(entry.value);
+      if (propagatedLine != null) {
+        entry.line = propagatedLine;
+        entry.comment = comments?.[propagatedLine - 1]?.content ?? "";
+      }
+    }
+    if (!entry.cssBlock) {
+      const propagatedBlock = cssBlockByValue.get(entry.value);
+      if (propagatedBlock) {
+        entry.cssBlock = propagatedBlock;
+      }
+    }
+  }
+  return entries;
+}
+// src/lib/generate-dts.ts
+var EMOJI_ARROW = "↗";
+var JS_IDENT_RE = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
+var ASTERISK_OPERATOR = "∗";
+function escapeCssCommentDelimiters(text) {
+  return text.replaceAll("/*", `/${ASTERISK_OPERATOR}`).replaceAll("*/", `${ASTERISK_OPERATOR}/`);
+}
+function buildJsDocLine(item, fileName, absolutePath) {
+  const lineInfo = item.line ? `#L${item.line}` : "";
+  const lineLabel = item.line ? `:${item.line}` : "";
+  const commentBlock = item.comment ? `\`\`\`txt
+${item.comment.trim()}
+\`\`\`
+` : "";
+  const cssBlock = item.cssBlock ? `---
+\`\`\`css
+${escapeCssCommentDelimiters(item.cssBlock).trim()}
+\`\`\`
+` : "";
+  const separator = commentBlock || cssBlock ? `---
+` : "";
+  const leadingBreak = commentBlock || cssBlock ? `
+` : "";
+  return `  /** ${leadingBreak}${commentBlock}${cssBlock}${separator} [${EMOJI_ARROW} ${fileName}${lineLabel}](file://${absolutePath}${lineInfo}) */`;
+}
+function generateDtsContent(entries, fileName, absolutePath, options = {}) {
+  if (entries.length === 0) {
+    return { content: `export {};
+`, lineMappings: [] };
+  }
+  const lines = [];
+  const lineMappings = [];
+  function pushContent(content) {
+    for (const part of content.split(`
+`)) {
+      lines.push(part);
+    }
+  }
+  function trackMapping(cssLine, dtsColumn) {
+    if (cssLine) {
+      lineMappings.push({
+        dtsLine: lines.length,
+        dtsColumn,
+        cssLine,
+        cssColumn: 0
+      });
+    }
+  }
+  function pushMappedPair(jsDoc, declaration, cssLine, declColumn) {
+    const jsDocFirstLine = lines.length + 1;
+    pushContent(jsDoc);
+    const jsDocLastLine = lines.length;
+    if (cssLine) {
+      for (let ln = jsDocFirstLine;ln <= jsDocLastLine; ln++) {
+        lineMappings.push({ dtsLine: ln, dtsColumn: 0, cssLine, cssColumn: 0 });
+      }
+    }
+    pushContent(declaration);
+    trackMapping(cssLine, declColumn);
+    lines.push("");
+    trackMapping(cssLine, 0);
+  }
+  if (options.namedExports) {
+    const emittedNamedExports = new Set;
+    for (const item of entries) {
+      if (!JS_IDENT_RE.test(item.rule))
+        continue;
+      if (emittedNamedExports.has(item.rule))
+        continue;
+      emittedNamedExports.add(item.rule);
+      const jsDoc = buildJsDocLine(item, fileName, absolutePath);
+      pushMappedPair(jsDoc, `export declare const ${item.rule}: string;`, item.line, 0);
+    }
+    lines.push("");
+    pushContent(`/** [${EMOJI_ARROW} ${fileName}](file://${absolutePath}) */`);
+    lines.push("declare const styles: {");
+    const emittedProps2 = new Set;
+    for (const item of entries) {
+      if (emittedProps2.has(item.rule))
+        continue;
+      emittedProps2.add(item.rule);
+      const jsDoc = buildJsDocLine(item, fileName, absolutePath);
+      pushMappedPair(jsDoc, `  readonly ${JSON.stringify(item.rule)}: ${JSON.stringify(item.value)};`, item.line, 2);
+    }
+    lines.push("};");
+    lines.push("export default styles;");
+    lines.push("");
+    return { content: lines.join(`
+`), lineMappings };
+  }
+  pushContent(`/** [${EMOJI_ARROW} ${fileName}](file://${absolutePath}) */`);
+  lines.push("declare const styles: {");
+  const emittedProps = new Set;
+  for (const item of entries) {
+    if (emittedProps.has(item.rule))
+      continue;
+    emittedProps.add(item.rule);
+    const jsDoc = buildJsDocLine(item, fileName, absolutePath);
+    pushMappedPair(jsDoc, `  readonly ${JSON.stringify(item.rule)}: ${JSON.stringify(item.value)};`, item.line, 2);
+  }
+  lines.push("};");
+  lines.push("export default styles;");
+  lines.push("");
+  return { content: lines.join(`
+`), lineMappings };
+}
+// src/lib/sourcemap.ts
+import { Buffer as Buffer2 } from "buffer";
+import { SourceMapConsumer } from "source-map";
+async function getInlineLineMappings(css) {
+  const prefix = "/*# sourceMappingURL=data:application/json;base64,";
+  const suffix = "*/";
+  const start = css.lastIndexOf(prefix);
+  const end = css.indexOf(suffix, start);
+  if (start === -1 || end === -1)
+    return [];
+  const base64 = css.slice(start + prefix.length, end).trim();
+  const rawMap = JSON.parse(Buffer2.from(base64, "base64").toString("utf8"));
+  const cssLines = css.split(`
+`);
+  const consumer = await new SourceMapConsumer(rawMap);
+  const sourceLineMap = new Map;
+  if (rawMap.sources && rawMap.sourcesContent) {
+    for (let i = 0;i < rawMap.sources.length; i++) {
+      const src = rawMap.sources[i];
+      const content = rawMap.sourcesContent[i];
+      if (typeof src === "string" && typeof content === "string") {
+        sourceLineMap.set(src, content.split(`
+`));
+      }
+    }
+  }
+  const lineToMapping = new Map;
+  consumer.eachMapping((m) => {
+    if (!lineToMapping.has(m.generatedLine)) {
+      lineToMapping.set(m.generatedLine, m);
+    }
+  });
+  const results = [];
+  for (let line = 1;line <= cssLines.length; line++) {
+    const generatedContent = cssLines[line - 1] ?? "";
+    const mapping = lineToMapping.get(line);
+    let source;
+    let originalLine;
+    let originalContent;
+    if (mapping?.source && mapping.originalLine) {
+      source = mapping.source;
+      originalLine = mapping.originalLine;
+      const srcLines = sourceLineMap.get(source);
+      if (srcLines && srcLines.length >= originalLine) {
+        originalContent = srcLines[originalLine - 1];
+      }
+    }
+    results.push({ generatedLine: line, generatedContent, source, originalLine, originalContent });
+  }
+  consumer.destroy();
+  return results;
+}
+// src/lib/declaration-map.ts
+import { encode } from "@jridgewell/sourcemap-codec";
+function generateDeclarationMap(dtsFileName, cssRelativePath, lineMappings, totalDtsLines) {
+  const sorted = [...lineMappings].sort((a, b) => a.dtsLine - b.dtsLine || a.dtsColumn - b.dtsColumn);
+  const decoded = [];
+  let mappingIdx = 0;
+  for (let line = 1;line <= totalDtsLines; line++) {
+    const lineSegments = [];
+    while (mappingIdx < sorted.length && sorted[mappingIdx]?.dtsLine === line) {
+      const m = sorted[mappingIdx];
+      if (!m)
+        break;
+      lineSegments.push([m.dtsColumn, 0, m.cssLine - 1, m.cssColumn]);
+      mappingIdx++;
+    }
+    decoded.push(lineSegments);
+  }
+  return JSON.stringify({
+    version: 3,
+    file: dtsFileName,
+    sourceRoot: "",
+    sources: [cssRelativePath],
+    mappings: encode(decoded)
+  });
+}
+// src/plugin.ts
+async function findFiles(dir, suffix) {
+  const results = [];
+  let entries;
+  try {
+    entries = await readdir(dir, { withFileTypes: true });
+  } catch {
+    return results;
+  }
+  for (const entry of entries) {
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...await findFiles(full, suffix));
+    } else if (entry.name.endsWith(suffix)) {
+      results.push(full);
+    }
+  }
+  return results;
+}
+function buildClassMappingFromSource(cssSource) {
+  const mapping = {};
+  const classRegex = /\.([a-zA-Z_][\w-]*)/g;
+  for (const match of cssSource.matchAll(classRegex)) {
+    const name = match[1];
+    if (!name || name in mapping)
+      continue;
+    mapping[name] = name;
+    const camel = toCamelCase(name);
+    if (camel !== name && !(camel in mapping)) {
+      mapping[camel] = name;
+    }
+  }
+  return mapping;
+}
+var DEFAULT_EXCLUDE_FOLDERS = ["node_modules", ".git", "dist", "build"];
+function viteCssModuleTypesPlugin(options = {
+  dtsOutputDir: ".css-module-types"
+}) {
+  let rootDir = "";
+  let cssSourceMapEnabled = false;
+  const includeFolders = normalizeFolderList(options.include);
+  const excludeFolders = normalizeFolderList(options.exclude ?? DEFAULT_EXCLUDE_FOLDERS);
+  let dtsGenOptions;
+  const createdDirs = new Set;
+  const contentCache = new Map;
+  async function ensureDir(dirPath) {
+    if (createdDirs.has(dirPath))
+      return;
+    await mkdir(dirPath, { recursive: true });
+    createdDirs.add(dirPath);
+  }
+  async function generateDtsFromSource(absolutePath, force = false) {
+    const relativePath = path.relative(rootDir, absolutePath);
+    const dtsFileName = options.allowArbitraryExtensions ? relativePath.replace(/\.css$/, ".d.css.ts") : `${relativePath}.d.ts`;
+    const dtsFilePath = path.join(rootDir, options.dtsOutputDir, dtsFileName);
+    if (!force) {
+      try {
+        await stat(dtsFilePath);
+        return;
+      } catch {}
+    }
+    const source = await readFile(absolutePath, "utf-8");
+    const classMapping = buildClassMappingFromSource(source);
+    const comments = extractCssComments(source);
+    const originalClassLines = buildOriginalClassLineMap(source);
+    const cssRuleBodies = extractCssRuleBodies(source);
+    const entries = resolveClassEntries(classMapping, null, comments, originalClassLines, cssRuleBodies);
+    const fileName = path.basename(absolutePath);
+    const { content: dtsBody } = generateDtsContent(entries, fileName, absolutePath, dtsGenOptions);
+    const outputDir = path.join(rootDir, options.dtsOutputDir, path.dirname(relativePath));
+    await ensureDir(outputDir);
+    await writeFile(dtsFilePath, dtsBody);
+  }
+  async function scanAllCssModules() {
+    const scanRoots = includeFolders.length > 0 ? includeFolders.map((f) => path.join(rootDir, f)) : [rootDir];
+    const allFiles = (await Promise.all(scanRoots.map((dir) => findFiles(dir, ".module.css")))).flat();
+    const eligible = allFiles.filter((f) => {
+      const rel = path.relative(rootDir, f);
+      return shouldProcessFile(rel, includeFolders, excludeFolders);
+    });
+    const results = await Promise.allSettled(eligible.map((f) => generateDtsFromSource(f)));
+    let generated = 0;
+    for (const r of results) {
+      if (r.status === "fulfilled")
+        generated++;
+    }
+    if (generated > 0) {
+      console.log(`[css-module-dts] Generated ${generated} declaration files on startup.`);
+    }
+  }
+  async function generateDtsFromTransform(code, id) {
+    const relativePath = path.relative(rootDir, id);
+    const patchedCode = patchViteModuleCode(code);
+    const { classMapping, cssText } = await evaluateModuleExports(patchedCode);
+    const lineMappings = cssSourceMapEnabled ? await getInlineLineMappings(cssText) : null;
+    const classIndex = lineMappings ? buildClassNameIndex(lineMappings) : null;
+    const source = await readFile(id, "utf-8");
+    const comments = extractCssComments(source);
+    const originalClassLines = buildOriginalClassLineMap(source);
+    const cssRuleBodies = extractCssRuleBodies(source);
+    const entries = resolveClassEntries(classMapping, classIndex, comments, originalClassLines, cssRuleBodies);
+    const fileName = path.basename(id);
+    const { content: dtsBody, lineMappings: dtsLineMappings } = generateDtsContent(entries, fileName, id, dtsGenOptions);
+    const outputDir = path.join(rootDir, options.dtsOutputDir, path.dirname(relativePath));
+    await ensureDir(outputDir);
+    const dtsFileName = options.allowArbitraryExtensions ? relativePath.replace(/\.css$/, ".d.css.ts") : `${relativePath}.d.ts`;
+    const dtsFilePath = path.join(rootDir, options.dtsOutputDir, dtsFileName);
+    const useDeclarationMap = (options.declarationMap ?? true) && cssSourceMapEnabled && dtsLineMappings.length > 0;
+    const dtsBaseName = path.basename(dtsFileName);
+    const mapFileName = `${dtsBaseName}.map`;
+    const dtsContent = useDeclarationMap ? `${dtsBody}//# sourceMappingURL=${mapFileName}
+` : dtsBody;
+    let mapContent;
+    if (useDeclarationMap) {
+      const cssRelativePath = path.relative(outputDir, id);
+      const totalDtsLines = dtsContent.split(`
+`).length;
+      mapContent = generateDeclarationMap(dtsBaseName, cssRelativePath, dtsLineMappings, totalDtsLines);
+    }
+    const mapFilePath = useDeclarationMap ? path.join(outputDir, mapFileName) : undefined;
+    try {
+      const existingDts = await readFile(dtsFilePath, "utf-8");
+      if (existingDts === dtsContent) {
+        if (!mapFilePath || !mapContent)
+          return;
+        try {
+          const existingMap = await readFile(mapFilePath, "utf-8");
+          if (existingMap === mapContent)
+            return;
+        } catch {}
+      }
+    } catch {}
+    await writeFile(dtsFilePath, dtsContent);
+    if (mapFilePath && mapContent) {
+      await writeFile(mapFilePath, mapContent);
+    }
+  }
+  return {
+    name: "vite-plugin-css-module-types",
+    apply: "serve",
+    enforce: "post",
+    configResolved(config) {
+      rootDir = config.root;
+      cssSourceMapEnabled = config.css.devSourcemap;
+      mkdirSync(path.join(rootDir, options.dtsOutputDir), { recursive: true });
+      dtsGenOptions = { namedExports: options.namedExports };
+    },
+    configureServer() {
+      scanAllCssModules().catch((err) => {
+        console.warn("[css-module-dts] Initial scan failed:", err);
+      });
+    },
+    async transform(code, id) {
+      if (!id.endsWith(".module.css"))
+        return null;
+      const relativePath = path.relative(rootDir, id);
+      if (!shouldProcessFile(relativePath, includeFolders, excludeFolders))
+        return null;
+      if (contentCache.get(id) === code)
+        return null;
+      contentCache.set(id, code);
+      try {
+        await generateDtsFromTransform(code, id);
+      } catch (error) {
+        console.warn(`[css-module-dts] Failed to generate types for ${relativePath}:`, error instanceof Error ? error.message : error);
+      }
+      return null;
+    },
+    handleHotUpdate({ file }) {
+      if (!file.endsWith(".module.css"))
+        return;
+      const relativePath = path.relative(rootDir, file);
+      if (!shouldProcessFile(relativePath, includeFolders, excludeFolders))
+        return;
+      contentCache.delete(file);
+      generateDtsFromSource(file, true).catch((err) => {
+        console.warn(`[css-module-dts] HMR re-generation failed for ${relativePath}:`, err);
+      });
+      return;
+    }
+  };
+}
+var plugin_default = viteCssModuleTypesPlugin;
+
+// index.ts
+var vite_plugin_css_module_types_default = plugin_default;
+export {
+  vite_plugin_css_module_types_default as default
+};

package/index.ts

@@ -0,0 +1,3 @@
+/** Plugin entry point — exposes only the stable public API. */
+import viteCssModuleTypesPlugin from './src/plugin.ts';
+export default viteCssModuleTypesPlugin;

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "vite-plugin-css-module-types",
+  "version": "1.0.0",
+  "description": "Vite dev-server plugin that generates .d.ts declarations for CSS Modules",
+  "keywords": [
+    "vite",
+    "plugin",
+    "css-modules",
+    "typescript",
+    "dts"
+  ],
+  "license": "MIT",
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./index.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "main": "./dist/index.js",
+  "files": [
+    "index.ts",
+    "src",
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "bun build index.ts --bundle --outdir dist --format esm --target node --packages external",
+    "check-types": "tsc --noEmit",
+    "prepublishOnly": "npm run check-types && npm run test && npm run build",
+    "test": "vitest run --config vitest.config.ts",
+    "test:watch": "vitest --config vitest.config.ts"
+  },
+  "dependencies": {
+    "@jridgewell/sourcemap-codec": "^1.5.5",
+    "source-map": "^0.7.6"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.0",
+    "vitest": "^4.1.0"
+  },
+  "peerDependencies": {
+    "typescript": ">=5",
+    "vite": ">=7"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/lib/camel-case.ts

@@ -0,0 +1,4 @@
+/** Converts kebab-case to camelCase (hyphens only, not underscores). */
+export function toCamelCase(name: string): string {
+  return name.replace(/-([a-zA-Z\d])/g, (_, char: string) => char.toUpperCase());
+}