caselyjs 0.0.1

package/LICENSE

@@ -0,0 +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.

package/README.md

@@ -0,0 +1,61 @@
+# 🛠️ caselyjs
+
+**renamejs** is a CLI and programmatic tool that helps you **rename files and folders** in bulk using a consistent naming convention like `kebab-case`, `camelCase`, or `PascalCase`.
+
+> Say goodbye to manually renaming 100+ files in your project!
+
+---
+
+## 📦 Installation
+
+```bash
+npm install renamejs
+```
+
+## 🚀 Usage
+
+### Minimum setup you need to start with `renamejs`
+
+```js
+// index.js
+import { rename } from 'renamejs';
+
+rename.config({
+  path: 'src'
+});
+
+rename.execute();
+```
+
+## ⚙️ Config Options
+
+### Default Options
+
+```js
+rename.config({
+  path: 'src',
+  case: 'kebab',
+  file: ['js', 'jsx'],
+  operate: 'partial'
+})
+```
+
+> [!NOTE]\
+> `path` is a required property.\
+> Don't need to pass any path as `'src/**/*'`, recursive is supported by default.
+>
+> currently, supporting three `case`s as `'kebab' | 'camel' | 'pascal'`\
+> default file extensions `['js', 'jsx']`, can include more extenstion in the array.\
+> eg.
+> ```js
+> rename.config({
+>  // ...previous
+>   file: ['js', 'jsx', 'ts', 'tsx']
+> })
+> ```
+> default operate mode is `'partial'`, which modifies only files.\
+> operate has two variants as `'partial' | 'full'`\
+> full will allow you to rename folders too.
+
+### Author
+**Made with ❤️ by Ninja-Vikash**

package/index.js

@@ -0,0 +1 @@
+export * from "./rename.js"

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "caselyjs",
+  "version": "0.0.1",
+  "description": "A tool for renaming files and folders in a efficient way",
+  "main": "index.js",
+  "type": "module",
+  "scripts": {
+    "rename": "node index.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Ninja-Vikash/renamejs.git"
+  },
+  "keywords": [
+    "rename",
+    "case",
+    "utility",
+    "file-renamer",
+    "casely",
+    "case-converter"
+  ],
+  "author": "ninja-vikash",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/Ninja-Vikash/renamejs/issues"
+  },
+  "homepage": "https://github.com/Ninja-Vikash/renamejs#readme"
+}

package/rename.js

@@ -0,0 +1,56 @@
+import path from "path";
+
+import { pathResolver } from "./tools/resolver.js";
+import { caseIdentifier } from "./tools/case-identifier.js";
+import { mutateCase } from "./tools/mutate-case.js";
+
+// ------------------------------------------------
+
+let defaultConfig = {
+  path: "",
+  file: ["js", "jsx"],
+  case: "kebab",
+  operate: "partial",
+};
+
+// -------------------------------------------------
+
+export const rename = {
+  config(options = {}) {
+    defaultConfig = {
+      ...defaultConfig,
+      ...options,
+    };
+  },
+
+  async execute() {
+    const { files, folders } = pathResolver(defaultConfig.path, {
+      recursive: true,
+    });
+
+    for (const file of files) {
+      const value = file.split("/").pop();
+      const fullPath = path.resolve(file);
+      const [fileName, fileExt] = value.split(".");
+      const currentCase = caseIdentifier(fileName);
+
+      if (defaultConfig.file.includes(fileExt)) {
+        if (currentCase !== defaultConfig.case) {
+          await mutateCase(fullPath, currentCase, defaultConfig.case);
+        }
+      }
+    }
+
+    if (defaultConfig.operate === "full") {
+      for (const folder of folders) {
+        const value = folder.split("/").pop();
+        const fullPath = path.resolve(folder);
+        const currentCase = caseIdentifier(value);
+
+        if (currentCase !== defaultConfig.case) {
+          await mutateCase(fullPath, currentCase, defaultConfig.case);
+        }
+      }
+    }
+  },
+};

package/tools/case-identifier.js

