pubm 0.2.12 → 0.3.4

package/dist/monorepo/dependency-graph.d.ts

@@ -0,0 +1,17 @@
+export interface PackageNode {
+    name: string;
+    version: string;
+    path: string;
+    dependencies: Record<string, string>;
+}
+/**
+ * Builds an adjacency list of internal dependencies only.
+ * Each key is a package name, and the value is an array of internal package names it depends on.
+ */
+export declare function buildDependencyGraph(packages: PackageNode[]): Map<string, string[]>;
+/**
+ * Topological sort using Kahn's algorithm.
+ * Returns packages in dependency order (dependencies first).
+ * Throws an error if circular dependencies are detected.
+ */
+export declare function topologicalSort(graph: Map<string, string[]>): string[];

package/dist/monorepo/discover.d.ts

@@ -0,0 +1,15 @@
+import type { PackageConfig } from "../config/types.js";
+import type { RegistryType } from "../types/options.js";
+type EcosystemType = "js" | "rust";
+export interface DiscoverOptions {
+    cwd: string;
+    ignore?: string[];
+    configPackages?: PackageConfig[];
+}
+export interface DiscoveredPackage {
+    path: string;
+    registries: RegistryType[];
+    ecosystem: EcosystemType;
+}
+export declare function discoverPackages(options: DiscoverOptions): DiscoveredPackage[];
+export {};

package/dist/monorepo/groups.d.ts

@@ -0,0 +1,17 @@
+import type { BumpType } from "../changeset/parser.js";
+/**
+ * Resolves glob patterns in groups to actual package names.
+ * Exact names are passed through; glob patterns are matched against allPackages.
+ */
+export declare function resolveGroups(groups: string[][], allPackages: string[]): string[][];
+/**
+ * Fixed group: all packages in the group get the maximum bump type,
+ * even those without changesets. If no packages in the group have bumps,
+ * nothing is changed.
+ */
+export declare function applyFixedGroup(bumps: Map<string, BumpType>, group: string[]): void;
+/**
+ * Linked group: only packages that already have bumps get aligned
+ * to the maximum bump type. Packages without bumps are not added.
+ */
+export declare function applyLinkedGroup(bumps: Map<string, BumpType>, group: string[]): void;

package/dist/monorepo/index.d.ts

@@ -0,0 +1,4 @@
+export { buildDependencyGraph, type PackageNode, topologicalSort, } from "./dependency-graph.js";
+export { type DiscoveredPackage, type DiscoverOptions, discoverPackages, } from "./discover.js";
+export { applyFixedGroup, applyLinkedGroup, resolveGroups } from "./groups.js";
+export { detectWorkspace, type WorkspaceInfo } from "./workspace.js";

package/dist/monorepo/workspace.d.ts

@@ -0,0 +1,5 @@
+export interface WorkspaceInfo {
+    type: "pnpm" | "npm" | "yarn";
+    patterns: string[];
+}
+export declare function detectWorkspace(cwd?: string): WorkspaceInfo | null;

package/dist/options.d.ts

@@ -0,0 +1,3 @@
+import type { Options, ResolvedOptions } from "./types/options.js";
+export declare const defaultOptions: Omit<Options, "version">;
+export declare function resolveOptions(options: Options): ResolvedOptions;

package/dist/plugin/index.d.ts

@@ -0,0 +1,2 @@
+export { PluginRunner } from "./runner.js";
+export type { AfterReleaseHookFn, ErrorHookFn, HookFn, HookName, PluginCommand, PluginCommandOption, PluginHooks, PluginSubcommand, PubmPlugin, } from "./types.js";

package/dist/plugin/runner.d.ts

