@tkeron/tools 0.2.2 → 0.4.0

package/.github/workflows/npm_deploy.yml

@@ -4,22 +4,26 @@ on:
     branches:
       - main
 
+permissions:
+  id-token: write
+  contents: read
+
 jobs:
   build-test-publish:
     runs-on: ubuntu-latest
+
     steps:
       - uses: actions/checkout@v4
 
       - uses: actions/setup-node@v4
         with:
-          node-version: 22.x
-          registry-url: "https://registry.npmjs.org/"
+          node-version: "lts/*"
+          registry-url: "https://registry.npmjs.org"
 
       - uses: oven-sh/setup-bun@v2
 
-      - run: |
-          bun i
-          bun test
-          npm publish --access public
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+      - run: npm install -g npm@latest
+      - run: bun i
+      - run: bun run test
+
+      - run: npm publish --provenance

package/bun.lock

@@ -1,28 +1,28 @@
 {
   "lockfileVersion": 1,
+  "configVersion": 0,
   "workspaces": {
     "": {
       "name": "@tkeron/tools",
       "devDependencies": {
-        "@types/bun": "latest",
+        "@types/bun": "^1.3.9",
+        "prettier": "^3.8.1",
       },
       "peerDependencies": {
-        "typescript": "^5.7.3",
+        "typescript": "^5.9.3",
       },
     },
   },
   "packages": {
-    "@types/bun": ["@types/bun@1.2.18", "", { "dependencies": { "bun-types": "1.2.18" } }, "sha512-Xf6RaWVheyemaThV0kUfaAUvCNokFr+bH8Jxp+tTZfx7dAPA8z9ePnP9S9+Vspzuxxx9JRAXhnyccRj3GyCMdQ=="],
+    "@types/bun": ["@types/bun@1.3.9", "", { "dependencies": { "bun-types": "1.3.9" } }, "sha512-KQ571yULOdWJiMH+RIWIOZ7B2RXQGpL1YQrBtLIV3FqDcCu6FsbFUBwhdKUlCKUpS3PJDsHlJ1QKlpxoVR+xtw=="],
 
     "@types/node": ["@types/node@22.13.1", "", { "dependencies": { "undici-types": "~6.20.0" } }, "sha512-jK8uzQlrvXqEU91UxiK5J7pKHyzgnI1Qnl0QDHIgVGuolJhRb9EEl28Cj9b3rGR8B2lhFCtvIm5os8lFnO/1Ew=="],
 
-    "@types/react": ["@types/react@19.1.8", "", { "dependencies": { "csstype": "^3.0.2" } }, "sha512-AwAfQ2Wa5bCx9WP8nZL2uMZWod7J7/JSplxbTmBQ5ms6QpqNYm672H0Vu9ZVKVngQ+ii4R/byguVEUZQyeg44g=="],
+    "bun-types": ["bun-types@1.3.9", "", { "dependencies": { "@types/node": "*" } }, "sha512-+UBWWOakIP4Tswh0Bt0QD0alpTY8cb5hvgiYeWCMet9YukHbzuruIEeXC2D7nMJPB12kbh8C7XJykSexEqGKJg=="],
 
-    "bun-types": ["bun-types@1.2.18", "", { "dependencies": { "@types/node": "*" }, "peerDependencies": { "@types/react": "^19" } }, "sha512-04+Eha5NP7Z0A9YgDAzMk5PHR16ZuLVa83b26kH5+cp1qZW4F6FmAURngE7INf4tKOvCE69vYvDEwoNl1tGiWw=="],
+    "prettier": ["prettier@3.8.1", "", { "bin": { "prettier": "bin/prettier.cjs" } }, "sha512-UOnG6LftzbdaHZcKoPFtOcCKztrQ57WkHDeRD9t/PTQtmT0NHSeWWepj6pS0z/N7+08BHFDQVUrfmfMRcZwbMg=="],
 
-    "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=="],
+    "typescript": ["typescript@5.9.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw=="],
 
     "undici-types": ["undici-types@6.20.0", "", {}, "sha512-Ny6QZ2Nju20vw1SRHe3d9jVu6gJ+4e3+MMpqu7pqE5HT6WsTSlce++GQmK5UXS8mzV8DSYHrQH+Xrf2jVcuKNg=="],
   }

