@preventive/compare 1.2.1 → 1.2.2

package/compare.d.ts

@@ -42,12 +42,15 @@ export type Status = 'added' | 'deleted' | 'modified' | 'renamed' | 'type-change
 // retained module load or `export {}` runs the same on both sides only within
 // one module format -- an `export {}` emits a marker transpiled to CommonJS, a
 // module load runs as one format and throws as the other -- so where the runtime
-// loads a module or carries a bare `export {}` a rename across formats (a `.d.mts`
-// to a `.d.cts`, either to a package-resolved `.d.ts` whose format is not known
-// here) is not stamped; a hashbang, a directive or a pragma runs the same either
+// loads a module, carries a bare `export {}`, or default-exports an identifier a
+// rename whose extensions fix different formats (a `.d.mts` to a `.d.cts`, or a
+// `.d.ts` to or from either) is not stamped, while a rename between two of the same
+// extension (two `.d.ts`, two `.d.mts`, two `.d.cts`) is; a hashbang, a directive or a pragma runs the same either
 // way, so a runtime of only those cancels across formats. A modification keeps its
-// path, hence its format, and an added or deleted file matches only an empty
-// runtime. A rename is otherwise taken by its matching
+// path, hence its format, and a deleted file matches only an empty runtime; an
+// added one an empty runtime or a single bare `export {}`, as nothing loaded it
+// before and what now does runs nothing of that alone, as a module or not. A
+// rename is otherwise taken by its matching
 // source, as any file's is here: a relative load may resolve to another module
 // once the file moves, but that is shown as a rename of its own, not traced. A
 // modification of a package-resolved `.d.ts` is taken to keep its format, though
@@ -217,12 +220,15 @@ export type TypeOnlyReason = 'unsupported' | 'unparsed' | 'code' | 'disagree'
 //   function's signature, `import type` and `export type`, a namespace of types
 //   alone -- and those it leaves to run: a module load that binds from it
 //   (`import`, `export *`, `export { a } from` a module, `import { type A }` whose
-//   inline `type` loads it all the same) and a bare `export {}`. `export { type A }`
+//   inline `type` loads it all the same), a bare `export {}`, and `export default E`
+//   on a bare identifier (the idiom a declaration file's default export takes,
+//   `declare const _d: T; export default _d`). `export { type A }`
 //   is code, not a run statement: it is `export {}` only once stripping takes its
 //   specifiers out, not as the source has it; nor is `export as namespace N`, left
 //   as invalid JavaScript that throws when imported, nor a side-effect load that
 //   binds nothing -- a bare `import`, an empty `import {}`, `export {}` with a
-//   source -- which loads a module for no type;
+//   source -- which loads a module for no type, nor an `export default` of anything
+//   but a bare identifier (a value expression, an object, a class body);
 // - Node's stripTypeScriptTypes erases, to the character, what oxc finds erased
 //   and leaves nothing it does not, but comments, the hashbang and those;
 // - what it leaves, the run statements set aside, read token by token apart from
@@ -244,7 +250,7 @@ export type TypeOnlyReason = 'unsupported' | 'unparsed' | 'code' | 'disagree'
 // point. A triple-slash directive counts only in the prologue,
 // before the first statement, where TypeScript honours it; below one it is prose, so moving
 // it out of the prologue drops it from `runtime`, as removing it does. `loads` is whether any
-// run statement is a module load or a bare `export {}`: the runtime that runs as one module
+// run statement is a module load, a bare `export {}`, or an `export default` on an identifier: the runtime that runs as one module
 // format and throws, or emits a different marker, as the other -- a hashbang, directive or
 // pragma does not. A change is types only where both sides prove and leave the same `runtime`:
 // it then touches erased types and ordinary comments alone. Where `loads`, a rename across

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@preventive/compare",
-  "version": "1.2.1",
+  "version": "1.2.2",
   "description": "Git-compatible file tree diffs and minified JavaScript comparison",
   "type": "module",
   "main": "./compare.js",

package/pretty.d.ts

@@ -1,7 +1,8 @@
 // `text` formatted by oxfmt as a file with `extension`, changing what is written
-// no more than layout needs (keys keep their quotes, no trailing commas or arrow
-// parentheses are added, template literals stay), the copy used only where checks
-// of oxfmt's output, apart from oxfmt, find it changes the layout alone:
+// no more than layout needs (keys keep their quotes, names their escapes, a comment
+// its place after an operator; no trailing commas or arrow parentheses are added,
+// template literals stay), the copy used only where checks of oxfmt's output, apart
+// from oxfmt, find it changes the layout alone:
 // - a script's (`js`, `mjs`, `cjs`, `jsx`, `ts`, `mts`, `cts`, `tsx`) syntax tree as
 //   oxc parses it, its comments and its text;
 // - a style sheet's (`css`) tree as css-tree, an optional peer, parses it, but for