@@ -0,0 +1,14 @@
+import type { Ecosystem } from "../ecosystem/ecosystem.js";
+import type { Registry } from "../registry/registry.js";
+import type { ReleaseContext } from "../tasks/github-release.js";
+import type { Ctx } from "../tasks/runner.js";
+import type { HookName, PubmPlugin } from "./types.js";
+export declare class PluginRunner {
+    private plugins;
+    constructor(plugins: PubmPlugin[]);
+    runHook(hookName: Exclude<HookName, "onError" | "afterRelease">, ctx: Ctx): Promise<void>;
+    runErrorHook(ctx: Ctx, error: Error): Promise<void>;
+    runAfterReleaseHook(ctx: Ctx, releaseCtx: ReleaseContext): Promise<void>;
+    collectRegistries(): Registry[];
+    collectEcosystems(): Ecosystem[];
+}

package/dist/plugin/types.d.ts

@@ -0,0 +1,47 @@
+import type { Ecosystem } from "../ecosystem/ecosystem.js";
+import type { Registry } from "../registry/registry.js";
+import type { ReleaseContext } from "../tasks/github-release.js";
+import type { Ctx } from "../tasks/runner.js";
+export type HookFn = (ctx: Ctx) => Promise<void> | void;
+export type ErrorHookFn = (ctx: Ctx, error: Error) => Promise<void> | void;
+export type AfterReleaseHookFn = (ctx: Ctx, releaseCtx: ReleaseContext) => Promise<void> | void;
+export interface PluginHooks {
+    beforeTest?: HookFn;
+    afterTest?: HookFn;
+    beforeBuild?: HookFn;
+    afterBuild?: HookFn;
+    beforeVersion?: HookFn;
+    afterVersion?: HookFn;
+    beforePublish?: HookFn;
+    afterPublish?: HookFn;
+    beforePush?: HookFn;
+    afterPush?: HookFn;
+    afterRelease?: AfterReleaseHookFn;
+    onError?: ErrorHookFn;
+    onRollback?: HookFn;
+    onSuccess?: HookFn;
+}
+export type HookName = keyof PluginHooks;
+export interface PluginCommandOption {
+    name: string;
+    description: string;
+    required?: boolean;
+}
+export interface PluginSubcommand {
+    name: string;
+    description: string;
+    options?: PluginCommandOption[];
+    action: (args: Record<string, unknown>) => Promise<void>;
+}
+export interface PluginCommand {
+    name: string;
+    description: string;
+    subcommands?: PluginSubcommand[];
+}
+export interface PubmPlugin {
+    name: string;
+    registries?: Registry[];
+    ecosystems?: Ecosystem[];
+    hooks?: PluginHooks;
+    commands?: PluginCommand[];
+}

package/dist/plugins/external-version-sync/index.d.ts

@@ -0,0 +1,4 @@
+import type { PubmPlugin } from "../../plugin/types.js";
+import type { ExternalVersionSyncOptions } from "./types.js";
+export type { ExternalVersionSyncOptions, JsonTarget, RegexTarget, SyncTarget, } from "./types.js";
+export declare function externalVersionSync(options: ExternalVersionSyncOptions): PubmPlugin;

package/dist/plugins/external-version-sync/sync.d.ts

@@ -0,0 +1,2 @@
+import type { SyncTarget } from "./types.js";
+export declare function syncVersionInFile(filePath: string, newVersion: string, target: SyncTarget): boolean;

package/dist/plugins/external-version-sync/types.d.ts

@@ -0,0 +1,14 @@
+export interface JsonTarget {
+    file: string;
+    jsonPath: string;
+}
+export interface RegexTarget {
+    file: string;
+    pattern: RegExp;
+}
+export type SyncTarget = JsonTarget | RegexTarget;
+export interface ExternalVersionSyncOptions {
+    targets: SyncTarget[];
+}
+export declare function isJsonTarget(target: SyncTarget): target is JsonTarget;
+export declare function isRegexTarget(target: SyncTarget): target is RegexTarget;

package/dist/prerelease/index.d.ts

@@ -0,0 +1,2 @@
+export { enterPreMode, exitPreMode, type PreState, readPreState, } from "./pre.js";
+export { generateSnapshotVersion, type SnapshotOptions, } from "./snapshot.js";

package/dist/prerelease/pre.d.ts

