@releasekit/notes 0.41.2 → 0.42.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/cli.d.ts CHANGED
@@ -1,10 +1,6 @@
1
1
  #!/usr/bin/env node
2
- export { createNotesCommand } from './command.ts';
3
- import './core/config.ts';
4
- import './core/pipeline.ts';
5
- import './core/types.ts';
6
- import './errors/index.ts';
7
- import './input/version-output.ts';
8
- import './monorepo/aggregator.ts';
9
- import './output/json.ts';
10
- import './output/markdown.ts';
2
+ import { Command } from 'commander';
3
+
4
+ declare function createNotesCommand(): Command;
5
+
6
+ export { createNotesCommand };
package/dist/cli.js CHANGED
@@ -1,10 +1,10 @@
1
1
  #!/usr/bin/env node
2
2
  import {
3
3
  createNotesCommand
4
- } from "./chunk-2PRVRNSI.js";
4
+ } from "./chunk-OTH3XXI4.js";
5
5
  import {
6
6
  readPackageVersion
7
- } from "./chunk-FI3F2ND5.js";
7
+ } from "./chunk-CBMVDKDR.js";
8
8
 
9
9
  // src/cli.ts
10
10
  import * as fs from "fs";
package/dist/index.d.ts CHANGED
@@ -1,9 +1,400 @@
1
- export { createNotesCommand } from './command.ts';
2
- export { getDefaultConfig, loadAuth, loadConfig, saveAuth } from './core/config.ts';
3
- export { PipelineOptions, PipelineResult, createTemplateContext, processInput, runPipeline } from './core/pipeline.ts';
4
- export * from './core/types.ts';
5
- export * from './errors/index.ts';
6
- export { parseVersionOutput, parseVersionOutputFile, parseVersionOutputStdin, versionOutputToChangelogInput } from './input/version-output.ts';
7
- export { aggregateToRoot, detectMonorepo, writeMonorepoChangelogs } from './monorepo/aggregator.ts';
8
- export { renderJson, writeJson } from './output/json.ts';
9
- export { formatVersion, renderMarkdown, writeMarkdown } from './output/markdown.ts';
1
+ export { createNotesCommand } from './cli.js';
2
+ import { z } from 'zod';
3
+ import 'commander';
4
+
5
+ declare const MonorepoConfigSchema: z.ZodObject<{
6
+ rootPath: z.ZodOptional<z.ZodString>;
7
+ packagesPath: z.ZodOptional<z.ZodString>;
8
+ }, z.core.$strip>;
9
+ type MonorepoConfig = z.infer<typeof MonorepoConfigSchema>;
10
+ declare function loadAuth(): Record<string, string>;
11
+ declare function saveAuth(provider: string, apiKey: string): void;
12
+
13
+ type ChangelogRefsMode = 'strip' | 'escape' | 'link';
14
+
15
+ declare abstract class ReleaseKitError extends Error {
16
+ abstract readonly code: string;
17
+ abstract readonly suggestions: string[];
18
+ constructor(message: string);
19
+ logError(): void;
20
+ /** True for an error from any copy of core (see {@link RELEASEKIT_ERROR_BRAND}), not just this one. */
21
+ static isReleaseKitError(error: unknown): error is ReleaseKitError;
22
+ }
23
+
24
+ interface VersionChangelogEntry {
25
+ type: string;
26
+ description: string;
27
+ issueIds?: string[];
28
+ /**
29
+ * The PR this entry shipped through, from the trailing `(#N)` GitHub appends to a squash-merge subject. Marks which
30
+ * of the {@link issueIds} is the PR (the rest are closed issues); the number stays in `issueIds` too, so a consumer
31
+ * that ignores this field still shows the ref. Absent when there's no identifiable PR (a non-squash commit or an
32
+ * old manifest).
33
+ */
34
+ prNumber?: string;
35
+ scope?: string;
36
+ originalType?: string;
37
+ breaking?: boolean;
38
+ /**
39
+ * True when this entry is a fabricated `Update version to X` placeholder minted by the version-groups engine for a
40
+ * lockstep carry - a group member bumped only to stay in sync, with no commits of its own. Not set on an
41
+ * extraction-error fallback, which isn't a no-change carry.
42
+ */
43
+ synthetic?: boolean;
44
+ }
45
+ interface VersionPackageChangelog {
46
+ packageName: string;
47
+ version: string;
48
+ previousVersion: string | null;
49
+ revisionRange: string;
50
+ repoUrl: string | null;
51
+ entries: VersionChangelogEntry[];
52
+ }
53
+ /** `'graduated'`: a prerelease promoted to stable, ignoring any requested bump. `'first-release'`: no prior tag. */
54
+ type VersionAction = 'first-release' | 'graduated' | 'bumped';
55
+ type ReleaseChannel = 'stable' | 'prerelease';
56
+ /**
57
+ * The `data` of @releasekit/version's `--json` envelope, passed between pipeline stages and persisted in standing-PR
58
+ * manifests. Open PRs carry old manifests, so new fields must be optional and consumers must tolerate their absence.
59
+ */
60
+ interface VersionOutput {
61
+ dryRun: boolean;
62
+ /** Absent in older manifests. */
63
+ strategy?: 'sync' | 'single' | 'async' | 'group';
64
+ updates: VersionPackageUpdate[];
65
+ changelogs: VersionPackageChangelog[];
66
+ /** Entries from commits that touch no package directory. */
67
+ sharedEntries?: VersionChangelogEntry[];
68
+ commitMessage?: string;
69
+ /** Consumer-facing tags from `tagTemplate`. */
70
+ tags: string[];
71
+ /**
72
+ * Internal baseline-marker tags from `baselineTagTemplate`, pushed alongside `tags` but never given a GitHub
73
+ * Release. They let later runs find the previous release on the source branch when the consumer-facing tag has
74
+ * been force-moved off it.
75
+ */
76
+ baselineTags?: string[];
77
+ }
78
+ interface VersionPackageUpdate {
79
+ packageName: string;
80
+ newVersion: string;
81
+ /**
82
+ * In the same consumer-tag display form as {@link VersionPackageChangelog.previousVersion}. Absent for a first
83
+ * release, when the baseline was unreachable or fell back to all-history, and in older manifests.
84
+ */
85
+ previousVersion?: string;
86
+ filePath: string;
87
+ /** Absent when all packages share one tag. */
88
+ tag?: string;
89
+ /**
90
+ * The workspace-root package.json, bumped only to keep the root version in lockstep. Not a publishable package, so
91
+ * exclude it from package counts and lists.
92
+ */
93
+ isRoot?: boolean;
94
+ group?: string;
95
+ /**
96
+ * Set in an `--include-prerequisites` release: `'target'` is an explicitly-selected (group-expanded) package that
97
+ * gets the bump/prerelease/stable override; `'prerequisite'` is a changed transitive dependency pulled in to keep
98
+ * the targets installable, which keeps its own commit-driven bump. Absent on plain releases and for the root
99
+ * lockstep bump - treat an absent role as a target.
100
+ */
101
+ role?: 'target' | 'prerequisite';
102
+ prerequisiteOf?: string[];
103
+ /** Absent in older manifests. */
104
+ action?: VersionAction;
105
+ actionReason?: string;
106
+ /** Absent in older manifests - re-derive it with {@link deriveReleaseChannel}. */
107
+ channel?: ReleaseChannel;
108
+ }
109
+
110
+ interface RetryOptions {
111
+ maxAttempts?: number;
112
+ initialDelay?: number;
113
+ maxDelay?: number;
114
+ backoffFactor?: number;
115
+ shouldRetry?: (error: unknown) => boolean;
116
+ }
117
+
118
+ type ChangelogType = 'added' | 'changed' | 'deprecated' | 'removed' | 'fixed' | 'security';
119
+ interface PRContext {
120
+ number: number;
121
+ title: string;
122
+ body: string;
123
+ }
124
+ interface ChangelogEntry {
125
+ type: ChangelogType;
126
+ description: string;
127
+ issueIds?: string[];
128
+ /** The PR this entry shipped through (trailing `(#N)` of a squash-merge subject); marks which of
129
+ * {@link issueIds} is the PR vs. a closed issue. */
130
+ prNumber?: string;
131
+ scope?: string;
132
+ originalType?: string;
133
+ breaking?: boolean;
134
+ leadIn?: string;
135
+ /** Populated upstream of LLM tasks; never serialised to disk. */
136
+ context?: {
137
+ prs: PRContext[];
138
+ };
139
+ }
140
+ interface PackageChangelog {
141
+ packageName: string;
142
+ version: string;
143
+ previousVersion: string | null;
144
+ revisionRange: string;
145
+ repoUrl: string | null;
146
+ date: string;
147
+ entries: ChangelogEntry[];
148
+ }
149
+ type InputSource = 'version' | 'conventional-changelog' | 'git-log' | 'manual';
150
+ interface ChangelogInput {
151
+ source: InputSource;
152
+ packages: PackageChangelog[];
153
+ metadata?: {
154
+ repoUrl?: string;
155
+ defaultBranch?: string;
156
+ };
157
+ }
158
+ interface EnhancedCategory {
159
+ name: string;
160
+ entries: ChangelogEntry[];
161
+ }
162
+ interface EnhancedData {
163
+ entries: ChangelogEntry[];
164
+ summary?: string;
165
+ categories?: EnhancedCategory[];
166
+ releaseNotes?: string;
167
+ }
168
+ interface TemplateContext {
169
+ packageName: string;
170
+ version: string;
171
+ previousVersion: string | null;
172
+ date: string;
173
+ repoUrl: string | null;
174
+ entries: ChangelogEntry[];
175
+ compareUrl?: string;
176
+ enhanced?: EnhancedData;
177
+ isFirstRelease?: boolean;
178
+ }
179
+ interface DocumentContext {
180
+ project: {
181
+ name: string;
182
+ repoUrl?: string;
183
+ };
184
+ versions: TemplateContext[];
185
+ unreleased?: TemplateContext;
186
+ compareUrls?: Record<string, string>;
187
+ /** Templates can use this to suppress document-level headings that are redundant
188
+ * when the content is embedded in a release that already shows the package/version. */
189
+ perPackage?: boolean;
190
+ /** `'release'` is the GitHub release body. Templates can branch on it - e.g. emit docs-site
191
+ * YAML frontmatter only for `'file'`, since it would render as literal text in a GitHub release. */
192
+ output?: 'file' | 'release';
193
+ }
194
+ interface LLMOptions {
195
+ timeout?: number;
196
+ maxTokens?: number;
197
+ temperature?: number;
198
+ }
199
+ interface LLMPromptOverrides {
200
+ enhance?: string;
201
+ categorize?: string;
202
+ enhanceAndCategorize?: string;
203
+ summarize?: string;
204
+ releaseNotes?: string;
205
+ }
206
+ interface LLMPromptsConfig {
207
+ instructions?: LLMPromptOverrides;
208
+ }
209
+ interface LLMCategory {
210
+ name: string;
211
+ description: string;
212
+ scopes?: string[];
213
+ }
214
+ interface ScopeRules {
215
+ allowed?: string[];
216
+ caseSensitive?: boolean;
217
+ invalidScopeAction?: 'remove' | 'keep' | 'fallback';
218
+ fallbackScope?: string;
219
+ }
220
+ interface ScopeConfig {
221
+ mode?: 'restricted' | 'packages' | 'none' | 'unrestricted';
222
+ rules?: ScopeRules;
223
+ }
224
+ type UpdateStrategy = 'prepend' | 'regenerate';
225
+ interface Config {
226
+ changelog?: false | ChangelogConfig;
227
+ releaseNotes?: false | ReleaseNotesConfig;
228
+ monorepo?: MonorepoConfig;
229
+ updateStrategy?: UpdateStrategy;
230
+ }
231
+ type JSONSchema = Record<string, unknown>;
232
+ interface CompleteOptions {
233
+ maxTokens?: number;
234
+ temperature?: number;
235
+ timeout?: number;
236
+ schema?: JSONSchema;
237
+ toolName?: string;
238
+ }
239
+ type TemplateEngine = 'handlebars' | 'liquid' | 'ejs';
240
+ interface TemplateConfig {
241
+ path?: string;
242
+ engine?: TemplateEngine;
243
+ }
244
+ interface LLMConfig {
245
+ provider: 'openai' | 'openai-compatible' | 'anthropic' | 'ollama';
246
+ model: string;
247
+ baseURL?: string;
248
+ apiKey?: string;
249
+ options?: {
250
+ timeout?: number;
251
+ maxTokens?: number;
252
+ temperature?: number;
253
+ };
254
+ concurrency?: number;
255
+ retry?: RetryOptions;
256
+ tasks?: {
257
+ summarize?: boolean;
258
+ enhance?: boolean;
259
+ categorize?: boolean;
260
+ releaseNotes?: boolean;
261
+ };
262
+ context?: {
263
+ pullRequests?: boolean;
264
+ };
265
+ examples?: number;
266
+ categoryOrder?: string[];
267
+ cache?: boolean;
268
+ categories?: Array<{
269
+ name: string;
270
+ description: string;
271
+ scopes?: string[];
272
+ }>;
273
+ style?: string;
274
+ scopes?: ScopeConfig;
275
+ prompts?: {
276
+ instructions?: Record<string, string>;
277
+ };
278
+ }
279
+ type LocationMode = 'root' | 'packages' | 'both';
280
+ interface ChangelogConfig {
281
+ mode?: LocationMode;
282
+ file?: string;
283
+ templates?: TemplateConfig;
284
+ refs?: ChangelogRefsMode;
285
+ }
286
+ interface LinksConfig {
287
+ items?: Array<{
288
+ label: string;
289
+ url: string;
290
+ }>;
291
+ fromPRBodyMarker?: string;
292
+ title?: string;
293
+ }
294
+ interface ReleaseNotesFileConfig {
295
+ dir?: string;
296
+ }
297
+ interface FirstReleaseConfig {
298
+ /** Supports ${packageName} and ${version}. */
299
+ text?: string;
300
+ }
301
+ interface ReleaseNotesConfig {
302
+ file?: ReleaseNotesFileConfig;
303
+ templates?: TemplateConfig;
304
+ llm?: LLMConfig;
305
+ links?: LinksConfig;
306
+ firstRelease?: false | FirstReleaseConfig;
307
+ }
308
+
309
+ declare function loadConfig(projectDir?: string, configFile?: string): Config;
310
+ declare function getDefaultConfig(): Config;
311
+
312
+ declare function createTemplateContext(pkg: PackageChangelog): TemplateContext;
313
+ interface PipelineResult {
314
+ /** Per-package rendered markdown keyed by package name. */
315
+ packageNotes: Record<string, string>;
316
+ /** File paths that were written to disk. */
317
+ files: string[];
318
+ /** GitHub release notes content keyed by package name. */
319
+ releaseNotes?: Record<string, string>;
320
+ }
321
+ interface PipelineOptions {
322
+ /**
323
+ * Skip the LLM pass and the release-notes file write. Use during standing-PR update so the
324
+ * standing-PR workflow doesn't depend on LLM availability and doesn't pay for
325
+ * an LLM call on every push to main.
326
+ */
327
+ skipReleaseNotes?: boolean;
328
+ /** Use during publish from manifest to regenerate only the release notes against an already-bumped tree. */
329
+ skipChangelogs?: boolean;
330
+ }
331
+ declare function runPipeline(input: ChangelogInput, config: Config, dryRun: boolean, pipelineOptions?: PipelineOptions): Promise<PipelineResult>;
332
+ declare function processInput(inputJson: string, config: Config, dryRun: boolean, pipelineOptions?: PipelineOptions): Promise<PipelineResult>;
333
+
334
+ declare abstract class NotesError extends ReleaseKitError {
335
+ }
336
+ declare class InputParseError extends NotesError {
337
+ readonly code = "INPUT_PARSE_ERROR";
338
+ readonly suggestions: string[];
339
+ }
340
+ declare class TemplateError extends NotesError {
341
+ readonly code = "TEMPLATE_ERROR";
342
+ readonly suggestions: string[];
343
+ }
344
+ declare class LLMError extends NotesError {
345
+ readonly code = "LLM_ERROR";
346
+ readonly suggestions: string[];
347
+ /** `undefined` means "unclassified" - callers retry by default. */
348
+ readonly retryable?: boolean;
349
+ constructor(message: string, options?: {
350
+ retryable?: boolean;
351
+ cause?: unknown;
352
+ });
353
+ }
354
+ declare class GitHubError extends NotesError {
355
+ readonly code = "GITHUB_ERROR";
356
+ readonly suggestions: string[];
357
+ }
358
+ declare class ConfigError extends NotesError {
359
+ readonly code = "CONFIG_ERROR";
360
+ readonly suggestions: string[];
361
+ }
362
+ declare function getExitCode(error: NotesError): number;
363
+
364
+ declare function versionOutputToChangelogInput(data: VersionOutput): ChangelogInput;
365
+ declare function parseVersionOutput(json: string): ChangelogInput;
366
+ declare function parseVersionOutputFile(filePath: string): ChangelogInput;
367
+ declare function parseVersionOutputStdin(): Promise<ChangelogInput>;
368
+
369
+ interface MonorepoOptions {
370
+ rootPath: string;
371
+ packagesPath: string;
372
+ mode: 'root' | 'packages' | 'both';
373
+ fileName?: string;
374
+ }
375
+ declare function aggregateToRoot(contexts: TemplateContext[]): TemplateContext;
376
+ declare function writeMonorepoChangelogs(contexts: TemplateContext[], options: MonorepoOptions, config: {
377
+ updateStrategy?: 'prepend' | 'regenerate';
378
+ }, dryRun: boolean, refs?: ChangelogRefsMode): string[];
379
+ declare function detectMonorepo(cwd: string): {
380
+ isMonorepo: boolean;
381
+ packagesPath: string;
382
+ };
383
+
384
+ declare function renderJson(contexts: TemplateContext[]): string;
385
+ declare function writeJson(outputPath: string, contexts: TemplateContext[], dryRun: boolean): void;
386
+
387
+ interface FormatVersionOptions {
388
+ includePackageName?: boolean;
389
+ /** Order to render LLM-categorised sections. */
390
+ categoryOrder?: string[];
391
+ links?: LinksConfig;
392
+ firstRelease?: FirstReleaseConfig | false;
393
+ refs?: ChangelogRefsMode;
394
+ }
395
+ declare function formatVersion(context: TemplateContext, options?: FormatVersionOptions): string;
396
+ declare function renderMarkdown(contexts: TemplateContext[], options?: FormatVersionOptions): string;
397
+ declare function writeMarkdown(outputPath: string, contexts: TemplateContext[], config: Config, dryRun: boolean, options?: FormatVersionOptions): void;
398
+
399
+ export { ConfigError, GitHubError, InputParseError, LLMError, NotesError, TemplateError, aggregateToRoot, createTemplateContext, detectMonorepo, formatVersion, getDefaultConfig, getExitCode, loadAuth, loadConfig, parseVersionOutput, parseVersionOutputFile, parseVersionOutputStdin, processInput, renderJson, renderMarkdown, runPipeline, saveAuth, versionOutputToChangelogInput, writeJson, writeMarkdown, writeMonorepoChangelogs };
400
+ export type { ChangelogConfig, ChangelogEntry, ChangelogInput, ChangelogType, CompleteOptions, Config, DocumentContext, EnhancedCategory, EnhancedData, FirstReleaseConfig, InputSource, JSONSchema, LLMCategory, LLMConfig, LLMOptions, LLMPromptOverrides, LLMPromptsConfig, LinksConfig, LocationMode, PRContext, PackageChangelog, PipelineOptions, PipelineResult, ReleaseNotesConfig, ReleaseNotesFileConfig, RetryOptions, ScopeConfig, ScopeRules, TemplateConfig, TemplateContext, TemplateEngine, UpdateStrategy };
package/dist/index.js CHANGED
@@ -18,12 +18,12 @@ import {
18
18
  runPipeline,
19
19
  saveAuth,
20
20
  versionOutputToChangelogInput
21
- } from "./chunk-2PRVRNSI.js";
21
+ } from "./chunk-OTH3XXI4.js";
22
22
  import {
23
23
  aggregateToRoot,
24
24
  detectMonorepo,
25
25
  writeMonorepoChangelogs
26
- } from "./chunk-YO6KWOCB.js";
26
+ } from "./chunk-KQQPQQSS.js";
27
27
  import {
28
28
  debug,
29
29
  formatVersion,
@@ -31,7 +31,7 @@ import {
31
31
  renderMarkdown,
32
32
  success,
33
33
  writeMarkdown
34
- } from "./chunk-FI3F2ND5.js";
34
+ } from "./chunk-CBMVDKDR.js";
35
35
 
