@reliverse/helpers 2.2.7

package/dist/impl/clear-logger-internals.d.ts

@@ -0,0 +1,17 @@
+interface ClearLoggerInternalsOptions {
+    packages: Array<{
+        name: string;
+        outputDir: string;
+        path: string;
+    }>;
+    ignorePackages?: string | string[];
+    verbose?: boolean;
+    onLog?: (message: string) => void;
+}
+interface ClearResult {
+    updated: number;
+    skipped: number;
+    files: string[];
+}
+export declare function clearLoggerInternalsInPackages(options: ClearLoggerInternalsOptions): Promise<ClearResult>;
+export {};

package/dist/impl/clear-logger-internals.js

@@ -0,0 +1,109 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { readdirRecursive } from "@reliverse/relifso";
+const patternCache = /* @__PURE__ */ new Map();
+function matchesPattern(str, pattern) {
+  if (pattern.includes("*")) {
+    let regex = patternCache.get(pattern);
+    if (!regex) {
+      regex = new RegExp(`^${pattern.replace(/\*/g, ".*")}$`);
+      patternCache.set(pattern, regex);
+    }
+    return regex.test(str);
+  }
+  return str === pattern;
+}
+function shouldIgnorePackage(packageName, ignorePackages) {
+  const patterns = typeof ignorePackages === "string" ? [ignorePackages] : ignorePackages;
+  return patterns.some((pattern) => matchesPattern(packageName, pattern));
+}
+const LOGGER_INTERNAL_REGEX = /logger\.internal\s*\(/;
+const LOG_INTERNAL_REGEX = /logInternal\s*\(/;
+function clearLoggerInternalsInFile(filePath) {
+  const content = readFileSync(filePath, "utf-8");
+  const lines = content.split("\n");
+  const filteredLines = [];
+  let hasChanges = false;
+  for (const line of lines) {
+    if (LOGGER_INTERNAL_REGEX.test(line) || LOG_INTERNAL_REGEX.test(line)) {
+      hasChanges = true;
+      continue;
+    }
+    filteredLines.push(line);
+  }
+  if (hasChanges) {
+    const updated = filteredLines.join("\n");
+    writeFileSync(filePath, updated, "utf-8");
+    return true;
+  }
+  return false;
+}
+export async function clearLoggerInternalsInPackages(options) {
+  const { packages, ignorePackages, verbose = false, onLog } = options;
+  const log = (message) => {
+    if (verbose && onLog) {
+      onLog(message);
+    }
+  };
+  if (verbose) {
+    log(`
+\u{1F9F9} Clearing logger internals from ${packages.length} package(s)...`);
+  }
+  let updatedCount = 0;
+  let skippedCount = 0;
+  const processedFiles = [];
+  for (const pkg of packages) {
+    log(`   Processing package: ${pkg.name}`);
+    if (ignorePackages && shouldIgnorePackage(pkg.name, ignorePackages)) {
+      log(`   \u23ED\uFE0F  Skipping ${pkg.name} (ignored by pattern)`);
+      skippedCount++;
+      continue;
+    }
+    const outputDir = pkg.outputDir;
+    if (!existsSync(outputDir)) {
+      log(
+        `   \u23ED\uFE0F  Skipping ${pkg.name} (dist directory not found: ${outputDir})`
+      );
+      skippedCount++;
+      continue;
+    }
+    log(`   \u{1F4C1} Scanning dist directory: ${outputDir}`);
+    let jsFiles = [];
+    try {
+      jsFiles = await readdirRecursive(outputDir, {
+        extensions: ["js"]
+      });
+      log(`   \u{1F4C4} Found ${jsFiles.length} .js file(s)`);
+    } catch (error) {
+      log(`   \u26A0\uFE0F  Error reading dist directory for ${pkg.name}: ${error}`);
+      skippedCount++;
+      continue;
+    }
+    let packageUpdatedCount = 0;
+    for (const filePath of jsFiles) {
+      try {
+        if (clearLoggerInternalsInFile(filePath)) {
+          updatedCount++;
+          packageUpdatedCount++;
+          processedFiles.push(filePath);
+          log(`   \u2713 Updated: ${filePath}`);
+        }
+      } catch (error) {
+        log(`   \u26A0\uFE0F  Error processing ${filePath}: ${error}`);
+      }
+    }
+    if (packageUpdatedCount === 0 && jsFiles.length > 0) {
+      log(`   \u2139\uFE0F  No logger internals found in ${pkg.name}`);
+    }
+  }
+  if (verbose) {
+    log(
+      `
+   Summary: Updated ${updatedCount} file(s), skipped ${skippedCount} package(s)`
+    );
+  }
+  return {
+    updated: updatedCount,
+    skipped: skippedCount,
+    files: processedFiles
+  };
+}

package/dist/impl/replace-exports.d.ts

@@ -0,0 +1,13 @@
+interface ReplaceExportsOptions {
+    direction?: "ts-to-js" | "js-to-ts";
+    cwd?: string;
+    ignorePackages?: string | string[];
+    verbose?: boolean;
+}
+interface ReplaceResult {
+    updated: number;
+    skipped: number;
+    files: string[];
+}
+export declare function replaceExportsInPackages(options?: ReplaceExportsOptions): Promise<ReplaceResult>;
+export {};

package/dist/impl/replace-exports.js

@@ -0,0 +1,155 @@
+import { readFileSync, writeFileSync } from "node:fs";
+import { Glob } from "bun";
+const patternCache = /* @__PURE__ */ new Map();
+function matchesPattern(str, pattern) {
+  if (pattern.includes("*")) {
+    let regex = patternCache.get(pattern);
+    if (!regex) {
+      regex = new RegExp(`^${pattern.replace(/\*/g, ".*")}$`);
+      patternCache.set(pattern, regex);
+    }
+    return regex.test(str);
+  }
+  return str === pattern;
+}
+function shouldIgnorePackage(packageName, ignorePackages) {
+  const patterns = typeof ignorePackages === "string" ? [ignorePackages] : ignorePackages;
+  return patterns.some((pattern) => matchesPattern(packageName, pattern));
+}
+const DEFAULT_PATTERN_TS_TO_JS = /"default":\s*"\.\/src\/([^"]+)\.ts"/g;
+const TYPES_PATTERN_TS_TO_JS = /"types":\s*"\.\/src\/([^"]+)\.ts"/g;
+const ROOT_JS_PATTERN_TS_TO_JS = /"default":\s*"\.\/([^"]+\.js)"/g;
+const ROOT_DTS_PATTERN_TS_TO_JS = /"types":\s*"\.\/([^"]+\.d\.ts)"/g;
+const DIST_JS_PATTERN_JS_TO_TS = /"default":\s*"\.\/dist\/([^"]+)\.js"/g;
+const DIST_DTS_PATTERN_JS_TO_TS = /"types":\s*"\.\/dist\/([^"]+)\.d\.ts"/g;
+const ROOT_JS_PATTERN_JS_TO_TS = /"default":\s*"\.\/([^"]+\.js)"/g;
+const ROOT_DTS_PATTERN_JS_TO_TS = /"types":\s*"\.\/([^"]+\.d\.ts)"/g;
+function replaceInPackageJson(filePath, direction) {
+  const content = readFileSync(filePath, "utf-8");
+  if (direction === "ts-to-js") {
+    let updated = content;
+    let hasChanges = false;
+    DEFAULT_PATTERN_TS_TO_JS.lastIndex = 0;
+    if (DEFAULT_PATTERN_TS_TO_JS.test(content)) {
+      DEFAULT_PATTERN_TS_TO_JS.lastIndex = 0;
+      updated = updated.replace(
+        DEFAULT_PATTERN_TS_TO_JS,
+        '"default": "./dist/$1.js"'
+      );
+      hasChanges = true;
+    }
+    TYPES_PATTERN_TS_TO_JS.lastIndex = 0;
+    if (TYPES_PATTERN_TS_TO_JS.test(content)) {
+      TYPES_PATTERN_TS_TO_JS.lastIndex = 0;
+      updated = updated.replace(
+        TYPES_PATTERN_TS_TO_JS,
+        '"types": "./dist/$1.d.ts"'
+      );
+      hasChanges = true;
+    }
+    ROOT_JS_PATTERN_TS_TO_JS.lastIndex = 0;
+    updated = updated.replace(ROOT_JS_PATTERN_TS_TO_JS, (match, fileName) => {
+      if (!fileName.startsWith("dist/")) {
+        hasChanges = true;
+        return `"default": "./dist/${fileName}"`;
+      }
+      return match;
+    });
+    ROOT_DTS_PATTERN_TS_TO_JS.lastIndex = 0;
+    updated = updated.replace(ROOT_DTS_PATTERN_TS_TO_JS, (match, fileName) => {
+      if (!fileName.startsWith("dist/")) {
+        hasChanges = true;
+        return `"types": "./dist/${fileName}"`;
+      }
+      return match;
+    });
+    if (hasChanges) {
+      writeFileSync(filePath, updated, "utf-8");
+      return true;
+    }
+  } else {
+    let updated = content;
+    let hasChanges = false;
+    DIST_JS_PATTERN_JS_TO_TS.lastIndex = 0;
+    if (DIST_JS_PATTERN_JS_TO_TS.test(content)) {
+      DIST_JS_PATTERN_JS_TO_TS.lastIndex = 0;
+      updated = updated.replace(
+        DIST_JS_PATTERN_JS_TO_TS,
+        '"default": "./src/$1.ts"'
+      );
+      hasChanges = true;
+    }
+    DIST_DTS_PATTERN_JS_TO_TS.lastIndex = 0;
+    if (DIST_DTS_PATTERN_JS_TO_TS.test(content)) {
+      DIST_DTS_PATTERN_JS_TO_TS.lastIndex = 0;
+      updated = updated.replace(
+        DIST_DTS_PATTERN_JS_TO_TS,
+        '"types": "./src/$1.ts"'
+      );
+      hasChanges = true;
+    }
+    ROOT_JS_PATTERN_JS_TO_TS.lastIndex = 0;
+    updated = updated.replace(ROOT_JS_PATTERN_JS_TO_TS, (match, fileName) => {
+      if (!fileName.startsWith("src/") && !fileName.startsWith("dist/")) {
+        const baseName = fileName.replace(/\.js$/, "");
+        hasChanges = true;
+        return `"default": "./src/${baseName}.ts"`;
+      }
+      return match;
+    });
+    ROOT_DTS_PATTERN_JS_TO_TS.lastIndex = 0;
+    updated = updated.replace(ROOT_DTS_PATTERN_JS_TO_TS, (match, fileName) => {
+      if (!fileName.startsWith("src/") && !fileName.startsWith("dist/")) {
+        const baseName = fileName.replace(/\.d\.ts$/, "");
+        hasChanges = true;
+        return `"types": "./src/${baseName}.ts"`;
+      }
+      return match;
+    });
+    if (hasChanges) {
+      writeFileSync(filePath, updated, "utf-8");
+      return true;
+    }
+  }
+  return false;
+}
+export async function replaceExportsInPackages(options = {}) {
+  const {
+    direction = "ts-to-js",
+    cwd = process.cwd(),
+    ignorePackages
+  } = options;
+  const glob = new Glob("**/package.json");
+  const packageJsonFiles = [];
+  for await (const file of glob.scan({ cwd, onlyFiles: true })) {
+    if (!file.includes("node_modules/")) {
+      packageJsonFiles.push(file);
+    }
+  }
+  let filteredFiles = packageJsonFiles;
+  if (ignorePackages) {
+    filteredFiles = [];
+    for (const file of packageJsonFiles) {
+      try {
+        const content = readFileSync(file, "utf-8");
+        const pkg = JSON.parse(content);
+        if (!pkg?.name || !shouldIgnorePackage(pkg.name, ignorePackages)) {
+          filteredFiles.push(file);
+        }
+      } catch {
+        filteredFiles.push(file);
+      }
+    }
+  }
+  let updatedCount = 0;
+  for (const file of filteredFiles) {
+    if (replaceInPackageJson(file, direction)) {
+      updatedCount++;
+    }
+  }
+  return {
+    updated: updatedCount,
+    skipped: filteredFiles.length - updatedCount,
+    files: filteredFiles
+  };
+}