@@ -0,0 +1,11 @@
+export interface PreState {
+    mode: "pre";
+    tag: string;
+    packages: Record<string, {
+        baseVersion: string;
+        iteration: number;
+    }>;
+}
+export declare function readPreState(cwd?: string): PreState | null;
+export declare function enterPreMode(tag: string, cwd?: string): void;
+export declare function exitPreMode(cwd?: string): void;

package/dist/prerelease/snapshot.d.ts

@@ -0,0 +1,8 @@
+export interface SnapshotOptions {
+    tag?: string;
+    baseVersion?: string;
+    useCalculatedVersion?: boolean;
+    template?: string;
+    commit?: string;
+}
+export declare function generateSnapshotVersion(options: SnapshotOptions): string;

package/dist/registry/crates.d.ts

@@ -0,0 +1,17 @@
+import { Registry, type RegistryRequirements } from "./registry.js";
+export declare class CratesRegistry extends Registry {
+    registry: string;
+    private get headers();
+    ping(): Promise<boolean>;
+    isInstalled(): Promise<boolean>;
+    distTags(): Promise<string[]>;
+    version(): Promise<string>;
+    publish(manifestDir?: string): Promise<boolean>;
+    dryRunPublish(manifestDir?: string): Promise<void>;
+    isVersionPublished(version: string): Promise<boolean>;
+    isPublished(): Promise<boolean>;
+    hasPermission(): Promise<boolean>;
+    getRequirements(): RegistryRequirements;
+    isPackageNameAvaliable(): Promise<boolean>;
+}
+export declare function cratesRegistry(packageName: string): Promise<CratesRegistry>;

package/dist/registry/custom-registry.d.ts

@@ -0,0 +1,5 @@
+import { NpmRegistry } from "./npm.js";
+export declare class CustomRegistry extends NpmRegistry {
+    npm(args: string[]): Promise<string>;
+}
+export declare function customRegistry(): Promise<CustomRegistry>;

package/dist/registry/index.d.ts

@@ -0,0 +1,3 @@
+import type { RegistryType } from "../types/options.js";
+import type { Registry } from "./registry.js";
+export declare function getRegistry(registryKey: RegistryType, packageName?: string): Promise<Registry>;

package/dist/registry/jsr.d.ts

@@ -0,0 +1,36 @@
+import type { JsrApi } from "../types/jsr-api.js";
+import { Registry, type RegistryRequirements } from "./registry.js";
+export declare class JsrRegisry extends Registry {
+    registry: string;
+    client: JsrClient;
+    packageCreationUrls?: string[];
+    constructor(packageName: string, registry?: string);
+    protected jsr(args: string[]): Promise<string>;
+    isInstalled(): Promise<boolean>;
+    distTags(): Promise<string[]>;
+    ping(): Promise<boolean>;
+    publish(): Promise<boolean>;
+    dryRunPublish(): Promise<void>;
+    version(): Promise<string>;
+    isPublished(): Promise<boolean>;
+    isVersionPublished(version: string): Promise<boolean>;
+    hasPermission(): Promise<boolean>;
+    isPackageNameAvaliable(): Promise<boolean>;
+    getRequirements(): RegistryRequirements;
+}
+export declare class JsrClient {
+    apiEndpoint: string;
+    static token: string | null;
+    constructor(apiEndpoint: string);
+    protected fetch(endpoint: string, init?: RequestInit): Promise<Response>;
+    user(): Promise<JsrApi.Users.User | null>;
+    scopePermission(scope: string): Promise<JsrApi.Users.Scopes.Permission | null>;
+    scopes(): Promise<string[]>;
+    package(packageName: string): Promise<JsrApi.Scopes.Packages.Package | null>;
+    createScope(scope: string): Promise<boolean>;
+    deleteScope(scope: string): Promise<boolean>;
+    createPackage(packageName: string): Promise<boolean>;
+    deletePackage(packageName: string): Promise<boolean>;
+    searchPackage(query: string): Promise<JsrApi.Packages>;
+}
+export declare function jsrRegistry(): Promise<JsrRegisry>;