36
36
  // src/output/json.ts
37
37
  import * as fs from "fs";
@@ -233,7 +233,7 @@ How existing changelog files are updated when new entries are generated.
233
233
 
234
234
  | Option | Type | Default | Description |
235
235
  |--------|------|---------|-------------|
236
- | `timeout` | `integer` (ms) | `60000` | Request timeout |
236
+ | `timeout` | `integer` (ms) | `60000` | Idle timeout: a streamed response fails only when nothing arrives for this long |
237
237
  | `maxTokens` | `integer` | `16384` | Maximum tokens to generate |
238
238
  | `temperature` | `number` | `0.7` | Sampling temperature (0–2) |
239
239
 
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@releasekit/notes",
3
- "version": "0.41.2",
3
+ "version": "0.42.1",
4
4
  "description": "Release notes and changelog generation with LLM-powered enhancement and flexible templating",
5
5
  "type": "module",
6
6
  "module": "./dist/index.js",
@@ -47,35 +47,35 @@
47
47
  "access": "public"
48
48
  },
49
49
  "dependencies": {
50
- "@anthropic-ai/sdk": "^0.112.4",
50
+ "@anthropic-ai/sdk": "^1.0.0",
51
51
  "@octokit/rest": "^22.0.1",
52
- "chalk": "^5.6.2",
53
- "commander": "^14.0.3",
54
- "ejs": "^4.0.1",
55
- "handlebars": "^4.7.9",
52
+ "chalk": "^6.0.1",
53
+ "commander": "^15.0.0",
54
+ "ejs": "^7.0.2",
55
+ "handlebars": "^4.7.10",
56
56
  "jsonc-parser": "^3.3.1",
57
- "liquidjs": "^10.27.2",
58
- "minimatch": "^10.0.0",
59
- "openai": "^6.48.0",
60
- "smol-toml": "^1.7.0",
61
- "yaml": "^2.9.0",
62
- "zod": "^4.4.3"
57
+ "liquidjs": "^10.30.0",
58
+ "minimatch": "^10.2.6",
59
+ "openai": "^7.41.0",
60
+ "smol-toml": "^1.9.0",
61
+ "yaml": "^2.9.1",
62
+ "zod": "^4.6.7"
63
63
  },
