@reliverse/dler 1.7.91 → 1.7.93

package/bin/app/utils/schemaTemplate.d.ts

@@ -0,0 +1,52 @@
+import { type Static } from "@sinclair/typebox";
+export declare const repoInfoSchema: import("@sinclair/typebox").TObject<{
+    id: import("@sinclair/typebox").TString;
+    author: import("@sinclair/typebox").TString;
+    name: import("@sinclair/typebox").TString;
+    description: import("@sinclair/typebox").TString;
+    category: import("@sinclair/typebox").TString;
+    lastUpdated: import("@sinclair/typebox").TString;
+    localPath: import("@sinclair/typebox").TString;
+    github: import("@sinclair/typebox").TObject<{
+        stars: import("@sinclair/typebox").TNumber;
+        forks: import("@sinclair/typebox").TNumber;
+        watchers: import("@sinclair/typebox").TNumber;
+        createdAt: import("@sinclair/typebox").TString;
+        updatedAt: import("@sinclair/typebox").TString;
+        pushedAt: import("@sinclair/typebox").TString;
+        defaultBranch: import("@sinclair/typebox").TString;
+    }>;
+}>;
+export type RepoInfo = Static<typeof repoInfoSchema>;
+export declare const reposSchema: import("@sinclair/typebox").TObject<{
+    $schema: import("@sinclair/typebox").TString;
+    version: import("@sinclair/typebox").TString;
+    repos: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+        id: import("@sinclair/typebox").TString;
+        author: import("@sinclair/typebox").TString;
+        name: import("@sinclair/typebox").TString;
+        description: import("@sinclair/typebox").TString;
+        category: import("@sinclair/typebox").TString;
+        lastUpdated: import("@sinclair/typebox").TString;
+        localPath: import("@sinclair/typebox").TString;
+        github: import("@sinclair/typebox").TObject<{
+            stars: import("@sinclair/typebox").TNumber;
+            forks: import("@sinclair/typebox").TNumber;
+            watchers: import("@sinclair/typebox").TNumber;
+            createdAt: import("@sinclair/typebox").TString;
+            updatedAt: import("@sinclair/typebox").TString;
+            pushedAt: import("@sinclair/typebox").TString;
+            defaultBranch: import("@sinclair/typebox").TString;
+        }>;
+    }>>;
+}>;
+export type ReposConfig = Static<typeof reposSchema>;
+export declare const DEFAULT_REPOS_CONFIG: ReposConfig;
+/**
+ * Generates a JSON schema file for repos
+ */
+export declare function generateReposJsonSchema(): Promise<void>;
+/**
+ * Checks if schema needs to be regenerated based on CLI version
+ */
+export declare function shouldRegenerateSchema(): Promise<boolean>;

package/bin/app/utils/schemaTemplate.js

