caselyjs 1.0.0 → 1.0.4

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2025 Vikash Kumar
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2025 Vikash Kumar
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,117 +1,104 @@
-# 🛠️ caselyjs
-
-**caselyjs** is a high-performance TypeScript-powered CLI and programmatic utility designed to **rename files and directories** across your entire codebase using consistent naming conventions.
-
-> Say goodbye to manually renaming 100+ files in your project!
-
----
-
-## ✨ New in v1.0
-
-- **Native TypeScript Support**: Full type definitions included.
-- **Powerful CLI**: Run transformations directly from your terminal.
-- **Dry Run Mode**: Preview changes before they are applied to your filesystem.
-- **Recursive Bottom-Up Renaming**: Safely renames nested directories without breaking paths.
-- **Enhanced Extension Support**: Easily filter which file types to transform.
-
----
-
-## 📦 Installation
-
-### For CLI usage (Global)
-
-```bash
-npm install -g caselyjs
-```
-
-### For Programmatic usage (Local)
-
-```bash
-npm install caselyjs
-```
-
-## 🚀 CLI Usage
-
-You can now run `caselyjs` directly from your terminal without writing any code.
-
-```bash
-# Basic usage (defaults to kebab-case and .js, .jsx, .ts, .tsx files)
-caselyjs ./src
-
-# Convert to PascalCase including folders
-caselyjs ./src --case pascal --full
-
-# Custom extensions and Dry Run (see changes before they happen)
-caselyjs ./src --ext "js,ts,css" --case camel --dry
-```
-
-## ⚡ Quick Run (No Installation Required)
-
-```bash
-# Rename all .js/ts files in the current folder to kebab-case
-npx caselyjs .
-
-# Run a full conversion to PascalCase on a specific folder
-npx caselyjs ./src/components --case pascal --full
-
-# Preview changes in a specific directory without actually renaming anything
-npx caselyjs ./my-project --dry
-```
-
-### Why this is the "Pro" way to use CaselyJS:
-
-- **No Clutter**: Doesn't stay on the user's machine or in their node_modules.
-
-- **Always Fresh**: npx always pulls the latest version (v2.0.0+), so they get your newest bug fixes and case-identification logic automatically.
-
-- **CI/CD Friendly**: Perfect for use in GitHub Actions or automation scripts where you want to enforce a naming convention during a build step without a permanent install.
-
-## CLI Options
-
-| Flag     | Shorthand | Description                                 | Default         |
-| :------- | :-------- | :------------------------------------------ | :-------------- |
-| `--case` | -c        | "Target case: camel, kebab, or pascal"      | kebab           |
-| `--ext`  | -e        | Comma-separated list of file extensions     | "js,jsx,ts,tsx" |
-| `--full` | -f        | Rename directories in addition to files     | false           |
-| `--dry`  |           | Show intended changes without applying them | false           |
-
-## 💻 Programmatic Usage
-
-If you prefer to integrate CaselyJS into your own build scripts or tools:
-
-```ts
-import { casely } from "caselyjs";
-
-casely.config({
-  path: "./src",
-  case: "camel",
-  file: ["ts", "tsx"],
-  operate: "full", // 'partial' (files only) or 'full' (files + folders)
-  dryRun: true, // highly recommended for testing
-});
-
-await casely.execute();
-```
-
-## ⚙️ Advanced Configuration
-
-> [!NOTE]\
->
-> - **Recursive by Default**: You only need to provide the root directory. CaselyJS automatically traverses all subdirectories.
-> - **Safety First**: When using operate: "full", CaselyJS uses a bottom-up renaming strategy to ensure directory paths remain valid during the process.
-
-### Supported Case Types
-
-- kebab-case
-- camelCase
-- PascalCase
-
-## 🛠️ Built With
-
-- **TypeScript** - For type-safe filesystem operations.
-- **Commander.js** - Robust CLI argument parsing.
-- **Chalk** - Beautifully colored terminal output.
-
-### 👨‍💻 Author
-
-**Made with ❤️ by _codezaura_**
+<img width="1420" height="640" alt="casely-js" src="https://github.com/user-attachments/assets/9e49a868-c644-4e8b-9c16-5759ffc35969" />
+
+<br />
+
+<div>
+  <h1>Caselyjs - CLI</h1>
+</div>
+
+Tired of Codebases with Mismatched File Casing?🛠️ Meet `CaselyJS (v1.0.1)`
+
+<div>
+<b>caselyjs</> is a high-performance TypeScript-powered CLI and programmatic utility designed to <b>rename files and directories</b> across your entire codebase using consistent naming conventions.</b>
+  <br />
+  <br />
+> <i>Say goodbye to manually renaming 100+ files in your project!</i>
+</div>
+
+## ✨ New in v1.0
+
+- **Native TypeScript Support**: Full type definitions included.
+- **Powerful CLI**: Run transformations directly from your terminal.
+- **Dry Run Mode**: Preview changes before they are applied to your filesystem.
+- **Recursive Bottom-Up Renaming**: Safely renames nested directories without breaking paths.
+- **Enhanced Extension Support**: Easily filter which file types to transform.
+
+---
+
+## ⚡ The 10-Second Quick Start (No Install Required)
+
+```bash
+# Rename all .js/ts files in the current folder to kebab-case
+npx caselyjs .
+
+# Run a full conversion to PascalCase on a specific folder
+npx caselyjs ./src/components --case pascal --full
+
+# Preview changes in a specific directory without actually renaming anything
+npx caselyjs ./my-project --dry
+```
+
+> [!IMPORTANT]
+> ```bash
+> # safe command before executing
+> npx caselyjs --dry
+> ```
+
+### Why this is the "Pro" way to use CaselyJS:
+
+- **No Clutter**: Doesn't stay on the user's machine or in their node_modules.
+
+- **Always Fresh**: npx always pulls the latest version (v1.0.0+), so they get your newest bug fixes and case-identification logic automatically.
+
+- **CI/CD Friendly**: Perfect for use in GitHub Actions or automation scripts where you want to enforce a naming convention during a build step without a permanent install.
+
+## ⚙️ CLI Options
+
+| Flag     | Shorthand | Description                                 | Default         |
+| :------- | :-------- | :------------------------------------------ | :-------------- |
+| `--case` | -c        | "Target case: camel, kebab, or pascal"      | kebab           |
+| `--ext`  | -e        | Comma-separated list of file extensions     | "js,jsx,ts,tsx" |
+| `--full` | -f        | Rename directories in addition to files     | false           |
+| `--dry`  |           | Show intended changes without applying them | false           |
+
+## 💻 Programmatic Usage
+
+If you prefer to integrate CaselyJS into your own build scripts or tools:
+
+```ts
+import { casely } from "caselyjs";
+
+casely.config({
+  path: "./src",
+  case: "camel",
+  file: ["ts", "tsx"],
+  operate: "full", // 'partial' (files only) or 'full' (files + folders)
+  dryRun: true, // highly recommended for testing
+});
+
+await casely.execute();
+```
+
+## ⚙️ Advanced Configuration
+
+- **Recursive by Default**: You only need to provide the root directory. CaselyJS automatically traverses all subdirectories.
+- **Safety First**: When using operate: "full", CaselyJS uses a bottom-up renaming strategy to ensure directory paths remain valid during the process.
+
+### Supported Case Types
+
+- kebab-case
+- camelCase
+- PascalCase
+
+## 🛠️ Built With
+
+- **TypeScript** - For type-safe filesystem operations.
+- **Commander.js** - Robust CLI argument parsing.
+- **Chalk** - Beautifully colored terminal output.
+
+### 🌐 Links
+- [dev.to](https://dev.to/thatonevikash/tired-of-codebases-with-mismatched-file-casing-meet-caselyjs-v101-479n)
+
+### 👨‍💻 Author
+
+**Made with ❤️ by _thatonevikash_**

package/package.json

@@ -1,43 +1,50 @@
-{
-  "name": "caselyjs",
-  "version": "1.0.0",
-  "description": "Rename codebase files and directories with ease",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/codezaura/caselyjs.git"
-  },
-  "keywords": [
-    "naming convention tool",
-    "file / folder renamer",
-    "case changer",
-    "kebab case to pascal case",
-    "pascal case to camel case",
-    "came case to kebab case"
-  ],
-  "author": "codezaura",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/codezaura/caselyjs/issues"
-  },
-  "homepage": "https://github.com/codezaura/caselyjs#readme",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "bin": {
-    "casely": "dist/bin.js"
-  },
-  "scripts": {
-    "build": "tsc",
-    "start": "node dist/bin.js",
-    "dev": "ts-node src/bin.ts",
-    "prepublishOnly": "npm run build"
-  },
-  "dependencies": {
-    "chalk": "^5.3.0",
-    "commander": "^11.0.0"
-  },
-  "devDependencies": {
-    "@types/node": "^20.19.39",
-    "ts-node": "^10.9.1",
-    "typescript": "^5.0.0"
-  }
-}
+{
+  "name": "caselyjs",
+  "version": "1.0.4",
+  "author": "thatonevikash",
+  "description": "Rename codebase files and directories with ease",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/thatonevikash/caselyjs.git"
+  },
+  "keywords": [
+    "naming convention tool",
+    "file / folder renamer",
+    "case changer",
+    "kebab case to pascal case",
+    "pascal case to camel case",
+    "came case to kebab case"
+  ],
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/thatonevikash/caselyjs/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "homepage": "https://github.com/thatonevikash/caselyjs#readme",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "casely": "dist/bin.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/bin.js",
+    "dev": "ts-node src/bin.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^11.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.19.39",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.0.0"
+  }
+}

