caselyjs 0.1.0 → 1.0.0

package/dist/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":""}

package/package.json

@@ -1,12 +1,7 @@
 {
   "name": "caselyjs",
-  "version": "0.1.0",
-  "description": "A minimal renaming tool for setting an uniform naming convetion accross all files, capable of renaming 100+ files in one go.",
-  "main": "index.js",
-  "type": "module",
-  "scripts": {
-    "rename": "node index.js"
-  },
+  "version": "1.0.0",
+  "description": "Rename codebase files and directories with ease",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/codezaura/caselyjs.git"
@@ -24,5 +19,25 @@
   "bugs": {
     "url": "https://github.com/codezaura/caselyjs/issues"
   },
-  "homepage": "https://github.com/codezaura/caselyjs#readme"
+  "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"
+  }
 }

package/src/bin.ts

@@ -0,0 +1,36 @@
+#!/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

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

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

package/src/tools/case-identifier.ts

@@ -0,0 +1,12 @@
+// -------------------------------------------------------------
+
+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

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

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

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

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

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

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

@@ -0,0 +1,33 @@
+{
+  "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"]
+}

package/casely.js

@@ -1,56 +0,0 @@
-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 casely = {
-  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/index.js

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

package/tools/case-identifier.js

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

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

@@ -1,36 +0,0 @@
-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;
-}