@reliverse/dler 1.7.153 → 2.0.0

package/bin/impl/utils/utils-package-json-regular.d.ts

@@ -1,8 +0,0 @@
-import type { NpmOutExt, ReliverseConfig } from "../schema/mod.js";
-/**
- * Creates a package.json for the main distribution.
- */
-export declare function regular_createPackageJSON(outDirRoot: string, isJsr: boolean, coreIsCLI: {
-    enabled: boolean;
-    scripts: Record<string, string>;
-}, unifiedBundlerOutExt: NpmOutExt, config: ReliverseConfig, coreDescription: string, coreBuildOutDir?: string): Promise<void>;

package/bin/impl/utils/utils-package-json-regular.js

@@ -1,165 +0,0 @@
-import path from "@reliverse/pathkit";
-import fs from "@reliverse/relifso";
-import { relinka } from "@reliverse/relinka";
-import { definePackageJSON, readPackageJSON } from "pkg-types";
-import { cliDomainDocs } from "../config/constants.js";
-import { filterDeps } from "./utils-deps.js";
-export async function regular_createPackageJSON(outDirRoot, isJsr, coreIsCLI, unifiedBundlerOutExt, config, coreDescription, coreBuildOutDir = "bin") {
-  relinka("verbose", `Generating distribution package.json and tsconfig.json (isJsr=${isJsr})...`);
-  const commonPkg = await regular_createCommonPackageFields(coreIsCLI, coreDescription);
-  const originalPkg = await readPackageJSON();
-  const packageName = originalPkg.name || "";
-  relinka(
-    "verbose",
-    `Package name: "${packageName}", CLI enabled: ${coreIsCLI.enabled}, scripts: ${JSON.stringify(coreIsCLI.scripts)}`
-  );
-  const outDirBin = path.join(outDirRoot, coreBuildOutDir);
-  const outExt = unifiedBundlerOutExt || "js";
-  if (isJsr) {
-    const binEntry = coreIsCLI.enabled ? Object.fromEntries(
-      Object.entries(coreIsCLI.scripts).map(([name, script]) => [
-        name,
-        `${coreBuildOutDir}/${path.basename(script)}`
-      ])
-    ) : void 0;
-    if (coreIsCLI.enabled) {
-      relinka("verbose", `Adding CLI bin entries for JSR: ${JSON.stringify(binEntry)}`);
-    }
-    const jsrPkg = definePackageJSON({
-      ...commonPkg,
-      bin: binEntry,
-      dependencies: await regular_getPkgKeepDeps(originalPkg.dependencies, outDirBin, true, config),
-      devDependencies: await filterDeps(originalPkg.devDependencies, true, outDirBin, true, config),
-      exports: {
-        ".": `./${coreBuildOutDir}/${config.coreEntryFile}`
-      },
-      files: [
-        .../* @__PURE__ */ new Set([
-          coreBuildOutDir,
-          ...config.publishArtifacts?.global || ["package.json", "README.md", "LICENSE"]
-        ])
-      ]
-    });
-    await fs.writeJSON(path.join(outDirRoot, "package.json"), jsrPkg, {
-      spaces: 2
-    });
-    if (coreIsCLI.enabled) {
-      relinka(
-        "verbose",
-        `JSR package.json created with CLI bin entries: ${JSON.stringify(jsrPkg.bin)}`
-      );
-    }
-  } else {
-    const binEntry = coreIsCLI.enabled ? Object.fromEntries(
-      Object.entries(coreIsCLI.scripts).map(([name, script]) => [
-        name,
-        `${coreBuildOutDir}/${path.basename(script).replace(/\.ts$/, `.${outExt}`)}`
-      ])
-    ) : void 0;
-    if (coreIsCLI.enabled) {
-      relinka("verbose", `Adding CLI bin entries for NPM: ${JSON.stringify(binEntry)}`);
-    }
-    const npmPkg = definePackageJSON({
-      ...commonPkg,
-      bin: binEntry,
-      dependencies: await regular_getPkgKeepDeps(
-        originalPkg.dependencies,
-        outDirBin,
-        false,
-        config
-      ),
-      devDependencies: await filterDeps(
-        originalPkg.devDependencies,
-        true,
-        outDirBin,
-        false,
-        config
-      ),
-      exports: {
-        ".": `./${coreBuildOutDir}/${config.coreEntryFile.replace(/\.ts$/, `.${outExt}`)}`
-      },
-      files: [
-        .../* @__PURE__ */ new Set([
-          coreBuildOutDir,
-          ...config.publishArtifacts?.global || ["package.json", "README.md", "LICENSE"]
-        ])
-      ],
-      main: `./${coreBuildOutDir}/${config.coreEntryFile.replace(/\.ts$/, `.${outExt}`)}`,
-      module: `./${coreBuildOutDir}/${config.coreEntryFile.replace(/\.ts$/, `.${outExt}`)}`,
-      publishConfig: { access: "public" }
-    });
-    await fs.writeJSON(path.join(outDirRoot, "package.json"), npmPkg, {
-      spaces: 2
-    });
-    if (coreIsCLI.enabled) {
-      relinka(
-        "verbose",
-        `NPM package.json created with CLI bin entries: ${JSON.stringify(npmPkg.bin)}`
-      );
-    }
-  }
-  relinka("verbose", `Created package.json in ${outDirRoot}`);
-}
-async function regular_createCommonPackageFields(coreIsCLI, coreDescription) {
-  relinka("verbose", "Generating common package fields");
-  const originalPkg = await readPackageJSON();
-  const { author, description, keywords, license, name, version } = originalPkg;
-  relinka("verbose", `Original package name: "${name}", version: "${version}"`);
-  const pkgHomepage = cliDomainDocs;
-  const commonPkg = {
-    dependencies: originalPkg.dependencies || {},
-    description: coreDescription || description,
-    homepage: pkgHomepage,
-    license: license || "MIT",
-    name,
-    type: "module",
-    version
-  };
-  if (coreIsCLI.enabled) {
-    relinka("verbose", "coreIsCLI is enabled, adding CLI-specific fields to common package fields");
-    if (commonPkg.keywords) {
-      const cliKeywords = Object.keys(coreIsCLI.scripts);
-      relinka(
-        "verbose",
-        `Adding CLI keywords to existing keywords: ${JSON.stringify(cliKeywords)}`
-      );
-      commonPkg.keywords = [
-        .../* @__PURE__ */ new Set(["cli", ...cliKeywords, "command-line", ...commonPkg.keywords])
-      ];
-      relinka("verbose", `Updated keywords: ${JSON.stringify(commonPkg.keywords)}`);
-    } else if (name) {
-      const cliKeywords = Object.keys(coreIsCLI.scripts);
-      relinka("verbose", `Setting new CLI keywords: ${JSON.stringify(cliKeywords)}`);
-      commonPkg.keywords = ["cli", "command-line", ...cliKeywords];
-      relinka("verbose", `Set keywords: ${JSON.stringify(commonPkg.keywords)}`);
-    }
-  } else {
-    relinka("verbose", "coreIsCLI is false, skipping CLI-specific fields");
-  }
-  if (author) {
-    const repoOwner = typeof author === "string" ? author : author.name;
-    const repoName = name ? name.startsWith("@") ? name.split("/").pop() || name : name : "";
-    Object.assign(commonPkg, {
-      author,
-      bugs: {
-        email: "blefnk@gmail.com",
-        url: `https://github.com/${repoOwner}/${repoName}/issues`
-      },
-      keywords: [.../* @__PURE__ */ new Set([repoOwner, ...commonPkg.keywords || []])],
-      repository: {
-        type: "git",
-        url: `git+https://github.com/${repoOwner}/${repoName}.git`
-      }
-    });
-  } else if (keywords && keywords.length > 0 && !commonPkg.keywords) {
-    commonPkg.keywords = keywords;
-  }
-  relinka("verbose", "Common package fields generated");
-  return commonPkg;
-}
-async function regular_getPkgKeepDeps(originalDeps, outDirBin, isJsr, config) {
-  if (!originalDeps) {
-    return {};
-  }
-  return filterDeps(originalDeps, false, outDirBin, isJsr, config);
-}

