put everithing into one folder
This commit is contained in:
Oleksii Bulenok
@@ -0,0 +1,412 @@
|
||||
/*
|
||||
* Lexicon-only "tree shaking".
|
||||
*
|
||||
* The @atproto/lex codegen exposes every lexicon through nested namespace
|
||||
* barrels (`export * as app from './app'` -> `export * as bsky ...` -> leaf),
|
||||
* and consumers write `app.bsky.feed.like.$build(...)`. Bundlers see a single
|
||||
* used binding (`app`) whose value is an opaque namespace object, so every leaf
|
||||
* stays in the bundle. This plugin rewrites static member chains that start at
|
||||
* a barrel import into a direct namespace import of the leaf module:
|
||||
*
|
||||
* import {app} from '#/lexicons'
|
||||
* app.bsky.feed.like.$build(x)
|
||||
*
|
||||
* becomes
|
||||
*
|
||||
* import * as _lex_app_bsky_feed_like from '../lexicons/app/bsky/feed/like'
|
||||
* _lex_app_bsky_feed_like.$build(x)
|
||||
*
|
||||
* Once nothing imports the barrels, Metro's reachability drops them and every
|
||||
* unreferenced leaf. The same rewrite is applied to @bsky/sdk's compiled output,
|
||||
* which imports its own copy of the barrel via '../lexicons/index.js'.
|
||||
*
|
||||
* Correctness fallback: if any reference to a barrel binding cannot be rewritten
|
||||
* (namespace used as a value, computed access, chain ending at a non-leaf,
|
||||
* chain in a write position), that binding is left on the barrel import. The result is always correct, merely
|
||||
* unshaken for that file. Set BSKY_LEXICON_IMPORTS_DEBUG=1 to log such bails.
|
||||
*
|
||||
* Caveat: the rewrite bakes leaf file paths into each consumer's transform
|
||||
* output, but Metro's and babel-jest's persistent caches key only on the
|
||||
* consumer's own content, so a regen that MOVES leaf files (or a @bsky/sdk
|
||||
* upgrade that reshuffles dist) can leave unchanged consumers replaying stale
|
||||
* leaf imports from a warm cache. Symptoms are a module-not-found error in a
|
||||
* file you did not touch or, if the old path still resolves, a runtime
|
||||
* undefined-member error. Restart with `expo start -c` (or clear the Jest
|
||||
* cache) after such a regen.
|
||||
*
|
||||
* Leaf vs barrel is decided from the filesystem: a segment with both `<seg>.ts`
|
||||
* (or `.js`) and a `<seg>/` directory is a barrel, a segment with only the file
|
||||
* is a leaf. This keeps the plugin independent of nesting depth (most NSIDs are
|
||||
* four segments, but e.g. com.germnetwork.declaration is three).
|
||||
*
|
||||
* The filesystem walk assumes barrel re-export names mirror file names 1:1,
|
||||
* which holds for codegen output but is not enforced by anything. So before
|
||||
* rewriting, each chain is verified against the actual barrel sources: starting
|
||||
* at the barrel's index file, follow the `export * as <segment> from '...'`
|
||||
* statement for every segment and require that walk to land on the same leaf
|
||||
* file the filesystem walk picked. `export * as X` yields the same module
|
||||
* namespace object as importing the target directly, so file identity is
|
||||
* sufficient proof that the rewrite preserves semantics. Any divergence
|
||||
* (renamed re-export, unexpected barrel shape) is a hard build error: a
|
||||
* rewrite that points at the wrong module must never ship silently.
|
||||
*/
|
||||
const fs = require('node:fs')
|
||||
const path = require('node:path')
|
||||
|
||||
const {
|
||||
EXTS,
|
||||
SDK_BARREL_RE,
|
||||
resolveModuleFile,
|
||||
barrelExports,
|
||||
clearBarrelExportCache,
|
||||
} = require('./lexiconBarrels')
|
||||
|
||||
const statCache = new Map()
|
||||
|
||||
/** @returns {'dir' | 'file' | null} */
|
||||
function classify(dir, segment) {
|
||||
const key = path.join(dir, segment)
|
||||
let kind = statCache.get(key)
|
||||
if (kind !== undefined) return kind
|
||||
kind = null
|
||||
try {
|
||||
if (fs.statSync(key).isDirectory()) kind = 'dir'
|
||||
} catch {}
|
||||
if (kind === null) {
|
||||
for (const ext of EXTS) {
|
||||
if (fs.existsSync(key + ext)) {
|
||||
kind = 'file'
|
||||
break
|
||||
}
|
||||
}
|
||||
} else {
|
||||
// A directory plus a sibling file of the same name is a barrel. A bare
|
||||
// directory with no sibling file is not something codegen produces.
|
||||
if (!EXTS.some(ext => fs.existsSync(key + ext))) kind = null
|
||||
}
|
||||
statCache.set(key, kind)
|
||||
return kind
|
||||
}
|
||||
|
||||
function leafFileFor(dir, segment) {
|
||||
const key = path.join(dir, segment)
|
||||
for (const ext of EXTS) {
|
||||
if (fs.existsSync(key + ext)) return key + ext
|
||||
}
|
||||
return null
|
||||
}
|
||||
|
||||
/**
|
||||
* True when the member chain is written to rather than read. Such a chain
|
||||
* cannot be collapsed into a bare identifier: imports are read-only bindings
|
||||
* (assignment/++ would throw where the original property write may not) and
|
||||
* `delete <identifier>` is a strict-mode SyntaxError in the emitted code.
|
||||
*/
|
||||
function isWriteTarget(memberPath) {
|
||||
const parent = memberPath.parentPath
|
||||
if (!parent) return false
|
||||
if (parent.isAssignmentExpression()) {
|
||||
return parent.node.left === memberPath.node
|
||||
}
|
||||
if (parent.isUpdateExpression()) return true
|
||||
if (parent.isUnaryExpression({operator: 'delete'})) return true
|
||||
if (parent.isForXStatement()) return parent.node.left === memberPath.node
|
||||
if (parent.isArrayPattern() || parent.isRestElement()) return true
|
||||
if (parent.isObjectProperty() && parent.parentPath.isObjectPattern()) {
|
||||
return parent.node.value === memberPath.node
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
/** `rootDir\0segments\0leafFile` -> boolean */
|
||||
const chainCache = new Map()
|
||||
|
||||
/**
|
||||
* Prove a planned rewrite correct by following the real export graph: parse
|
||||
* each barrel on the way down and require the `export * as` chain to resolve
|
||||
* to the exact leaf file the filesystem walk picked. Returns false on any
|
||||
* divergence; the caller turns that into a hard build error.
|
||||
*/
|
||||
function verifyChain(rootDir, segments, leafFile) {
|
||||
/*
|
||||
* leafFile is part of the key: the cached boolean encodes `walk === leafFile`,
|
||||
* so a hit for the same chain but a different planned leaf must not be reused.
|
||||
*/
|
||||
const key = rootDir + '\0' + segments.join('.') + '\0' + leafFile
|
||||
let ok = chainCache.get(key)
|
||||
if (ok !== undefined) return ok
|
||||
let cur = leafFileFor(rootDir, 'index')
|
||||
ok = cur !== null
|
||||
if (ok) {
|
||||
for (const segment of segments) {
|
||||
const spec = barrelExports(cur)?.get(segment)
|
||||
cur = spec ? resolveModuleFile(cur, spec) : null
|
||||
if (!cur) {
|
||||
ok = false
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
if (ok) ok = cur === leafFile
|
||||
chainCache.set(key, ok)
|
||||
return ok
|
||||
}
|
||||
|
||||
/** Barrel root dir -> mtimeMs of its index file when the caches were filled. */
|
||||
const rootEpochs = new Map()
|
||||
|
||||
/*
|
||||
* The caches above are module-level and would otherwise outlive a lexicon
|
||||
* regen inside a long-lived Metro or Jest watch worker, serving stale stats,
|
||||
* export maps, and verified chains until the process restarts. Codegen
|
||||
* (`lex build --clear`) rewrites the whole tree including the root index, so
|
||||
* the index mtime works as an epoch: when it moves, drop all three caches.
|
||||
* Costs one statSync per file that actually imports a barrel.
|
||||
*/
|
||||
function invalidateStaleCaches(rootDir) {
|
||||
let mtime = -1
|
||||
for (const ext of EXTS) {
|
||||
try {
|
||||
mtime = fs.statSync(path.join(rootDir, 'index' + ext)).mtimeMs
|
||||
break
|
||||
} catch {}
|
||||
}
|
||||
const prev = rootEpochs.get(rootDir)
|
||||
if (prev !== undefined && prev !== mtime) {
|
||||
statCache.clear()
|
||||
clearBarrelExportCache()
|
||||
chainCache.clear()
|
||||
}
|
||||
rootEpochs.set(rootDir, mtime)
|
||||
}
|
||||
|
||||
const SDK_SEGMENT = `${path.sep}@bsky${path.sep}sdk${path.sep}`
|
||||
|
||||
module.exports = function lexiconLeafImports(babel, options = {}) {
|
||||
const {types: t} = babel
|
||||
/**
|
||||
* Absolute paths of barrel directories (e.g. <root>/src/lexicons). Matched
|
||||
* against the import specifier after resolving it relative to the importing
|
||||
* file, because babel-plugin-module-resolver has already turned '#/lexicons'
|
||||
* into a relative path by the time this plugin runs. Relative entries are
|
||||
* resolved against Babel's root, not process.cwd(): cwd depends on how the
|
||||
* host process (Metro worker, Jest, an IDE runner) was launched, and a wrong
|
||||
* base would silently disable every rewrite.
|
||||
*/
|
||||
let roots = null
|
||||
function resolveRoots(state) {
|
||||
if (!roots) {
|
||||
const base = state.file.opts.root ?? state.cwd
|
||||
roots = new Set((options.roots ?? []).map(r => path.resolve(base, r)))
|
||||
}
|
||||
}
|
||||
const debug = !!process.env.BSKY_LEXICON_IMPORTS_DEBUG
|
||||
/*
|
||||
* Test hook: when set, every performed rewrite is reported on the Babel file
|
||||
* metadata as `metadata.lexiconLeafImports[chain] = emitted specifier`, so a
|
||||
* caller of transformSync can compare each rewrite against the real barrel.
|
||||
*/
|
||||
const collectRewrites = !!options.collectRewrites
|
||||
const stats = {files: 0, rewrites: 0, bails: 0}
|
||||
|
||||
function barrelDirFor(source, filename) {
|
||||
if (source.startsWith('.')) {
|
||||
const abs = path
|
||||
.resolve(path.dirname(filename), source)
|
||||
.replace(/[\\/]index(\.[jt]s)?$/, '')
|
||||
if (roots.has(abs)) return abs
|
||||
if (SDK_BARREL_RE.test(source) && filename.includes(SDK_SEGMENT)) {
|
||||
return abs
|
||||
}
|
||||
}
|
||||
return null
|
||||
}
|
||||
|
||||
/**
|
||||
* Walk the member chain hanging off a reference to a barrel binding down to
|
||||
* the leaf module. Returns the MemberExpression path whose value is the leaf
|
||||
* namespace plus the leaf's absolute file path, or null if the chain cannot
|
||||
* be rewritten safely.
|
||||
*/
|
||||
function planRewrite(refPath, rootDir, rootSegment) {
|
||||
let dir = rootDir
|
||||
let segment = rootSegment
|
||||
let cur = refPath
|
||||
const segments = [rootSegment]
|
||||
for (;;) {
|
||||
const kind = classify(dir, segment)
|
||||
if (kind === 'file') {
|
||||
if (isWriteTarget(cur)) return null
|
||||
return {memberPath: cur, leafFile: leafFileFor(dir, segment), segments}
|
||||
}
|
||||
if (kind !== 'dir') return null
|
||||
const parent = cur.parentPath
|
||||
if (
|
||||
!parent ||
|
||||
!parent.isMemberExpression() ||
|
||||
parent.node.object !== cur.node ||
|
||||
parent.node.computed ||
|
||||
!t.isIdentifier(parent.node.property)
|
||||
) {
|
||||
return null
|
||||
}
|
||||
dir = path.join(dir, segment)
|
||||
segment = parent.node.property.name
|
||||
segments.push(segment)
|
||||
cur = parent
|
||||
}
|
||||
}
|
||||
|
||||
function toSpecifier(fromFile, leafFile) {
|
||||
let rel = path
|
||||
.relative(path.dirname(fromFile), leafFile)
|
||||
.split(path.sep)
|
||||
.join('/')
|
||||
// Keep `.js` for the SDK's ESM output; strip `.ts` so Metro resolves
|
||||
// platform extensions for app sources normally.
|
||||
rel = rel.replace(/\.ts$/, '')
|
||||
if (!rel.startsWith('.')) rel = './' + rel
|
||||
return rel
|
||||
}
|
||||
|
||||
return {
|
||||
name: 'lexicon-leaf-imports',
|
||||
visitor: {
|
||||
Program: {
|
||||
exit(programPath, state) {
|
||||
const filename = state.filename
|
||||
if (!filename) return
|
||||
resolveRoots(state)
|
||||
const targets = []
|
||||
for (const stmt of programPath.get('body')) {
|
||||
if (!stmt.isImportDeclaration()) continue
|
||||
if (stmt.node.importKind === 'type') continue
|
||||
/*
|
||||
* A specifier-less import exists only for module evaluation; there is
|
||||
* nothing to rewrite, so leave it untouched.
|
||||
*/
|
||||
if (stmt.node.specifiers.length === 0) continue
|
||||
|
||||
const dir = barrelDirFor(stmt.node.source.value, filename)
|
||||
if (dir) targets.push({imp: stmt, dir})
|
||||
}
|
||||
if (targets.length === 0) return
|
||||
for (const {dir} of targets) {
|
||||
invalidateStaleCaches(dir)
|
||||
}
|
||||
|
||||
/*
|
||||
* Type-only references were stripped by the TypeScript transform
|
||||
* earlier in this traversal; re-crawl so referencePaths reflect the
|
||||
* current tree.
|
||||
*/
|
||||
programPath.scope.crawl()
|
||||
const leafImports = new Map()
|
||||
let pendingDecls = []
|
||||
let touched = false
|
||||
|
||||
function namespaceIdFor(leafFile) {
|
||||
let id = leafImports.get(leafFile)
|
||||
if (id) return id
|
||||
const hint =
|
||||
'lex_' +
|
||||
leafFile
|
||||
.replace(/\.(ts|js)$/, '')
|
||||
.split(path.sep)
|
||||
.slice(-4)
|
||||
.join('_')
|
||||
.replace(/[^A-Za-z0-9_]/g, '_')
|
||||
id = programPath.scope.generateUidIdentifier(hint)
|
||||
leafImports.set(leafFile, id)
|
||||
pendingDecls.push(
|
||||
t.importDeclaration(
|
||||
[t.importNamespaceSpecifier(t.cloneNode(id))],
|
||||
t.stringLiteral(toSpecifier(filename, leafFile)),
|
||||
),
|
||||
)
|
||||
return id
|
||||
}
|
||||
|
||||
for (const {imp, dir} of targets) {
|
||||
pendingDecls = []
|
||||
const keep = []
|
||||
for (const spec of imp.get('specifiers')) {
|
||||
if (
|
||||
!spec.isImportSpecifier() ||
|
||||
spec.node.importKind === 'type'
|
||||
) {
|
||||
keep.push(spec.node)
|
||||
continue
|
||||
}
|
||||
const imported = spec.node.imported
|
||||
const rootSegment = t.isIdentifier(imported)
|
||||
? imported.name
|
||||
: imported.value
|
||||
const binding = programPath.scope.getBinding(spec.node.local.name)
|
||||
if (!binding || binding.path !== spec) {
|
||||
keep.push(spec.node)
|
||||
continue
|
||||
}
|
||||
const plan = []
|
||||
let ok = true
|
||||
for (const ref of binding.referencePaths) {
|
||||
const r = planRewrite(ref, dir, rootSegment)
|
||||
if (r && !verifyChain(dir, r.segments, r.leafFile)) {
|
||||
throw ref.buildCodeFrameError(
|
||||
`[lexicon-leaf-imports] filesystem walk resolved '${r.segments.join('.')}' to ${path.relative(process.cwd(), r.leafFile)}, but following the barrel's own 'export * as' chain does not reach that file. The barrel layout no longer matches the plugin's assumptions; fix the barrels or the plugin.`,
|
||||
)
|
||||
}
|
||||
if (!r) {
|
||||
ok = false
|
||||
if (debug) {
|
||||
const loc = ref.node.loc?.start
|
||||
console.warn(
|
||||
`[lexicon-leaf-imports] bail: ${path.relative(process.cwd(), filename)}:${loc?.line}:${loc?.column} (${rootSegment})`,
|
||||
)
|
||||
}
|
||||
break
|
||||
}
|
||||
plan.push(r)
|
||||
}
|
||||
if (!ok) {
|
||||
stats.bails++
|
||||
keep.push(spec.node)
|
||||
continue
|
||||
}
|
||||
for (const {memberPath, leafFile, segments} of plan) {
|
||||
if (collectRewrites) {
|
||||
const map = (state.file.metadata.lexiconLeafImports ??= {})
|
||||
map[segments.join('.')] = toSpecifier(filename, leafFile)
|
||||
}
|
||||
memberPath.replaceWith(t.cloneNode(namespaceIdFor(leafFile)))
|
||||
stats.rewrites++
|
||||
}
|
||||
touched = true
|
||||
}
|
||||
/*
|
||||
* Insert the leaf imports at the barrel import's own position so
|
||||
* they evaluate exactly when the barrel would have - hoisting them
|
||||
* to the top of the file would run the lexicon modules ahead of
|
||||
* ordering-sensitive side-effect imports (polyfills, sentry setup).
|
||||
*/
|
||||
if (pendingDecls.length > 0) {
|
||||
imp.insertBefore(pendingDecls)
|
||||
}
|
||||
if (keep.length === 0) {
|
||||
imp.remove()
|
||||
} else if (keep.length !== imp.node.specifiers.length) {
|
||||
imp.node.specifiers = keep
|
||||
}
|
||||
}
|
||||
|
||||
if (touched) stats.files++
|
||||
if (debug && touched) {
|
||||
console.warn(
|
||||
`[lexicon-leaf-imports] ${path.relative(process.cwd(), filename)}: ${leafImports.size} leaf imports (total files=${stats.files} rewrites=${stats.rewrites} bails=${stats.bails})`,
|
||||
)
|
||||
}
|
||||
},
|
||||
},
|
||||
},
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user