package/src/bin.ts

@@ -1,36 +0,0 @@
-#!/usr/bin/env node
-import { Command } from "commander";
-import { casely } from "./index";
-import chalk from "chalk";
-
-const program = new Command();
-
-program
-  .name("caselyjs")
-  .description("Transform codebase file and directory casing")
-  .version("2.0.0")
-  .argument("[path]", "Path to process", ".")
-  .option("-c, --case <type>", "Target case: camel, kebab, pascal", "kebab")
-  .option(
-    "-e, --ext <extensions>",
-    "Comma separated extensions",
-    "js,jsx,ts,tsx",
-  )
-  .option("-f, --full", "Rename directories as well", false)
-  .option("--dry", "Dry run (show changes without applying)", false)
-  .action(async (path, options) => {
-    console.log(chalk.blue.bold(`\n🚀 CaselyJS starting in ${path}...`));
-
-    casely.config({
-      path: path,
-      case: options.case,
-      file: options.ext.split(","),
-      operate: options.full ? "full" : "partial",
-      dryRun: options.dry,
-    });
-
-    await casely.execute();
-    console.log(chalk.green.bold("\n✨ Casing transformation complete!"));
-  });
-
-program.parse();

package/src/casely.ts

@@ -1,87 +0,0 @@
-import path from "path";
-import fs from "fs";
-import { pathResolver } from "./tools/resolver";
-import { caseIdentifier } from "./tools/case-identifier";
-import { CaselyConfig, CaseType } from "./types";
-import chalk from "chalk";
-
-// -------------------------------------------------------------
-
-let defaultConfig: CaselyConfig = {
-  path: process.cwd(),
-  file: ["js", "jsx", "ts", "tsx"],
-  case: "kebab",
-  operate: "partial",
-  dryRun: false,
-};
-
-// -------------------------------------------------------------
-
-export const casely = {
-  config(options: Partial<CaselyConfig>) {
-    defaultConfig = { ...defaultConfig, ...options };
-  },
-
-  async execute() {
-    const { files, folders } = pathResolver(defaultConfig.path, {
-      recursive: true,
-    });
-
-    // 1. Handle Files
-    for (const filePath of files) {
-      const ext = path.extname(filePath).slice(1);
-      if (!defaultConfig.file.includes(ext)) continue;
-
-      const dirname = path.dirname(filePath);
-      const basename = path.basename(filePath, `.${ext}`);
-      const currentCase = caseIdentifier(basename);
-
-      if (currentCase !== defaultConfig.case) {
-        this.rename(filePath, basename, ext, currentCase);
-      }
-    }
-
-    // 2. Handle Folders (Bottom-Up)
-    if (defaultConfig.operate === "full") {
-      const sortedFolders = folders.sort((a, b) => b.length - a.length);
-      for (const folderPath of sortedFolders) {
-        const basename = path.basename(folderPath);
-        const currentCase = caseIdentifier(basename);
-
-        if (currentCase !== defaultConfig.case) {
-          this.rename(folderPath, basename, "", currentCase);
-        }
-      }
-    }
-  },
-
-  rename(fullPath: string, name: string, ext: string, currentCase: CaseType) {
-    const newName = this.transform(name, defaultConfig.case);
-    const finalName = ext ? `${newName}.${ext}` : newName;
-    const newPath = path.join(path.dirname(fullPath), finalName);
-
-    if (defaultConfig.dryRun) {
-      console.log(
-        chalk.yellow(`[DRY RUN] ${path.basename(fullPath)} ➝ ${finalName}`),
-      );
-    } else {
-      fs.renameSync(fullPath, newPath);
-      console.log(chalk.cyan(`✔ Renamed: ${finalName}`));
-    }
-  },
-
-  transform(str: string, target: CaseType): string {
-    // Your transformation logic (toCamel, toKebab, etc)
-    if (target === "kebab")
-      return str.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
-    if (target === "camel")
-      return str
-        .replace(/[-_](.)/g, (_, g) => g.toUpperCase())
-        .replace(/^(.)/, (g) => g.toLowerCase());
-    if (target === "pascal")
-      return str
-        .replace(/[-_](.)/g, (_, g) => g.toUpperCase())
-        .replace(/^(.)/, (g) => g.toUpperCase());
-    return str;
-  },
-};