package/bin/impl/utils/utils-perf.d.ts

@@ -1,5 +0,0 @@
-import type { PerfTimer } from "../types/mod.js";
-export declare function createPerfTimer(): PerfTimer;
-export declare function getElapsedPerfTime(timer: PerfTimer): number;
-export declare function pausePerfTimer(timer: PerfTimer): void;
-export declare function resumePerfTimer(timer: PerfTimer): void;

package/bin/impl/utils/utils-perf.js

@@ -1,22 +0,0 @@
-export function createPerfTimer() {
-  return {
-    pausedAt: null,
-    pausedDuration: 0,
-    startTime: performance.now()
-  };
-}
-export function getElapsedPerfTime(timer) {
-  const currentPausedTime = timer.pausedAt !== null ? performance.now() - timer.pausedAt : 0;
-  return performance.now() - timer.startTime - timer.pausedDuration - currentPausedTime;
-}
-export function pausePerfTimer(timer) {
-  if (timer.pausedAt === null) {
-    timer.pausedAt = performance.now();
-  }
-}
-export function resumePerfTimer(timer) {
-  if (timer.pausedAt !== null) {
-    timer.pausedDuration += performance.now() - timer.pausedAt;
-    timer.pausedAt = null;
-  }
-}

package/bin/impl/utils/utils-security.d.ts