package/changelog.md

@@ -0,0 +1,42 @@
+# Changelog
+
+## [0.4.0] - 2026-02-15
+
+### Added
+
+- **Logger system**: Generic logging abstraction for standardized logging across the ecosystem
+  - `Logger` interface: Standard interface with `log`, `error`, `warn`, `info` methods
+  - `logger`: Default implementation using console methods
+  - `silentLogger`: No-op logger for silent operation (useful in production or tests)
+  - `createTestLogger()`: Captures logs in arrays for testing and verification
+  - Full TypeScript support with exported types
+  - Comprehensive test coverage (45 tests across 3 test files)
+
+### Documentation
+
+- Logger system fully tested with edge cases (null, undefined, Error objects, mixed types)
+- Test logger supports independent instances and manual array manipulation
+
+## [0.3.0] - 2026-02-15
+
+### Added
+
+- Configured trusted publisher with OIDC for npm deployment
+- Added `lint` script using Prettier for code formatting
+- Added Prettier as devDependency
+
+### Changed
+
+- Updated npm deployment workflow to use OIDC authentication instead of NPM_TOKEN
+- Standardized repository URL format in package.json
+- Code formatting applied across all source and test files
+
+### Infrastructure
+
+- GitHub Actions now uses `permissions: id-token: write` for secure publishing
+- npm publish now includes `--provenance` flag for supply chain security
+- Node.js version standardized to `lts/*` in CI workflow
+
+## [0.2.2] - Previous releases
+
+(Previous version history not documented)

package/package.json

@@ -1,20 +1,25 @@
 {
   "name": "@tkeron/tools",
-  "version": "0.2.2",
+  "version": "0.4.0",
   "description": "Useful JavaScript utilities for Bun runtime",
   "main": "src/index.ts",
   "module": "src/index.ts",
   "type": "module",
   "author": "tkeron",
   "license": "MIT",
+  "scripts": {
+    "test": "bun test --concurrent",
+    "lint": "prettier --write ."
+  },
   "engines": {
     "bun": ">=1.0.0"
   },
   "devDependencies": {
-    "@types/bun": "latest"
+    "@types/bun": "^1.3.9",
+    "prettier": "^3.8.1"
   },
   "peerDependencies": {
-    "typescript": "^5.7.3"
+    "typescript": "^5.9.3"
   },
   "keywords": [
     "bun",
@@ -22,7 +27,11 @@
     "utils",
     "tools"
   ],
+  "publishConfig": {
+    "access": "public"
+  },
   "repository": {
-    "url": "git@github.com:tkeron/tools.git"
+    "type": "git",
+    "url": "git+https://github.com/tkeron/tools.git"
   }
 }

package/readme.md

