@reliverse/dler 1.7.152 → 2.0.0

package/bin/impl/rempts/cmd.js

@@ -1,260 +0,0 @@
-import path from "@reliverse/pathkit";
-import fs from "@reliverse/relifso";
-import { relinka } from "@reliverse/relinka";
-import { createJiti } from "jiti";
-export async function handleReliverseConfig() {
-  const dlerConfigPath = path.resolve("reliverse.ts");
-  let cmdsRoot = "src/app";
-  let cliFilePath = "";
-  try {
-    const jiti = createJiti(import.meta.url);
-    const dlerConfig = await jiti.import(dlerConfigPath, {
-      default: true
-    });
-    const coreIsCLI = dlerConfig?.coreIsCLI;
-    if (!coreIsCLI?.enabled || !coreIsCLI?.scripts) {
-      cliFilePath = await ensureCliFile("src/cli.ts");
-      cmdsRoot = "src/app";
-    } else {
-      const firstScript = Object.values(coreIsCLI.scripts)[0];
-      const scriptPath = path.resolve(firstScript);
-      if (await fs.pathExists(scriptPath)) {
-        const content = await fs.readFile(scriptPath, "utf8");
-        if (content.includes("@reliverse/rempts")) {
-          if (content.includes("runMain")) {
-            const cmdsRootMatch = content.match(/cmdsRootPath:\s*["']([^"']+)["']/);
-            if (cmdsRootMatch?.[1]) {
-              cmdsRoot = path.resolve(cmdsRootMatch[1]);
-            }
-          }
-        } else {
-          relinka("warn", `${scriptPath} doesn't use @reliverse/rempts`);
-          cmdsRoot = "src/app";
-        }
-      } else {
-        cliFilePath = await ensureCliFile(scriptPath);
-        cmdsRoot = "src/app";
-      }
-    }
-  } catch {
-    cliFilePath = await ensureCliFile("src/cli.ts");
-    cmdsRoot = "src/app";
-  }
-  return { cmdsRoot: path.resolve(cmdsRoot), cliFile: cliFilePath };
-}
-export async function ensureCliFile(filePath) {
-  const resolvedPath = path.resolve(filePath);
-  if (!await fs.pathExists(resolvedPath)) {
-    await fs.ensureDir(path.dirname(resolvedPath));
-    await fs.writeFile(resolvedPath, cliTemplate, "utf8");
-    relinka("verbose", `\u2705 Created CLI entry file: ${resolvedPath}`);
-    return resolvedPath;
-  }
-  return "";
-}
-export async function findCommandDirs(root) {
-  const cmdDirs = [];
-  async function scan(dir) {
-    const entries = await fs.readdir(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      const fullPath = path.join(dir, entry.name);
-      if (entry.isDirectory()) {
-        const hasCmdTs = await fs.pathExists(path.join(fullPath, "cmd.ts"));
-        const hasCmdJs = await fs.pathExists(path.join(fullPath, "cmd.js"));
-        if (hasCmdTs || hasCmdJs) {
-          const relPath = path.relative(root, fullPath);
-          cmdDirs.push(relPath);
-        }
-        await scan(fullPath);
-      }
-    }
-  }
-  await scan(root);
-  return cmdDirs;
-}
-export async function generateCommandArgsMap(cmdDirs) {
-  let interfaceContent = "// Argument types for each command based on their defineArgs\ninterface CommandArgsMap {\n";
-  for (const dir of cmdDirs) {
-    const cmdPath = path.join("src/app", dir, "cmd.ts");
-    try {
-      if (await fs.pathExists(cmdPath)) {
-        const content = await fs.readFile(cmdPath, "utf-8");
-        const args = extractArgsFromContent(content);
-        const keyName = dir.replace(/[/\\]/g, "_");
-        interfaceContent += `  "${keyName}": {
-`;
-        if (args.length > 0) {
-          for (const arg of args) {
-            let tsType;
-            switch (arg.type) {
-              case "boolean":
-                tsType = "boolean";
-                break;
-              case "number":
-                tsType = "number";
-                break;
-              case "array":
-                tsType = "string[]";
-                break;
-              case "string":
-                if (arg.allowed) {
-                  tsType = arg.allowed.map((v) => `"${v}"`).join(" | ");
-                } else {
-                  tsType = "string";
-                }
-                break;
-              default:
-                tsType = "string";
-            }
-            const optional = arg.required ? "" : "?";
-            interfaceContent += `    ${arg.name}${optional}: ${tsType};
-`;
-          }
-        } else {
-          interfaceContent += `    // No arguments defined
-`;
-        }
-        interfaceContent += "  };\n";
-      } else {
-        const keyName = dir.replace(/[/\\]/g, "_");
-        interfaceContent += `  "${keyName}": Record<string, unknown>;
-`;
-      }
-    } catch (error) {
-      const keyName = dir.replace(/[/\\]/g, "_");
-      interfaceContent += `  "${keyName}": Record<string, unknown>;
-`;
-    }
-  }
-  interfaceContent += "}";
-  return interfaceContent;
-}
-export function extractArgsFromContent(content) {
-  const args = [];
-  const defineArgsMatch = content.match(/defineArgs\(\s*\{([\s\S]*?)\}\s*\)/);
-  if (!defineArgsMatch?.[1]) return args;
-  const argsBlock = defineArgsMatch[1];
-  const argMatches = argsBlock.matchAll(/(\w+):\s*\{([^}]*)\}/g);
-  for (const match of argMatches) {
-    const argName = match[1];
-    const argProps = match[2];
-    if (!argName || !argProps) continue;
-    const typeMatch = argProps.match(/type:\s*["']([^"']+)["']/);
-    const type = typeMatch?.[1] || "string";
-    const requiredMatch = argProps.match(/required:\s*(true|false)/);
-    const required = requiredMatch?.[1] === "true";
-    const defaultMatch = argProps.match(/default:\s*([^,\n]+)/);
-    let defaultValue;
-    if (defaultMatch?.[1]) {
-      const defaultStr = defaultMatch[1].trim();
-      try {
-        defaultValue = JSON.parse(defaultStr);
-      } catch {
-        defaultValue = defaultStr.replace(/["']/g, "");
-      }
-    }
-    const allowedMatch = argProps.match(/allowed:\s*\[([^\]]+)\]/);
-    let allowed;
-    if (allowedMatch?.[1]) {
-      allowed = allowedMatch[1].split(",").map((s) => s.trim().replace(/["']/g, ""));
-    }
-    args.push({
-      name: argName,
-      type,
-      required,
-      default: defaultValue,
-      allowed
-    });
-  }
-  return args;
-}
-export async function generateExports(cmdDirs) {
-  const lines = [
-    "// autogenerated by `dler rempts`",
-    "// don't edit this file manually",
-    "",
-    'import type { Command } from "@reliverse/rempts";',
-    "",
-    'import { callCmdImpl, getTypedCmdImpl, loadCommand } from "@reliverse/rempts";'
-  ];
-  lines.push("", "// ========== TYPED COMMAND SYSTEM ==========", "");
-  const commandArgsMap = await generateCommandArgsMap(cmdDirs);
-  lines.push(commandArgsMap);
-  lines.push(
-    "",
-    "// Typed loadCommand wrapper with intellisense",
-    "export async function loadTypedCommand<T extends keyof CommandArgsMap>(",
-    "  cmdName: T",
-    "): Promise<Command> {",
-    "  return await loadCommand(cmdName as string);",
-    "}",
-    ""
-  );
-  const traditionalExports = [
-    "",
-    "// ========== TRADITIONAL COMMAND EXPORTS (with typed intellisense) ==========",
-    ""
-  ];
-  for (const dir of cmdDirs) {
-    const funcName = "get" + dir.split(/[/\\]/).map((part) => part.charAt(0).toUpperCase() + part.slice(1).replace(/[^a-zA-Z0-9]/g, "")).join("") + "Cmd";
-    const keyName = dir.replace(/[/\\]/g, "_");
-    traditionalExports.push(
-      `export const ${funcName} = async (): Promise<Command> => loadTypedCommand("${keyName}");`
-    );
-  }
-  lines.push(...traditionalExports);
-  lines.push(
-    "",
-    "// Typed command functions with type safety",
-    "export async function callCmd<T extends keyof CommandArgsMap>(",
-    "  cmdName: T,",
-    "  args?: CommandArgsMap[T]",
-    "): Promise<void> {",
-    "  await callCmdImpl<CommandArgsMap>(cmdName, args);",
-    "}",
-    "",
-    "export async function getTypedCmd<T extends keyof CommandArgsMap>(",
-    "  cmdName: T",
-    "): Promise<{",
-    "  command: Command;",
-    "  run: (args?: CommandArgsMap[T]) => Promise<void>;",
-    "}> {",
-    "  return await getTypedCmdImpl<CommandArgsMap>(cmdName);",
-    "}",
-    "",
-    "// Export type for external use",
-    "export type { CommandArgsMap };",
-    ""
-  );
-  return lines.join("\n");
-}
-export function generateCommandTemplate(cmdName) {
-  return `import { defineCommand, defineArgs } from "@reliverse/rempts";
-export default defineCommand({
-  meta: {
-    name: "${cmdName}",
-    version: "1.0.0",
-    description: "Describe what ${cmdName} command does.",
-  },
-  args: defineArgs({
-    exampleArg: {
-      type: "string",
-      default: "defaultValue",
-      description: "An example argument",
-    },
-  }),
-  async run({ args }) {
-    console.log("Command '${cmdName}' executed.");
-    console.log("Received args:", args);
-  },
-});
-`;
-}
-const cliTemplate = `import { defineCommand, runMain } from "@reliverse/rempts";
-await runMain(
-  defineCommand({
-    // empty object activates file-based
-    // commands in the src/app directory
-  }),
-);
-`;

package/bin/impl/rules/reliverse/dler-config-health/dler-config-health.d.ts

@@ -1,2 +0,0 @@
-import type { CheckResult } from "../../../types/mod.js";
-export declare function checkReliverseConfigHealth(): Promise<CheckResult>;

package/bin/impl/rules/reliverse/dler-config-health/dler-config-health.js

@@ -1,37 +0,0 @@
-import { getConfigDler } from "../../../config/load.js";
-export async function checkReliverseConfigHealth() {
-  const startTime = Date.now();
-  const issues = [];
-  try {
-    const config = await getConfigDler();
-    const libsList = config.libsList || {};
-    for (const [, libConfig] of Object.entries(libsList)) {
-      const typedConfig = libConfig;
-      const mainFile = typedConfig.libMainFile;
-      if (mainFile && !mainFile.includes("/")) {
-        issues.push({
-          type: "dler-config-health",
-          message: `currently you should specify libsMainFile like "sdk/sdk-mod.ts" to get correct build, please correct "${mainFile}" to "${typedConfig.libDirName}/${mainFile}" to continue checks.`,
-          file: "reliverse.ts",
-          line: 0
-        });
-      }
-    }
-  } catch (error) {
-    issues.push({
-      type: "dler-config-health",
-      message: `failed to check libsMainFile format: ${error instanceof Error ? error.message : "unknown error"}`,
-      file: "reliverse.ts",
-      line: 0
-    });
-  }
-  return {
-    success: issues.length === 0,
-    issues,
-    stats: {
-      filesChecked: 1,
-      importsChecked: 0,
-      timeElapsed: Date.now() - startTime
-    }
-  };
-}

package/bin/impl/rules/reliverse/file-extensions/file-extensions.d.ts

@@ -1,2 +0,0 @@
-import type { CheckResult, RulesCheckOptions } from "../../../types/mod.js";
-export declare function checkFileExtensions(options: RulesCheckOptions): Promise<CheckResult>;

package/bin/impl/rules/reliverse/file-extensions/file-extensions.js

@@ -1,62 +0,0 @@
-import { extname } from "@reliverse/pathkit";
-import { ALLOWED_FILE_EXTENSIONS, STRICT_FILE_EXTENSIONS } from "../../rules-consts.js";
-import { getAllFiles } from "../../rules-utils.js";
-function getAllowedFileExtensions(directory, strict, moduleResolution) {
-  if (!strict) {
-    return ALLOWED_FILE_EXTENSIONS[directory];
-  }
-  if (moduleResolution === "bundler") {
-    return STRICT_FILE_EXTENSIONS[directory];
-  }
-  return STRICT_FILE_EXTENSIONS[directory];
-}
-export async function checkFileExtensions(options) {
-  const startTime = Date.now();
-  const issues = [];
-  const { directory, strict, moduleResolution, onProgress } = options;
-  const allowedExts = getAllowedFileExtensions(directory, strict, moduleResolution);
-  try {
-    const files = await getAllFiles(directory, onProgress);
-    const batchSize = 50;
-    const batches = [];
-    for (let i = 0; i < files.length; i += batchSize) {
-      batches.push(files.slice(i, i + batchSize));
-    }
-    for (const [batchIndex, batch] of batches.entries()) {
-      const batchPromises = batch.map(async (file, fileIndex) => {
-        const globalIndex = batchIndex * batchSize + fileIndex;
-        onProgress?.(globalIndex + 1, files.length, file);
-        const ext = extname(file);
-        if (!allowedExts.includes(ext)) {
-          let message = `file has disallowed extension "${ext}" (allowed: ${allowedExts.join(", ")})`;
-          if (ext === ".ts" && (directory === "dist-npm" || directory === "dist-libs/npm")) {
-            message = `typescript file found in javascript environment: ${file} (should be compiled to .js)`;
-          } else if (ext === ".js" && (directory === "src" || directory === "dist-jsr" || directory === "dist-libs/jsr")) {
-            message = `javascript file found in typescript environment: ${file} (should be .ts)`;
-          }
-          return {
-            file,
-            message,
-            type: "file-extension"
-          };
-        }
-        return null;
-      });
-      const batchResults = await Promise.all(batchPromises);
-      issues.push(...batchResults.filter(Boolean));
-    }
-    return {
-      success: issues.length === 0,
-      issues,
-      stats: {
-        filesChecked: files.length,
-        importsChecked: 0,
-        timeElapsed: Date.now() - startTime
-      }
-    };
-  } catch (error) {
-    throw new Error(
-      `failed to check file extensions: ${error instanceof Error ? error.message : "unknown error"}`
-    );
-  }
-}

package/bin/impl/rules/reliverse/missing-deps/analyzer.d.ts

@@ -1,2 +0,0 @@
-import type { DependencyResult, FinderOptions } from "./deps-types";
-export declare const analyzeDependencies: (options: FinderOptions) => Promise<DependencyResult>;

package/bin/impl/rules/reliverse/missing-deps/analyzer.js

@@ -1,49 +0,0 @@
-import { findSourceFiles, readFile, readPackageJson } from "./filesystem.js";
-import { extractPackageNames, getBuiltinModules, getListedDependencies } from "./parser.js";
-export const analyzeDependencies = async (options) => {
-  const packageJson = await readPackageJson(options.directory);
-  const listedDependencies = getListedDependencies(packageJson);
-  const sourceFiles = await findSourceFiles(options.directory, options.ignorePatterns);
-  const builtinModules = getBuiltinModules();
-  const allDependencies = /* @__PURE__ */ new Set();
-  const devOnlyDependencies = /* @__PURE__ */ new Set();
-  const duplicateDependencies = /* @__PURE__ */ new Set();
-  if (packageJson.dependencies && packageJson.devDependencies) {
-    for (const dep of Object.keys(packageJson.dependencies)) {
-      if (packageJson.devDependencies[dep]) {
-        duplicateDependencies.add(dep);
-      }
-    }
-  }
-  for (const filePath of sourceFiles) {
-    const fileContent = await readFile(filePath);
-    const packageNames = extractPackageNames(fileContent);
-    for (const packageName of packageNames) {
-      allDependencies.add(packageName);
-      if (packageJson.devDependencies?.[packageName] && !packageJson.dependencies?.[packageName] && !packageJson.peerDependencies?.[packageName] && !packageJson.optionalDependencies?.[packageName] && !builtinModules.has(packageName)) {
-        devOnlyDependencies.add(packageName);
-      }
-    }
-  }
-  const missingDependencies = /* @__PURE__ */ new Set();
-  const builtinModulesList = [];
-  for (const dependency of allDependencies) {
-    if (!listedDependencies.has(dependency)) {
-      if (builtinModules.has(dependency)) {
-        if (options.builtins) {
-          builtinModulesList.push(dependency);
-        }
-      } else {
-        missingDependencies.add(dependency);
-      }
-    }
-  }
-  return {
-    missingDependencies: Array.from(missingDependencies).sort(),
-    allDependencies: Array.from(allDependencies).sort(),
-    listedDependencies: Array.from(listedDependencies).sort(),
-    builtinModules: builtinModulesList.sort(),
-    devOnlyDependencies: Array.from(devOnlyDependencies).sort(),
-    duplicateDependencies: Array.from(duplicateDependencies).sort()
-  };
-};

package/bin/impl/rules/reliverse/missing-deps/deps-mod.d.ts

@@ -1,2 +0,0 @@
-import type { CheckResult, RulesCheckOptions } from "../../../types/mod.js";
-export declare function checkMissingDependencies(options: RulesCheckOptions): Promise<CheckResult>;

package/bin/impl/rules/reliverse/missing-deps/deps-mod.js

@@ -1,57 +0,0 @@
-import { IGNORE_PATTERNS } from "../../../config/constants.js";
-import { analyzeDependencies } from "./analyzer.js";
-export async function checkMissingDependencies(options) {
-  const startTime = Date.now();
-  const issues = [];
-  const {
-    directory,
-    json = false,
-    builtins = true,
-    dev = false,
-    peer = false,
-    optional = false,
-    fix = false,
-    depth = 0
-  } = options;
-  try {
-    const result = await analyzeDependencies({
-      directory,
-      showAll: false,
-      ignorePatterns: Array.from(IGNORE_PATTERNS),
-      json,
-      builtins,
-      dev,
-      peer,
-      optional,
-      fix,
-      depth
-    });
-    for (const dep of result.missingDependencies) {
-      issues.push({
-        file: "package.json",
-        message: `missing dependency: ${dep}`,
-        type: "missing-dependency"
-      });
-    }
-    for (const dep of result.builtinModules) {
-      issues.push({
-        file: "package.json",
-        message: `using builtin module: ${dep}`,
-        type: "builtin-module"
-      });
-    }
-    return {
-      success: issues.length === 0,
-      issues,
-      stats: {
-        filesChecked: result.allDependencies.length,
-        importsChecked: result.allDependencies.length,
-        timeElapsed: Date.now() - startTime
-      }
-    };
-  } catch (error) {
-    throw new Error(
-      `failed to check missing dependencies: ${error instanceof Error ? error.message : "unknown error"}`
-    );
-  }
-}

package/bin/impl/rules/reliverse/missing-deps/deps-types.d.ts

@@ -1,28 +0,0 @@
-export type MissingDepsFileType = ".js" | ".jsx" | ".ts" | ".tsx";
-export interface PackageJson {
-    name?: string;
-    dependencies?: Record<string, string>;
-    devDependencies?: Record<string, string>;
-    peerDependencies?: Record<string, string>;
-    optionalDependencies?: Record<string, string>;
-}
-export interface FinderOptions {
-    directory: string;
-    showAll: boolean;
-    ignorePatterns: string[];
-    json: boolean;
-    builtins: boolean;
-    dev: boolean;
-    peer: boolean;
-    optional: boolean;
-    fix: boolean;
-    depth: number;
-}
-export interface DependencyResult {
-    missingDependencies: string[];
-    allDependencies: string[];
-    listedDependencies: string[];
-    builtinModules: string[];
-    devOnlyDependencies: string[];
-    duplicateDependencies: string[];
-}

package/bin/impl/rules/reliverse/missing-deps/filesystem.d.ts

@@ -1,4 +0,0 @@
-import type { PackageJson } from "./deps-types";
-export declare const findSourceFiles: (directory: string, ignorePatterns: string[]) => Promise<string[]>;
-export declare const readFile: (filePath: string) => Promise<string>;
-export declare const readPackageJson: (directory: string) => Promise<PackageJson>;

package/bin/impl/rules/reliverse/missing-deps/filesystem.js

@@ -1,39 +0,0 @@
-import path from "@reliverse/pathkit";
-import fs from "@reliverse/relifso";
-import { glob } from "tinyglobby";
-export const findSourceFiles = async (directory, ignorePatterns) => {
-  const pattern = `${directory}/**/*.{js,jsx,ts,tsx}`;
-  const defaultIgnores = [
-    "**/node_modules/**",
-    "**/.git/**",
-    "**/build/**",
-    "**/dist/**",
-    "**/dist-npm/**",
-    "**/dist-jsr/**",
-    "**/dist-libs/**",
-    "**/coverage/**"
-  ];
-  const allIgnores = [...defaultIgnores, ...ignorePatterns];
-  return await glob(pattern, {
-    ignore: allIgnores,
-    absolute: true
-  });
-};
-export const readFile = async (filePath) => {
-  try {
-    return await fs.readFile(filePath, "utf8");
-  } catch (error) {
-    console.error(`Error reading file ${filePath}:`, error);
-    return "";
-  }
-};
-export const readPackageJson = async (directory) => {
-  const packageJsonPath = path.join(directory, "package.json");
-  try {
-    const content = await readFile(packageJsonPath);
-    return JSON.parse(content);
-  } catch (error) {
-    console.error("Error reading package.json:", error);
-    return {};
-  }
-};

package/bin/impl/rules/reliverse/missing-deps/formatter.d.ts

@@ -1,2 +0,0 @@
-import type { DependencyResult, FinderOptions } from "./deps-types";
-export declare const formatOutput: (result: DependencyResult, options: FinderOptions) => string;

package/bin/impl/rules/reliverse/missing-deps/formatter.js

@@ -1,101 +0,0 @@
-import { re } from "@reliverse/relico";
-export const formatOutput = (result, options) => {
-  if (options.json) {
-    return JSON.stringify(result, null, 2);
-  }
-  let output = "";
-  output += re.blueBright("\nMissing Dependencies Finder Results\n");
-  output += re.gray("---------------------------------------\n\n");
-  output += re.bold("Statistics:\n");
-  output += `${re.gray("\u2022 ")}Total dependencies found: ${result.allDependencies.length}
-`;
-  output += `${re.gray("\u2022 ")}Listed in package.json: ${result.listedDependencies.length}
-`;
-  output += `${re.gray("\u2022 ")}Missing from package.json: ${result.missingDependencies.length}
-`;
-  if (options.builtins) {
-    output += `${re.gray("\u2022 ")}Node.js built-in modules: ${result.builtinModules.length}
-`;
-  }
-  output += `${re.gray("\u2022 ")}Dev-only dependencies used in production: ${result.devOnlyDependencies.length}
-`;
-  output += `${re.gray("\u2022 ")}Duplicate dependencies: ${result.duplicateDependencies.length}
-`;
-  output += "\n";
-  if (result.duplicateDependencies.length > 0) {
-    output += re.yellowBright("\u26A0\uFE0F  Duplicate Dependencies Found:\n");
-    output += re.yellow("These packages are listed in both dependencies and devDependencies.\n");
-    output += re.yellow(
-      "This can cause confusion and potential issues. Consider keeping them in only one section.\n\n"
-    );
-    for (const dep of result.duplicateDependencies) {
-      output += `${re.gray("\u2022 ")}${re.yellow(dep)}
-`;
-    }
-    output += "\n";
-  }
-  if (result.devOnlyDependencies.length > 0) {
-    output += re.yellowBright("\u26A0\uFE0F  Dev-only Dependencies Used in Production Code:\n");
-    output += re.yellow(
-      "These packages are only in devDependencies but are imported in your code.\n"
-    );
-    output += re.yellow("They will cause errors in production after bundling!\n\n");
-    for (const dep of result.devOnlyDependencies) {
-      output += `${re.gray("\u2022 ")}${re.yellow(dep)}
-`;
-    }
-    output += "\n";
-    output += re.gray("To fix, move these to dependencies:\n");
-    output += re.cyan(`npm install ${result.devOnlyDependencies.join(" ")} --save
-`);
-  }
-  if (result.missingDependencies.length > 0) {
-    output += re.redBright("Missing Dependencies:\n");
-    for (const dep of result.missingDependencies) {
-      output += `${re.gray("\u2022 ")}${re.yellow(dep)}
-`;
-    }
-    output += "\n";
-    output += re.gray("To install, run:\n");
-    output += re.cyan(`npm install ${result.missingDependencies.join(" ")}
-`);
-  } else {
-    output += re.greenBright("No missing dependencies found! \u2705\n\n");
-  }
-  if (options.builtins && result.builtinModules.length > 0) {
-    output += re.blueBright("Node.js Built-in Modules Used:\n");
-    for (const dep of result.builtinModules) {
-      output += `${re.gray("\u2022 ")}${re.blue(dep)}
-`;
-    }
-    output += "\n";
-  }
-  if (options.showAll) {
-    output += re.bold("All Dependencies:\n");
-    output += re.gray("(\u2713 = listed in package.json, \u2717 = missing, \u26A0\uFE0F = dev-only, \u{1F504} = duplicate)\n");
-    for (const dep of result.allDependencies) {
-      const isListed = result.listedDependencies.includes(dep);
-      const isBuiltin = result.builtinModules.includes(dep);
-      const isDevOnly = result.devOnlyDependencies.includes(dep);
-      const isDuplicate = result.duplicateDependencies.includes(dep);
-      if (isDuplicate) {
-        output += `${re.gray("\u2022 ")}${re.yellow("\u{1F504} ")}${re.yellow(dep)}${re.gray(" (duplicate)")}
-`;
-      } else if (isListed && !isDevOnly) {
-        output += `${re.gray("\u2022 ") + re.green("\u2713 ") + dep}
-`;
-      } else if (isBuiltin) {
-        output += `${re.gray("\u2022 ")}${re.blue("\u26A1 ")}${dep}${re.gray(" (built-in)")}
-`;
-      } else if (isDevOnly) {
-        output += `${re.gray("\u2022 ")}${re.yellow("\u26A0\uFE0F ")}${re.yellow(dep)}${re.gray(" (dev-only)")}
-`;
-      } else {
-        output += `${re.gray("\u2022 ")}${re.red("\u2717 ")}${re.yellow(dep)}
-`;
-      }
-    }
-    output += "\n";
-  }
-  return output;
-};

package/bin/impl/rules/reliverse/missing-deps/parser.d.ts

@@ -1,5 +0,0 @@
-import type { PackageJson } from "./deps-types";
-export declare const extractPackageNames: (fileContent: string) => Set<string>;
-export declare const normalizePackageName: (importPath: string) => string | null;
-export declare const getListedDependencies: (packageJson: PackageJson) => Set<string>;
-export declare const getBuiltinModules: () => Set<string>;