@preventive/compare 1.2.5 → 1.2.6

package/names.d.ts

@@ -21,12 +21,15 @@ export type RenameReason = 'unparsed' | 'dynamic' | 'jsx' | 'block-function' | '
 // The diff of two JavaScript files minified on both sides with renamed names
 // set aside. The old side is given the new side's names wherever a minifier
 // renamed a variable alike throughout (a declared variable's short ASCII name,
-// not a script's top level -- but where the file's other version is a module,
-// as a bundle's chunk is once it exports, the same file loaded alike -- a name
-// exported or imported as itself, or a shorthand property's), checked to bind
+// not a script's top level -- but where either version of the file is a module,
+// as a bundle's chunk is once it exports, or declares 16 names or more there,
+// every one short, as a minifier renames a script's top level only told that no
+// other script reads it: the same file loaded alike -- a name exported or
+// imported as itself, or a shorthand property's), checked to bind
 // every name as before by this package's scope analysis and again by oxc's
 // minifier; formatted again where that changes its layout alone and still binds
-// alike; diffed as diff -U0 has it; and the blocks checked to take `before` to
+// alike; diffed as diff -U0 has it, and as --minimal does where that is cheap
+// (lines by lines changed up to 2e8); and the blocks checked to take `before` to
 // the new side (thrown should they not). `reason` says why no names were given;
 // `reads` the properties either text reads names through (`name`, `toString`,
 // `stack`, `callee`, `caller`), sorted, as code reading its names may act

package/package.json

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

package/src/names/analyze.js

@@ -248,8 +248,18 @@ function resolved(program, s) {
   return { scopes: s.scopes, variables: s.variables, occurrences: deduplicated, globals, names, reads: s.reads, module: program.sourceType === 'module', commonjs: program.sourceType === 'commonjs', own }
 }
 
+const minified = (name) => name.length <= RENAMED_MAX_LENGTH && MINIFIED.test(name)
 // A short minified name, declared, and kept by no export, import or shorthand.
-const renamable = (variable) => variable.name.length <= RENAMED_MAX_LENGTH && MINIFIED.test(variable.name) && !variable.kept
+const renamable = (variable) => minified(variable.name) && !variable.kept
+
+// A script whose top level a minifier renamed: many names there, every one short.
+// A minifier renames a script's top level only told that no other script reads
+// it, as a bundle's chunk loaded as a module is; globals others read are few.
+const MANY_TOP_LEVEL = 16
+export function minifiedTopLevel(analysis) {
+  const top = analysis.variables.filter((variable) => variable.scope.parent === null)
+  return top.length >= MANY_TOP_LEVEL && top.every((variable) => minified(variable.name))
+}
 
 // A script's analysis with its top level its own, as a module's: renamable there
 // too. Still read as a script, `this` and all, but no global of it set aside.

package/src/names/diff.js

@@ -1,12 +1,12 @@
 // A diff of a file minified on both sides with renamed names set aside: the
 // old side renamed, formatted again where that changes its layout alone and
-// still binds alike, diffed, and the diff checked to hide no change.
+// still binds alike, diffed at its shortest where affordable, and the diff
+// checked to hide no change.
 
-import { changeSet } from '@preventive/diff'
 import { blocksHold } from '../blocks.js'
 import { markedBlocks } from '../marked.js'
 import { format } from '../pretty.js'
-import { checkLineOptions } from '../text.js'
+import { checkLineOptions, shortestChangeSet } from '../text.js'
 import { bindsAlike } from './binds.js'
 import { renameMap } from './rename.js'
 