package/dist/impl/terminal-helpers.d.ts

@@ -0,0 +1,20 @@
+export declare function ensuredir(dir: string): Promise<void>;
+export declare const handleError: (error: unknown) => string;
+/**
+ * Changes the current working directory to the specified path.
+ * Logs a warning if the target directory does not exist.
+ */
+export declare function cd(dir: string): Promise<void>;
+/**
+ * Returns the current working directory.
+ */
+export declare function pwd(): void;
+/**
+ * Removes a file or directory (recursively, if it's a directory).
+ * Logs an error if removal fails.
+ */
+export declare function rm(target: string): Promise<void>;
+/**
+ * Returns the current working directory.
+ */
+export declare function getCurrentWorkingDirectory(useCache?: boolean): string;

package/dist/impl/terminal-helpers.js

@@ -0,0 +1,48 @@
+import fs from "node:fs/promises";
+import { normalize } from "node:path";
+import { cwd } from "node:process";
+export async function ensuredir(dir) {
+  await fs.mkdir(dir, { recursive: true });
+}
+export const handleError = (error) => error instanceof Error ? error.message : "Unknown error";
+export async function cd(dir) {
+  try {
+    await ensuredir(dir);
+    await fs.access(dir);
+    process.chdir(dir);
+    console.log(`Changed directory to: ${process.cwd()}`);
+  } catch (error) {
+    console.warn(`Directory does not exist: ${dir}`, handleError(error));
+  }
+}
+export function pwd() {
+  const cwd2 = getCurrentWorkingDirectory();
+  console.log(`Current working directory: ${cwd2}`);
+}
+export async function rm(target) {
+  try {
+    await fs.rm(target, { recursive: true, force: true });
+    console.log(`Removed: ${target}`);
+  } catch (error) {
+    console.error(`Failed to remove: ${target}`, handleError(error));
+  }
+}
+let cachedCWD = null;
+export function getCurrentWorkingDirectory(useCache = true) {
+  if (useCache && cachedCWD) {
+    return cachedCWD;
+  }
+  try {
+    const currentDirectory = normalize(cwd());
+    if (useCache) {
+      cachedCWD = currentDirectory;
+    }
+    return currentDirectory;
+  } catch (error) {
+    console.error(
+      "Error getting current working directory:",
+      handleError(error)
+    );
+    throw error;
+  }
+}