package/src/index.ts

@@ -1 +0,0 @@
-export * from "./casely";

package/src/tools/case-identifier.ts

@@ -1,12 +0,0 @@
-// -------------------------------------------------------------
-
-export function caseIdentifier(val: string) {
-  const str = val.split(".")[0];
-
-  if (/^[a-z]+$/.test(str)) return "kebab";
-  if (/^[a-z]+(-[a-z]+)+$/.test(str)) return "kebab";
-  if (/^[a-z]+(?:[A-Z][a-z]*)*$/.test(str)) return "camel";
-  if (/^[A-Z][a-z]+(?:[A-Z][a-z]*)*$/.test(str)) return "pascal";
-
-  return "unknown";
-}

package/src/tools/mutate-case.ts

@@ -1,24 +0,0 @@
-import { toCamel } from "../transforms/to-camel.js";
-import { toKebab } from "../transforms/to-kebab.js";
-import { toPascal } from "../transforms/to-pascal.js";
-import { CaseType } from "../types.js";
-
-// -------------------------------------------------------------
-
-export async function mutateCase(
-  path: string,
-  currentType: Exclude<CaseType, "unknown">,
-  expectedType: Exclude<CaseType, "unknown">,
-): Promise<void> {
-  if (expectedType === "camel") {
-    toCamel(path, currentType);
-  }
-
-  if (expectedType === "kebab") {
-    toKebab(path, currentType);
-  }
-
-  if (expectedType === "pascal") {
-    toPascal(path, currentType);
-  }
-}