@@ -21,15 +21,94 @@ This package provides a growing collection of utility functions and data structu
 
 ```typescript
 // Import all utilities
-import * as tools from '@tkeron/tools';
+import * as tools from "@tkeron/tools";
 
 // Or import specific utilities
-import { rng, getLIFO, getPaths } from '@tkeron/tools';
+import { rng, getLIFO, getPaths } from "@tkeron/tools";
+```
+
+## 📚 Available Utilities
+
+### Logger System
+
+Generic logging abstraction for standardized logging across applications:
+
+```typescript
+import { Logger, logger, silentLogger, createTestLogger } from "@tkeron/tools";
+
+// Default logger (uses console)
+logger.log("Hello world");
+logger.error("Error message");
+logger.warn("Warning message");
+logger.info("Info message");
+
+// Silent logger (no output, useful for production or testing)
+silentLogger.log("This won't appear");
+
+// Test logger (captures logs in arrays for testing)
+const { logger: testLog, logs, errors, warns, infos } = createTestLogger();
+testLog.log("Test message");
+console.log(logs); // ["Test message"]
+
+// Inject logger in your functions
+const myFunction = (data: string, log: Logger = logger) => {
+  log.info("Processing:", data);
+  // ... your logic
+};
+```
+
+### File System Utilities
+
+Glob pattern matching and path retrieval:
+
+```typescript
+import { getPaths, getFilePaths, getDirectoryPaths } from "@tkeron/tools";
+
+// Get all files and directories
+const allPaths = getPaths("/path/to/dir", "**/*", "yes");
+
+// Get only files
+const files = getFilePaths("/path/to/dir", "**/*.ts");
+
+// Get only directories
+const dirs = getDirectoryPaths("/path/to/dir", "**/");
+```
+
+### Data Structures
+
+Stack implementations (LIFO/FIFO):
+
+```typescript
+import { getLIFO, getFIFO } from "@tkeron/tools";
+
+const stack = getLIFO<string>();
+stack.push("first");
+stack.push("second");
+console.log(stack.current); // "second"
+console.log(stack.pop()); // "second"
+```
+
+### Random Number Generator
+
+Seedable random number generator:
+
+```typescript
+import { rng } from "@tkeron/tools";
+
+// Generate infinite sequence with seed
+for (const num of rng(42)) {
+  console.log(num);
+}
+
+// Generate limited sequence
+for (const num of rng(42, 10)) {
+  console.log(num); // Only 10 numbers
+}
 ```
 
 ## 📚 Documentation
 
-For detailed documentation of all available utilities, please refer to the TypeScript definitions or explore the source code. Each utility is fully typed and includes JSDoc comments for better IDE support.
+For detailed documentation and TypeScript definitions, refer to the source code. Each utility is fully typed with JSDoc comments for IDE support.
 
 ## 🧪 Testing
 