@@ -0,0 +1,117 @@
+import path from "@reliverse/pathkit";
+import fs, { ensuredir } from "@reliverse/relifso";
+import { Type } from "@sinclair/typebox";
+import { cliHomeRepos, cliVersion } from "../config/constants.js";
+export const repoInfoSchema = Type.Object({
+  id: Type.String(),
+  author: Type.String(),
+  name: Type.String(),
+  description: Type.String(),
+  category: Type.String(),
+  lastUpdated: Type.String(),
+  // ISO date string
+  localPath: Type.String(),
+  // GitHub repository information from ungh
+  github: Type.Object({
+    stars: Type.Number(),
+    forks: Type.Number(),
+    watchers: Type.Number(),
+    createdAt: Type.String(),
+    updatedAt: Type.String(),
+    pushedAt: Type.String(),
+    defaultBranch: Type.String()
+  })
+});
+export const reposSchema = Type.Object(
+  {
+    $schema: Type.String(),
+    version: Type.String(),
+    // CLI version when repos.json was last updated
+    repos: Type.Array(repoInfoSchema)
+  },
+  { additionalProperties: false }
+);
+export const DEFAULT_REPOS_CONFIG = {
+  $schema: "./schema.json",
+  version: cliVersion,
+  repos: []
+};
+function convertTypeBoxToJsonSchema(schema) {
+  if (!schema || typeof schema !== "object") return schema;
+  if (schema.type === "string" && schema.enum) {
+    return {
+      type: "string",
+      enum: schema.enum
+    };
+  }
+  if (schema.anyOf || schema.allOf || schema.oneOf) {
+    const variants = schema.anyOf || schema.allOf || schema.oneOf;
+    const allLiterals = variants.every((v) => v.const !== void 0);
+    if (allLiterals) {
+      return {
+        type: "string",
+        enum: variants.map((v) => v.const)
+      };
+    }
+  }
+  if (schema.type === "object") {
+    const result = {
+      type: "object",
+      properties: {}
+    };
+    if (schema.required) {
+      result.required = schema.required;
+    }
+    if (schema.properties) {
+      for (const [key, value] of Object.entries(schema.properties)) {
+        result.properties[key] = convertTypeBoxToJsonSchema(value);
+      }
+    }
+    return result;
+  }
+  if (schema.type === "array") {
+    return {
+      type: "array",
+      items: convertTypeBoxToJsonSchema(schema.items)
+    };
+  }
+  if (schema.type) {
+    const result = { type: schema.type };
+    if (schema.minimum !== void 0) result.minimum = schema.minimum;
+    if (schema.maximum !== void 0) result.maximum = schema.maximum;
+    if (schema.minLength !== void 0) result.minLength = schema.minLength;
+    if (schema.maxLength !== void 0) result.maxLength = schema.maxLength;
+    if (schema.pattern !== void 0) result.pattern = schema.pattern;
+    if (schema.format !== void 0) result.format = schema.format;
+    if (schema.default !== void 0) result.default = schema.default;
+    return result;
+  }
+  return schema;
+}
+export async function generateReposJsonSchema() {
+  const converted = convertTypeBoxToJsonSchema(reposSchema);
+  const schema = {
+    $schema: "http://json-schema.org/draft-07/schema#",
+    title: "rse Repos Schema",
+    description: "Schema for repos.json configuration file",
+    type: "object",
+    properties: converted.properties,
+    required: converted.required
+  };
+  await ensuredir(cliHomeRepos);
+  const schemaPath = path.join(cliHomeRepos, "schema.json");
+  await fs.writeFile(schemaPath, JSON.stringify(schema, null, 2));
+}
+export async function shouldRegenerateSchema() {
+  const configPath = path.join(cliHomeRepos, "repos.json");
+  if (!await fs.pathExists(configPath)) {
+    return true;
+  }
+  try {
+    const content = await fs.readFile(configPath, "utf-8");
+    const config = JSON.parse(content);
+    return config.version !== cliVersion;
+  } catch {
+    return true;
+  }
+}

package/bin/app/utils/spinner.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Simple console spinner utility for showing progress when displayBuildPubLogs is false
+ */
+export declare class SimpleSpinner {
+    private interval?;
+    private message;
+    private readonly frames;
+    private currentFrame;
+    private isSpinning;
+    constructor(message: string);
+    start(): this;
+    stop(finalMessage?: string): this;
+    updateMessage(message: string): this;
+    succeed(message?: string): this;
+    fail(message?: string): this;
+}
+export declare function createSpinner(message: string): SimpleSpinner;

package/bin/app/utils/spinner.js