package/src/tools/resolver.ts

@@ -1,55 +0,0 @@
-import fs from "fs";
-import path from "path";
-
-// -------------------------------------------------------------
-
-interface PathResolverOptions {
-  recursive?: boolean;
-}
-
-interface PathResolverResult {
-  files: string[];
-  folders: string[];
-}
-
-// -------------------------------------------------------------
-
-/**
- * List all files and folders in a given path
- * @param targetPath - The directory to scan
- * @param options - Configuration options
- * @param options.recursive - If true, lists recursively (default: false)
- * @returns An object containing arrays of file and folder paths
- */
-export function pathResolver(
-  targetPath: string,
-  options: PathResolverOptions = {},
-): PathResolverResult {
-  const { recursive = false } = options;
-
-  const result: PathResolverResult = {
-    files: [],
-    folders: [],
-  };
-
-  function scan(dir: string): void {
-    const entries = fs.readdirSync(dir, { withFileTypes: true });
-
-    for (const entry of entries) {
-      const fullPath = path.join(dir, entry.name);
-      const normalizedPath = fullPath.replace(/\\/g, "/");
-
-      if (entry.isDirectory()) {
-        result.folders.push(normalizedPath);
-        if (recursive) {
-          scan(fullPath);
-        }
-      } else if (entry.isFile()) {
-        result.files.push(normalizedPath);
-      }
-    }
-  }
-
-  scan(targetPath);
-  return result;
-}