64
64
  "devDependencies": {
65
- "@biomejs/biome": "^2.5.4",
66
- "@types/ejs": "^3.1.5",
67
- "@types/node": "^22.20.1",
68
- "@vitest/coverage-v8": "^4.1.10",
69
- "tsup": "^8.5.1",
70
- "typescript": "^5.9.3",
71
- "vitest": "^4.1.10",
65
+ "@biomejs/biome": "^2.6.2",
72
66
  "@releasekit/config": "0.0.0",
73
- "@releasekit/forge": "0.0.0",
74
67
  "@releasekit/core": "0.0.0",
75
- "@releasekit/git": "0.0.0"
68
+ "@releasekit/forge": "0.0.0",
69
+ "@releasekit/git": "0.0.0",
70
+ "@types/ejs": "^3.1.5",
71
+ "@types/node": "^26.6.5",
72
+ "@vitest/coverage-v8": "^5.0.5",
73
+ "tsup": "^9.0.0",
74
+ "typescript": "^6.0.3",
75
+ "vitest": "^5.0.5"
76
76
  },
77
77
  "engines": {
78
- "node": ">=22"
78
+ "node": ">=22.12"
79
79
  },
80
80
  "scripts": {
81
81
  "build": "tsup",
@@ -1,2 +1,2 @@
1
- - {{#if scope}}**{{scope}}**: {{/if}}{{description}}{{#if issueIds}} ({{join issueIds ", "}}){{/if}}
1
+ - {{#if breaking}}**BREAKING** {{/if}}{{#if scope}}**{{scope}}**: {{/if}}{{description}}{{#if issueIds}} ({{join issueIds ", "}}){{/if}}
2
2
 
@@ -8,7 +8,7 @@
8
8
  <% } else { %>
9
9
  <% if (version.entries.length > 0) { %>
10
10
  <% version.entries.forEach(function(entry) { %>
11
- - <% if (entry.scope) { %>**<%= entry.scope %>**: <% } %><%= entry.description %><% if (entry.issueIds) { %> (<%= entry.issueIds.join(', ') %>)<% } %>
11
+ - <% if (entry.breaking) { %>**BREAKING** <% } %><% if (entry.scope) { %>**<%= entry.scope %>**: <% } %><%= entry.description %><% if (entry.issueIds) { %> (<%= entry.issueIds.join(', ') %>)<% } %>
12
12
 
13
13
  <% }); %>
14
14
  <% } %>
@@ -1,2 +1,2 @@
1
- - {% if entry.scope %}**{{ entry.scope }}**: {% endif %}{{ entry.description }}{% if entry.issueIds %} ({{ entry.issueIds | join: ", " }}){% endif %}
1
+ - {% if entry.breaking %}**BREAKING** {% endif %}{% if entry.scope %}**{{ entry.scope }}**: {% endif %}{{ entry.description }}{% if entry.issueIds %} ({{ entry.issueIds | join: ", " }}){% endif %}
2
2
 
@@ -13,42 +13,42 @@
13
13
  {% if added.size > 0 %}
14
14
  ### Added
15
15
  {% for entry in added %}
16
- - {% if entry.scope %}**{{ entry.scope }}**: {% endif %}{{ entry.description }}{% if entry.issueIds %} ({{ entry.issueIds | join: ", " }}){% endif %}
16
+ - {% if entry.breaking %}**BREAKING** {% endif %}{% if entry.scope %}**{{ entry.scope }}**: {% endif %}{{ entry.description }}{% if entry.issueIds %} ({{ entry.issueIds | join: ", " }}){% endif %}
17
17
 
18
18
  {% endfor %}
19
19
  {% endif %}
20
20
  {% if changed.size > 0 %}
21
21
  ### Changed
22
22
  {% for entry in changed %}
23
- - {% if entry.scope %}**{{ entry.scope }}**: {% endif %}{{ entry.description }}{% if entry.issueIds %} ({{ entry.issueIds | join: ", " }}){% endif %}
23
+ - {% if entry.breaking %}**BREAKING** {% endif %}{% if entry.scope %}**{{ entry.scope }}**: {% endif %}{{ entry.description }}{% if entry.issueIds %} ({{ entry.issueIds | join: ", " }}){% endif %}
24
24
 
25
25
  {% endfor %}
26
26
  {% endif %}
27
27
  {% if deprecated.size > 0 %}
28
28
  ### Deprecated
29
29
  {% for entry in deprecated %}
30
- - {% if entry.scope %}**{{ entry.scope }}**: {% endif %}{{ entry.description }}{% if entry.issueIds %} ({{ entry.issueIds | join: ", " }}){% endif %}
30
+ - {% if entry.breaking %}**BREAKING** {% endif %}{% if entry.scope %}**{{ entry.scope }}**: {% endif %}{{ entry.description }}{% if entry.issueIds %} ({{ entry.issueIds | join: ", " }}){% endif %}
31
31
 
32
32
  {% endfor %}
33
33
  {% endif %}
34
34
  {% if removed.size > 0 %}
35
35
  ### Removed
36
36
  {% for entry in removed %}
37
- - {% if entry.scope %}**{{ entry.scope }}**: {% endif %}{{ entry.description }}{% if entry.issueIds %} ({{ entry.issueIds | join: ", " }}){% endif %}
37
+ - {% if entry.breaking %}**BREAKING** {% endif %}{% if entry.scope %}**{{ entry.scope }}**: {% endif %}{{ entry.description }}{% if entry.issueIds %} ({{ entry.issueIds | join: ", " }}){% endif %}
38
38
 
39
39
  {% endfor %}
40
40
  {% endif %}
41
41
  {% if fixed.size > 0 %}
42
42
  ### Fixed
43
43
  {% for entry in fixed %}
44
- - {% if entry.scope %}**{{ entry.scope }}**: {% endif %}{{ entry.description }}{% if entry.issueIds %} ({{ entry.issueIds | join: ", " }}){% endif %}
44
+ - {% if entry.breaking %}**BREAKING** {% endif %}{% if entry.scope %}**{{ entry.scope }}**: {% endif %}{{ entry.description }}{% if entry.issueIds %} ({{ entry.issueIds | join: ", " }}){% endif %}
45
45
 
46
46
  {% endfor %}
47
47
  {% endif %}
48
48
  {% if security.size > 0 %}
49
49
  ### Security
50
50
  {% for entry in security %}
51
- - {% if entry.scope %}**{{ entry.scope }}**: {% endif %}{{ entry.description }}{% if entry.issueIds %} ({{ entry.issueIds | join: ", " }}){% endif %}
51
+ - {% if entry.breaking %}**BREAKING** {% endif %}{% if entry.scope %}**{{ entry.scope }}**: {% endif %}{{ entry.description }}{% if entry.issueIds %} ({{ entry.issueIds | join: ", " }}){% endif %}
52
52
 
53
53
  {% endfor %}
54
54
  {% endif %}