relizy 0.1.0

package/dist/index.d.mts

@@ -0,0 +1,559 @@
+import { LogLevel } from '@maz-ui/node';
+import { GitCommit, ChangelogConfig as ChangelogConfig$1, SemverBumpType } from 'changelogen';
+import { ReleaseType } from 'semver';
+import { DeepPartial } from '@maz-ui/utils';
+
+declare function generateChangelog({ pkg, commits, config, from, dryRun, }: {
+    pkg: PackageInfo;
+    commits: GitCommit[];
+    config: ResolvedChangelogMonorepoConfig;
+    from: string;
+    dryRun: boolean;
+}): Promise<string>;
+declare function writeChangelogToFile({ pkg, changelog, dryRun, }: {
+    pkg: PackageInfo;
+    changelog: string;
+    dryRun: boolean;
+}): void;
+declare function executeFormatCmd({ config, dryRun, }: {
+    config: ResolvedChangelogMonorepoConfig;
+    dryRun: boolean;
+}): Promise<void>;
+declare function executeBuildCmd({ config, dryRun, }: {
+    config: ResolvedChangelogMonorepoConfig;
+    dryRun: boolean;
+}): Promise<void>;
+
+declare function getDefaultConfig(): {
+    cwd: string;
+    types: NonNullable<ChangelogMonorepoConfig["types"]>;
+    templates: {
+        commitMessage: string;
+        tagMessage: string;
+        tagBody: string;
+        emptyChangelogContent: string;
+    };
+    excludeAuthors: never[];
+    noAuthors: boolean;
+    bump: Required<Omit<BumpConfig, "preid">>;
+    changelog: Required<ChangelogConfig>;
+    publish: {
+        private: boolean;
+        args: never[];
+    };
+    tokens: {
+        gitlab: string | undefined;
+        github: string | undefined;
+    };
+    scopeMap: {};
+    release: Required<ReleaseConfig>;
+    logLevel: LogLevel;
+};
+declare function loadMonorepoConfig({ baseConfig, overrides, configName }: {
+    baseConfig?: ResolvedChangelogMonorepoConfig;
+    overrides?: DeepPartial<ChangelogMonorepoConfig>;
+    configName?: string;
+}): Promise<ResolvedChangelogMonorepoConfig>;
+type ResolvedConfig = ChangelogMonorepoConfig & ReturnType<typeof getDefaultConfig>;
+type ResolvedChangelogMonorepoConfig = ResolvedConfig & {
+    output: string;
+};
+declare function defineConfig(config: ChangelogMonorepoConfig): ChangelogMonorepoConfig;
+
+interface PackageWithDeps extends PackageInfo {
+    dependencies: string[];
+}
+interface PackageToBump extends PackageInfo {
+    reason: 'commits' | 'dependency';
+    dependencyChain?: string[];
+    commits: GitCommit[];
+}
+/**
+ * Get workspace dependencies of a package (only dependencies and peerDependencies, not devDependencies)
+ */
+declare function getPackageDependencies(packagePath: string, allPackageNames: Set<string>, dependencyTypes: BumpConfig['dependencyTypes']): string[];
+/**
+ * Transform packages array into PackageWithDeps with their workspace dependencies
+ */
+declare function getPackagesWithDependencies(packages: PackageInfo[], dependencyTypes: BumpConfig['dependencyTypes']): PackageWithDeps[];
+/**
+ * Get all packages that depend on the given package name
+ */
+declare function getDependentsOf(packageName: string, allPackages: PackageWithDeps[]): PackageWithDeps[];
+/**
+ * Recursively expand packages to bump with all their dependents (transitive)
+ * Returns packages with reason for bumping and dependency chain for traceability
+ */
+declare function expandPackagesToBumpWithDependents({ packagesWithCommits, allPackages, dependencyTypes, }: {
+    packagesWithCommits: PackageWithCommits[];
+    allPackages: PackageInfo[];
+    dependencyTypes: BumpConfig['dependencyTypes'];
+}): PackageToBump[];
+/**
+ * Topological sort of packages based on their dependencies
+ * Ensures dependencies are processed before dependents
+ */
+declare function topologicalSort(packages: PackageWithDeps[]): PackageWithDeps[];
+
+declare function getGitStatus(cwd?: string): string;
+declare function checkGitStatusIfDirty(): void;
+declare function fetchGitTags(cwd?: string): Promise<void>;
+declare function detectGitProvider(cwd?: string): GitProvider | null;
+declare function parseGitRemoteUrl(remoteUrl: string): {
+    owner: string;
+    repo: string;
+} | null;
+declare function createCommitAndTags({ config, noVerify, bumpedPackages, newVersion, dryRun, logLevel, }: {
+    config: ResolvedChangelogMonorepoConfig;
+    noVerify?: boolean;
+    bumpedPackages?: PackageInfo[];
+    newVersion?: string;
+    dryRun: boolean;
+    logLevel?: LogLevel;
+}): Promise<string[]>;
+declare function pushCommitAndTags({ dryRun, logLevel, cwd }: {
+    dryRun: boolean;
+    logLevel?: LogLevel;
+    cwd: string;
+}): Promise<void>;
+declare function getFirstCommit(cwd: string): string;
+declare function getCurrentGitBranch(cwd: string): string;
+declare function getCurrentGitRef(cwd: string): string;
+
+declare function github(options?: Partial<GitProviderOptions> & {
+    bumpResult?: BumpResult;
+}): Promise<PostedRelease[]>;
+
+interface GitlabRelease {
+    tag_name: string;
+    name?: string;
+    description?: string;
+    ref?: string;
+    milestones?: string[];
+    assets?: {
+        links?: Array<{
+            name: string;
+            url: string;
+        }>;
+    };
+    released_at?: string;
+}
+interface GitlabReleaseResponse {
+    tag_name: string;
+    name: string;
+    description: string;
+    created_at: string;
+    released_at: string;
+    _links: {
+        self: string;
+    };
+}
+declare function createGitlabRelease({ config, release, dryRun, }: {
+    config: ResolvedChangelogMonorepoConfig;
+    release: GitlabRelease;
+    dryRun?: boolean;
+}): Promise<GitlabReleaseResponse>;
+declare function gitlab(options?: Partial<GitProviderOptions> & {
+    bumpResult?: BumpResult;
+}): Promise<PostedRelease[]>;
+
+declare function getPackages({ cwd, patterns, ignorePackageNames, }: {
+    cwd: string;
+    patterns?: string[];
+    ignorePackageNames: NonNullable<ResolvedChangelogMonorepoConfig['monorepo']>['ignorePackageNames'];
+}): PackageInfo[];
+declare function getPackageCommits({ pkg, from, to, config, changelog, }: {
+    pkg: PackageInfo;
+    from: string;
+    to: string;
+    config: ResolvedChangelogMonorepoConfig;
+    changelog: boolean;
+}): Promise<GitCommit[]>;
+declare function getRootPackage(rootDir: string): PackageInfo;
+declare function hasLernaJson(rootDir: string): boolean;
+declare function getPackageToBump({ packages, config, from, to, }: {
+    packages: PackageInfo[];
+    config: ResolvedChangelogMonorepoConfig;
+    from: string;
+    to: string;
+}): Promise<PackageToBump[]>;
+
+declare function detectPackageManager(cwd?: string): PackageManager;
+declare function determinePublishTag(version: string | undefined, configTag?: string): string;
+declare function getPackagesToPublishInSelectiveMode(sortedPackages: PackageWithDeps[], rootVersion: string | undefined): PackageInfo[];
+declare function getPackagesToPublishInIndependentMode(sortedPackages: PackageWithDeps[], config: ResolvedChangelogMonorepoConfig): Promise<PackageInfo[]>;
+declare function publishPackage({ pkg, config, packageManager, dryRun, }: {
+    pkg: PackageInfo;
+    config: ResolvedChangelogMonorepoConfig;
+    packageManager: PackageManager;
+    dryRun: boolean;
+}): Promise<void>;
+
+declare function getLastRepoTag(options?: {
+    onlyStable?: boolean;
+    logLevel?: LogLevel;
+    cwd?: string;
+}): Promise<string | null>;
+declare function getLastPackageTag({ packageName, onlyStable, logLevel, cwd, }: {
+    packageName: string;
+    onlyStable?: boolean;
+    logLevel?: LogLevel;
+    cwd?: string;
+}): Promise<string | null>;
+type Step = 'bump' | 'changelog' | 'publish' | 'provider-release';
+interface ResolvedTags {
+    from: string;
+    to: string;
+}
+interface ResolveTagsOptions<VM extends VersionMode, S extends Step, Package = VM extends 'independent' ? PackageInfo : undefined, NewVersion = S extends 'bump' | 'changelog' ? undefined : string, CurrentVersion = S extends 'bump' | 'changelog' ? string : undefined> {
+    config: ResolvedChangelogMonorepoConfig;
+    versionMode: VM;
+    step: S;
+    pkg: Package;
+    currentVersion: CurrentVersion;
+    newVersion: NewVersion;
+    logLevel: LogLevel;
+}
+declare function resolveTags<T extends VersionMode, S extends Step>({ config, versionMode, step, pkg, currentVersion, newVersion, logLevel, }: ResolveTagsOptions<T, S>): Promise<ResolvedTags>;
+
+declare function determineReleaseType({ currentVersion, from, to, commits, config, force, }: {
+    currentVersion: string;
+    from: string;
+    to: string;
+    commits?: GitCommit[];
+    config: ResolvedChangelogMonorepoConfig;
+    force: boolean;
+}): BumpOptions['type'] | null;
+declare function writeVersion(pkgPath: string, version: string, dryRun?: boolean): void;
+declare function bumpPackageVersion({ currentVersion, releaseType, preid, suffix, }: {
+    currentVersion: string;
+    releaseType: ReleaseType;
+    preid: string | undefined;
+    suffix: string | undefined;
+}): string;
+declare function updateLernaVersion({ rootDir, versionMode, version, dryRun, }: {
+    rootDir: string;
+    versionMode?: VersionMode;
+    version: string;
+    dryRun?: boolean;
+}): void;
+declare function extractVersionFromPackageTag(tag: string): string | null;
+declare function isPrerelease(version?: string): boolean;
+declare function isStableReleaseType(releaseType: ReleaseType): boolean;
+declare function isPrereleaseReleaseType(releaseType: ReleaseType): boolean;
+declare function isGraduating(currentVersion: string, releaseType: ReleaseType): boolean;
+declare function getPreid(version: string): string | null;
+declare function isChangedPreid(currentVersion: string, targetPreid?: string): boolean;
+declare function bumpPackageIndependently({ pkg, dryRun, }: {
+    pkg: PackageToBump & PackageInfo;
+    dryRun: boolean;
+}): {
+    bumped: true;
+    newVersion: string;
+    oldVersion: string;
+} | {
+    bumped: false;
+};
+declare function confirmBump({ versionMode, config, packages, force, currentVersion, newVersion, dryRun, }: {
+    versionMode: VersionMode;
+    config: ResolvedChangelogMonorepoConfig;
+    packages: PackageInfo[];
+    force: boolean;
+    currentVersion?: string;
+    newVersion?: string;
+    dryRun: boolean;
+}): Promise<void>;
+declare function findPackagesWithCommitsAndCalculateVersions({ packages, config, force, suffix, }: {
+    packages: PackageInfo[];
+    config: ResolvedChangelogMonorepoConfig;
+    force: boolean;
+    suffix: string | undefined;
+}): Promise<(PackageInfo & PackageToBump)[]>;
+declare function bumpIndependentPackages({ packages, dryRun, }: {
+    packages: (PackageToBump & PackageInfo)[];
+    dryRun: boolean;
+}): PackageInfo[];
+
+type VersionMode = 'unified' | 'independent' | 'selective';
+type GitProvider = 'github' | 'gitlab';
+interface PackageInfo {
+    name: string;
+    path: string;
+    currentVersion: string;
+    version: string;
+    fromTag?: string;
+}
+interface PackageWithCommits extends PackageInfo {
+    commits: GitCommit[];
+}
+interface PublishResponse {
+    publishedPackages: PackageInfo[];
+}
+type BumpResult = {
+    oldVersion?: string;
+    newVersion?: string;
+    fromTag?: string;
+    bumpedPackages: PackageInfo[];
+    bumped: true;
+} | {
+    bumped: false;
+};
+interface PostedRelease {
+    name: string;
+    tag: string;
+    prerelease: boolean;
+    version: string;
+}
+interface MonorepoConfig {
+    /**
+     * Version mode for the monorepo.
+     * @required
+     */
+    versionMode: VersionMode;
+    /**
+     * Glob pattern matching for packages to bump.
+     * @required
+     */
+    packages: string[];
+    /**
+     * Package names to ignore.
+     * @default []
+     */
+    ignorePackageNames?: string[];
+}
+type ConfigType = {
+    title: string;
+    semver?: SemverBumpType;
+} | boolean;
+interface BumpConfig {
+    /**
+     * @default 'release'
+     */
+    type?: ReleaseType;
+    /**
+     * @default undefined
+     */
+    preid?: string;
+    /**
+     * Check if there are any changes to commit before bumping.
+     * @default true
+     */
+    clean?: boolean;
+    /**
+     * Include dev dependencies when bumping.
+     * @default ['dependencies']
+     */
+    dependencyTypes?: ('dependencies' | 'devDependencies' | 'peerDependencies')[];
+    /**
+     * Skip confirmation prompt about bumping packages
+     * @default true
+     */
+    yes?: boolean;
+}
+interface BumpOptions extends BumpConfig {
+    /**
+     * @default false
+     */
+    dryRun?: boolean;
+    /**
+     * @default undefined
+     */
+    config?: ResolvedChangelogMonorepoConfig;
+    /**
+     * @default undefined
+     */
+    logLevel?: LogLevel;
+    /**
+     * @default false
+     */
+    force?: boolean;
+    /**
+     * @default 'relizy'
+     */
+    configName?: string;
+    /**
+     * Custom suffix for prerelease versions - replace the last .X with .suffix (e.g. 1.0.0-beta.0 -> 1.0.0-beta.suffix)
+     * @default undefined
+     */
+    suffix?: string;
+}
+interface ChangelogConfig {
+    formatCmd?: string;
+    rootChangelog?: boolean;
+    /**
+     * Include commit body in the changelog.
+     * @default false
+     */
+    includeCommitBody?: boolean;
+}
+interface ChangelogOptions extends ChangelogConfig {
+    from?: string;
+    to?: string;
+    dryRun?: boolean;
+    bumpedPackages?: PackageInfo[];
+    config?: ResolvedChangelogMonorepoConfig;
+    logLevel?: LogLevel;
+    configName?: string;
+}
+interface GitProviderOptions {
+    from?: string;
+    to?: string;
+    token?: string;
+    config?: ResolvedChangelogMonorepoConfig;
+    configName?: string;
+    provider?: GitProvider;
+    bumpResult?: BumpResult;
+    logLevel?: LogLevel;
+    dryRun?: boolean;
+}
+type PublishConfig = ChangelogConfig$1['publish'] & {
+    registry?: string;
+    tag?: string;
+    access?: 'public' | 'restricted';
+    otp?: string;
+    /**
+     * Glob pattern matching for packages to publish.
+     * @default undefined
+     */
+    packages?: string[];
+    /**
+     * Command to build your packages before publishing.
+     * @default undefined
+     */
+    buildCmd?: string;
+};
+interface PublishOptions extends PublishConfig {
+    dryRun?: boolean;
+    config?: ResolvedChangelogMonorepoConfig;
+    bumpedPackages?: PackageInfo[];
+    logLevel?: LogLevel;
+    configName?: string;
+}
+interface ReleaseConfig {
+    /**
+     * Commit changes and create tag
+     * @default true
+     */
+    commit?: boolean;
+    /**
+     * Push changes to your repository (commit and tag(s))
+     * @default true
+     */
+    push?: boolean;
+    /**
+     * Generate changelog files (CHANGELOG.md)
+     * @default true
+     */
+    changelog?: boolean;
+    /**
+     * Publish release to your repository (github or gitlab)
+     * @default true
+     */
+    release?: boolean;
+    /**
+     * Publish release to your registry
+     * @default true
+     */
+    publish?: boolean;
+    /**
+     * Skip git verification while committing by using --no-verify flag
+     * @default true
+     */
+    noVerify?: boolean;
+    /**
+     * Determine if the working directory is clean and if it is not clean, exit
+     * @default false
+     */
+    clean?: boolean;
+}
+interface ReleaseOptions extends ReleaseConfig, BumpConfig, ChangelogConfig, PublishConfig {
+    /**
+     * Run without side effects
+     * @default false
+     */
+    dryRun?: boolean;
+    /**
+     * @default undefined
+     */
+    from?: string;
+    /**
+     * @default undefined
+     */
+    to?: string;
+    /**
+     * @default undefined
+     */
+    token?: string;
+    /**
+     * @default undefined
+     */
+    logLevel?: LogLevel;
+    /**
+     * @default 'relizy'
+     */
+    configName?: string;
+    /**
+     * Bump even if there are no commits
+     * @default false
+     */
+    force?: boolean;
+    /**
+     * Custom suffix for prerelease versions - replace the last .X with .suffix (e.g. 1.0.0-beta.0 -> 1.0.0-beta.suffix)
+     * @default undefined
+     */
+    suffix?: string;
+}
+interface TemplatesConfig {
+    commitMessage?: string;
+    tagMessage?: string;
+    /**
+     * Not used with "independent" version mode
+     */
+    tagBody?: string;
+    emptyChangelogContent?: string;
+}
+interface RepoConfig {
+    domain?: string;
+    repo?: string;
+    token?: string;
+    provider?: GitProvider;
+}
+interface ChangelogMonorepoConfig extends Partial<Omit<ChangelogConfig$1, 'output' | 'templates' | 'publish'>> {
+    cwd?: string;
+    from?: string;
+    to?: string;
+    /**
+     * @default `{
+      versionMode: 'selective',
+      packages: ['packages/*'],
+      ignorePackageNames: [],
+    }`
+     */
+    monorepo?: MonorepoConfig;
+    repo?: RepoConfig;
+    templates?: TemplatesConfig;
+    bump?: BumpConfig;
+    publish?: PublishConfig;
+    changelog?: ChangelogConfig;
+    release?: ReleaseConfig;
+    logLevel?: LogLevel;
+}
+type PackageManager = 'npm' | 'yarn' | 'pnpm' | 'bun';
+
+declare function bump(options?: Partial<BumpOptions>): Promise<BumpResult>;
+
+declare function changelog(options?: Partial<ChangelogOptions>): Promise<void>;
+
+declare function providerRelease(options?: Partial<GitProviderOptions>): Promise<{
+    detectedProvider: GitProvider;
+    postedReleases: PostedRelease[];
+}>;
+
+declare function publish(options?: Partial<PublishOptions>): Promise<{
+    publishedPackages: PackageInfo[];
+} | undefined>;
+
+declare function release(options?: Partial<ReleaseOptions>): Promise<void>;
+
+export { bump, bumpIndependentPackages, bumpPackageIndependently, bumpPackageVersion, changelog, checkGitStatusIfDirty, confirmBump, createCommitAndTags, createGitlabRelease, defineConfig, detectGitProvider, detectPackageManager, determinePublishTag, determineReleaseType, executeBuildCmd, executeFormatCmd, expandPackagesToBumpWithDependents, extractVersionFromPackageTag, fetchGitTags, findPackagesWithCommitsAndCalculateVersions, generateChangelog, getCurrentGitBranch, getCurrentGitRef, getDefaultConfig, getDependentsOf, getFirstCommit, getGitStatus, getLastPackageTag, getLastRepoTag, getPackageCommits, getPackageDependencies, getPackageToBump, getPackages, getPackagesToPublishInIndependentMode, getPackagesToPublishInSelectiveMode, getPackagesWithDependencies, getPreid, getRootPackage, github, gitlab, hasLernaJson, isChangedPreid, isGraduating, isPrerelease, isPrereleaseReleaseType, isStableReleaseType, loadMonorepoConfig, parseGitRemoteUrl, providerRelease, publish, publishPackage, pushCommitAndTags, release, resolveTags, topologicalSort, updateLernaVersion, writeChangelogToFile, writeVersion };
+export type { BumpConfig, BumpOptions, BumpResult, ChangelogConfig, ChangelogMonorepoConfig, ChangelogOptions, ConfigType, GitProvider, GitProviderOptions, GitlabRelease, GitlabReleaseResponse, MonorepoConfig, PackageInfo, PackageManager, PackageToBump, PackageWithCommits, PackageWithDeps, PostedRelease, PublishConfig, PublishOptions, PublishResponse, ReleaseConfig, ReleaseOptions, RepoConfig, ResolvedChangelogMonorepoConfig, TemplatesConfig, VersionMode };