package/src/transforms/to-camel.ts

@@ -1,70 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { type CaseType } from "../types";
-
-// -------------------------------------------------------------
-
-function toCamelCase(str: string): string {
-  return str
-    .replace(/[-_](.)/g, (_, group1: string) => group1.toUpperCase())
-    .replace(/^(.)/, (_, group1: string) => group1.toLowerCase());
-}
-
-// -------------------------------------------------------------
-
-function kebabToCamel(targetPath: string): void {
-  const parent = path.dirname(targetPath);
-  const currentName = path.basename(targetPath);
-  const newName = toCamelCase(currentName);
-  const newPath = path.join(parent, newName);
-
-  if (currentName === newName) {
-    console.log(`✅ Already in camelCase: ${currentName}`);
-    return;
-  }
-
-  try {
-    fs.renameSync(targetPath, newPath);
-    console.log(`✨ Renamed Kebab → Camel: ${currentName} ➝ ${newName}`);
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    console.error(`❌ Rename failed: ${message}`);
-  }
-}
-
-// -------------------------------------------------------------
-
-function pascalToCamel(targetPath: string): void {
-  const parent = path.dirname(targetPath);
-  const currentName = path.basename(targetPath);
-  const newName = currentName.charAt(0).toLowerCase() + currentName.slice(1);
-  const newPath = path.join(parent, newName);
-
-  if (currentName === newName) {
-    console.log(`✅ Already in camelCase: ${currentName}`);
-    return;
-  }
-
-  try {
-    fs.renameSync(targetPath, newPath);
-    console.log(`✨ Renamed Pascal → Camel: ${currentName} ➝ ${newName}`);
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    console.error(`❌ Rename failed: ${message}`);
-  }
-}
-
-// -------------------------------------------------------------
-
-export function toCamel(
-  targetPath: string,
-  currentType: Partial<CaseType>,
-): void {
-  if (currentType === "kebab") {
-    kebabToCamel(targetPath);
-  } else if (currentType === "pascal") {
-    pascalToCamel(targetPath);
-  } else {
-    console.log("⚠️ Unsupported case type passed.");
-  }
-}

package/src/transforms/to-kebab.ts

@@ -1,71 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { type CaseType } from "../types";
-
-// -------------------------------------------------------------
-
-function toKebabCase(str: string): string {
-  return str
-    .replace(/([a-z0-9])([A-Z])/g, "$1-$2")
-    .replace(/([A-Z])([A-Z][a-z])/g, "$1-$2")
-    .toLowerCase();
-}
-
-// -------------------------------------------------------------
-
-function pascalToKebab(targetPath: string): void {
-  const parent = path.dirname(targetPath);
-  const currentName = path.basename(targetPath);
-  const newName = toKebabCase(currentName);
-  const newPath = path.join(parent, newName);
-
-  if (currentName === newName) {
-    console.log(`✅ Already in kebab-case: ${currentName}`);
-    return;
-  }
-
-  try {
-    fs.renameSync(targetPath, newPath);
-    console.log(`✨ Renamed Pascal → Kebab: ${currentName} ➝ ${newName}`);
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    console.error(`❌ Rename failed: ${message}`);
-  }
-}
-
-// -------------------------------------------------------------
-
-function camelToKebab(targetPath: string): void {
-  const parent = path.dirname(targetPath);
-  const currentName = path.basename(targetPath);
-  const newName = toKebabCase(currentName);
-  const newPath = path.join(parent, newName);
-
-  if (currentName === newName) {
-    console.log(`✅ Already in kebab-case: ${currentName}`);
-    return;
-  }
-
-  try {
-    fs.renameSync(targetPath, newPath);
-    console.log(`✨ Renamed Camel → Kebab: ${currentName} ➝ ${newName}`);
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    console.error(`❌ Rename failed: ${message}`);
-  }
-}
-
-// -------------------------------------------------------------
-
-export function toKebab(
-  targetPath: string,
-  currentType: Partial<CaseType>,
-): void {
-  if (currentType === "pascal") {
-    pascalToKebab(targetPath);
-  } else if (currentType === "camel") {
-    camelToKebab(targetPath);
-  } else {
-    console.log("⚠️ Unsupported case type passed.");
-  }
-}

