depfresh 0.9.2

package/dist/index.d.ts

@@ -0,0 +1,204 @@
+type ProvenanceLevel = 'trusted' | 'attested' | 'none';
+interface PackageData {
+    name: string;
+    versions: string[];
+    distTags: Record<string, string>;
+    time?: Record<string, string>;
+    deprecated?: Record<string, string>;
+    description?: string;
+    homepage?: string;
+    repository?: string;
+    provenance?: Record<string, ProvenanceLevel>;
+    engines?: Record<string, string>;
+}
+interface RegistryConfig {
+    url: string;
+    token?: string;
+    authType?: 'bearer' | 'basic';
+    scope?: string;
+}
+interface NpmrcConfig {
+    registries: Map<string, RegistryConfig>;
+    defaultRegistry: string;
+    proxy?: string;
+    httpsProxy?: string;
+    strictSsl: boolean;
+    cafile?: string;
+}
+
+type RangeMode = 'default' | 'major' | 'minor' | 'patch' | 'latest' | 'newest' | 'next' | 'ignore';
+type DiffType = 'major' | 'minor' | 'patch' | 'none' | 'error';
+type SortOption = 'diff-asc' | 'diff-desc' | 'time-asc' | 'time-desc' | 'name-asc' | 'name-desc';
+type DepFieldType = 'dependencies' | 'devDependencies' | 'peerDependencies' | 'optionalDependencies' | 'overrides' | 'resolutions' | 'packageManager' | 'pnpm.overrides' | 'catalog';
+interface RawDep {
+    name: string;
+    currentVersion: string;
+    source: DepFieldType;
+    update: boolean;
+    parents: string[];
+    aliasName?: string;
+    protocol?: string;
+}
+interface UpdateScore {
+    confidence: number;
+    maturity: number;
+    adoption: number;
+    breaking: boolean;
+}
+interface ResolvedDepChange extends RawDep {
+    targetVersion: string;
+    diff: DiffType;
+    pkgData: PackageData;
+    resolvedUrl?: string;
+    deprecated?: string | boolean;
+    latestVersion?: string;
+    publishedAt?: string;
+    currentVersionTime?: string;
+    score?: UpdateScore;
+    provenance?: ProvenanceLevel;
+    currentProvenance?: ProvenanceLevel;
+    nodeCompat?: string;
+    nodeCompatible?: boolean;
+}
+
+type PackageManagerName = 'npm' | 'pnpm' | 'yarn' | 'bun';
+type OutputFormat = 'table' | 'json' | 'sarif';
+interface PackageManagerField {
+    name: PackageManagerName;
+    version: string;
+    hash?: string;
+    raw: string;
+}
+interface CatalogSource {
+    type: 'pnpm' | 'bun' | 'yarn';
+    name: string;
+    filepath: string;
+    deps: RawDep[];
+    raw: unknown;
+    indent: string;
+}
+type PackageType = 'package.json' | 'package.yaml' | 'pnpm-workspace' | 'bun-workspace' | 'yarn-workspace' | 'global';
+interface PackageMeta {
+    name: string;
+    type: PackageType;
+    filepath: string;
+    deps: RawDep[];
+    resolved: ResolvedDepChange[];
+    raw: unknown;
+    indent: string;
+    catalogs?: CatalogSource[];
+    packageManager?: PackageManagerField;
+}
+
+interface DepzyOptions {
+    cwd: string;
+    recursive: boolean;
+    mode: RangeMode;
+    write: boolean;
+    interactive: boolean;
+    force: boolean;
+    includeLocked: boolean;
+    includeWorkspace: boolean;
+    include?: string[];
+    exclude?: string[];
+    depFields?: Partial<Record<DepFieldType, boolean>>;
+    packageMode?: Record<string, RangeMode>;
+    concurrency: number;
+    timeout: number;
+    retries: number;
+    cacheTTL: number;
+    output: OutputFormat;
+    loglevel: 'silent' | 'info' | 'debug';
+    peer: boolean;
+    global: boolean;
+    ignorePaths: string[];
+    ignoreOtherWorkspaces: boolean;
+    all: boolean;
+    group: boolean;
+    sort: SortOption;
+    timediff: boolean;
+    cooldown: number;
+    nodecompat: boolean;
+    long: boolean;
+    explain: boolean;
+    failOnOutdated: boolean;
+    install: boolean;
+    update: boolean;
+    execute?: string;
+    verifyCommand?: string;
+    beforePackageStart?: (pkg: PackageMeta) => void | Promise<void>;
+    onDependencyResolved?: (pkg: PackageMeta, dep: ResolvedDepChange) => void | Promise<void>;
+    beforePackageWrite?: (pkg: PackageMeta) => boolean | Promise<boolean>;
+    afterPackageWrite?: (pkg: PackageMeta) => void | Promise<void>;
+    afterPackagesLoaded?: (pkgs: PackageMeta[]) => void | Promise<void>;
+    afterPackageEnd?: (pkg: PackageMeta) => void | Promise<void>;
+    afterPackagesEnd?: (pkgs: PackageMeta[]) => void | Promise<void>;
+}
+declare const DEFAULT_OPTIONS: Partial<DepzyOptions>;
+
+declare function check(options: DepzyOptions): Promise<number>;
+
+declare function resolveConfig(overrides?: Partial<DepzyOptions>): Promise<DepzyOptions>;
+
+interface DepzyErrorOptions {
+    cause?: unknown;
+}
+/**
+ * Base error class for all depzy runtime errors.
+ * Allows API users to reliably branch on `instanceof DepzyError` and `code`.
+ */
+declare class DepzyError extends Error {
+    readonly code: string;
+    readonly cause?: unknown;
+    constructor(message: string, code: string, options?: DepzyErrorOptions);
+}
+declare class RegistryError extends DepzyError {
+    readonly status: number;
+    readonly url: string;
+    constructor(message: string, status: number, url: string, options?: DepzyErrorOptions);
+}
+declare class CacheError extends DepzyError {
+    constructor(message: string, options?: DepzyErrorOptions);
+}
+declare class ConfigError extends DepzyError {
+    constructor(message: string, options?: DepzyErrorOptions);
+}
+declare class WriteError extends DepzyError {
+    constructor(message: string, options?: DepzyErrorOptions);
+}
+declare class ResolveError extends DepzyError {
+    constructor(message: string, options?: DepzyErrorOptions);
+}
+
+declare function parseDependencies(raw: Record<string, unknown>, options: DepzyOptions): RawDep[];
+
+declare function loadGlobalPackages(pm?: string): PackageMeta[];
+declare function writeGlobalPackage(pm: PackageManagerName, name: string, version: string): void;
+
+declare function loadPackages(options: DepzyOptions): Promise<PackageMeta[]>;
+
+interface Cache {
+    get(key: string): PackageData | undefined;
+    set(key: string, data: PackageData, ttl: number): void;
+    has(key: string): boolean;
+    clear(): void;
+    close(): void;
+    stats(): {
+        hits: number;
+        misses: number;
+        size: number;
+    };
+}
+
+declare function resolvePackage(pkg: PackageMeta, options: DepzyOptions, externalCache?: Cache, externalNpmrc?: NpmrcConfig, privatePackages?: Set<string>, onDependencyProcessed?: (pkg: PackageMeta, dep: RawDep) => void | Promise<void>): Promise<ResolvedDepChange[]>;
+
+/**
+ * Single-writer architecture: reads once, applies all mutations, writes once.
+ * Never allow independent writers to clobber each other.
+ */
+declare function writePackage(pkg: PackageMeta, changes: ResolvedDepChange[], loglevel?: 'silent' | 'info' | 'debug'): void;
+
+declare function defineConfig(options: Partial<DepzyOptions>): Partial<DepzyOptions>;
+
+export { CacheError, ConfigError, DEFAULT_OPTIONS, DepzyError, RegistryError, ResolveError, WriteError, check, defineConfig, loadGlobalPackages, loadPackages, parseDependencies, resolveConfig, resolvePackage, writeGlobalPackage, writePackage };
+export type { CatalogSource, DepFieldType, DepzyOptions, DiffType, NpmrcConfig, OutputFormat, PackageData, PackageManagerField, PackageManagerName, PackageMeta, PackageType, ProvenanceLevel, RangeMode, RawDep, RegistryConfig, ResolvedDepChange, SortOption, UpdateScore };

