@absolutejs/changelog 0.6.0 → 0.7.1

package/dist/entries.d.ts

@@ -8,6 +8,18 @@ export type LoadedEntries = {
     entries: LoadedEntry[];
     problems: string[];
 };
+/**
+ * Whether the build is older than the source it was built from.
+ *
+ * The gate compares what is on disk against what was published, so a `dist`
+ * from yesterday reports yesterday's package. It cost an afternoon once: six
+ * exports reported as withdrawn from a package that had withdrawn nothing,
+ * because the build predated the source by a day.
+ *
+ * A warning rather than a failure -- a fresh checkout has every file at the
+ * same moment, and the publish path builds first anyway.
+ */
+export declare const buildIsStale: (packageRoot: string) => Promise<boolean>;
 /**
  * The public surface a build produced, read the way a consumer would.
  *

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 export { applyMigration, applyMigrations, type MigrationResult } from "./apply";
 export { change, manual, moved, renamed } from "./authoring";
-export { builtSurface, changelogPaths, loadUnreleased, readJsonFile, type LoadedEntries, type LoadedEntry, } from "./entries";
+export { buildIsStale, builtSurface, changelogPaths, loadUnreleased, readJsonFile, type LoadedEntries, type LoadedEntry, } from "./entries";
 export { changesBetween, disruptiveBetween, mechanicalMigrations, migrationsBetween, parseChangelog, releasesBetween, symbolsDisturbedBetween, validateChange, type ChangeAt, type ChangelogRead, type MigrationAt, } from "./read";
 export { describeReconciliation, reconcile, type Reconciliation, type Unannounced, } from "./reconcile";
 export { forgetRegistry, isPackageName, packageArchive, packageVersions, publishedChangelog, publishedSurface, type PackageVersions, type RegistryOptions, } from "./registry";

package/dist/index.js

@@ -324,7 +324,7 @@ var renamed = (input) => change({
   symbols: [input.from]
 });
 // src/entries.ts
-import { readdir, readFile } from "fs/promises";
+import { readdir, readFile, stat } from "fs/promises";
 import { join } from "path";
 import { pathToFileURL } from "url";
 
@@ -430,11 +430,11 @@ var readMigration = (value, where, problems) => {
       instruction,
       rename: { from: rename.from, to: rename.to }
     };
-  const { moved: moved2 } = value;
-  if (isRecord(moved2) && isText(moved2.symbol) && isText(moved2.from) && isText(moved2.to))
+  const { moved } = value;
+  if (isRecord(moved) && isText(moved.symbol) && isText(moved.from) && isText(moved.to))
     return {
       instruction,
-      moved: { from: moved2.from, symbol: moved2.symbol, to: moved2.to }
+      moved: { from: moved.from, symbol: moved.symbol, to: moved.to }
     };
   const { resubpath } = value;
   if (isRecord(resubpath) && isText(resubpath.from) && isText(resubpath.to))
@@ -527,12 +527,12 @@ var readRelease = (value, where, problems) => {
 };
 var validateChange = (value, where = "entry") => {
   const problems = [];
-  const change2 = readChange(value, where, problems);
-  if (change2 === undefined) {
+  const change = readChange(value, where, problems);
+  if (change === undefined) {
     const failed = { problems };
     return failed;
   }
-  const read = { change: change2 };
+  const read = { change };
   return read;
 };
 var parseChangelog = (value) => {
@@ -558,22 +558,22 @@ var parseChangelog = (value) => {
   };
 };
 var releasesBetween = (changelog, from, upto) => [...changelog.releases].filter((release) => compareVersions(release.version, from) > 0 && compareVersions(release.version, upto) <= 0).sort((left, right) => compareVersions(left.version, right.version));
-var changesBetween = (changelog, from, upto) => releasesBetween(changelog, from, upto).flatMap((release) => release.changes.map((change2) => {
-  const found = { change: change2, version: release.version };
+var changesBetween = (changelog, from, upto) => releasesBetween(changelog, from, upto).flatMap((release) => release.changes.map((change) => {
+  const found = { change, version: release.version };
   return found;
 }));
 var isDisruptiveAt = (found) => isDisruptive(found.change);
 var disruptiveBetween = (changelog, from, upto) => changesBetween(changelog, from, upto).filter(isDisruptiveAt);
 var mechanicalMigrations = (migrations) => migrations.filter((found) => isMechanical(found.migration));
-var migrationsBetween = (changelog, from, upto) => disruptiveBetween(changelog, from, upto).map(({ change: change2, version }) => {
+var migrationsBetween = (changelog, from, upto) => disruptiveBetween(changelog, from, upto).map(({ change, version }) => {
   const found = {
-    migration: change2.migration,
-    symbols: change2.symbols,
+    migration: change.migration,
+    symbols: change.symbols,
     version
   };
   return found;
 });
-var symbolsDisturbedBetween = (changelog, from, upto) => new Set(disruptiveBetween(changelog, from, upto).flatMap(({ change: change2 }) => change2.symbols));
+var symbolsDisturbedBetween = (changelog, from, upto) => new Set(disruptiveBetween(changelog, from, upto).flatMap(({ change }) => change.symbols));
 
 // src/surface.ts
 import path from "path";
@@ -634,6 +634,38 @@ var readTar = (archive, keep, limits = {}) => {
 var DECLARATION = /\.d\.[cm]?ts$/u;
 var parse2 = (source, name) => ts2.createSourceFile(name, source, ts2.ScriptTarget.Latest, true, ts2.ScriptKind.TS);
 var normalize = (text) => text.replace(/\s+/gu, " ").trim();
+var CLOSERS = new Set(["}", ")", "]", ">"]);
+var wordy = (token) => /^[\w$#@]/u.test(token) || /[\w$]$/u.test(token);
+var LAST2 = -1;
+var tokenText = (scanner, scanned, state) => {
+  const closesTemplate = scanned === ts2.SyntaxKind.CloseBraceToken && state.templates.at(LAST2) === state.depth;
+  const token = closesTemplate ? scanner.reScanTemplateToken(false) : scanned;
+  if (closesTemplate && token === ts2.SyntaxKind.TemplateTail)
+    state.templates.pop();
+  if (closesTemplate)
+    return scanner.getTokenText();
+  if (token === ts2.SyntaxKind.StringLiteral)
+    return JSON.stringify(scanner.getTokenValue());
+  if (token === ts2.SyntaxKind.TemplateHead)
+    state.templates.push(state.depth);
+  if (token === ts2.SyntaxKind.OpenBraceToken)
+    state.depth += 1;
+  if (token === ts2.SyntaxKind.CloseBraceToken)
+    state.depth -= 1;
+  return scanner.getTokenText();
+};
+var canonical = (text) => {
+  const scanner = ts2.createScanner(ts2.ScriptTarget.Latest, true, ts2.LanguageVariant.Standard, text);
+  const state = { depth: 0, templates: [] };
+  const tokens = [];
+  for (let token = scanner.scan();token !== ts2.SyntaxKind.EndOfFileToken; token = scanner.scan()) {
+    const value = tokenText(scanner, token, state);
+    if (CLOSERS.has(value) && tokens.at(LAST2) === ",")
+      tokens.pop();
+    tokens.push(value);
+  }
+  return tokens.reduce((joined, token, index) => index > 0 && wordy(tokens[index - 1] ?? "") && wordy(token) ? `${joined} ${token}` : `${joined}${token}`, "");
+};
 var resolveFrom = (files, from, specifier) => {
   if (!specifier.startsWith("."))
     return;
@@ -799,7 +831,7 @@ var SHAPE = {
   types: "types",
   unknown: "unknown"
 };
-var isStub = (declaration) => declaration.startsWith("export {");
+var isStub = (declaration) => /^export\s*\{/u.test(declaration);
 var signatureOf = (declaration) => {
   const file = parse2(`${declaration}
 `, "declaration.d.ts");
@@ -815,7 +847,7 @@ var parametersOf = (declaration) => {
   const found = [];
   const visit = (node) => {
     if (ts2.isFunctionTypeNode(node) || ts2.isFunctionDeclaration(node) || ts2.isMethodSignature(node) || ts2.isMethodDeclaration(node) || ts2.isConstructSignatureDeclaration(node) || ts2.isConstructorDeclaration(node))
-      found.push(node.parameters.map((parameter) => normalize(parameter.getText())).join(", "));
+      found.push(node.parameters.map((parameter) => canonical(parameter.getText())).join(", "));
     ts2.forEachChild(node, visit);
   };
   visit(statement);
@@ -835,12 +867,12 @@ var membersOf = (declaration) => {
   return members;
 };
 var sameNames = (left, right) => left.size === right.size && [...left].every((name) => right.has(name));
-var changeShape = (change2) => {
-  if (isStub(change2.before) !== isStub(change2.after))
+var changeShape = (change) => {
+  if (isStub(change.before) !== isStub(change.after))
     return SHAPE.unknown;
-  if (parametersOf(change2.before) !== parametersOf(change2.after))
+  if (parametersOf(change.before) !== parametersOf(change.after))
     return SHAPE.parameters;
-  if (!sameNames(membersOf(change2.before), membersOf(change2.after)))
+  if (!sameNames(membersOf(change.before), membersOf(change.after)))
     return SHAPE.members;
   return SHAPE.types;
 };
@@ -857,7 +889,7 @@ var diffSurface = (before, after) => {
     const lost = was.entries.filter((entry) => !now.entries.includes(entry));
     if (lost.length > 0)
       withdrawn.push({ from: lost, name });
-    if (now.declaration !== was.declaration)
+    if (canonical(now.declaration) !== canonical(was.declaration))
       changed.push({
         after: now.declaration,
         before: was.declaration,
@@ -875,12 +907,12 @@ var diffSurface = (before, after) => {
     withdrawn
   };
 };
-var notable = (diff) => diff.changed.filter((change2) => change2.shape === "parameters" || change2.shape === "members");
+var notable = (diff) => diff.changed.filter((change) => change.shape === "parameters" || change.shape === "members");
 
 // src/entries.ts
-var loadEntry = async (path2) => {
+var loadEntry = async (path) => {
   try {
-    const module = await import(pathToFileURL(path2).href);
+    const module = await import(pathToFileURL(path).href);
     const named = typeof module === "object" && module !== null && "change" in module ? module.change : undefined;
     const exported = named ?? (typeof module === "object" && module !== null && "default" in module ? module.default : undefined);
     const read = { exported };
@@ -895,6 +927,23 @@ var loadEntry = async (path2) => {
 var ENTRY = /\.[cm]?ts$/u;
 var DECLARATION2 = /\.d\.[cm]?ts$/u;
 var OUTPUT_DIRECTORIES = ["dist", "build", "lib", "types", "out"];
+var newestUnder = async (root) => {
+  const found = await readdir(root, { withFileTypes: true }).catch(() => []);
+  const times = await Promise.all(found.map(async (entry) => {
+    const path = join(root, entry.name);
+    if (entry.isDirectory())
+      return newestUnder(path);
+    return stat(path).then((stats) => stats.mtimeMs, () => 0);
+  }));
+  return Math.max(0, ...times);
+};
+var buildIsStale = async (packageRoot) => {
+  const [source, built] = await Promise.all([
+    newestUnder(join(packageRoot, "src")),
+    Promise.all(OUTPUT_DIRECTORIES.map((directory) => newestUnder(join(packageRoot, directory)))).then((times) => Math.max(0, ...times))
+  ]);
+  return source > 0 && built > 0 && source > built;
+};
 var builtSurface = async (packageRoot) => {
   const manifest = await readJsonFile(join(packageRoot, "package.json"));
   const files = new Map;
@@ -940,8 +989,8 @@ var loadUnreleased = async (packageRoot) => {
   }
   return { entries, problems };
 };
-var readJsonFile = async (path2) => {
-  const source = await readFile(path2, "utf8").catch(() => {
+var readJsonFile = async (path) => {
+  const source = await readFile(path, "utf8").catch(() => {
     return;
   });
   if (source === undefined)
@@ -959,39 +1008,39 @@ var strayEntries = async (packageRoot) => {
 };
 // src/reconcile.ts
 var migrationHolds = (input) => {
-  const { after, change: change2, subpaths } = input;
+  const { after, change, subpaths } = input;
   const wrong = [];
-  const { migration } = change2;
+  const { migration } = change;
   if ("rename" in migration) {
     const { from } = migration.rename;
     const into = migration.rename.to;
     if (!after.has(into))
-      wrong.push(`\`${change2.summary}\` renames to \`${into}\`, which this version does not export`);
+      wrong.push(`\`${change.summary}\` renames to \`${into}\`, which this version does not export`);
     if (after.has(from))
-      wrong.push(`\`${change2.summary}\` renames \`${from}\` away, but this version still exports it`);
-    if (!change2.symbols.includes(from))
-      wrong.push(`\`${change2.summary}\` renames \`${from}\`, which is not in its own symbols`);
+      wrong.push(`\`${change.summary}\` renames \`${from}\` away, but this version still exports it`);
+    if (!change.symbols.includes(from))
+      wrong.push(`\`${change.summary}\` renames \`${from}\`, which is not in its own symbols`);
   }
   if ("moved" in migration) {
     const { symbol } = migration.moved;
     const into = migration.moved.to;
     if (!after.has(symbol))
-      wrong.push(`\`${change2.summary}\` moves \`${symbol}\`, which this version does not export`);
+      wrong.push(`\`${change.summary}\` moves \`${symbol}\`, which this version does not export`);
     if (subpaths.size > 0 && !subpaths.has(into))
-      wrong.push(`\`${change2.summary}\` moves \`${symbol}\` to \`${into}\`, which is not an entry point of this package`);
+      wrong.push(`\`${change.summary}\` moves \`${symbol}\` to \`${into}\`, which is not an entry point of this package`);
   }
   if ("resubpath" in migration && subpaths.size > 0 && !subpaths.has(migration.resubpath.to))
-    wrong.push(`\`${change2.summary}\` points at \`${migration.resubpath.to}\`, which is not an entry point of this package`);
-  if (change2.kind === "removed") {
-    for (const symbol of change2.symbols)
+    wrong.push(`\`${change.summary}\` points at \`${migration.resubpath.to}\`, which is not an entry point of this package`);
+  if (change.kind === "removed") {
+    for (const symbol of change.symbols)
       if (after.has(symbol))
-        wrong.push(`\`${change2.summary}\` says \`${symbol}\` was removed, but this version still exports it`);
+        wrong.push(`\`${change.summary}\` says \`${symbol}\` was removed, but this version still exports it`);
   }
   return wrong;
 };
 var describeReconciliation = (found) => {
   const lines = [];
-  const moved2 = {
+  const moved = {
     members: "changed the members of its type",
     parameters: "changed what it is called with",
     removed: "is no longer exported",
@@ -999,27 +1048,27 @@ var describeReconciliation = (found) => {
     withdrawn: "is no longer exported from"
   };
   for (const entry of found.unannounced)
-    lines.push(entry.kind === "withdrawn" ? `\`${entry.name}\` ${moved2.withdrawn} ${(entry.from ?? []).join(", ")} and no entry says so` : `\`${entry.name}\` ${moved2[entry.kind]} and no entry says so`);
+    lines.push(entry.kind === "withdrawn" ? `\`${entry.name}\` ${moved.withdrawn} ${(entry.from ?? []).join(", ")} and no entry says so` : `\`${entry.name}\` ${moved[entry.kind]} and no entry says so`);
   for (const name of found.unknownSymbols)
     lines.push(`an entry names \`${name}\`, which this package does not export`);
   lines.push(...found.wrongMigrations);
   return lines;
 };
 var reconcile = (input) => {
-  const disruptive = new Set(input.changes.filter(isDisruptive).flatMap((change2) => [...change2.symbols]));
-  const mentioned = new Set(input.changes.flatMap((change2) => [...change2.symbols ?? []]));
+  const disruptive = new Set(input.changes.filter(isDisruptive).flatMap((change) => [...change.symbols]));
+  const mentioned = new Set(input.changes.flatMap((change) => [...change.symbols ?? []]));
   const unannounced = [
     ...input.diff.removed.filter((name) => !disruptive.has(name)).map((name) => ({ kind: "removed", name })),
     ...input.diff.withdrawn.filter((entry) => !disruptive.has(entry.name)).map((entry) => ({ from: entry.from, kind: "withdrawn", name: entry.name })),
-    ...input.diff.changed.filter((change2) => !mentioned.has(change2.name) && change2.shape !== "unknown").map((change2) => ({ kind: change2.shape, name: change2.name }))
+    ...input.diff.changed.filter((change) => !mentioned.has(change.name) && change.shape !== "unknown").map((change) => ({ kind: change.shape, name: change.name }))
   ];
   const unknownSymbols = [
-    ...new Set(input.changes.flatMap((change2) => [...change2.symbols ?? []]).filter((name) => !input.known.has(name)))
+    ...new Set(input.changes.flatMap((change) => [...change.symbols ?? []]).filter((name) => !input.known.has(name)))
   ];
   const { after } = input;
-  const wrongMigrations = after === undefined ? [] : input.changes.filter(isDisruptive).flatMap((change2) => migrationHolds({
+  const wrongMigrations = after === undefined ? [] : input.changes.filter(isDisruptive).flatMap((change) => migrationHolds({
     after,
-    change: change2,
+    change,
     subpaths: input.subpaths ?? new Set
   }));
   return { unannounced, unknownSymbols, wrongMigrations };
@@ -1118,7 +1167,7 @@ var publishedChangelog = async (name, version, options = {}) => {
   const archive = await packageArchive(name, version, options);
   if (!archive)
     return;
-  const file = readTar(archive, (path2) => path2 === CHANGELOG_FILE).get(CHANGELOG_FILE);
+  const file = readTar(archive, (path) => path === CHANGELOG_FILE).get(CHANGELOG_FILE);
   if (!file)
     return;
   try {
@@ -1161,19 +1210,19 @@ var migrationLine = (migration) => {
     return `Import from \`${migration.resubpath.to}\` instead of \`${migration.resubpath.from}\`.`;
   return migration.instruction;
 };
-var renderChange = (change2) => {
-  const symbols = change2.symbols && change2.symbols.length > 0 ? ` (${change2.symbols.map((name) => `\`${name}\``).join(", ")})` : "";
-  const lines = [`- **${change2.summary}**${symbols}`];
-  if (change2.detail !== undefined)
-    lines.push(`  ${change2.detail}`);
-  if (isDisruptive(change2)) {
-    lines.push(`  _Migration:_ ${change2.migration.instruction}`);
-    const mechanical = migrationLine(change2.migration);
-    if (mechanical !== change2.migration.instruction)
+var renderChange = (change) => {
+  const symbols = change.symbols && change.symbols.length > 0 ? ` (${change.symbols.map((name) => `\`${name}\``).join(", ")})` : "";
+  const lines = [`- **${change.summary}**${symbols}`];
+  if (change.detail !== undefined)
+    lines.push(`  ${change.detail}`);
+  if (isDisruptive(change)) {
+    lines.push(`  _Migration:_ ${change.migration.instruction}`);
+    const mechanical = migrationLine(change.migration);
+    if (mechanical !== change.migration.instruction)
       lines.push(`  _Applied automatically:_ ${mechanical}`);
   }
-  if (change2.reference !== undefined)
-    lines.push(`  See ${change2.reference}.`);
+  if (change.reference !== undefined)
+    lines.push(`  See ${change.reference}.`);
   return lines.join(`
 `);
 };
@@ -1200,13 +1249,13 @@ var renderChangelogJson = (changelog) => `${JSON.stringify({
   contract: CHANGELOG_CONTRACT,
   name: changelog.name,
   releases: [...changelog.releases].sort((left, right) => compareVersions(right.version, left.version)).map((release) => ({
-    changes: release.changes.map((change2) => ({
-      ...change2.detail === undefined ? {} : { detail: change2.detail },
-      kind: change2.kind,
-      ...isDisruptive(change2) ? { migration: change2.migration } : {},
-      ...change2.reference === undefined ? {} : { reference: change2.reference },
-      summary: change2.summary,
-      ...change2.symbols && change2.symbols.length > 0 ? { symbols: change2.symbols } : {}
+    changes: release.changes.map((change) => ({
+      ...change.detail === undefined ? {} : { detail: change.detail },
+      kind: change.kind,
+      ...isDisruptive(change) ? { migration: change.migration } : {},
+      ...change.reference === undefined ? {} : { reference: change.reference },
+      summary: change.summary,
+      ...change.symbols && change.symbols.length > 0 ? { symbols: change.symbols } : {}
     })),
     date: release.date,
     ...release.note === undefined ? {} : { note: release.note },
@@ -1246,6 +1295,7 @@ export {
   applyMigration,
   applyMigrations,
   asText,
+  buildIsStale,
   builtSurface,
   change,
   changeShape,
@@ -1289,5 +1339,5 @@ export {
   validateChange
 };
 
-//# debugId=C07818292D22AD6164756E2164756E21
+//# debugId=00D829A9B9D35BB264756E2164756E21
 //# sourceMappingURL=index.js.map