@@ -30,7 +30,7 @@ export async function renamedDiffs(before, after, { extension = 'js', otherExten
   }
   let unmarked = false
   const diffs = settings.map((options) => {
-    const blocks = changeSet(renamed, after, options).map(ranges)
+    const blocks = shortestChangeSet(renamed, after, options).map(ranges)
     if (!blocksHold(renamed, after, blocks, options)) throw new Error('change blocks that do not take the old side to the new')
     // Read off the renamed text before formatting, line for line the old side's.
     const marks = mapped.reason ? [] : markedBlocks(before, mapped.text, after, options)

package/src/names/pairing.js

@@ -2,24 +2,14 @@
 // their keys (names set aside) pairs them, counts its variables as standing for
 // each other, and two each the other's most counted pair, a tie pairing neither.
 
-import { changeSet } from '@preventive/diff'
+import { shortestChangeSet } from '../text.js'
 import { RESERVED } from './syntax.js'
 
 // Unchanged lines between changes that pair as unchanged ones, not as changed.
 const ANCHORED_RUN = 3
 
 // Whitespace alone never tells a name apart.
-const changes = (a, b, minimal = false) => changeSet(a, b, { horizon: 0, whitespace: 'all', minimal })
-
-// The search's cutoff can face a run with lines alike far from its own: old code
-// that a block of new code now comes before, its lines faced with that block's
-// braces. The shortest diff instead, where its cost, lines by lines changed, allows.
-const MINIMAL_COST = 2e8
-function linedUp(a, b, lines) {
-  const quick = changes(a, b)
-  const changed = quick.reduce((n, { a0, a1, b0, b1 }) => n + a1 - a0 + b1 - b0, 0)
-  return lines * changed > MINIMAL_COST ? quick : changes(a, b, true)
-}
+const KEYS = { horizon: 0, whitespace: 'all' }
 
 // A text's lines with its renamable variables' names set aside (`key`), but
 // those `written` names (a pair found), each line's variables set aside in
@@ -79,7 +69,7 @@ const reading = (k, from = 0) => (x, y) => {
 // The pairs of lines a diff of `a` and `b` keeps, each told whether slack.
 function* kept(a, b, sameA, sameB) {
   const text = (lines) => lines.map((line) => `${line}\n`).join('')
-  const blocks = linedUp(text(a), text(b), a.length + b.length)
+  const blocks = shortestChangeSet(text(a), text(b), KEYS, a.length + b.length)
   const [looseA, looseB] = slack(a, b, blocks, sameA, sameB)
   let i = 0, j = 0
   for (const { a0, a1, b1 } of [...blocks, { a0: a.length, a1: a.length, b1: b.length }]) {
@@ -174,7 +164,7 @@ function tallied(ka, kb) {
   }
   const alike = (counts, olds, news) => olds.length === news.length && olds.forEach((variable, k) => counted(counts, variable, news[k]))
   const trimmed = (lines, from, to) => plain(lines.slice(from, to).map((line) => line.replace(/[;,]\s*$/u, '')))
-  const blocks = linedUp(ka.key, kb.key, ka.keys.length + kb.keys.length)
+  const blocks = shortestChangeSet(ka.key, kb.key, KEYS, ka.keys.length + kb.keys.length)
   const [looseA, looseB] = slack(plain(ka.keys), plain(kb.keys), blocks, reading(ka), reading(kb))
   let i = 0, j = 0
   for (const block of [...blocks, { a0: ka.lines.length, a1: ka.lines.length, b0: kb.lines.length, b1: kb.lines.length }]) {

package/src/names/rename.js

@@ -3,7 +3,7 @@
 // to read wrongly, and the result checked again by oxc (bindsAlike).
 
 import { getOxc } from '#oxc'
-import { analyze, ownTopLevel } from './analyze.js'
+import { analyze, minifiedTopLevel, ownTopLevel } from './analyze.js'
 import { bindsAlike } from './binds.js'
 import { checkAnalysis, checkGiven, checkPairing, checkRenamed } from './check.js'
 import { misread } from './misread.js'
@@ -36,9 +36,10 @@ function renamedNames(before, after, { extension = 'js', otherExtension = extens
   let a = analyze(before, extension), b = analyze(after, otherExtension)
   if (a.reason || b.reason) return { reason: a.reason ?? b.reason }
   // A file is a module by how it is loaded, which its versions share, more than
-  // by its syntax: a bundle's chunk that one version exports from, the other not.
-  // Where its other version is a module, a script's top level is its own too.
-  if (a.module || b.module) [a, b] = [ownTopLevel(a), ownTopLevel(b)]
+  // by its syntax: a bundle's chunk that one version exports from, the other not,
+  // or that neither does, its top level renamed by a minifier as a module's is.
+  // Where either version is one, a script's top level is its own too.
+  if ([a, b].some((side) => side.module || minifiedTopLevel(side))) [a, b] = [ownTopLevel(a), ownTopLevel(b)]
   checkAnalysis(before, a)
   checkAnalysis(after, b)
   const paired = pairing(before, after, a, b)

package/src/text.js

@@ -31,6 +31,17 @@ export function checkLineOptions({ horizon = Infinity, whitespace = 'none', igno
   return { horizon, whitespace, ignoreCase }
 }
 
+// The shortest diff where its cost, lines by lines changed, allows, as --minimal
+// has it; past that the search's cutoff, which can face a run with lines alike
+// far from its own: old code that new code now comes before, faced with its braces.
+const SHORTEST_COST = 2e8
+const lineCount = (text) => text.split('\n').length
+export function shortestChangeSet(a, b, options, lines = lineCount(a) + lineCount(b)) {
+  const quick = changeSet(a, b, options)
+  const changed = quick.reduce((n, { a0, a1, b0, b1 }) => n + a1 - a0 + b1 - b0, 0)
+  return lines * changed > SHORTEST_COST ? quick : changeSet(a, b, { ...options, minimal: true })
+}
+
 // Binary content has no blocks and no counts, as --numstat prints `-` for it.
 export function contentOf(old, fresh, options) {
   const a = textOf(old), b = textOf(fresh)