@@ -0,0 +1,10 @@
+export function caseIdentifier(val) {
+  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/tools/mutate-case.js

@@ -0,0 +1,21 @@
+import { toCamel } from "./transforms/to-camel.js";
+import { toKebab } from "./transforms/to-kebab.js";
+import { toPascal } from "./transforms/to-pascal.js";
+
+// --------------------------------------------------------
+
+export async function mutateCase(path, currentType, expectedType) {
+
+  if (expectedType === "camel") {
+    toCamel(path, currentType);
+  }
+
+  if (expectedType === "kebab") {
+    toKebab(path, currentType);
+  }
+
+  if (expectedType === "pascal") {
+    toPascal(path, currentType);
+  }
+
+}

package/tools/resolver.js

@@ -0,0 +1,36 @@
+import fs from 'fs';
+import path from 'path';
+
+/**
+ * List all files and folders in a given path
+ * @param {string} targetPath - The directory to scan
+ * @param {Object} options
+ * @param {boolean} [options.recursive=false] - If true, lists recursively
+ * @returns {{ files: string[], folders: string[] }}
+ */
+export function pathResolver(targetPath, options = { recursive: false }) {
+  const result = {
+    files: [],
+    folders: [],
+  };
+
+  function scan(dir) {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+
+      if (entry.isDirectory()) {
+        result.folders.push(fullPath.replace(/\\/g, '/'));
+        if (options.recursive) {
+          scan(fullPath);
+        }
+      } else if (entry.isFile()) {
+        result.files.push(fullPath.replace(/\\/g, '/'));
+      }
+    }
+  }
+
+  scan(targetPath);
+  return result;
+}

package/tools/transforms/to-camel.js

@@ -0,0 +1,58 @@
+import fs from 'fs';
+import path from 'path';
+
+function toCamelCase(str) {
+  return str
+    .replace(/[-_](.)/g, (_, group1) => group1.toUpperCase())
+    .replace(/^(.)/, (_, group1) => group1.toLowerCase());
+}
+
+function kebabToCamel(targetPath) {
+  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) {
+    console.error(`❌ Rename failed: ${err.message}`);
+  }
+}
+
+function pascalToCamel(targetPath) {
+  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) {
+    console.error(`❌ Rename failed: ${err.message}`);
+  }
+}
+
+// ----------------------------------------------------
+
+export function toCamel(targetPath, currentType) {
+  if (currentType === 'kebab') {
+    kebabToCamel(targetPath);
+  } else if (currentType === 'pascal') {
+    pascalToCamel(targetPath);
+  } else {
+    console.log('⚠️ Unsupported case type passed.');
+  }
+}

package/tools/transforms/to-kebab.js

@@ -0,0 +1,59 @@
+import fs from 'fs';
+import path from 'path';
+
+function toKebabCase(str) {
+  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) {
+  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) {
+    console.error(`❌ Rename failed: ${err.message}`);
+  }
+}
+
+function camelToKebab(targetPath) {
+  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) {
+    console.error(`❌ Rename failed: ${err.message}`);
+  }
+}
+
+// ----------------------------------------------------
+
+export function toKebab(targetPath, currentType) {
+  if (currentType === 'pascal') {
+    pascalToKebab(targetPath);
+  } else if (currentType === 'camel') {
+    camelToKebab(targetPath);
+  } else {
+    console.log('⚠️ Unsupported case type passed.');
+  }
+}

package/tools/transforms/to-pascal.js

@@ -0,0 +1,58 @@
+import fs from 'fs';
+import path from 'path';
+
+function toPascalCase(str) {
+  return str
+    .replace(/[-_](.)/g, (_, group1) => group1.toUpperCase())
+    .replace(/^(.)/, (_, group1) => group1.toUpperCase());
+}
+
+function kebabToPascal(targetPath) {
+  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) {
+    console.error(`❌ Rename failed: ${err.message}`);
+  }
+}
+
+function camelToPascal(targetPath) {
+  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) {
+    console.error(`❌ Rename failed: ${err.message}`);
+  }
+}
+
+// ----------------------------------------------------
+
+export function toPascal(targetPath, currentType) {
+  if (currentType === 'kebab') {
+    kebabToPascal(targetPath);
+  } else if (currentType === 'camel') {
+    camelToPascal(targetPath);
+  } else {
+    console.log('⚠️ Unsupported case type passed.');
+  }
+}