package/dist/registry/npm.d.ts

@@ -0,0 +1,25 @@
+import { Registry, type RegistryRequirements } from "./registry.js";
+export declare class NpmRegistry extends Registry {
+    registry: string;
+    protected npm(args: string[]): Promise<string>;
+    isInstalled(): Promise<boolean>;
+    installGlobally(packageName: string): Promise<boolean>;
+    isPublished(): Promise<boolean>;
+    isVersionPublished(version: string): Promise<boolean>;
+    userName(): Promise<string>;
+    isLoggedIn(): Promise<boolean>;
+    collaborators(): Promise<Record<string, string>>;
+    hasPermission(): Promise<boolean>;
+    distTags(): Promise<string[]>;
+    version(): Promise<string>;
+    ping(): Promise<boolean>;
+    publishProvenance(): Promise<boolean>;
+    publish(otp?: string): Promise<boolean>;
+    dryRunPublish(): Promise<void>;
+    twoFactorAuthMode(): Promise<string | null>;
+    isPackageNameAvaliable(): Promise<boolean>;
+    getRequirements(): RegistryRequirements;
+    private isProvenanceError;
+    private classifyPublishError;
+}
+export declare function npmRegistry(): Promise<NpmRegistry>;

package/dist/registry/registry.d.ts

@@ -0,0 +1,20 @@
+export interface RegistryRequirements {
+    needsPackageScripts: boolean;
+    requiredManifest: string;
+}
+export declare abstract class Registry {
+    packageName: string;
+    registry?: string | undefined;
+    constructor(packageName: string, registry?: string | undefined);
+    abstract ping(): Promise<boolean>;
+    abstract isInstalled(): Promise<boolean>;
+    abstract distTags(): Promise<string[]>;
+    abstract version(): Promise<string>;
+    abstract publish(): Promise<boolean>;
+    abstract isPublished(): Promise<boolean>;
+    abstract isVersionPublished(version: string): Promise<boolean>;
+    abstract hasPermission(): Promise<boolean>;
+    abstract isPackageNameAvaliable(): Promise<boolean>;
+    abstract getRequirements(): RegistryRequirements;
+    dryRunPublish(_manifestDir?: string): Promise<void>;
+}

package/dist/tasks/crates.d.ts

@@ -0,0 +1,6 @@
+import type { ListrTask } from "listr2";
+import type { Ctx } from "./runner.js";
+export declare function createCratesAvailableCheckTask(packagePath?: string): ListrTask<Ctx>;
+export declare function createCratesPublishTask(packagePath?: string): ListrTask<Ctx>;
+export declare const cratesAvailableCheckTasks: ListrTask<Ctx>;
+export declare const cratesPublishTasks: ListrTask<Ctx>;

package/dist/tasks/dry-run-publish.d.ts

@@ -0,0 +1,6 @@
+import type { ListrTask } from "listr2";
+import type { Ctx } from "./runner.js";
+export declare const npmDryRunPublishTask: ListrTask<Ctx>;
+export declare const jsrDryRunPublishTask: ListrTask<Ctx>;
+export declare function createCratesDryRunPublishTask(packagePath?: string, siblingCrateNames?: string[]): ListrTask<Ctx>;
+export declare const cratesDryRunPublishTask: ListrTask<Ctx>;

package/dist/tasks/github-release.d.ts

@@ -0,0 +1,19 @@
+export interface ReleaseAsset {
+    name: string;
+    url: string;
+    sha256: string;
+}
+export interface ReleaseContext {
+    version: string;
+    tag: string;
+    releaseUrl: string;
+    assets: ReleaseAsset[];
+}
+interface Ctx {
+    version: string;
+}
+/**
+ * Create a GitHub Release using the GitHub REST API
+ */
+export declare function createGitHubRelease(ctx: Ctx): Promise<ReleaseContext>;
+export {};

package/dist/tasks/jsr.d.ts