package/dist/index.mjs

@@ -0,0 +1,21 @@
+export { D as DEFAULT_OPTIONS, r as resolveConfig } from './chunks/config.mjs';
+export { C as CacheError, a as ConfigError, D as DepzyError, R as RegistryError, b as ResolveError, W as WriteError } from './shared/depfresh.B1o7OHO_.mjs';
+export { d as defineConfig, l as loadGlobalPackages, w as writeGlobalPackage } from './chunks/index3.mjs';
+export { c as check, l as loadPackages, p as parseDependencies, r as resolvePackage, w as writePackage } from './shared/depfresh.ClIHCCxD.mjs';
+import 'node:fs/promises';
+import 'node:url';
+import 'defu';
+import 'pathe';
+import 'ansis';
+import 'node:child_process';
+import 'node:fs';
+import 'node:os';
+import 'find-up-simple';
+import 'ini';
+import 'detect-indent';
+import 'semver';
+import 'pnpm-workspace-yaml';
+import 'yaml';
+import 'p-limit';
+import 'better-sqlite3';
+import 'tinyglobby';

package/dist/shared/depfresh.B1o7OHO_.mjs

@@ -0,0 +1,63 @@
+import c from 'ansis';
+
+class DepzyError extends Error {
+  code;
+  cause;
+  constructor(message, code, options = {}) {
+    super(message);
+    this.name = new.target.name;
+    this.code = code;
+    this.cause = options.cause;
+  }
+}
+class RegistryError extends DepzyError {
+  status;
+  url;
+  constructor(message, status, url, options = {}) {
+    super(message, "ERR_REGISTRY", options);
+    this.status = status;
+    this.url = url;
+  }
+}
+class CacheError extends DepzyError {
+  constructor(message, options = {}) {
+    super(message, "ERR_CACHE", options);
+  }
+}
+class ConfigError extends DepzyError {
+  constructor(message, options = {}) {
+    super(message, "ERR_CONFIG", options);
+  }
+}
+class WriteError extends DepzyError {
+  constructor(message, options = {}) {
+    super(message, "ERR_WRITE", options);
+  }
+}
+class ResolveError extends DepzyError {
+  constructor(message, options = {}) {
+    super(message, "ERR_RESOLVE", options);
+  }
+}
+
+function createLogger(level = "info") {
+  const noop = () => {
+  };
+  if (level === "silent") {
+    return { info: noop, warn: noop, error: noop, debug: noop, success: noop };
+  }
+  return {
+    // biome-ignore lint/suspicious/noConsole: logger is the intentional console wrapper
+    info: (...args) => console.log(c.blue("i"), ...args),
+    // biome-ignore lint/suspicious/noConsole: logger is the intentional console wrapper
+    warn: (...args) => console.warn(c.yellow("!"), ...args),
+    // biome-ignore lint/suspicious/noConsole: logger is the intentional console wrapper
+    error: (...args) => console.error(c.red("x"), ...args),
+    // biome-ignore lint/suspicious/noConsole: logger is the intentional console wrapper
+    debug: level === "debug" ? (...args) => console.log(c.gray("~"), ...args) : noop,
+    // biome-ignore lint/suspicious/noConsole: logger is the intentional console wrapper
+    success: (...args) => console.log(c.green("*"), ...args)
+  };
+}
+
+export { CacheError as C, DepzyError as D, RegistryError as R, WriteError as W, ConfigError as a, ResolveError as b, createLogger as c };