package/src/changes.js

@@ -54,9 +54,13 @@ const DECLARATION = /\.d\.(?:[^./]+\.)?[cm]?ts$/u
 // a change across them is not types only.
 const fixedModule = (path) => (path.endsWith('.mts') ? 'module' : path.endsWith('.cts') ? 'commonjs' : null)
 
+// A runtime of a single bare `export {}`, any trailing `;`, as proveTypeOnly spells one: its blanks as the
+// source has them, a comment within it a single blank.
+const EXPORT_EMPTY = /^export\s*\{\s*\}\s*;?$/u
+
 // A file's proof: that it holds types alone but for its `runtime` -- a hashbang, the module loads and
 // `export {}` stripping leaves -- which a change must leave byte for byte untouched to be types only.
-// `loads` is whether that runtime holds a module load or `export {}`, the part that runs differently per
+// `loads` is whether that runtime holds a module load, `export {}`, or an `export default` on an identifier, the part that runs differently per
 // module format; a hashbang, a directive or a pragma does not, so a runtime of only those is format-free. A
 // side not there has none. Not proven where the proof throws, as no check should.
 function proven(file) {
@@ -71,28 +75,32 @@ function proven(file) {
 
 // Stamped where each side there is a declaration file proven to hold types alone and the two leave the
 // same runtime -- a change touching only erased types (and comments). A mode changing is a change of its
-// own. Where that runtime loads a module or carries a bare `export {}` it runs the same on both sides only
-// within one module format, so a rename across formats (a `.d.mts` to a `.d.cts`, either to a
-// package-resolved `.d.ts`) does not qualify; a hashbang, a directive or a pragma runs the same either way,
+// own. Where that runtime loads a module, carries a bare `export {}`, or default-exports an identifier it runs
+// the same on both sides only within one module format, so a rename cancels it only between two extensions
+// that fix the same format -- two `.d.ts` (both package-resolved), two `.d.mts`, or two `.d.cts`; a rename
+// whose extensions differ (a `.d.mts` to a `.d.cts`, or a `.d.ts` to or from either) does not qualify, since
+// an extension pins a format where a package-resolved `.d.ts` leaves it open. A hashbang, a directive or a pragma runs the same either way,
 // so a runtime of only those cancels across formats. A modification keeps its path, hence its format, and
-// an added or deleted file matches only an empty one.
+// a deleted file matches only an empty runtime; an added one an empty runtime or a single bare `export {}`
+// (EXPORT_EMPTY). Nothing loaded an added file before, so only what else the diff changes can, shown as a
+// change of its own, and that loading runs nothing of a bare `export {}` alone: it runs nothing as a module
+// and throws on it as CommonJS, whatever the extension. A module load beside it would run another module.
 // A rename is taken by its matching source, as any file's is here: a relative load in the runtime may
 // resolve to another module once the file moves, but that is the rename's doing, shown as a rename of its
-// own, not traced. Known limitation: a modification of a package-resolved `.d.ts` is taken to keep its
-// format, though the `package.json` that resolves it could change `type` between the two trees and flip it;
-// that flip is a change to `package.json`, seen in the diff on its own, and format is read from the
-// extension here, not resolved from a package.
+// own, not traced. Known limitation: a package-resolved `.d.ts` is taken to keep its format across a
+// modification (same path) and to share one across a rename to another `.d.ts`, since format is read from
+// the extension, not resolved from a package. The governing `package.json` could differ -- edited between
+// the two trees, or a different one at the rename's destination -- and flip the format; that flip rides the
+// `package.json` change or the move, each seen in the diff on its own, and is not traced here.
 
 function stamped(change) {
   const sides = [change.old, change.new].filter((file) => file !== null)
   if (!sides.every((file) => file.type === 'file' && DECLARATION.test(file.path))) return change
   if (change.old && change.new && change.old.mode !== change.new.mode) return change
   const fresh = proven(change.new), old = proven(change.old)
-  if (!old.proven || !fresh.proven || old.runtime !== fresh.runtime) return change
-  if (old.loads && change.old && change.new && change.old.path !== change.new.path) {
-    const format = fixedModule(change.old.path)
-    if (format === null || format !== fixedModule(change.new.path)) return change
-  }
+  if (!old.proven || !fresh.proven) return change
+  if (old.runtime !== fresh.runtime && !(change.old === null && EXPORT_EMPTY.test(fresh.runtime))) return change
+  if (old.loads && change.old && change.new && change.old.path !== change.new.path && fixedModule(change.old.path) !== fixedModule(change.new.path)) return change
   return { ...change, typeOnly: true }
 }
 

package/src/erasure.js

@@ -72,7 +72,13 @@ export function strippedAs(statement) {
       // load; `export { a } from` a module re-exports a binding. A bare `export {}`, no source, is a marker.
       if (statement.source) return bindingless(statement) ? CODE : IMPORT
       return statement.specifiers.length === 0 ? INERT : CODE
-    case 'ExportDefaultDeclaration': return statement.declaration.type === 'TSInterfaceDeclaration' || statement.declaration.type === 'TSDeclareFunction' ? ERASED : CODE
+    case 'ExportDefaultDeclaration':
+      if (statement.declaration.type === 'TSInterfaceDeclaration' || statement.declaration.type === 'TSDeclareFunction') return ERASED
+      // `export default E`, a bare identifier, re-exports a binding by name: a run statement that runs as an
+      // ES module and throws as CommonJS, like `export {}`, so it is inert here, not code -- it is the idiom a
+      // declaration file's default export takes (`declare const _d: T; export default _d`). Any other default,
+      // a value expression or a class body among it, is code a declaration file has no reason to hold.
+      return statement.declaration.type === 'Identifier' ? INERT : CODE
     // `export as namespace N` is left verbatim, invalid as JavaScript, so importing the file throws.
     case 'TSNamespaceExportDeclaration': return CODE
     default: return erased(statement) ? ERASED : CODE

package/src/pretty.js

@@ -29,11 +29,11 @@ function numberSpelling(text) {
 
 const sorted = (flags) => [...flags].toSorted().join('')
 // A script's text but for what the formatter may respell, beside the syntax tree compared after:
-// blanks, parentheses, semicolons, quotes, numbers and a regular expression's flags, and a comma before
-// a closing bracket, past any comments (`import { a, b, }`).
+// blanks, parentheses, semicolons, quotes and numbers, and a comma before a closing bracket, past any
+// comments (`import { a, b, }`). A regular expression's flags it may reorder are sorted where the
+// syntax tree has them (respelled).
 const scriptForm = (text) => text.replaceAll(NUMBER, numberSpelling).replaceAll(/,(?=(?:\s|\/\/[^\n]*|\/\*[^]*?\*\/)*[\])}>])/gu, '')
   .replaceAll(/\\(?=["'])|[\s();]/gu, '').replaceAll("'", '"')
-  .replaceAll(/(?<=\/)[dgimsuvy]{2,}(?![\p{L}\p{N}_$])/gu, sorted)
 
 // JSON has no point without a digit either side: such a number is kept as written, or a copy would read as
 // valid, as would one with other blanks than JSON's four, which stay.
@@ -84,32 +84,48 @@ function sameTree(a, b) {
   return true
 }
 
-// A script's types as the formatter writes them: a member's separator `;` where it was `,`
-// (`{ a: string, b: number }`), and no `|` or `&` before a union's or an intersection's first type
-// (`type P =\n  | A\n  | B`, `[K in\n  | A\n  | B]`). oxc reads a member with the separator ending it
-// and a union from the mark leading it, so each is taken where it is, in whatever context.
-function typed(text, program) {
-  const edits = [], work = [program]
+// Each node of a syntax tree given to `each`.
+function visit(program, each) {
+  const work = [program]
   while (work.length > 0) {
     const node = work.pop()
     // Pushed one by one: a spread of a file's statements could pass more arguments than a call takes.
     if (Array.isArray(node)) for (const item of node) work.push(item)
     else if (node !== null && typeof node === 'object') {
-      const members = node.type === 'TSTypeLiteral' ? node.members : node.type === 'TSInterfaceBody' ? node.body : []
-      for (const member of members) if (text[member.end - 1] === ',') edits.push([member.end - 1, ';'])
-      const mark = node.type === 'TSUnionType' ? '|' : node.type === 'TSIntersectionType' ? '&' : null
-      if (mark && text[node.start] === mark && node.types[0]?.start > node.start) edits.push([node.start, ''])
+      each(node)
       for (const key of Object.keys(node)) if (!POSITION.has(key) && typeof node[key] === 'object') work.push(node[key])
     }
   }
+}
+
+// `text` with each of `edits`, `[from, to, put]`, none overlapping another.
+function edited(text, edits) {
   let from = 0, out = ''
-  for (const [at, put] of edits.toSorted(([x], [y]) => x - y)) {
-    out += text.slice(from, at) + put
-    from = at + 1
+  for (const [start, end, put] of edits.toSorted(([x], [y]) => x - y)) {
+    out += text.slice(from, start) + put
+    from = end
   }
   return out + text.slice(from)
 }
 
+// A script as the formatter may write it, read off its syntax tree: each regular expression's flags
+// sorted (`/x/yu` as `/x/uy`), and where it has `types`, a member's separator `;` where it was `,`
+// (`{ a: string, b: number }`), and no `|` or `&` before a union's or an intersection's first type
+// (`type P =\n  | A\n  | B`, `[K in\n  | A\n  | B]`). oxc reads a member with the separator ending it
+// and a union from the mark leading it, so each is taken where it is, in whatever context.
+function respelled(text, program, types) {
+  const edits = []
+  visit(program, (node) => {
+    if (node.regex) edits.push([node.end - node.regex.flags.length, node.end, sorted(node.regex.flags)])
+    if (!types) return
+    const members = node.type === 'TSTypeLiteral' ? node.members : node.type === 'TSInterfaceBody' ? node.body : []
+    for (const member of members) if (text[member.end - 1] === ',') edits.push([member.end - 1, member.end, ';'])
+    const mark = node.type === 'TSUnionType' ? '|' : node.type === 'TSIntersectionType' ? '&' : null
+    if (mark && text[node.start] === mark && node.types[0]?.start > node.start) edits.push([node.start, node.start + 1, ''])
+  })
+  return edited(text, edits)
+}
+
 // A safeguard on oxfmt's own output, not a comparison of any two texts: exported
 // for tests alone, not by the package. CSS is read by `csstree` where given.
 export function sameCode(text, formatted, extension = 'js', csstree = null) {
@@ -118,10 +134,76 @@ export function sameCode(text, formatted, extension = 'js', csstree = null) {
   if (!SCRIPTS.has(extension)) return false
   const [before, after] = [parsed(text, extension), parsed(formatted, extension)]
   if (before === null || after === null) return false
-  const form = (code, { program }) => scriptForm(/^[cm]?tsx?$/u.test(extension) ? typed(code, program) : code)
+  const form = (code, { program }) => scriptForm(respelled(code, program, /^[cm]?tsx?$/u.test(extension)))
   return form(text, before) === form(formatted, after) && sameList(comments(before), comments(after)) && sameTree(before.program, after.program)
 }
 
+// A name as written from where it starts, escapes and all.
+const NAME = /(?:\\u\{[\dA-Fa-f]+\}|\\u[\dA-Fa-f]{4}|[$\p{ID_Continue}\u{200C}\u{200D}])+/uy
+// What oxfmt may write after a block comment the file has after it: an operator, `,`, `?` or `:`.
+const MOVED = /[\t ]*([!%&*+,\-/:<=>?^|~]+|in(?:stanceof)?(?![$\p{ID_Continue}]))/uy
+const MARK = /[!%&*+,\-/:<=>?^|~]/u
+const NAME_PART = /[$\p{ID_Continue}]/u
+
+// Each name of a syntax tree, `[where it starts, what it reads, as written]`, in order: a shorthand
+// property's key and value, one name, once.
+function names(text, program) {
+  const found = new Map()
+  visit(program, (node) => {
+    if (node.type !== 'Identifier' && node.type !== 'PrivateIdentifier') return
+    const at = node.type === 'Identifier' ? node.start : node.start + 1
+    NAME.lastIndex = at
+    found.set(at, [at, node.name, NAME.exec(text)?.[0] ?? ''])
+  })
+  return [...found.values()].toSorted(([x], [y]) => x - y)
+}
+
+// Where the blanks on its line before `at` start.
+function blanksFrom(text, at) {
+  let from = at
+  while (from > 0 && (text[from - 1] === ' ' || text[from - 1] === '\t')) from--
+  return from
+}
+
+// The copy as the file writes what oxfmt writes otherwise, where that changes no more than its layout,
+// before it is checked as any copy is:
+// - a name's escapes, which oxfmt reads (`\u{61}` as `a`): a copy shows no character the file only
+//   escapes, one unseen, a joiner in a name say, or one like another;
+// - a block comment after an operator, a `,`, `?` or `:`, which oxfmt moves before it where the comment
+//   ends its line (`a &&/* c */\nb` as `a /* c */ && b`): where a comment is may matter to what reads
+//   it, a bundler a `#__PURE__` mark say, and a reader sees it where the file has it.
+// Names and comments are paired in order, as the check finds them alike or refuses the copy.
+function asWritten(text, code, extension) {
+  if (!SCRIPTS.has(extension) || !/\\u|\/\*/u.test(text)) return code
+  const [before, after] = [parsed(text, extension), parsed(code, extension)]
+  if (before === null || after === null) return code
+  const edits = []
+  const [olds, news] = [names(text, before.program), names(code, after.program)]
+  if (olds.length === news.length) {
+    olds.forEach(([, name, written], i) => {
+      const [at, read, spelled] = news[i]
+      if (written !== spelled && written.includes('\\') && name === read) edits.push([at, at + spelled.length, written])
+    })
+  }
+  const [was, now] = [before.comments, after.comments]
+  for (let i = 0; was.length === now.length && i < now.length; i++) {
+    // A run of comments on one line moves as one.
+    const first = i
+    while (i + 1 < now.length && /^[\t ]*$/u.test(code.slice(now[i].end, now[i + 1].start))) i++
+    MOVED.lastIndex = now[i].end
+    const from = blanksFrom(code, now[first].start), moved = MOVED.exec(code)
+    if (moved === null || from === 0 || code[from - 1] === '\n') continue
+    const [, mark] = moved
+    // One the copy has before the comment too stayed, the one after another (`a + /* c */ +b`).
+    if (code.startsWith(mark, from - mark.length)) continue
+    const at = blanksFrom(text, was[first].start) - mark.length
+    if (at >= 0 && text.startsWith(mark, at) && !(mark.startsWith('i') ? NAME_PART : MARK).test(text[at - 1] ?? '')) {
+      edits.push([from, now[first].start, `${mark === ',' ? '' : ' '}${mark} `], [now[i].end, now[i].end + moved[0].length, ''])
+    }
+  }
+  return edited(code, edits)
+}
+
 // A script's block comments over more than one line, a license's say, each end their line: what oxfmt
 // leaves after one on its last line (`*/ class A {`) goes to the next, indented as the comment's first
 // line is. A comment holding a line break ends a line to the parser already (`return /*\n*/ 1` returns),
@@ -151,10 +233,12 @@ export async function format(text, extension) {
   const oxfmt = await loadFormatter()
   const result = await oxfmt(`pretty.${extension}`, text, PRETTY_OPTIONS).catch(() => null)
   if (result === null || result.errors.length > 0) return { error: 'unformattable' }
-  // A check that fails in itself, its stack say, refuses the copy as one that finds it changed would.
+  // oxfmt's copy as it is, or where the check refuses it, as the file writes what oxfmt respelled: a
+  // copy the check takes respelled nothing so, as its text would differ. A check that fails in itself,
+  // its stack say, refuses the copy as one that finds it changed would.
+  const checked = (code) => (sameCode(text, code, extension, csstree) ? { code } : null)
   try {
-    const code = breakAfterComments(result.code, extension)
-    return sameCode(text, code, extension, csstree) ? { code } : { error: 'pretty-mismatch' }
+    return checked(breakAfterComments(result.code, extension)) ?? checked(breakAfterComments(asWritten(text, result.code, extension), extension)) ?? { error: 'pretty-mismatch' }
   } catch {
     return { error: 'pretty-mismatch' }
   }

package/src/types.node.js

@@ -194,9 +194,9 @@ export function proveWith(text, stripTypeScriptTypes) {
   // type specifier or a comment within it does not count; the hashbang, a directive and a pragma stand
   // verbatim, since what they say is the point. A triple-slash directive counts only in the prologue, before
   // the first statement, where TypeScript honours it; a comment blanked within an erased statement reads as
-  // blanks here, so only a kept one steers. `loads` is whether any run statement is a module load or
-  // `export {}`, the runtime that runs differently per module format -- a hashbang, directive or pragma does
-  // not.
+  // blanks here, so only a kept one steers. `loads` is whether any run statement is a module load, a bare
+  // `export {}`, or an `export default` on an identifier, the runtime that runs differently per module format
+  // -- a hashbang, directive or pragma does not.
   const prologue = tree.program.body.length > 0 ? tree.program.body[0].start : stripped.code.length
   const hashbang = tree.program.hashbang ? [tree.program.hashbang] : []
   const steering = tree.comments.filter(({ start, end }) => steers(stripped.code.slice(start, end), start < prologue))