@@ -0,0 +1,54 @@
+export class SimpleSpinner {
+  interval;
+  message;
+  frames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+  // biome-ignore lint/style/useReadonlyClassProperties: <false positive probably>
+  currentFrame = 0;
+  isSpinning = false;
+  constructor(message) {
+    this.message = message;
+  }
+  start() {
+    if (this.isSpinning || !process.stdout.isTTY) {
+      return this;
+    }
+    this.isSpinning = true;
+    process.stdout.write("\x1B[?25l");
+    this.interval = setInterval(() => {
+      const frame = this.frames[this.currentFrame];
+      process.stdout.write(`\r${frame} ${this.message}`);
+      this.currentFrame = (this.currentFrame + 1) % this.frames.length;
+    }, 80);
+    return this;
+  }
+  stop(finalMessage) {
+    if (!this.isSpinning) {
+      return this;
+    }
+    if (this.interval) {
+      clearInterval(this.interval);
+      this.interval = void 0;
+    }
+    this.isSpinning = false;
+    process.stdout.write("\r\x1B[K");
+    process.stdout.write("\x1B[?25h");
+    if (finalMessage) {
+      process.stdout.write(`${finalMessage}
+`);
+    }
+    return this;
+  }
+  updateMessage(message) {
+    this.message = message;
+    return this;
+  }
+  succeed(message) {
+    return this.stop(message ? `\u2705 ${message}` : `\u2705 ${this.message}`);
+  }
+  fail(message) {
+    return this.stop(message ? `\u274C ${message}` : `\u274C ${this.message}`);
+  }
+}
+export function createSpinner(message) {
+  return new SimpleSpinner(message);
+}

package/bin/app/utils/startEndPrompts.d.ts

@@ -0,0 +1,2 @@
+export declare const getPkgName: () => string;
+export declare const getPkgVersion: () => string;

package/bin/app/utils/startEndPrompts.js

@@ -0,0 +1,14 @@
+import { relinka } from "@reliverse/relinka";
+import { readPackageJSON } from "pkg-types";
+const pkgInfo = {
+  name: "unknown",
+  version: "0.0.0"
+};
+readPackageJSON().then((pkg) => {
+  pkgInfo.name = pkg.name || "unknown";
+  pkgInfo.version = pkg.version || "0.0.0";
+}).catch(() => {
+  relinka("warn", "Could not read package.json, using default values");
+});
+export const getPkgName = () => pkgInfo.name;
+export const getPkgVersion = () => pkgInfo.version;

package/bin/app/utils/terminalHelpers.d.ts

@@ -0,0 +1,19 @@
+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/bin/app/utils/terminalHelpers.js

@@ -0,0 +1,43 @@
+import { cwd } from "node:process";
+import { normalize } from "@reliverse/pathkit";
+import fs, { ensuredir } from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+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);
+    relinka("verbose", `Changed directory to: ${process.cwd()}`);
+  } catch (error) {
+    relinka("warn", `Directory does not exist: ${dir}`, handleError(error));
+  }
+}
+export function pwd() {
+  const cwd2 = getCurrentWorkingDirectory();
+  relinka("verbose", `Current working directory: ${cwd2}`);
+}
+export async function rm(target) {
+  try {
+    await fs.remove(target);
+    relinka("verbose", `Removed: ${target}`);
+  } catch (error) {
+    relinka("error", `Failed to remove: ${target}`, handleError(error));
+  }
+}
+export function getCurrentWorkingDirectory(useCache = true) {
+  let cachedCWD = null;
+  if (useCache && cachedCWD) {
+    return cachedCWD;
+  }
+  try {
+    const currentDirectory = normalize(cwd());
+    if (useCache) {
+      cachedCWD = currentDirectory;
+    }
+    return currentDirectory;
+  } catch (error) {
+    relinka("error", "Error getting current working directory:", handleError(error));
+    throw error;
+  }
+}

package/bin/app/utils/testsRuntime.d.ts

@@ -0,0 +1,5 @@
+import type { ParamsOmitReli } from "../types/mod.js";
+/**
+ * Sets up the dev environment if the isDev flag is true.
+ */
+export declare function setupDevModeIfNeeded(params: ParamsOmitReli): Promise<void>;

package/bin/app/utils/testsRuntime.js

@@ -0,0 +1,11 @@
+import path from "@reliverse/pathkit";
+import { ensuredir } from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+export async function setupDevModeIfNeeded(params) {
+  if (params.isDev) {
+    const newCwd = path.join(params.cwd, "tests-runtime");
+    await ensuredir(newCwd);
+    params.cwd = newCwd;
+    relinka("verbose", `Dev mode: using tests-runtime => ${newCwd}`);
+  }
+}

package/bin/app/utils/tsconfigHelpers.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Searches upward from the given path for a tsconfig.json.
+ * Returns the full path if found, otherwise undefined.
+ */
+export declare function findTsconfigUp(fromPath: string): Promise<string | undefined>;