@@ -0,0 +1,9 @@
+import { type ListrTask } from "listr2";
+import type { Ctx } from "./runner.js";
+interface JsrCtx extends Ctx {
+    scopeCreated?: boolean;
+    packageCreated?: boolean;
+}
+export declare const jsrAvailableCheckTasks: ListrTask<JsrCtx>;
+export declare const jsrPublishTasks: ListrTask<Ctx>;
+export {};

package/dist/tasks/npm.d.ts

@@ -0,0 +1,4 @@
+import { type ListrTask } from "listr2";
+import type { Ctx } from "./runner.js";
+export declare const npmAvailableCheckTasks: ListrTask<Ctx>;
+export declare const npmPublishTasks: ListrTask<Ctx>;

package/dist/tasks/preflight.d.ts

@@ -0,0 +1,3 @@
+export declare function collectTokens(registries: string[], task: any): Promise<Record<string, string>>;
+export declare function syncGhSecrets(tokens: Record<string, string>): Promise<void>;
+export declare function promptGhSecretsSync(tokens: Record<string, string>, task: any): Promise<void>;

package/dist/tasks/prerequisites-check.d.ts

@@ -0,0 +1,3 @@
+import type { Listr, ListrTask } from "listr2";
+import type { Ctx } from "./runner.js";
+export declare const prerequisitesCheckTask: (options?: Omit<ListrTask<Ctx>, "title" | "task">) => Listr<Ctx>;

package/dist/tasks/required-conditions-check.d.ts

@@ -0,0 +1,3 @@
+import type { Listr, ListrTask } from "listr2";
+import type { Ctx } from "./runner.js";
+export declare const requiredConditionsCheckTask: (options?: Omit<ListrTask<Ctx>, "title" | "task">) => Listr<Ctx>;

package/dist/tasks/required-missing-information.d.ts

@@ -0,0 +1,7 @@
+import { type Listr, type ListrTask } from "listr2";
+interface Ctx {
+    version?: string;
+    tag: string;
+}
+export declare const requiredMissingInformationTasks: (options?: Omit<ListrTask<Ctx>, "title" | "task">) => Listr<Ctx>;
+export {};

package/dist/tasks/runner.d.ts

@@ -0,0 +1,10 @@
+import { PluginRunner } from "../plugin/runner.js";
+import type { ResolvedOptions } from "../types/options.js";
+import { type ReleaseContext } from "./github-release.js";
+export interface Ctx extends ResolvedOptions {
+    promptEnabled: boolean;
+    cleanWorkingTree: boolean;
+    pluginRunner: PluginRunner;
+    releaseContext?: ReleaseContext;
+}
+export declare function run(options: ResolvedOptions): Promise<void>;

package/dist/types/jsr-api.d.ts

