relion 0.1.1 → 0.3.0

package/dist/cli.js

@@ -0,0 +1,64 @@
+import { resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import relion from "./index.js";
+import { cli } from "cleye";
+
+//#region src/cli.ts
+let config;
+try {
+	const configFileURL = pathToFileURL(resolve(process.cwd(), "relion.config.ts")).href;
+	config = (await import(configFileURL)).default;
+} catch (error) {
+	throw new Error(`Error loading config: ${error.message}`);
+}
+const argv = cli({
+	name: "relion",
+	flags: {
+		bump: {
+			alias: "b",
+			type: Boolean,
+			description: "Bump the version",
+			default: false
+		},
+		changelog: {
+			alias: "l",
+			type: Boolean,
+			description: "Generate a changelog",
+			default: false
+		},
+		commit: {
+			alias: "c",
+			type: Boolean,
+			description: "Create a commit",
+			default: false
+		},
+		tag: {
+			alias: "t",
+			type: Boolean,
+			description: "Create a tag",
+			default: false
+		},
+		profile: {
+			alias: "p",
+			type: String,
+			description: "Use config profile"
+		},
+		dryRun: {
+			alias: "d",
+			type: Boolean,
+			description: "Run without making any changes",
+			default: false
+		}
+	}
+});
+if (!argv.flags.bump) config.bump = false;
+if (!argv.flags.changelog) config.changelog = false;
+if (!argv.flags.commit) config.commit = false;
+if (!argv.flags.tag) config.tag = false;
+if (argv.flags.profile) config.profile = argv.flags.profile;
+if (argv.flags.dryRun) config.dryRun = argv.flags.dryRun;
+await relion(config);
+
+//#endregion
+export {  };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/index.d.ts

@@ -0,0 +1,231 @@
+import { HelperDeclareSpec } from "handlebars";
+
+//#region src/types/config.d.ts
+type FalseOrComplete<T> = false | Required<T>;
+interface UserConfig {
+  bump?: boolean | BumpFiles;
+  changelog?: boolean | ChangelogOptions;
+  commit?: boolean | CommitOptions;
+  tag?: boolean | TagOptions;
+  newTagFormat?: string;
+  versionSourceFile?: string | VersionedFile;
+  releaseVersion?: string;
+  releaseType?: ReleaseType;
+  zeroMajorBreakingIsMinor?: boolean;
+  context?: Context;
+  commitsParser?: CommitsParser;
+  prevReleaseTagPattern?: RegExp;
+  dryRun?: boolean;
+  profile?: string;
+  [profile: `_${string}`]: UserConfig | undefined;
+}
+type OptionalKeys = 'releaseVersion' | 'releaseType' | 'context' | 'profile';
+interface MergedConfig extends Omit<Required<UserConfig>, OptionalKeys>, Pick<UserConfig, OptionalKeys> {
+  changelog: FalseOrComplete<ChangelogOptions>;
+  commit: FalseOrComplete<CommitOptions>;
+  tag: FalseOrComplete<TagOptions>;
+  commitsParser: CompleteCommitsParser;
+}
+interface TransformedConfig extends Omit<MergedConfig, 'changelog'> {
+  versionSourceFile: VersionedFile;
+  bump: FalseOrComplete<VersionedFile[]>;
+  changelog: false | ResolvedChangelogOptions;
+}
+interface ContextualConfig extends TransformedConfig {
+  context: ResolvedContext;
+}
+type ResolvedConfig = ContextualConfig;
+type BumpFiles = (string | VersionedFile)[];
+interface ChangelogOptions {
+  stdout?: boolean;
+  outputFile?: string;
+  commitRange?: CommitRange;
+  sections?: ChangelogSectionDefinition[];
+  header?: string;
+  prevReleaseHeaderPattern?: RegExp;
+  helpers?: HelperDeclareSpec;
+  partials?: Record<string, string>;
+}
+type CompleteChangelogOptions = Required<ChangelogOptions>;
+interface ResolvedChangelogOptions extends Omit<CompleteChangelogOptions, 'partials'> {
+  compiledPartials: Record<string, HandlebarsTemplateDelegate>;
+}
+interface CommitOptions {
+  message?: string;
+  signOff?: boolean;
+  gpgSign?: boolean;
+  stageAll?: boolean;
+  extraArgs?: string;
+}
+type CompleteCommitOptions = Required<CommitOptions>;
+interface TagOptions {
+  name?: string;
+  message?: string;
+  gpgSign?: boolean;
+  force?: boolean;
+  extraArgs?: string;
+}
+type CompleteTagOptions = Required<TagOptions>;
+interface CommitsParser {
+  breakingChangesPattern?: RegExp;
+  breakingChangeListPattern?: RegExp;
+  headerPattern?: RegExp;
+  tagPattern?: RegExp;
+  coAuthorPattern?: RegExp;
+  ghEmailPattern?: RegExp;
+  refPattern?: RegExp;
+  refActionPattern?: RegExp;
+  refLabelPattern?: RegExp;
+  remoteUrlPattern?: RegExp;
+  signerPattern?: RegExp;
+  dateSource?: 'authorDate' | 'committerDate';
+  dateFormat?: string;
+}
+type CompleteCommitsParser = Required<CommitsParser>;
+interface RepoInfo {
+  host?: string;
+  owner?: string;
+  name?: string;
+  homepage?: string;
+}
+interface Context {
+  commits?: Commit[] | RawCommit[];
+  currentVersion?: string;
+  currentTag?: string;
+  newVersion?: string;
+  newTag?: string;
+  repo?: RepoInfo;
+  [key: string]: unknown;
+}
+interface ResolvedContext extends Required<Context> {
+  commits: Commit[];
+  releases: ReleaseWithGroupedCommits[] | null;
+}
+type CommitRange = 'all' | 'unreleased' | {
+  versionTag: string;
+} | {
+  from: 'firstCommit' | (string & {});
+} | {
+  to: 'HEAD' | (string & {});
+} | {
+  from: 'firstCommit' | (string & {});
+  to: 'HEAD' | (string & {});
+};
+type ReleaseType = 'major' | 'minor' | 'patch';
+interface VersionedFile {
+  filePath: string;
+  versionPattern: RegExp;
+}
+interface DefaultVersionedFile extends Omit<VersionedFile, 'filePath'> {
+  filePathRegex: RegExp;
+}
+//#endregion
+//#region src/enums.d.ts
+declare enum GpgSigLabel {
+  G = "valid",
+  B = "bad",
+  U = "valid, unknown validity",
+  X = "valid, expired",
+  Y = "valid, made by expired key",
+  R = "valid, made by revoked key",
+  E = "cannot check (missing key)",
+  N = "no signature",
+}
+declare enum RefType {
+  issue = "issue",
+  pr = "PR",
+}
+//#endregion
+//#region src/types/commit.d.ts
+type RawCommit = CommitMessageString | {
+  hash?: string;
+  message: string;
+  tagRefs?: string;
+  authorName?: string;
+  authorEmail?: string;
+  authorTs?: string;
+  committerName?: string;
+  committerEmail?: string;
+  committerTs?: string;
+  gpgSigCode?: GpgSigCode;
+  gpgSigKeyId?: string;
+};
+interface Commit extends CommitMessage {
+  hash?: string;
+  tags?: string[];
+  authors?: Contributor[];
+  committer?: Contributor;
+  refs?: Reference[];
+  gpgSig?: GpgSig;
+  date?: string;
+}
+interface CommitMessage {
+  type: string;
+  scope?: string;
+  subject: string;
+  body?: string;
+  breakingChanges?: string | string[];
+  footer?: string;
+}
+type CommitMessageString = string;
+interface Reference {
+  action: string;
+  type?: RefType;
+  owner?: string;
+  repo?: string;
+  number: string;
+}
+type RefLabel = Pick<Reference, 'owner' | 'repo' | 'number'>;
+interface Contributor {
+  name: string;
+  email: string;
+  hasSignedOff?: boolean;
+  ghLogin?: string;
+  ghUrl?: string;
+}
+type GithubUserInfo = Pick<Contributor, 'ghLogin' | 'ghUrl'>;
+interface GpgSig {
+  code: GpgSigCode;
+  label: GpgSigLabel;
+  keyId?: string;
+}
+type GpgSigCode = 'G' | 'B' | 'U' | 'X' | 'Y' | 'R' | 'E' | 'N';
+interface RawReference {
+  action: string;
+  labels: string;
+}
+//#endregion
+//#region src/types/changelog.d.ts
+interface ChangelogSectionDefinition {
+  title: string;
+  commitType: 'breaking' | '*' | (string & {}) | string[];
+  filter?: (commit: Commit) => boolean;
+}
+interface ResolvedChangelogSection {
+  title: string;
+  commits: Commit[];
+}
+interface ReleaseWithFlatCommits {
+  tag: string;
+  version?: string;
+  date?: string;
+  commits: Commit[];
+}
+interface ReleaseWithGroupedCommits extends Omit<ReleaseWithFlatCommits, 'commits'> {
+  commitGroups: ResolvedChangelogSection[];
+}
+interface ReleaseContext extends ReleaseWithGroupedCommits, ResolvedContext {
+  prevTag?: string;
+  prevVersion?: string;
+}
+type ChangelogSectionsMap = Record<string, ChangelogSectionDefinition>;
+interface DefaultChangelogSections extends ChangelogSectionsMap {
+  [Symbol.iterator](): Iterator<ChangelogSectionDefinition>;
+}
+//#endregion
+//#region src/relion.d.ts
+declare function relion(userConfig: UserConfig): Promise<void>;
+declare const defineConfig: (config: UserConfig) => UserConfig;
+//#endregion
+export { BumpFiles, ChangelogOptions, ChangelogSectionDefinition, ChangelogSectionsMap, Commit, CommitMessage, CommitOptions, CommitRange, CommitsParser, CompleteChangelogOptions, CompleteCommitOptions, CompleteCommitsParser, CompleteTagOptions, Context, ContextualConfig, Contributor, DefaultChangelogSections, DefaultVersionedFile, FalseOrComplete, GithubUserInfo, GpgSig, GpgSigCode, MergedConfig, RawCommit, RawReference, RefLabel, Reference, ReleaseContext, ReleaseType, ReleaseWithFlatCommits, ReleaseWithGroupedCommits, RepoInfo, ResolvedChangelogOptions, ResolvedChangelogSection, ResolvedConfig, ResolvedContext, TagOptions, TransformedConfig, UserConfig, VersionedFile, relion as default, defineConfig };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"index.d.ts","names":[],"sources":["../src/types/config.d.ts","../src/enums.d.ts","../src/types/commit.d.ts","../src/types/changelog.d.ts","../src/relion.d.ts"],"sourcesContent":["import type { Commit, RawCommit, ChangelogSectionDefinition, ReleaseWithGroupedCommits } from '@/types'\nimport type { HelperDeclareSpec } from 'handlebars'\n\nexport type FalseOrComplete<T> = false | Required<T>\n\nexport interface UserConfig {\n\tbump?: boolean | BumpFiles\n\tchangelog?: boolean | ChangelogOptions\n\tcommit?: boolean | CommitOptions\n\ttag?: boolean | TagOptions\n\tnewTagFormat?: string\n\tversionSourceFile?: string | VersionedFile\n\treleaseVersion?: string\n\treleaseType?: ReleaseType\n\tzeroMajorBreakingIsMinor?: boolean\n\tcontext?: Context\n\tcommitsParser?: CommitsParser\n\tprevReleaseTagPattern?: RegExp\n\tdryRun?: boolean\n\tprofile?: string\n\t[profile: `_${string}`]: UserConfig | undefined\n}\n\ntype OptionalKeys = 'releaseVersion' | 'releaseType' | 'context' | 'profile'\nexport interface MergedConfig extends Omit<Required<UserConfig>, OptionalKeys>, Pick<UserConfig, OptionalKeys> {\n\tchangelog: FalseOrComplete<ChangelogOptions>\n\tcommit: FalseOrComplete<CommitOptions>\n\ttag: FalseOrComplete<TagOptions>\n\tcommitsParser: CompleteCommitsParser\n}\nexport interface TransformedConfig extends Omit<MergedConfig, 'changelog'> {\n\tversionSourceFile: VersionedFile\n\tbump: FalseOrComplete<VersionedFile[]>\n\tchangelog: false | ResolvedChangelogOptions\n}\n\nexport interface ContextualConfig extends TransformedConfig {\n\tcontext: ResolvedContext\n}\nexport type ResolvedConfig = ContextualConfig\n\nexport type BumpFiles = (string | VersionedFile)[]\n\nexport interface ChangelogOptions {\n\tstdout?: boolean\n\toutputFile?: string\n\tcommitRange?: CommitRange\n\tsections?: ChangelogSectionDefinition[]\n\theader?: string\n\tprevReleaseHeaderPattern?: RegExp\n\thelpers?: HelperDeclareSpec\n\tpartials?: Record<string, string>\n}\nexport type CompleteChangelogOptions = Required<ChangelogOptions>\nexport interface ResolvedChangelogOptions extends Omit<CompleteChangelogOptions, 'partials'> {\n\tcompiledPartials: Record<string, HandlebarsTemplateDelegate>\n}\n\nexport interface CommitOptions {\n\tmessage?: string\n\tsignOff?: boolean\n\tgpgSign?: boolean\n\tstageAll?: boolean\n\textraArgs?: string\n}\nexport type CompleteCommitOptions = Required<CommitOptions>\n\nexport interface TagOptions {\n\tname?: string\n\tmessage?: string\n\tgpgSign?: boolean\n\tforce?: boolean\n\textraArgs?: string\n}\nexport type CompleteTagOptions = Required<TagOptions>\n\nexport interface CommitsParser {\n\tbreakingChangesPattern?: RegExp\n\tbreakingChangeListPattern?: RegExp\n\theaderPattern?: RegExp\n\ttagPattern?: RegExp\n\tcoAuthorPattern?: RegExp\n\tghEmailPattern?: RegExp\n\trefPattern?: RegExp\n\trefActionPattern?: RegExp\n\trefLabelPattern?: RegExp\n\tremoteUrlPattern?: RegExp\n\tsignerPattern?: RegExp\n\tdateSource?: 'authorDate' | 'committerDate'\n\tdateFormat?: string\n}\nexport type CompleteCommitsParser = Required<CommitsParser>\n\nexport interface RepoInfo {\n\thost?: string\n\towner?: string\n\tname?: string\n\thomepage?: string\n}\nexport interface Context {\n\tcommits?: Commit[] | RawCommit[]\n\tcurrentVersion?: string\n\tcurrentTag?: string\n\tnewVersion?: string\n\tnewTag?: string\n\trepo?: RepoInfo\n\t[key: string]: unknown\n}\nexport interface ResolvedContext extends Required<Context> {\n\tcommits: Commit[]\n\treleases: ReleaseWithGroupedCommits[] | null\n}\n\nexport type CommitRange =\n\t| 'all'\n\t| 'unreleased'\n\t| { versionTag: string }\n\t| { from: 'firstCommit' | (string & {}) }\n\t| { to: 'HEAD' | (string & {}) }\n\t| { from: 'firstCommit' | (string & {}), to: 'HEAD' | (string & {}) }\n\nexport type ReleaseType = 'major' | 'minor' | 'patch'\n\nexport interface VersionedFile {\n\tfilePath: string\n\tversionPattern: RegExp\n}\nexport interface DefaultVersionedFile extends Omit<VersionedFile, 'filePath'> {\n\tfilePathRegex: RegExp\n}","export declare enum GpgSigLabel {\n    G = \"valid\",\n    B = \"bad\",\n    U = \"valid, unknown validity\",\n    X = \"valid, expired\",\n    Y = \"valid, made by expired key\",\n    R = \"valid, made by revoked key\",\n    E = \"cannot check (missing key)\",\n    N = \"no signature\"\n}\nexport declare enum RefType {\n    issue = \"issue\",\n    pr = \"PR\"\n}\n","import type { GpgSigLabel, RefType } from '@/enums'\n\nexport type RawCommit = CommitMessageString | {\n\thash?: string\n\tmessage: string\n\ttagRefs?: string\n\tauthorName?: string\n\tauthorEmail?: string\n\tauthorTs?: string\n\tcommitterName?: string\n\tcommitterEmail?: string\n\tcommitterTs?: string\n\tgpgSigCode?: GpgSigCode\n\tgpgSigKeyId?: string\n}\n\nexport interface Commit extends CommitMessage {\n\thash?: string\n\ttags?: string[]\n\tauthors?: Contributor[]\n\tcommitter?: Contributor\n\trefs?: Reference[]\n\tgpgSig?: GpgSig\n\tdate?: string\n}\n\nexport interface CommitMessage {\n\ttype: string\n\tscope?: string\n\tsubject: string\n\tbody?: string\n\tbreakingChanges?: string | string[]\n\tfooter?: string\n}\ntype CommitMessageString = string\n\nexport interface Reference {\n\taction: string\n\ttype?: RefType\n\towner?: string\n\trepo?: string\n\tnumber: string\n}\n\nexport type RefLabel = Pick<Reference, 'owner' | 'repo' | 'number'>\n\nexport interface Contributor {\n\tname: string\n\temail: string\n\thasSignedOff?: boolean\n\tghLogin?: string\n\tghUrl?: string\n}\n\nexport type GithubUserInfo = Pick<Contributor, 'ghLogin' | 'ghUrl'>\n\nexport interface GpgSig {\n\tcode: GpgSigCode\n\tlabel: GpgSigLabel\n\tkeyId?: string\n}\n\nexport type GpgSigCode = 'G' | 'B' | 'U' | 'X' | 'Y' | 'R' | 'E' | 'N'\n\nexport interface RawReference {\n\taction: string\n\tlabels: string\n}","import type { Commit, ResolvedContext } from '@/types'\n\nexport interface ChangelogSectionDefinition {\n\ttitle: string\n\tcommitType: 'breaking' | '*' | (string & {}) | string[]\n\tfilter?: (commit: Commit) => boolean\n}\n\nexport interface ResolvedChangelogSection {\n\ttitle: string\n\tcommits: Commit[]\n}\n\nexport interface ReleaseWithFlatCommits {\n\ttag: string\n\tversion?: string\n\tdate?: string\n\tcommits: Commit[]\n}\n\nexport interface ReleaseWithGroupedCommits extends Omit<ReleaseWithFlatCommits, 'commits'> {\n\tcommitGroups: ResolvedChangelogSection[]\n}\n\nexport interface ReleaseContext extends ReleaseWithGroupedCommits, ResolvedContext {\n\tprevTag?: string\n\tprevVersion?: string\n}\n\nexport type ChangelogSectionsMap = Record<string, ChangelogSectionDefinition>\n\nexport interface DefaultChangelogSections extends ChangelogSectionsMap {\n\t[Symbol.iterator](): Iterator<ChangelogSectionDefinition>\n}","import type { UserConfig } from '@/types';\nexport default function relion(userConfig: UserConfig): Promise<void>;\nexport declare const defineConfig: (config: UserConfig) => UserConfig;\n"],"mappings":";;;;;;;;AAGA,IAAW,aAAa;CAAC;OAAU;OAAgB;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;;;AAEnD,IAAW,eAAe;CAAC;OAAC;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;;AAC5B,IAAW,oBAAe;CAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;;AAC1B,IAAW,mBAAmB;CAAC;OAAO;OAAA;;AACtC,IAAW,iBAAiB,CAAC,UAAG;AAChC,IAAW,YAAY,CAAC,UAAE;AAC1B,IAAW,mBAAU;CAAA;OAAA;OAAA;OAAA;OAAA;OAAA;;AACrB,IAAW,2BAA2B;CAAC;OAAG;OAAA;;AAC1C,IAAW,2BAAY;CAAA;OAAA;OAAA;OAAA;OAAA;;AACvB,IAAW,gBAAc,CAAA;AACzB,IAAW,wBAAuB;CAAA;OAAA;OAAA;;AAClC,IAAW,aAAM,CAAA;AACjB,IAAW,qBAAkB;CAAA;OAAA;OAAA;;AAC7B,IAAW,gBAAgB;CAAC;OAAE;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;;AAC9B,IAAW,wBAAK;CAAA;OAAA;OAAA;;AAChB,IAAW,WAAK,CAAA;AAChB,IAAW,UAAU;CAAC;OAAU;OAAc;OAAC;;AAC/C,IAAA,kBAAA;CAAA;OAAA;OAAA;OAAA;OAAA;;;AAEA,IAAW,cAAc,CAAC;AAC1B,IAAW,gBAAgB,CAAC,UAAU;AACtC,IAAW,uBAAuB;CAAC;OAAS;OAAA;OAAA;;;;;ACzB5C,IAAW,cAAc,CAAC;AAC1B,IAAW,UAAI,CAAA;;;;;;;;;ACCf,IAAW,SAAS;CAAC;OAAU;OAAe;OAAA;OAAA;OAAA;;AAC9C,IAAW,gBAAE,CAAA;AACb,IAAI,sBAAW,CAAA;AACf,IAAW,YAAK,CAAA,UAAA;AAChB,IAAW,WAAQ;CAAA;OAAA;OAAA;;AACnB,IAAW,cAAS,CAAA;AACpB,IAAW,iBAAM;CAAA;OAAA;OAAA;;AACjB,IAAW,SAAS;CAAC;OAAC;OAAA;;AACtB,IAAW,aAAY,CAAA;AACvB,IAAW,eAAS,CAAA;;;;;ACTpB,IAAW,2BAA2B,CAAC,SAAK;AAC5C,IAAW,yBAAE,CAAA,SAAA;AACb,IAAW,4BAA4B;CAAC;OAAS;OAAM;OAAA;;AACvD,IAAW,iBAAiB;CAAC;OAAO;OAAA;;AACpC,IAAA,uBAAA;CAAA;OAAA;OAAA;;;;;;;;;;;ACLA,IAAI,SAAS;CAAC;OAAS;OAAkB;;AACzC,IAAW,eAAe;CAAC;OAAS;OAAkB"}