package/bin/app/utils/tsconfigHelpers.js

@@ -0,0 +1,14 @@
+import path from "@reliverse/pathkit";
+import fs from "@reliverse/relifso";
+export async function findTsconfigUp(fromPath) {
+  let currentDir = fromPath;
+  const rootPath = path.parse(currentDir).root;
+  while (true) {
+    const candidate = path.join(currentDir, "tsconfig.json");
+    if (await fs.pathExists(candidate)) return candidate;
+    const parentDir = path.dirname(currentDir);
+    if (parentDir === currentDir || currentDir === rootPath) break;
+    currentDir = parentDir;
+  }
+  return;
+}

package/bin/app/utils/utils-build.d.ts

@@ -0,0 +1,33 @@
+import type { DlerConfig, NpmOutExt, Sourcemap } from "../types/mod.js";
+/**
+ * Converts the Unified build sourcemap option to a Bun-friendly value.
+ * @param transpileSourcemap - The sourcemap configuration ('none', 'inline', 'linked', 'external', true, false).
+ * @returns "none", "inline", or "external" for Bun's bundler.
+ */
+export declare function getBunSourcemapOption(transpileSourcemap: Sourcemap): "external" | "inline" | "none";
+/**
+ * Converts the Unified build sourcemap option to a Rollup/Unified-bundler friendly value.
+ * @param transpileSourcemap - The sourcemap configuration ('none', 'inline', 'linked', 'external', true, false).
+ * @returns "inline" if inline is specified; true for linked/external or boolean true; otherwise false.
+ */
+export declare function getUnifiedSourcemapOption(transpileSourcemap: Sourcemap): "inline" | boolean;
+/**
+ * Renames the primary output file (and its declaration file, if applicable)
+ * in the output directory.
+ *
+ * @deprecated Earlier dler used to rename to a standardized name (e.g., mod.js, mod.ts).
+ *
+ * TODO: It will be removed in the future.
+ *
+ * @param isJsr - Flag indicating if the target platform is JSR.
+ * @param outDirBin - The output directory where the compiled files reside.
+ * @param originalEntryFileBasename - The base name (file name only) of the original entry file processed by the bundler.
+ * @param unifiedBundlerOutExt - The file extension used for standard (non-JSR) builds (e.g., 'js', 'mjs').
+ * @param distJsrOutFilesExt - The file extension used for JSR builds (likely 'ts' or 'js').
+ * @param config - The configuration object.
+ * @returns An object containing the new base name of the entry file.
+ * @throws If the expected source entry file is not found in the output directory.
+ */
+export declare function renameEntryFile(isJsr: boolean, outDirBin: string, originalEntryFileBasename: string, unifiedBundlerOutExt: NpmOutExt, distJsrOutFilesExt: NpmOutExt, config: DlerConfig): Promise<{
+    updatedEntryFile: string;
+}>;

package/bin/app/utils/utils-clean.d.ts

@@ -0,0 +1,11 @@
+import type { LibConfig } from "../types/mod.js";
+/**
+ * Recursively removes any existing distribution folders.
+ */
+export declare function removeDistFolders(distNpmDirName: string, distJsrDirName: string, libsDirDist: string, libsList: Record<string, LibConfig>, distTmpDirName?: string): Promise<boolean>;
+/**
+ * Removes logInternal and relinka "internal" calls from TypeScript/JavaScript files
+ * @param targetDir Directory to process recursively
+ * @returns Promise<boolean> True if successful
+ */
+export declare function removeLogInternalCalls(targetDir: string): Promise<boolean>;

package/bin/app/utils/utils-clean.js