package/src/transforms/to-pascal.ts

@@ -1,68 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { type CaseType } from "../types";
-
-// -------------------------------------------------------------
-
-function toPascalCase(str: string): string {
-  return str
-    .replace(/[-_](.)/g, (_, group1: string) => group1.toUpperCase())
-    .replace(/^(.)/, (_, group1: string) => group1.toUpperCase());
-}
-
-function kebabToPascal(targetPath: string): void {
-  const parent = path.dirname(targetPath);
-  const currentName = path.basename(targetPath);
-  const newName = toPascalCase(currentName);
-  const newPath = path.join(parent, newName);
-
-  if (currentName === newName) {
-    console.log(`✅ Already in PascalCase: ${currentName}`);
-    return;
-  }
-
-  try {
-    fs.renameSync(targetPath, newPath);
-    console.log(`✨ Renamed Kebab → Pascal: ${currentName} ➝ ${newName}`);
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    console.error(`❌ Rename failed: ${message}`);
-  }
-}
-
-// -------------------------------------------------------------
-
-function camelToPascal(targetPath: string): void {
-  const parent = path.dirname(targetPath);
-  const currentName = path.basename(targetPath);
-  const newName = currentName.charAt(0).toUpperCase() + currentName.slice(1);
-  const newPath = path.join(parent, newName);
-
-  if (currentName === newName) {
-    console.log(`✅ Already in PascalCase: ${currentName}`);
-    return;
-  }
-
-  try {
-    fs.renameSync(targetPath, newPath);
-    console.log(`✨ Renamed Camel → Pascal: ${currentName} ➝ ${newName}`);
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    console.error(`❌ Rename failed: ${message}`);
-  }
-}
-
-// -------------------------------------------------------------
-
-export function toPascal(
-  targetPath: string,
-  currentType: Partial<CaseType>,
-): void {
-  if (currentType === "kebab") {
-    kebabToPascal(targetPath);
-  } else if (currentType === "camel") {
-    camelToPascal(targetPath);
-  } else {
-    console.log("⚠️ Unsupported case type passed.");
-  }
-}

package/src/types.ts

@@ -1,10 +0,0 @@
-export type CaseType = "camel" | "kebab" | "pascal" | "unknown";
-export type OperationMode = "partial" | "full";
-
-export interface CaselyConfig {
-  path: string;
-  file: string[]; // e.g. ["js", "ts"]
-  case: CaseType;
-  operate: OperationMode;
-  dryRun?: boolean;
-}

package/tsconfig.json

@@ -1,33 +0,0 @@
-{
-  "compilerOptions": {
-    /* Base Options */
-    "target": "ES2022",
-    "module": "nodenext",
-    "allowSyntheticDefaultImports": true,
-
-    "moduleResolution": "nodenext",
-    "lib": ["ES2022"],
-    "declaration": true /* Generates .d.ts files for your library users */,
-    "sourceMap": true /* Helps with debugging */,
-
-    /* Output Settings */
-    "outDir": "./dist" /* Where the compiled JS goes */,
-    "rootDir": "./src" /* Where your TS source lives */,
-    "removeComments": true,
-
-    /* Strictness & Safety */
-    "strict": true /* Ensures high-quality, type-safe code */,
-    "noImplicitAny": true,
-    "esModuleInterop": true /* Fixes compatibility with some older JS packages */,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-
-    /* Path Mapping (Optional) */
-    "baseUrl": ".",
-    "paths": {
-      "*": ["node_modules/*"]
-    }
-  },
-  "include": ["src/**/*"] /* Only compile files in the src folder */,
-  "exclude": ["node_modules", "dist"]
-}