@@ -39,7 +118,4 @@ The project includes comprehensive tests for all utilities:
 bun test
 ```
 
-
-
-
-Built with ❤️ for the Bun ecosystem
+Built with ❤️ for the Bun ecosystem

package/src/createTestLogger.ts

@@ -0,0 +1,31 @@
+import type { Logger } from "./loggerObj.js";
+
+export const createTestLogger = () => {
+  const logs: string[] = [];
+  const errors: string[] = [];
+  const warns: string[] = [];
+  const infos: string[] = [];
+
+  const format = (args: unknown[]) =>
+    args
+      .map((a) => {
+        if (typeof a === "string") return a;
+        if (a === undefined) return "undefined";
+        if (a instanceof Error) return a.stack || a.message || String(a);
+        return JSON.stringify(a);
+      })
+      .join(" ");
+
+  return {
+    logger: {
+      log: (...args: unknown[]) => logs.push(format(args)),
+      error: (...args: unknown[]) => errors.push(format(args)),
+      warn: (...args: unknown[]) => warns.push(format(args)),
+      info: (...args: unknown[]) => infos.push(format(args)),
+    } as Logger,
+    logs,
+    errors,
+    warns,
+    infos,
+  };
+};

package/src/getPaths.ts

@@ -2,113 +2,100 @@ import { Glob } from "bun";
 import { statSync } from "fs";
 import { join } from "path";
 
-/**
- * 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,
+  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 [];
-    }
+  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 [];
-    }
+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 {
-                const fullPath = absolute ? item : join(path, item);
-                return statSync(fullPath).isDirectory();
-            } catch {
-                return false;
-            }
-        });
-
-        paths.push(...directories);
-
-        return paths;
-    } catch (error) {
-        console.error(`Error getting directory paths from ${path}:`, error);
-        return [];
-    }
+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 {
+        const fullPath = absolute ? item : join(path, item);
+        return statSync(fullPath).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,3 +1,6 @@
 export * from "./random";
 export * from "./stack";
 export * from "./getPaths";
+export * from "./loggerObj";
+export * from "./silentLogger";
+export * from "./createTestLogger";

package/src/loggerObj.ts

@@ -0,0 +1,13 @@
+export interface Logger {
+  log: (...args: unknown[]) => void;
+  error: (...args: unknown[]) => void;
+  warn: (...args: unknown[]) => void;
+  info: (...args: unknown[]) => void;
+}
+
+export const logger: Logger = {
+  log: (...args: unknown[]) => console.log(...args),
+  error: (...args: unknown[]) => console.error(...args),
+  warn: (...args: unknown[]) => console.warn(...args),
+  info: (...args: unknown[]) => console.info(...args),
+};

package/src/silentLogger.ts

@@ -0,0 +1,8 @@
+import type { Logger } from "./loggerObj.js";
+
+export const silentLogger: Logger = {
+  log: () => {},
+  error: () => {},
+  warn: () => {},
+  info: () => {},
+};

package/src/stack.ts

@@ -1,70 +1,53 @@
-
 export interface Stack<T> {
-    pop: () => T;
-    push: (item: T) => void;
-    readonly length: number;
-    current: T | null;
+  pop: () => T;
+  push: (item: T) => void;
+  readonly length: number;
+  current: T | null;
 }
 
-/**
- * Returns a LIFO (Last In First Out) stack.
- * Same as FILO (First In Last Out) stack.
- * @returns an empty LIFO stack.
- */
 export const getLIFO = <T>(): Stack<T> => {
-
-    const _stack: T[] = [];
-
-
-    const stack = <Stack<T>>{
-        pop: () => _stack.pop(),
-        push: (item) => _stack.push(item),
-        length: 0,
-        current: <T><unknown>null
-    };
-
-    Object.defineProperty(stack, "current", {
-        get: () => _stack.length ? _stack[_stack.length - 1] : null,
-        set: (value) => {
-            if (_stack.length) _stack[_stack.length - 1] = value;
-        }
-    });
-
-    Object.defineProperty(stack, "length", {
-        get: () => _stack.length,
-    });
-
-
-    return stack;
-
-
+  const _stack: T[] = [];
+
+  const stack = <Stack<T>>{
+    pop: () => _stack.pop(),
+    push: (item) => _stack.push(item),
+    length: 0,
+    current: <T>(<unknown>null),
+  };
+
+  Object.defineProperty(stack, "current", {
+    get: () => (_stack.length ? _stack[_stack.length - 1] : null),
+    set: (value) => {
+      if (_stack.length) _stack[_stack.length - 1] = value;
+    },
+  });
+
+  Object.defineProperty(stack, "length", {
+    get: () => _stack.length,
+  });
+
+  return stack;
 };
 
-/**
- * Returns a FIFO (First In First Out) stack
- * @returns an empty FIFO stack
- */
 export const getFIFO = <T>(): Stack<T> => {
-
-    const _stack: T[] = [];
-    const stack = <Stack<T>>{
-        pop: () => _stack.shift(),
-        push: (item) => _stack.push(item),
-        length: 0,
-        current: <T><unknown>null
-    };
-
-    Object.defineProperty(stack, "current", {
-        get: () => _stack.length ? _stack[0] : null,
-        set: (value) => {
-            if (_stack.length) _stack[0] = value;
-        }
-    });
-
-    Object.defineProperty(stack, "length", {
-        get: () => _stack.length,
-    });
-
-    return stack;
-
-}
+  const _stack: T[] = [];
+  const stack = <Stack<T>>{
+    pop: () => _stack.shift(),
+    push: (item) => _stack.push(item),
+    length: 0,
+    current: <T>(<unknown>null),
+  };
+
+  Object.defineProperty(stack, "current", {
+    get: () => (_stack.length ? _stack[0] : null),
+    set: (value) => {
+      if (_stack.length) _stack[0] = value;
+    },
+  });
+
+  Object.defineProperty(stack, "length", {
+    get: () => _stack.length,
+  });
+
+  return stack;
+};