@@ -0,0 +1,70 @@
+import path from "@reliverse/pathkit";
+import fs from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+import pMap from "p-map";
+import { CONCURRENCY_DEFAULT, PROJECT_ROOT } from "../config/constants.js";
+export async function removeDistFolders(distNpmDirName, distJsrDirName, libsDirDist, libsList, distTmpDirName = "") {
+  const foldersToRemove = [];
+  foldersToRemove.push(distNpmDirName);
+  foldersToRemove.push(distJsrDirName);
+  if (distTmpDirName !== "") {
+    foldersToRemove.push(distTmpDirName);
+  }
+  if (libsList && Object.keys(libsList).length > 0) {
+    foldersToRemove.push(libsDirDist);
+  }
+  const existingFolders = [];
+  for (const folder of foldersToRemove) {
+    const folderPath = path.resolve(PROJECT_ROOT, folder);
+    if (await fs.pathExists(folderPath)) {
+      existingFolders.push(folder);
+    }
+  }
+  if (existingFolders.length > 0) {
+    await pMap(
+      existingFolders,
+      async (folder) => {
+        const folderPath = path.resolve(PROJECT_ROOT, folder);
+        if (await fs.pathExists(folderPath)) {
+          await fs.remove(folderPath);
+          relinka("verbose", `Removed: ${folderPath}`);
+        }
+      },
+      { concurrency: CONCURRENCY_DEFAULT }
+    );
+    relinka("verbose", "Distribution folders removed successfully");
+  }
+  return true;
+}
+export async function removeLogInternalCalls(targetDir) {
+  const files = await fs.readdir(targetDir, { recursive: true });
+  const tsJsFiles = files.filter(
+    (file) => file.endsWith(".ts") || file.endsWith(".js") || file.endsWith(".tsx") || file.endsWith(".jsx")
+  );
+  await pMap(
+    tsJsFiles,
+    async (file) => {
+      const filePath = path.join(targetDir, file);
+      const content = await fs.readFile(filePath, "utf8");
+      let newContent = content.replace(
+        /logInternal\s*\(\s*(?:`[^`]*`|'[^']*'|"[^"]*"|(?:[^;]*?,\s*)*[^;]*?)\s*\)\s*;?/g,
+        ""
+      );
+      newContent = newContent.replace(
+        /relinka\s*\(\s*["']internal["']\s*,\s*(?:`[^`]*`|'[^']*'|"[^"]*"|(?:[^;]*?,\s*)*[^;]*?)\s*\)\s*;?/g,
+        ""
+      );
+      newContent = newContent.replace(
+        /relinka\.internal\s*\(\s*(?:`[^`]*`|'[^']*'|"[^"]*"|(?:[^;]*?,\s*)*[^;]*?)\s*\)\s*;?/g,
+        ""
+      );
+      newContent = newContent.replace(/\n\s*\n\s*\n/g, "\n\n").replace(/^\s*\n/gm, "").replace(/\n\s*$/g, "\n");
+      if (newContent !== content) {
+        await fs.writeFile(filePath, newContent);
+      }
+    },
+    { concurrency: CONCURRENCY_DEFAULT }
+  );
+  relinka("verbose", "Successfully removed logInternal and relinka internal calls from files");
+  return true;
+}

package/bin/app/utils/utils-deps.d.ts

@@ -0,0 +1,5 @@
+import type { DlerConfig } from "../types/mod.js";
+/**
+ * Filters out development dependencies from a dependency record.
+ */
+export declare function filterDeps(deps: Record<string, string> | undefined, clearUnused: boolean, outDirBin: string, isJsr: boolean, config: DlerConfig, libName?: string): Promise<Record<string, string>>;

package/bin/app/utils/utils-determine.d.ts

@@ -0,0 +1,12 @@
+import type { LibConfig } from "../types/mod.js";
+/**
+ * Determines the distribution name based on the file path and build type.
+ * This function is used for logging and determining output paths.
+ *
+ * @returns The distribution name in the transpileFormat of:
+ *   - For empty isJsr: "root"
+ *   - For regular builds: "dist-jsr" or "dist-npm"
+ *   - For library builds: "dist-libs/{lib-name}/jsr" or "dist-libs/{lib-name}/npm"
+ *   - For library builds with libDirName: "dist-libs/{libDirName}/jsr" or "dist-libs/{libDirName}/npm"
+ */
+export declare function determineDistName(filePath: string, isJsr: "" | boolean, libsList?: Record<string, LibConfig>): string;