@@ -0,0 +1,91 @@
+export interface PackageInterface {
+    scope: string;
+    name: string;
+    description: string;
+    runtimeCompat: RuntimeCompat;
+    createdAt: string;
+    updatedAt: string;
+    githubRepository: GithubRepository;
+    score: number;
+}
+export interface RuntimeCompat {
+    browser: boolean;
+    deno: boolean;
+    node: boolean;
+    workerd: boolean;
+    bun: boolean;
+}
+export interface GithubRepository {
+    owner: string;
+    name: string;
+}
+export interface Scope {
+    scope: string;
+    creator: Creator;
+    quotas: Quotas;
+    ghActionsVerifyActor: boolean;
+    requirePublishingFromCI: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface Creator {
+    id: string;
+    name: string;
+    email: string;
+    avatarUrl: string;
+    githubId: number;
+    isBlocked: boolean;
+    isStaff: boolean;
+    scopeUsage: number;
+    scopeLimit: number;
+    inviteCount: number;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface Quotas {
+    packageUsage: number;
+    packageLimit: number;
+    newPackagePerWeekUsage: number;
+    newPackagePerWeekLimit: number;
+    publishAttemptsPerWeekUsage: number;
+    publishAttemptsPerWeekLimit: number;
+}
+export interface UserInfo {
+    id: string;
+    name: string;
+    email: string;
+    avatarUrl: string;
+    githubId: number;
+    isBlocked: boolean;
+    isStaff: boolean;
+    scopeUsage: number;
+    scopeLimit: number;
+    inviteCount: number;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface PermissionInfo {
+    scope: string;
+    user: UserInfo;
+    isAdmin: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+export declare namespace JsrApi {
+    interface Packages {
+        items: PackageInterface[];
+        total: number;
+    }
+    namespace Scopes {
+        namespace Packages {
+            type Package = PackageInterface;
+        }
+    }
+    namespace Users {
+        type User = UserInfo;
+        type Scopes = Scope[];
+        namespace Scopes {
+            type Permission = PermissionInfo;
+        }
+    }
+}

package/dist/types/jsr-json.d.ts

@@ -0,0 +1,10 @@
+export interface JsrJson {
+    name: string;
+    version: string;
+    exports: string | Record<string, string>;
+    publish?: {
+        include?: string[];
+        exclude?: string[];
+    };
+    [k: string]: unknown;
+}

package/dist/types/options.d.ts

@@ -0,0 +1,115 @@
+import type { PackageConfig } from "../config/types.js";
+import type { PluginRunner } from "../plugin/runner.js";
+export type RegistryType = "npm" | "jsr" | "crates" | string;
+/**
+ * Options for configuring the {@linkcode pubm} function.
+ */
+export interface Options {
+    /**
+     * @description Version to publish
+     */
+    version: string;
+    /**
+     * @description The npm script to run tests before publishing
+     * @default "test"
+     */
+    testScript?: string;
+    /**
+     * @description The npm script to run build before publishing
+     * @default "build"
+     */
+    buildScript?: string;
+    /**
+     * @description Run tasks without actually publishing
+     * @default false
+     */
+    preview?: boolean;
+    /**
+     * @description Target branch for the release
+     * @default "main"
+     */
+    branch?: string;
+    /**
+     * @description Allow publishing from any branch
+     * @default false
+     */
+    anyBranch?: boolean;
+    /**
+     * @description Skip running tests before publishing
+     * @default false
+     */
+    skipTests?: boolean;
+    /**
+     * @description Skip build before publishing
+     * @default false
+     */
+    skipBuild?: boolean;
+    /**
+     * @description Skip publishing task
+     * @default false
+     */
+    skipPublish?: boolean;
+    /**
+     * @description Skip creating a GitHub release draft
+     * @default false
+     */
+    skipReleaseDraft?: boolean;
+    /**
+     * @description Skip prerequisites check task
+     * @default false
+     */
+    skipPrerequisitesCheck?: boolean;
+    /**
+     * @description Skip required conditions check task
+     * @default false
+     */
+    skipConditionsCheck?: boolean;
+    /**
+     * @description Run only publish task for latest tag
+     * @default false
+     */
+    publishOnly?: boolean;
+    /**
+     * @description CI mode: publish from latest tag and create GitHub Release with assets
+     * @default false
+     */
+    ci?: boolean;
+    /**
+     * @description Simulate CI publish locally (dry-run with token-based auth)
+     * @default false
+     */
+    preflight?: boolean;
+    /**
+     * @description Publish under a specific dist-tag
+     * @default "latest"
+     */
+    tag?: string;
+    /**
+     * @description Subdirectory to publish
+     */
+    contents?: string;
+    /**
+     * @description Do not save jsr tokens (request the token each time)
+     * @default true
+     */
+    saveToken?: boolean;
+    /**
+     * @description Target registries for publish
+     * @default ['npm', 'jsr']
+     */
+    registries?: RegistryType[];
+    /**
+     * @description Per-package publish configuration (from pubm.config.ts)
+     */
+    packages?: PackageConfig[];
+}
+export interface ResolvedOptions extends Options {
+    testScript: string;
+    buildScript: string;
+    branch: string;
+    tag: string;
+    saveToken: boolean;
+    registries: RegistryType[];
+    packages?: PackageConfig[];
+    pluginRunner?: PluginRunner;
+}