package/dist/impl/write.d.ts

@@ -0,0 +1,5 @@
+export declare const writeLine: (text: string) => void;
+export declare const writeError: (text: string) => void;
+export declare const writeErrorLines: (lines: string[]) => void;
+export declare const writeJsonFile: (path: string, data: unknown) => Promise<void>;
+export declare const writeTextFile: (path: string, content: string) => Promise<void>;

package/dist/impl/write.js

@@ -0,0 +1,23 @@
+const textEncoder = new TextEncoder();
+export const writeLine = (text) => {
+  const encoded = textEncoder.encode(`${text}
+`);
+  Bun.write(Bun.stdout, encoded);
+};
+export const writeError = (text) => {
+  const encoded = textEncoder.encode(`${text}
+`);
+  Bun.write(Bun.stderr, encoded);
+};
+export const writeErrorLines = (lines) => {
+  const encoded = textEncoder.encode(`${lines.join("\n")}
+`);
+  Bun.write(Bun.stderr, encoded);
+};
+export const writeJsonFile = async (path, data) => {
+  await Bun.write(path, `${JSON.stringify(data, null, 2)}
+`);
+};
+export const writeTextFile = async (path, content) => {
+  await Bun.write(path, content);
+};

package/dist/mod.d.ts

@@ -0,0 +1,4 @@
+export { clearLoggerInternalsInPackages } from "./impl/clear-logger-internals.js";
+export { replaceExportsInPackages } from "./impl/replace-exports.js";
+export { cd, ensuredir, getCurrentWorkingDirectory, handleError, pwd, rm, } from "./impl/terminal-helpers.js";
+export { writeError, writeErrorLines, writeJsonFile, writeLine, writeTextFile, } from "./impl/write.js";

package/dist/mod.js

@@ -0,0 +1,17 @@
+export { clearLoggerInternalsInPackages } from "./impl/clear-logger-internals.js";
+export { replaceExportsInPackages } from "./impl/replace-exports.js";
+export {
+  cd,
+  ensuredir,
+  getCurrentWorkingDirectory,
+  handleError,
+  pwd,
+  rm
+} from "./impl/terminal-helpers.js";
+export {
+  writeError,
+  writeErrorLines,
+  writeJsonFile,
+  writeLine,
+  writeTextFile
+} from "./impl/write.js";

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@reliverse/helpers",
+  "version": "2.2.7",
+  "private": false,
+  "type": "module",
+  "description": "@reliverse/helpers is a collection of helper functions for the dler monorepo.",
+  "exports": {
+    ".": {
+      "types": "./dist/mod.d.ts",
+      "default": "./dist/mod.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@reliverse/relifso": "2.2.7",
+    "@reliverse/matcha": "2.2.7",
+    "@reliverse/typerso": "2.2.7"
+  },
+  "files": [
+    "dist",
+    "package.json"
+  ],
+  "license": "MIT"
+}