@@ -1,12 +0,0 @@
-export declare const setFileSizeLimits: (maxFileSize?: number, maxMergeSize?: number) => void;
-export declare const ALLOWED_FILE_TYPES: Set<string>;
-export declare const validatePath: (filePath: string, baseDir: string) => string;
-export declare const validateFileType: (type: string) => void;
-export declare const validateContent: (content: unknown, type: string) => void;
-export declare const sanitizeInput: (input: string) => string;
-export declare const checkPermissions: (filePath: string, operation: "read" | "write") => Promise<void>;
-export declare const checkFileSize: (filePath: string) => Promise<void>;
-export declare const handleCtxError: (error: unknown, context: string) => never;
-export declare const validateTemplate: (template: any) => void;
-export declare const validateMergeOperation: (files: string[]) => Promise<void>;
-export declare const validateFileExists: (filePath: string, operation: string) => Promise<void>;

package/bin/impl/utils/utils-security.js

@@ -1,95 +0,0 @@
-import path from "@reliverse/pathkit";
-import fs from "@reliverse/relifso";
-import { relinka } from "@reliverse/relinka";
-const DEFAULT_MAX_FILE_SIZE = 10 * 1024 * 1024;
-const DEFAULT_MAX_MERGE_SIZE = DEFAULT_MAX_FILE_SIZE * 10;
-let MAX_FILE_SIZE = DEFAULT_MAX_FILE_SIZE;
-let MAX_MERGE_SIZE = DEFAULT_MAX_MERGE_SIZE;
-export const setFileSizeLimits = (maxFileSize, maxMergeSize) => {
-  if (maxFileSize !== void 0) {
-    MAX_FILE_SIZE = maxFileSize;
-  }
-  if (maxMergeSize !== void 0) {
-    MAX_MERGE_SIZE = maxMergeSize;
-  }
-};
-export const ALLOWED_FILE_TYPES = /* @__PURE__ */ new Set(["text", "json", "binary"]);
-export const validatePath = (filePath, baseDir) => {
-  const normalizedPath = path.normalize(filePath);
-  const normalizedBaseDir = path.normalize(baseDir);
-  const resolvedPath = path.resolve(normalizedBaseDir, normalizedPath);
-  const relativePath = path.relative(normalizedBaseDir, resolvedPath);
-  if (relativePath.startsWith("..") || path.isAbsolute(relativePath)) {
-    throw new Error(`Path traversal attempt detected: ${filePath}`);
-  }
-  return resolvedPath;
-};
-export const validateFileType = (type) => {
-  if (!ALLOWED_FILE_TYPES.has(type)) {
-    throw new Error(`Invalid file type: ${type}`);
-  }
-};
-export const validateContent = (content, type) => {
-  if (type === "json" && typeof content !== "object") {
-    throw new Error("Invalid JSON content");
-  }
-  if (type === "text" && typeof content !== "string") {
-    throw new Error("Invalid text content");
-  }
-};
-export const sanitizeInput = (input) => {
-  return input.replace(/[<>"|?*]/g, "_");
-};
-export const checkPermissions = async (filePath, operation) => {
-  try {
-    const dir = path.dirname(filePath);
-    if (operation === "write") {
-      await fs.ensureDir(dir);
-      await fs.access(dir, fs.constants.W_OK);
-      return;
-    }
-    if (operation === "read") {
-      if (!await fs.pathExists(filePath)) {
-        throw new Error(`File does not exist: ${filePath}`);
-      }
-      await fs.access(filePath, fs.constants.R_OK);
-    }
-  } catch (error) {
-    if (error instanceof Error && error.message.includes("does not exist")) {
-      throw error;
-    }
-    throw new Error(`Permission denied: ${operation} access to ${filePath}`);
-  }
-};
-export const checkFileSize = async (filePath) => {
-  const stats = await fs.stat(filePath);
-  if (stats.size > MAX_FILE_SIZE) {
-    throw new Error(`File too large: ${filePath}`);
-  }
-};
-export const handleCtxError = (error, context) => {
-  const message = error instanceof Error ? error.message : String(error);
-  relinka("error", `Error in ${context}: ${message}`);
-  process.exit(1);
-};
-export const validateTemplate = (template) => {
-  if (!template.name || typeof template.name !== "string") {
-    throw new Error("Invalid template name");
-  }
-  if (!template.config?.files || typeof template.config.files !== "object") {
-    throw new Error("Invalid template files configuration");
-  }
-};
-export const validateMergeOperation = async (files) => {
-  const totalSize = await Promise.all(files.map(async (f) => (await fs.stat(f)).size)).then(
-    (sizes) => sizes.reduce((a, b) => a + b, 0)
-  );
-  if (totalSize > MAX_MERGE_SIZE) {
-    throw new Error("Total size of files to merge exceeds limit");
-  }
-};
-export const validateFileExists = async (filePath, operation) => {
-  if (!await fs.pathExists(filePath)) {
-    throw new Error(`File does not exist for ${operation}: ${filePath}`);
-  }
-};

package/bin/impl/utils/utils-tsconfig.d.ts

@@ -1,10 +0,0 @@
-/**
- * Creates a tsconfig.json file for the distribution.
- */
-export declare function createTSConfig(outDirRoot: string, allowImportingTsExtensions: boolean): Promise<void>;
-/**
- * Creates a minimal tsconfig file for a new project. If `isDev` is true and
- * the project path contains "tests-runtime", the file is saved as "tsconfig.txt"
- * instead of "tsconfig.json".
- */
-export declare function createProjectTSConfig(projectPath: string, isLib: boolean, isDev: boolean): Promise<void>;

package/bin/impl/utils/utils-tsconfig.js

@@ -1,81 +0,0 @@
-import path from "@reliverse/pathkit";
-import fs from "@reliverse/relifso";
-import { relinka } from "@reliverse/relinka";
-import { defineTSConfig, writeTSConfig } from "pkg-types";
-import { tsconfigJson } from "../config/constants.js";
-export async function createTSConfig(outDirRoot, allowImportingTsExtensions) {
-  relinka(
-    "verbose",
-    `Creating tsconfig.json in ${outDirRoot} (allowImportingTsExtensions=${allowImportingTsExtensions})`
-  );
-  const tsConfig = defineTSConfig({
-    compilerOptions: {
-      allowImportingTsExtensions,
-      allowJs: true,
-      esModuleInterop: true,
-      exactOptionalPropertyTypes: false,
-      isolatedModules: true,
-      lib: ["ESNext"],
-      module: "NodeNext",
-      moduleDetection: "force",
-      moduleResolution: "nodenext",
-      noEmit: true,
-      noFallthroughCasesInSwitch: false,
-      noImplicitAny: false,
-      noImplicitOverride: true,
-      noImplicitReturns: false,
-      noUncheckedIndexedAccess: true,
-      noUnusedLocals: false,
-      noUnusedParameters: false,
-      resolveJsonModule: true,
-      skipLibCheck: true,
-      strict: true,
-      strictNullChecks: false,
-      transpileTarget: "ESNext",
-      verbatimModuleSyntax: true
-    },
-    exclude: ["**/node_modules"],
-    include: ["./bin/**/*.ts"]
-  });
-  await fs.writeJSON(path.join(outDirRoot, tsconfigJson), tsConfig, {
-    spaces: 2
-  });
-  relinka("verbose", `Created tsconfig.json in ${outDirRoot}`);
-}
-export async function createProjectTSConfig(projectPath, isLib, isDev) {
-  const tsconfig = defineTSConfig({
-    compilerOptions: {
-      esModuleInterop: true,
-      skipLibCheck: true,
-      target: "es2022",
-      allowJs: true,
-      resolveJsonModule: true,
-      moduleDetection: "force",
-      isolatedModules: true,
-      verbatimModuleSyntax: true,
-      strict: true,
-      noUncheckedIndexedAccess: true,
-      noImplicitOverride: true,
-      ...isLib ? { lib: ["es2022"] } : {
-        module: "preserve",
-        noEmit: true,
-        lib: ["es2022", "dom", "dom.iterable"]
-      }
-    },
-    ...isLib ? { include: ["**/*.ts"] } : { include: ["**/*.ts", "**/*.tsx"] },
-    exclude: ["node_modules"]
-  });
-  const useTxt = isDev && projectPath.includes("tests-runtime");
-  const filename = useTxt ? "tsconfig.txt" : "tsconfig.json";
-  const tsconfigPath = path.join(projectPath, filename);
-  if (useTxt) {
-    const rawContent = JSON.stringify(tsconfig, null, 2);
-    await fs.writeFile(tsconfigPath, rawContent, "utf-8");
-  } else {
-    await writeTSConfig(tsconfigPath, tsconfig);
-    const content = await fs.readFile(tsconfigPath, "utf-8");
-    const formatted = JSON.stringify(JSON.parse(content), null, 2);
-    await fs.writeFile(tsconfigPath, formatted, "utf-8");
-  }
-  relinka("verbose", `Created ${filename} with ${isLib ? "library" : "application"} configuration`);
-}

package/bin/impl/utils/workspace-prompt.d.ts

@@ -1,9 +0,0 @@
-import type { WorkspacePackage } from "./workspace-utils";
-/**
- * Prompts user to select workspace packages for build or publish operations
- */
-export declare function promptWorkspacePackages(packages: WorkspacePackage[], command: "build" | "publish", skipPrompt?: boolean): Promise<WorkspacePackage[]>;
-/**
- * Shows a summary of selected packages and their dependency order
- */
-export declare function showPackageSummary(packages: WorkspacePackage[], command: "build" | "publish"): void;

package/bin/impl/utils/workspace-prompt.js

@@ -1,46 +0,0 @@
-import { re } from "@reliverse/relico";
-import { cancel, isCancel, multiselectPrompt } from "@reliverse/rempts";
-export async function promptWorkspacePackages(packages, command, skipPrompt = false) {
-  if (packages.length === 0) {
-    return [];
-  }
-  const sortedPackages = packages.sort((a, b) => {
-    if (a.workspaceDependencies.includes(b.name)) return 1;
-    if (b.workspaceDependencies.includes(a.name)) return -1;
-    return a.name.localeCompare(b.name);
-  });
-  if (skipPrompt) {
-    return sortedPackages;
-  }
-  const options = sortedPackages.map((pkg) => ({
-    label: `${pkg.name} ${re.dim(`(${pkg.version})`)}`,
-    value: pkg.name,
-    hint: pkg.workspaceDependencies.length > 0 ? `Depends on: ${pkg.workspaceDependencies.join(", ")}` : "No workspace dependencies"
-  }));
-  const title = command === "build" ? "Select packages to build" : "Select packages to publish";
-  const content = command === "build" ? "Choose which workspace packages to build. Packages will be built in dependency order." : "Choose which workspace packages to publish. Packages will be built and published in dependency order.";
-  const selectedPackageNames = await multiselectPrompt({
-    title,
-    content,
-    options,
-    defaultValue: packages.map((pkg) => pkg.name),
-    // Select all by default
-    displayInstructions: true
-  });
-  if (isCancel(selectedPackageNames)) {
-    cancel(re.red("Operation cancelled"));
-    process.exit(0);
-  }
-  const selectedPackages = selectedPackageNames.map((name) => packages.find((pkg) => pkg.name === name)).filter((pkg) => pkg !== void 0);
-  return selectedPackages;
-}
-export function showPackageSummary(packages, command) {
-  const action = command === "build" ? "Building" : "Publishing";
-  console.log(`
-${re.cyan(`${action} ${packages.length} package(s) in dependency order:`)}`);
-  packages.forEach((pkg, index) => {
-    const deps = pkg.workspaceDependencies.length > 0 ? ` ${re.dim(`(depends on: ${pkg.workspaceDependencies.join(", ")})`)}` : "";
-    console.log(`  ${index + 1}. ${re.green(pkg.name)} ${re.dim(`v${pkg.version}`)}${deps}`);
-  });
-  console.log();
-}

package/bin/impl/utils/workspace-utils.d.ts

@@ -1,28 +0,0 @@
-export interface WorkspacePackage {
-    name: string;
-    path: string;
-    packageJsonPath: string;
-    version: string;
-    private: boolean;
-    dependencies: string[];
-    workspaceDependencies: string[];
-}
-export interface WorkspaceConfig {
-    enabled: boolean;
-    autoDiscoverPackages: boolean;
-    buildOrder: "dependency" | "parallel";
-    includePatterns: string[];
-    excludePatterns: string[];
-}
-/**
- * Detects if the current directory has workspace configuration and returns publishable packages
- */
-export declare function detectWorkspaces(cwd: string): Promise<WorkspacePackage[] | null>;
-/**
- * Sorts packages by their dependencies to ensure correct build/publish order
- */
-export declare function sortPackagesByDependencies(packages: WorkspacePackage[]): WorkspacePackage[];
-/**
- * Filters packages based on include/exclude patterns
- */
-export declare function filterPackagesByPatterns(packages: WorkspacePackage[], includePatterns: string[], excludePatterns: string[]): WorkspacePackage[];

package/bin/impl/utils/workspace-utils.js

@@ -1,127 +0,0 @@
-import path from "@reliverse/pathkit";
-import fs from "@reliverse/relifso";
-import { relinka } from "@reliverse/relinka";
-import { glob } from "glob";
-import { readPackageJson } from "../monorepo/monorepo-mod.js";
-export async function detectWorkspaces(cwd) {
-  const packageJsonPath = path.join(cwd, "package.json");
-  if (!await fs.pathExists(packageJsonPath)) {
-    return null;
-  }
-  try {
-    const packageJsonContent = await fs.readFile(packageJsonPath, "utf-8");
-    const packageJson = JSON.parse(packageJsonContent);
-    let workspaceGlobs = [];
-    if (packageJson.workspaces) {
-      if (Array.isArray(packageJson.workspaces)) {
-        workspaceGlobs = packageJson.workspaces;
-      } else if (typeof packageJson.workspaces === "object" && packageJson.workspaces.packages) {
-        workspaceGlobs = Array.isArray(packageJson.workspaces.packages) ? packageJson.workspaces.packages : [];
-      }
-    }
-    if (workspaceGlobs.length === 0) {
-      return null;
-    }
-    relinka("verbose", `Found workspace configuration with patterns: ${workspaceGlobs.join(", ")}`);
-    const packageJsonPaths = [];
-    for (const pattern of workspaceGlobs) {
-      const searchPattern = path.join(cwd, pattern, "package.json");
-      const matches = await glob(searchPattern, { cwd });
-      packageJsonPaths.push(...matches.map((match) => path.resolve(cwd, match)));
-    }
-    const uniquePackageJsonPaths = [...new Set(packageJsonPaths)];
-    relinka("verbose", `Found ${uniquePackageJsonPaths.length} package.json files in workspace`);
-    const packages = [];
-    for (const packageJsonPath2 of uniquePackageJsonPaths) {
-      const pkg = await readPackageJson(packageJsonPath2);
-      if (!pkg) {
-        relinka("verbose", `Skipping invalid package.json at ${packageJsonPath2}`);
-        continue;
-      }
-      try {
-        const rawContent = await fs.readFile(packageJsonPath2, "utf-8");
-        const rawPkg = JSON.parse(rawContent);
-        if (!rawPkg.name || rawPkg.private === true) {
-          relinka(
-            "verbose",
-            `Skipping package ${rawPkg.name || "unnamed"} (${rawPkg.private ? "private" : "no name"})`
-          );
-          continue;
-        }
-        const workspaceDependencies = [];
-        const allDeps = { ...rawPkg.dependencies, ...rawPkg.devDependencies };
-        for (const [depName, version] of Object.entries(allDeps)) {
-          if (typeof version === "string" && version.startsWith("workspace:")) {
-            workspaceDependencies.push(depName);
-          }
-        }
-        packages.push({
-          name: rawPkg.name,
-          path: path.dirname(packageJsonPath2),
-          packageJsonPath: packageJsonPath2,
-          version: rawPkg.version || "0.0.0",
-          private: rawPkg.private === true,
-          dependencies: Object.keys(allDeps),
-          workspaceDependencies
-        });
-        relinka("verbose", `Added package: ${rawPkg.name} (${rawPkg.version})`);
-      } catch (error) {
-        relinka("warn", `Failed to read package.json at ${packageJsonPath2}: ${error}`);
-      }
-    }
-    relinka("verbose", `Found ${packages.length} publishable packages in workspace`);
-    return packages.length > 0 ? packages : null;
-  } catch (error) {
-    relinka("warn", `Failed to detect workspaces: ${error}`);
-    return null;
-  }
-}
-export function sortPackagesByDependencies(packages) {
-  const sorted = [];
-  const visited = /* @__PURE__ */ new Set();
-  const visiting = /* @__PURE__ */ new Set();
-  function visit(pkg) {
-    if (visiting.has(pkg.name)) {
-      relinka("warn", `Circular dependency detected involving package: ${pkg.name}`);
-      return;
-    }
-    if (visited.has(pkg.name)) {
-      return;
-    }
-    visiting.add(pkg.name);
-    for (const depName of pkg.workspaceDependencies) {
-      const depPkg = packages.find((p) => p.name === depName);
-      if (depPkg) {
-        visit(depPkg);
-      }
-    }
-    visiting.delete(pkg.name);
-    visited.add(pkg.name);
-    sorted.push(pkg);
-  }
-  for (const pkg of packages) {
-    visit(pkg);
-  }
-  relinka("verbose", `Sorted packages by dependencies: ${sorted.map((p) => p.name).join(" -> ")}`);
-  return sorted;
-}
-export function filterPackagesByPatterns(packages, includePatterns, excludePatterns) {
-  let filtered = packages;
-  if (includePatterns.length > 0) {
-    filtered = filtered.filter(
-      (pkg) => includePatterns.some((pattern) => {
-        const regex = new RegExp(pattern.replace(/\*/g, ".*"));
-        return regex.test(pkg.name) || regex.test(pkg.path);
-      })
-    );
-  }
-  if (excludePatterns.length > 0) {
-    filtered = filtered.filter(
-      (pkg) => !excludePatterns.some((pattern) => {
-        const regex = new RegExp(pattern.replace(/\*/g, ".*"));
-        return regex.test(pkg.name) || regex.test(pkg.path);
-      })
-    );
-  }
-  return filtered;
-}