@tkeron/tools 0.1.1 → 0.2.0

package/bun.lock

@@ -7,18 +7,20 @@
         "@types/bun": "latest",
       },
       "peerDependencies": {
-        "typescript": "^5.0.0",
+        "typescript": "^5.7.3",
       },
     },
   },
   "packages": {
-    "@types/bun": ["@types/bun@1.2.2", "", { "dependencies": { "bun-types": "1.2.2" } }, "sha512-tr74gdku+AEDN5ergNiBnplr7hpDp3V1h7fqI2GcR/rsUaM39jpSeKH0TFibRvU0KwniRx5POgaYnaXbk0hU+w=="],
+    "@types/bun": ["@types/bun@1.2.18", "", { "dependencies": { "bun-types": "1.2.18" } }, "sha512-Xf6RaWVheyemaThV0kUfaAUvCNokFr+bH8Jxp+tTZfx7dAPA8z9ePnP9S9+Vspzuxxx9JRAXhnyccRj3GyCMdQ=="],
 
     "@types/node": ["@types/node@22.13.1", "", { "dependencies": { "undici-types": "~6.20.0" } }, "sha512-jK8uzQlrvXqEU91UxiK5J7pKHyzgnI1Qnl0QDHIgVGuolJhRb9EEl28Cj9b3rGR8B2lhFCtvIm5os8lFnO/1Ew=="],
 
-    "@types/ws": ["@types/ws@8.5.14", "", { "dependencies": { "@types/node": "*" } }, "sha512-bd/YFLW+URhBzMXurx7lWByOu+xzU9+kb3RboOteXYDfW+tr+JZa99OyNmPINEGB/ahzKrEuc8rcv4gnpJmxTw=="],
+    "@types/react": ["@types/react@19.1.8", "", { "dependencies": { "csstype": "^3.0.2" } }, "sha512-AwAfQ2Wa5bCx9WP8nZL2uMZWod7J7/JSplxbTmBQ5ms6QpqNYm672H0Vu9ZVKVngQ+ii4R/byguVEUZQyeg44g=="],
 
-    "bun-types": ["bun-types@1.2.2", "", { "dependencies": { "@types/node": "*", "@types/ws": "~8.5.10" } }, "sha512-RCbMH5elr9gjgDGDhkTTugA21XtJAy/9jkKe/G3WR2q17VPGhcquf9Sir6uay9iW+7P/BV0CAHA1XlHXMAVKHg=="],
+    "bun-types": ["bun-types@1.2.18", "", { "dependencies": { "@types/node": "*" }, "peerDependencies": { "@types/react": "^19" } }, "sha512-04+Eha5NP7Z0A9YgDAzMk5PHR16ZuLVa83b26kH5+cp1qZW4F6FmAURngE7INf4tKOvCE69vYvDEwoNl1tGiWw=="],
+
+    "csstype": ["csstype@3.1.3", "", {}, "sha512-M1uQkMl8rQK/szD0LNhtqxIPLpimGm8sOBwU7lLnCpSbTyY3yeU1Vc7l4KT5zT4s/yOxHH5O7tIuuLOCnLADRw=="],
 
     "typescript": ["typescript@5.7.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-84MVSjMEHP+FQRPy3pX9sTVV/INIex71s9TL2Gm5FG/WG1SqXeKyZ0k7/blY/4FdOzI12CBy1vGc4og/eus0fw=="],
 

package/package.json

@@ -1,21 +1,26 @@
 {
   "name": "@tkeron/tools",
-  "version": "0.1.1",
-  "description": "Useful JavaScript utilities",
+  "version": "0.2.0",
+  "description": "Useful JavaScript utilities for Bun runtime",
   "main": "src/index.ts",
   "module": "src/index.ts",
   "type": "module",
   "author": "tkeron",
   "license": "MIT",
+  "engines": {
+    "bun": ">=1.0.0"
+  },
   "devDependencies": {
     "@types/bun": "latest"
   },
   "peerDependencies": {
-    "typescript": "^5.0.0"
+    "typescript": "^5.7.3"
   },
   "keywords": [
+    "bun",
     "utilities",
-    "utils"
+    "utils",
+    "tools"
   ],
   "repository": {
     "url": "git@github.com:tkeron/tools.git"

package/src/getPaths.test.ts

@@ -0,0 +1,492 @@
+import { describe, test, expect, beforeAll, afterAll, it } from "bun:test";
+import { mkdirSync, writeFileSync, rmSync } from "fs";
+import { join } from "path";
+import { getPaths, getFilePaths, getDirectoryPaths } from "./getPaths";
+
+const testDir = join(process.cwd(), "test-temp");
+
+describe("getPaths Tests", () => {
+
+    beforeAll(() => {
+        mkdirSync(testDir, { recursive: true });
+
+        writeFileSync(join(testDir, "file1.txt"), "content");
+        writeFileSync(join(testDir, "file2.js"), "content");
+        writeFileSync(join(testDir, "README.md"), "content");
+
+        mkdirSync(join(testDir, "src"), { recursive: true });
+        writeFileSync(join(testDir, "src", "index.ts"), "content");
+        writeFileSync(join(testDir, "src", "utils.ts"), "content");
+
+        mkdirSync(join(testDir, "docs"), { recursive: true });
+        writeFileSync(join(testDir, "docs", "guide.md"), "content");
+
+        mkdirSync(join(testDir, "empty-dir"), { recursive: true });
+
+        mkdirSync(join(testDir, "src", "components"), { recursive: true });
+        writeFileSync(join(testDir, "src", "components", "Button.tsx"), "content");
+
+        writeFileSync(join(testDir, ".env"), "content");
+        mkdirSync(join(testDir, ".git"), { recursive: true });
+        writeFileSync(join(testDir, ".git", "config"), "content");
+
+        writeFileSync(join(testDir, "file with spaces.txt"), "content");
+        writeFileSync(join(testDir, "file-no-extension"), "content");
+        writeFileSync(join(testDir, "UPPERCASE.TXT"), "content");
+        writeFileSync(join(testDir, "números-ñ-ü.js"), "content");
+
+        writeFileSync(join(testDir, "config.json"), "content");
+        writeFileSync(join(testDir, "styles.css"), "content");
+        writeFileSync(join(testDir, "script.jsx"), "content");
+
+        mkdirSync(join(testDir, "deep", "very", "nested", "structure"), { recursive: true });
+        writeFileSync(join(testDir, "deep", "very", "nested", "structure", "deep-file.txt"), "content");
+
+        mkdirSync(join(testDir, "node_modules"), { recursive: true });
+        writeFileSync(join(testDir, "node_modules", "package.json"), "content");
+        mkdirSync(join(testDir, "build"), { recursive: true });
+        writeFileSync(join(testDir, "build", "output.js"), "content");
+    });
+
+    afterAll(() => {
+        rmSync(testDir, { recursive: true, force: true });
+    });
+
+    describe("getPaths", () => {
+        test("should return both files and directories when includeDirectories is 'yes'", () => {
+            const result = getPaths(testDir, "**/*", "yes");
+
+            expect(result.length).toBeGreaterThan(0);
+            expect(result.some(path => path.includes("file1.txt"))).toBe(true);
+            expect(result.some(path => path.includes("src"))).toBe(true);
+            expect(result.some(path => path.includes("docs"))).toBe(true);
+        });
+
+        test("should return only files when includeDirectories is 'no'", () => {
+            const result = getPaths(testDir, "**/*", "no");
+
+            expect(result.length).toBeGreaterThan(0);
+            expect(result.some(path => path.includes("file1.txt"))).toBe(true);
+            expect(result.some(path => path.includes("index.ts"))).toBe(true);
+            expect(result.some(path => path.endsWith("src"))).toBe(false);
+            expect(result.some(path => path.endsWith("docs"))).toBe(false);
+        });
+
+        test("should return only directories when includeDirectories is 'onlyDirectories'", () => {
+            const result = getPaths(testDir, "**/*", "onlyDirectories");
+
+            expect(result.length).toBeGreaterThan(0);
+            expect(result.some(path => path.endsWith("src"))).toBe(true);
+            expect(result.some(path => path.endsWith("docs"))).toBe(true);
+            expect(result.some(path => path.endsWith("empty-dir"))).toBe(true);
+            expect(result.some(path => path.includes("file1.txt"))).toBe(false);
+            expect(result.some(path => path.includes("index.ts"))).toBe(false);
+        });
+
+        test("should use default includeDirectories value ('no')", () => {
+            const result = getPaths(testDir, "**/*");
+            const filesOnlyResult = getPaths(testDir, "**/*", "no");
+
+            expect(result).toEqual(filesOnlyResult);
+        });
+
+        test("should work with specific patterns", () => {
+            const result = getPaths(testDir, "*.txt", "no");
+
+            expect(result.some(path => path.includes("file1.txt"))).toBe(true);
+            expect(result.some(path => path.includes("file2.js"))).toBe(false);
+            expect(result.some(path => path.includes("README.md"))).toBe(false);
+        });
+
+        test("should include hidden files and directories", () => {
+            const allResult = getPaths(testDir, "**/*", "yes");
+
+            expect(allResult.some(path => path.includes(".env"))).toBe(true);
+            expect(allResult.some(path => path.includes(".git"))).toBe(true);
+        });
+
+        test("should return empty array for non-existent path", () => {
+            const result = getPaths("/non/existent/path", "**/*", "yes");
+
+            expect(result).toEqual([]);
+        });
+    });
+
+    describe("getFilePaths", () => {
+        test("should return only files", () => {
+            const result = getFilePaths(testDir, "**/*");
+
+            expect(result.length).toBeGreaterThan(0);
+            expect(result.some(path => path.includes("file1.txt"))).toBe(true);
+            expect(result.some(path => path.includes("index.ts"))).toBe(true);
+            expect(result.some(path => path.includes("Button.tsx"))).toBe(true);
+            expect(result.some(path => path.endsWith("src"))).toBe(false);
+            expect(result.some(path => path.endsWith("docs"))).toBe(false);
+        });
+
+        test("should work with specific file patterns", () => {
+            const jsFiles = getFilePaths(testDir, "**/*.js");
+            const tsFiles = getFilePaths(testDir, "**/*.ts");
+
+            expect(jsFiles.some(path => path.includes("file2.js"))).toBe(true);
+            expect(jsFiles.some(path => path.includes("file1.txt"))).toBe(false);
+
+            expect(tsFiles.some(path => path.includes("index.ts"))).toBe(true);
+            expect(tsFiles.some(path => path.includes("utils.ts"))).toBe(true);
+        });
+
+        test("should include hidden files", () => {
+            const result = getFilePaths(testDir, "**/*");
+
+            expect(result.some(path => path.includes(".env"))).toBe(true);
+            expect(result.some(path => path.includes(".git/config"))).toBe(true);
+        });
+
+        test("should return empty array for non-existent path", () => {
+            const result = getFilePaths("/non/existent/path", "**/*");
+
+            expect(result).toEqual([]);
+        });
+    });
+
+    describe("getDirectoryPaths", () => {
+        test("should return only directories", () => {
+            const result = getDirectoryPaths(testDir, "**/*");
+
+            expect(result.length).toBeGreaterThan(0);
+            expect(result.some(path => path.endsWith("src"))).toBe(true);
+            expect(result.some(path => path.endsWith("docs"))).toBe(true);
+            expect(result.some(path => path.endsWith("empty-dir"))).toBe(true);
+            expect(result.some(path => path.endsWith("components"))).toBe(true);
+            expect(result.some(path => path.includes("file1.txt"))).toBe(false);
+            expect(result.some(path => path.includes("index.ts"))).toBe(false);
+        });
+
+        test("should include hidden directories", () => {
+            const result = getDirectoryPaths(testDir, "**/*");
+
+            expect(result.some(path => path.includes(".git"))).toBe(true);
+        });
+
+        test("should work with directory patterns", () => {
+            const result = getDirectoryPaths(testDir, "src/**");
+
+            expect(result.some(path => path.endsWith("components"))).toBe(true);
+            expect(result.some(path => path.endsWith("docs"))).toBe(false);
+        });
+
+        test("should return empty array for non-existent path", () => {
+            const result = getDirectoryPaths("/non/existent/path", "**/*");
+
+            expect(result).toEqual([]);
+        });
+    });
+
+    describe("Edge cases", () => {
+        test("should handle empty directory", () => {
+            const emptyDirPath = join(testDir, "empty-dir");
+            const files = getFilePaths(emptyDirPath, "**/*");
+            const dirs = getDirectoryPaths(emptyDirPath, "**/*");
+
+            expect(files).toEqual([]);
+            expect(dirs).toEqual([]);
+        });
+
+        test("should handle invalid glob patterns gracefully", () => {
+            const result = getPaths(testDir, "[invalid", "yes");
+
+            expect(Array.isArray(result)).toBe(true);
+        });
+
+        test("all functions should return absolute paths by default", () => {
+            const files = getFilePaths(testDir, "**/*");
+            const dirs = getDirectoryPaths(testDir, "**/*");
+            const all = getPaths(testDir, "**/*", "yes");
+
+            files.forEach(path => {
+                expect(path).toMatch(/^[\/\\]|^[a-zA-Z]:[\/\\]/);
+            });
+
+            dirs.forEach(path => {
+                expect(path).toMatch(/^[\/\\]|^[a-zA-Z]:[\/\\]/);
+            });
+
+            all.forEach(path => {
+                expect(path).toMatch(/^[\/\\]|^[a-zA-Z]:[\/\\]/);
+            });
+        });
+
+        test("all functions should return relative paths when absolute is false", () => {
+            const files = getFilePaths(testDir, "**/*", false);
+            const dirs = getDirectoryPaths(testDir, "**/*", false);
+            const all = getPaths(testDir, "**/*", "yes", false);
+
+            files.forEach(path => {
+                expect(path).not.toMatch(/^[\/\\]|^[a-zA-Z]:[\/\\]/);
+                expect(path.length).toBeGreaterThan(0);
+            });
+
+            dirs.forEach(path => {
+                expect(path).not.toMatch(/^[\/\\]|^[a-zA-Z]:[\/\\]/);
+                expect(path.length).toBeGreaterThan(0);
+            });
+
+            all.forEach(path => {
+                expect(path).not.toMatch(/^[\/\\]|^[a-zA-Z]:[\/\\]/);
+                expect(path.length).toBeGreaterThan(0);
+            });
+        });
+
+        test("relative paths should contain expected file and directory names", () => {
+            const files = getFilePaths(testDir, "**/*", false);
+            const dirs = getDirectoryPaths(testDir, "**/*", false);
+
+            expect(files.some(path => path === "file1.txt")).toBe(true);
+            expect(files.some(path => path === ".env")).toBe(true);
+            expect(files.some(path => path === "src/index.ts")).toBe(true);
+            expect(files.some(path => path === "src/components/Button.tsx")).toBe(true);
+            
+            const nestedFiles = files.filter(path => path.includes("/"));
+            expect(nestedFiles.length).toBeGreaterThan(0);
+
+            expect(dirs.some(path => path === "src")).toBe(true);
+            expect(dirs.some(path => path === ".git")).toBe(true);
+            
+            expect(dirs.length).toBeGreaterThan(0);
+        });
+
+        test("absolute parameter should work consistently across all function variants", () => {
+            const pattern = "src/**";
+
+            // Test with absolute = true
+            const absoluteFiles = getFilePaths(testDir, pattern, true);
+            const absoluteDirs = getDirectoryPaths(testDir, pattern, true);
+            const absoluteAll = getPaths(testDir, pattern, "yes", true);
+
+            // Test with absolute = false
+            const relativeFiles = getFilePaths(testDir, pattern, false);
+            const relativeDirs = getDirectoryPaths(testDir, pattern, false);
+            const relativeAll = getPaths(testDir, pattern, "yes", false);
+
+            expect(absoluteFiles.length).toBe(relativeFiles.length);
+            expect(absoluteAll.length).toBe(relativeAll.length);
+
+            expect(Array.isArray(absoluteDirs)).toBe(true);
+            expect(Array.isArray(relativeDirs)).toBe(true);
+
+            absoluteFiles.forEach(path => {
+                expect(path).toMatch(/^[\/\\]|^[a-zA-Z]:[\/\\]/);
+            });
+
+            relativeFiles.forEach(path => {
+                expect(path).not.toMatch(/^[\/\\]|^[a-zA-Z]:[\/\\]/);
+            });
+        });
+    });
+
+    describe("Advanced Glob Patterns", () => {
+        test("should work with multiple extension patterns", () => {
+            const result = getFilePaths(testDir, "*.{js,ts,json}");
+
+            expect(result.some(path => path.includes("file2.js"))).toBe(true);
+            expect(result.some(path => path.includes("config.json"))).toBe(true);
+            expect(result.some(path => path.includes("números-ñ-ü.js"))).toBe(true);
+            expect(result.some(path => path.includes("file1.txt"))).toBe(false);
+            expect(result.some(path => path.includes("styles.css"))).toBe(false);
+        });
+
+        test("should work with exclusion patterns", () => {
+            const allFiles = getFilePaths(testDir, "**/*");
+            expect(allFiles.some(path => path.includes("node_modules"))).toBe(true);
+            expect(allFiles.some(path => path.includes("build"))).toBe(true);
+        });
+
+        test("should work with specific directory depth patterns", () => {
+            const topLevel = getFilePaths(testDir, "*");
+            expect(topLevel.some(path => path.includes("file1.txt"))).toBe(true);
+            expect(topLevel.some(path => path.includes("index.ts"))).toBe(false);
+
+            const srcFiles = getFilePaths(testDir, "src/*");
+            expect(srcFiles.some(path => path.includes("index.ts"))).toBe(true);
+            expect(srcFiles.some(path => path.includes("Button.tsx"))).toBe(false);
+        });
+
+        test("should work with character class patterns", () => {
+            const result = getFilePaths(testDir, "*[Ee]*");
+
+            expect(result.some(path => path.includes("README.md"))).toBe(true);
+            expect(result.some(path => path.includes(".env"))).toBe(true);
+        });
+
+        test("should work with case sensitive patterns", () => {
+            const upperFiles = getFilePaths(testDir, "*.TXT");
+            const lowerFiles = getFilePaths(testDir, "*.txt");
+
+            expect(upperFiles.some(path => path.includes("UPPERCASE.TXT"))).toBe(true);
+            expect(lowerFiles.some(path => path.includes("file1.txt"))).toBe(true);
+
+            expect(upperFiles).not.toEqual(lowerFiles);
+        });
+
+        test("should handle patterns that match nothing", () => {
+            const result = getFilePaths(testDir, "*.nonexistent");
+            expect(result).toEqual([]);
+
+            const dirs = getDirectoryPaths(testDir, "nonexistent-*");
+            expect(dirs).toEqual([]);
+        });
+
+        test("should work with deep nested patterns", () => {
+            const deepFiles = getFilePaths(testDir, "**/very/**/*.txt");
+            expect(deepFiles.some(path => path.includes("deep-file.txt"))).toBe(true);
+
+            const deepDirs = getDirectoryPaths(testDir, "**/very/**");
+            expect(deepDirs.some(path => path.endsWith("nested"))).toBe(true);
+            expect(deepDirs.some(path => path.endsWith("structure"))).toBe(true);
+        });
+    });
+
+    describe("Function Consistency", () => {
+        test("getPaths('yes') should equal getFilePaths() + getDirectoryPaths()", () => {
+            const pattern = "**/*";
+
+            const allPaths = getPaths(testDir, pattern, "yes");
+            const files = getFilePaths(testDir, pattern);
+            const dirs = getDirectoryPaths(testDir, pattern);
+
+            const combined = [...files, ...dirs].sort();
+            const allSorted = allPaths.sort();
+
+            expect(allSorted).toEqual(combined);
+        });
+
+        test("should not have duplicates in any function", () => {
+            const files = getFilePaths(testDir, "**/*");
+            const dirs = getDirectoryPaths(testDir, "**/*");
+            const all = getPaths(testDir, "**/*", "yes");
+
+            expect(files.length).toBe(new Set(files).size);
+            expect(dirs.length).toBe(new Set(dirs).size);
+            expect(all.length).toBe(new Set(all).size);
+        });
+
+        test("files and directories should be mutually exclusive", () => {
+            const files = getFilePaths(testDir, "**/*");
+            const dirs = getDirectoryPaths(testDir, "**/*");
+
+            const intersection = files.filter(file => dirs.includes(file));
+            expect(intersection).toEqual([]);
+        });
+
+        test("different patterns should be consistent across functions", () => {
+            const patterns = ["*.js", "src/**", "**/*.md", "**/components/*"];
+
+            patterns.forEach(pattern => {
+                const allPaths = getPaths(testDir, pattern, "yes");
+                const files = getFilePaths(testDir, pattern);
+                const dirs = getDirectoryPaths(testDir, pattern);
+
+                files.forEach(file => {
+                    expect(allPaths).toContain(file);
+                });
+
+                dirs.forEach(dir => {
+                    expect(allPaths).toContain(dir);
+                });
+            });
+        });
+
+        test("should maintain consistent behavior with default parameters", () => {
+            const result1 = getPaths(testDir);
+            const result2 = getPaths(testDir, "**/*");
+            const result3 = getPaths(testDir, "**/*", "no");
+            const result4 = getFilePaths(testDir);
+            const result5 = getFilePaths(testDir, "**/*");
+
+            expect(result1).toEqual(result2);
+            expect(result2).toEqual(result3);
+            expect(result3).toEqual(result4);
+            expect(result4).toEqual(result5);
+        });
+    });
+
+    describe("Special File Names", () => {
+        test("should handle files with spaces", () => {
+            const files = getFilePaths(testDir, "**/*");
+            expect(files.some(path => path.includes("file with spaces.txt"))).toBe(true);
+
+            const specific = getFilePaths(testDir, "*with*");
+            expect(specific.some(path => path.includes("file with spaces.txt"))).toBe(true);
+        });
+
+        test("should handle files without extensions", () => {
+            const files = getFilePaths(testDir, "**/*");
+            expect(files.some(path => path.includes("file-no-extension"))).toBe(true);
+
+            const withExt = getFilePaths(testDir, "*.txt");
+            expect(withExt.some(path => path.includes("file-no-extension"))).toBe(false);
+        });
+
+        test("should handle files with unicode characters", () => {
+            const files = getFilePaths(testDir, "**/*");
+            expect(files.some(path => path.includes("números-ñ-ü.js"))).toBe(true);
+
+            const jsFiles = getFilePaths(testDir, "*.js");
+            expect(jsFiles.some(path => path.includes("números-ñ-ü.js"))).toBe(true);
+        });
+
+        test("should handle uppercase/lowercase variations", () => {
+            const files = getFilePaths(testDir, "**/*");
+            expect(files.some(path => path.includes("UPPERCASE.TXT"))).toBe(true);
+            expect(files.some(path => path.includes("file1.txt"))).toBe(true);
+
+            // Should be case sensitive
+            const upper = getFilePaths(testDir, "*UPPER*");
+            const lower = getFilePaths(testDir, "*upper*");
+            expect(upper.length).toBeGreaterThan(0);
+            expect(lower).toEqual([]);
+        });
+
+        test("should handle various file extensions", () => {
+            const extensions = ["js", "ts", "tsx", "json", "css", "jsx", "md", "txt"];
+
+            extensions.forEach(ext => {
+                const files = getFilePaths(testDir, `*.${ext}`);
+                expect(Array.isArray(files)).toBe(true);
+            });
+
+            expect(getFilePaths(testDir, "*.css").some(path => path.includes("styles.css"))).toBe(true);
+            expect(getFilePaths(testDir, "*.jsx").some(path => path.includes("script.jsx"))).toBe(true);
+        });
+
+        test("should handle deeply nested paths correctly", () => {
+            const deepFiles = getFilePaths(testDir, "**/structure/*");
+            expect(deepFiles.some(path => path.includes("deep-file.txt"))).toBe(true);
+
+            const deepDirs = getDirectoryPaths(testDir, "**/very/*");
+            expect(deepDirs.some(path => path.endsWith("nested"))).toBe(true);
+
+            const allDeep = getPaths(testDir, "deep/**", "yes");
+            expect(allDeep.length).toBeGreaterThanOrEqual(4);
+        });
+
+        test("should normalize paths consistently", () => {
+            const files = getFilePaths(testDir, "**/*");
+            const dirs = getDirectoryPaths(testDir, "**/*");
+
+            files.forEach(file => {
+                expect(file).toMatch(/^[\/\\]|^[a-zA-Z]:[\/\\]/);
+                expect(file).not.toMatch(/[\/\\]$/);
+            });
+
+            dirs.forEach(dir => {
+                expect(dir).toMatch(/^[\/\\]|^[a-zA-Z]:[\/\\]/);
+            });
+        });
+    });
+
+
+})
+
+
+

package/src/getPaths.ts

@@ -0,0 +1,112 @@
+import { Glob } from "bun";
+import { statSync } from "fs";
+
+/**
+ * Gets file paths, directory paths, or both based on the specified parameters
+ * @param path - The base directory path to search in
+ * @param pattern - The glob pattern to match files/directories (default: **\/*)
+ * @param includeDirectories - Controls what to include: yes (files + dirs), no (files only), onlyDirectories (dirs only)
+ * @param absolute - Whether to return absolute paths (default: true)
+ * @returns Array of paths matching the criteria
+ */
+export const getPaths = (
+    path: string,
+    pattern: string = "**/*",
+    includeDirectories: "yes" | "no" | "onlyDirectories" = "no",
+    absolute: boolean = true,
+): string[] => {
+    try {
+        if (includeDirectories === "no") return getFilePaths(path, pattern, absolute);
+        if (includeDirectories === "onlyDirectories") return getDirectoryPaths(path, pattern, absolute);
+
+        const paths: string[] = [];
+
+        const glob = new Glob(pattern);
+
+        const files = glob.scanSync({
+            cwd: path,
+            onlyFiles: false,
+            absolute: absolute,
+            dot: true,
+            followSymlinks: false,
+        });
+
+        paths.push(...files);
+
+        return paths;
+    } catch (error) {
+        console.error(`Error getting paths from ${path}:`, error);
+        return [];
+    }
+};
+
+
+/**
+ * Gets only file paths (excluding directories) matching the pattern
+ * @param path - The base directory path to search in
+ * @param pattern - The glob pattern to match files (default: **\/*)
+ * @param absolute - Whether to return absolute paths (default: true)
+ * @returns Array of file paths
+ */
+export const getFilePaths = (path: string, pattern: string = "**/*", absolute: boolean = true): string[] => {
+    try {
+        const paths: string[] = [];
+
+        const glob = new Glob(pattern);
+
+        const files = glob.scanSync({
+            cwd: path,
+            onlyFiles: true,
+            absolute: absolute,
+            dot: true,
+            followSymlinks: false,
+        });
+
+        paths.push(...files);
+
+        return paths;
+    } catch (error) {
+        console.error(`Error getting file paths from ${path}:`, error);
+        return [];
+    }
+};
+
+/**
+ * Gets only directory paths (excluding files) matching the pattern
+ * @param path - The base directory path to search in
+ * @param pattern - The glob pattern to match directories (default: **\/*)
+ * @param absolute - Whether to return absolute paths (default: true)
+ * @returns Array of directory paths
+ */
+export const getDirectoryPaths = (path: string, pattern: string = "**/*", absolute: boolean = true): string[] => {
+    try {
+        const paths: string[] = [];
+
+        const glob = new Glob(pattern);
+
+        const allItems = [...glob.scanSync({
+            cwd: path,
+            onlyFiles: false,
+            absolute: absolute,
+            dot: true,
+            followSymlinks: false,
+        })];
+
+        const directories = allItems.filter(item => {
+            try {
+                return statSync(item).isDirectory();
+            } catch {
+                return false;
+            }
+        });
+
+        paths.push(...directories);
+
+        return paths;
+    } catch (error) {
+        console.error(`Error getting directory paths from ${path}:`, error);
+        return [];
+    }
+};
+
+

package/src/index.ts

@@ -1,2 +1,3 @@
 export * from "./random";
 export * from "./stack";
+export * from "./getPaths";

package/changelog.md

@@ -1,3 +0,0 @@
-# v0.1.0
-
-- initial repo with useful tools.