mirror of
https://github.com/zhw2590582/ArtPlayer.git
synced 2026-10-17 10:01:20 -08:00
59 lines
4.6 KiB
TypeScript
59 lines
4.6 KiB
TypeScript
import assert from 'node:assert/strict'
|
|
import { createHash } from 'node:crypto'
|
|
import fs from 'node:fs'
|
|
import { createRequire } from 'node:module'
|
|
import path from 'node:path'
|
|
import process from 'node:process'
|
|
import { fileURLToPath } from 'node:url'
|
|
import { ArchiveCache } from './archives.ts'
|
|
import { readUnicodeOrigins, verifyMonacoUnicodeNotices } from './unicode-origins.ts'
|
|
import { readUnicodeTables, replayUnicodeGenerator, verifyUnicodeGeneration } from './unicode.ts'
|
|
|
|
const root = fileURLToPath(new URL('../../../', import.meta.url))
|
|
assert(process.argv.slice(2).every(arg => arg === '--fetch'), 'Use reproduce-unicode.ts [--fetch]')
|
|
assert.equal(process.version, `v${fs.readFileSync(path.join(root, '.node-version'), 'utf8').trim()}`, 'Use canonical Node')
|
|
const record = readUnicodeOrigins(root)
|
|
const cache = new ArchiveCache(root, path.join(root, 'refactor/.cache/monaco-review'))
|
|
const generators = new ArchiveCache(root, path.join(cache.directory, 'unicode-generator'))
|
|
await cache.verify(record.archives, record.remotes, process.argv.includes('--fetch'))
|
|
await generators.verify(record.generatorArchives, [], process.argv.includes('--fetch'))
|
|
verifyMonacoUnicodeNotices(root, JSON.parse(fs.readFileSync(path.join(root, 'scripts/site-vendor/manifest.json'), 'utf8')))
|
|
const lock: { lockfileVersion: number, dependencies: Record<string, { version: string, resolved: string, integrity: string, dependencies?: unknown }> } = JSON.parse(fs.readFileSync(path.join(root, record.lockSource), 'utf8'))
|
|
assert.equal(lock.lockfileVersion, 1)
|
|
assert.deepEqual(record.generatorArchives.map(archive => archive.name).sort(), Object.keys(lock.dependencies).sort(), 'Incomplete Unicode dependency closure')
|
|
for (const archive of record.generatorArchives) {
|
|
const dependency = lock.dependencies[archive.name]!
|
|
assert.equal(dependency.dependencies, undefined, 'Unexpected nested Unicode dependency')
|
|
assert.deepEqual([archive.version, archive.tarball, archive.lockedIntegrity], [dependency.version, dependency.resolved, dependency.integrity], 'Changed Unicode lock resolution')
|
|
const bytes = fs.readFileSync(path.join(generators.directory, `${archive.name}-${archive.version}.tgz`))
|
|
const algorithm = archive.lockedIntegrity.split('-')[0]!
|
|
assert(['sha1', 'sha512'].includes(algorithm), 'Unexpected original Unicode integrity algorithm')
|
|
assert.equal(`${algorithm}-${createHash(algorithm).update(bytes).digest('base64')}`, archive.lockedIntegrity, 'Changed original Unicode archive integrity')
|
|
generators.extractCompiler(archive)
|
|
}
|
|
const require = createRequire(path.join(generators.directory, 'compiler/entry.cjs'))
|
|
assert.equal(require('regexpu/package.json').version, '3.3.0')
|
|
|
|
const recipeSources = new Set(record.remotes.map(remote => remote.source))
|
|
assert.deepEqual(record.generators.map(generator => generator.kind), ['rtl', 'emoji', 'grapheme'])
|
|
const outputs = record.generators.map((generator) => {
|
|
assert(recipeSources.has(generator.source), 'Unverified Unicode generator')
|
|
const inputs = new Map(Object.entries(generator.inputs).map(([name, source]) => {
|
|
assert(recipeSources.has(source), 'Unverified Unicode data input')
|
|
return [name, fs.readFileSync(path.join(root, source))]
|
|
}))
|
|
return replayUnicodeGenerator(fs.readFileSync(path.join(root, generator.source), 'utf8'), inputs, generator.outputs, require('regexpu'))
|
|
})
|
|
const tables = readUnicodeTables(fs.readFileSync(path.join(root, record.vscodeSource), 'utf8'))
|
|
verifyUnicodeGeneration(tables, outputs[0]!, outputs[1]!, outputs[2]!)
|
|
assert.deepEqual(record.maps.map(entry => entry.member), ['package/dev/vs/editor/editor.main.js.map', 'package/dev/vs/base/worker/workerMain.js.map'], 'Incomplete Unicode map coverage')
|
|
for (const entry of record.maps) {
|
|
const map: { sources: string[], sourcesContent: string[] } = JSON.parse(cache.member(entry).toString('utf8'))
|
|
assert.equal(map.sources.filter(source => source === entry.source).length, 1, 'Missing or repeated Unicode mapped source')
|
|
assert.deepEqual(readUnicodeTables(map.sourcesContent[map.sources.indexOf(entry.source)]!), tables, 'Mapped Unicode differs from fixed VS Code')
|
|
}
|
|
assert.deepEqual(record.shipped.map(asset => asset.target), record.component.assets, 'Incomplete Unicode shipped coverage')
|
|
for (const asset of record.shipped)
|
|
assert.deepEqual(fs.readFileSync(path.join(root, asset.target)), cache.member(asset), 'Shipped Unicode asset changed')
|
|
console.log(JSON.stringify({ archives: record.archives.length, generatorArchives: record.generatorArchives.length, gitSources: record.remotes.length, maps: record.maps.length, shippedAssets: record.shipped.length, exactGenerated: record.generated, fullMonacoCompilation: false, unicodeConformance: false }))
|