@cplieger/deadset-ts 8.0.0-dev.14 → 8.0.0-dev.16

package/dist/src/build-scripts.js

@@ -1,418 +0,0 @@
-/**
- * The files a bundler's JavaScript API builds from, read from the build scripts a
- * manifest's scripts run: the strings an options object passes as the bundler's entries.
- * A script is read without running it, so a value that is not written out, a computed
- * path or an options object built at run time among them, names nothing.
- */
-import { isArrayBindingPattern, isArrayLiteralExpression, isArrowFunction, isCallExpression, isConstructorDeclaration, isFunctionDeclaration, isFunctionExpression, isGetAccessorDeclaration, isIdentifier, isImportDeclaration, isMetaProperty, isMethodDeclaration, isNamedImports, isNamespaceImport, isNewExpression, isNoSubstitutionTemplateLiteral, isObjectBindingPattern, isObjectLiteralExpression, isPropertyAccessExpression, isPropertyAssignment, isSetAccessorDeclaration, isStringLiteral, isVariableDeclaration, isVariableStatement, NodeFlags, } from "@typescript/native/ast";
-import { filesNamedBy } from "./configuration-files.js";
-import { ancestors, dirnamePath, relativePath, resolvePath } from "./paths.js";
-import { bytewise } from "./text/compare.js";
-import { unwrapped } from "./unwrap.js";
-import { holdsManifest, inInstalledPackages, manifestAt } from "./fs/manifest.js";
-import { globExpression } from "./text/glob.js";
-import { pathsNamed, readCommands } from "./commands/read.js";
-import { manifestCommands } from "./manifest.js";
-/**
- * The bundlers whose build call names its entries: esbuild resolves `entryPoints` against
- * `absWorkingDir` (https://esbuild.github.io/api/#working-directory), webpack `entry`
- * against `context` (https://webpack.js.org/configuration/entry-context/), and Rollup
- * `input` against the working directory, each the manifest's directory when its script runs.
- */
-const BUNDLERS = [
-    {
-        module: "esbuild",
-        calls: ["build", "buildSync", "context"],
-        option: "entryPoints",
-        base: "absWorkingDir",
-        paths: true,
-    },
-    { module: "webpack", calls: ["default"], option: "entry", base: "context", paths: false },
-    { module: "rollup", calls: ["rollup", "watch"], option: "input", base: "", paths: true },
-];
-const MODULE_EXTENSION = /\.(?:js|mjs|cjs|ts|mts|cts)$/u;
-function literalOf(node) {
-    const at = unwrapped(node);
-    return isStringLiteral(at) || isNoSubstitutionTemplateLiteral(at) ? at.text : undefined;
-}
-/** Whether one call is `require(<module>)`. */
-function requires(node, module) {
-    const at = unwrapped(node);
-    return (isCallExpression(at) &&
-        isIdentifier(at.expression) &&
-        at.expression.text === "require" &&
-        at.arguments.length === 1 &&
-        at.arguments[0] !== undefined &&
-        literalOf(at.arguments[0]) === module);
-}
-function bindingsOf(file, api) {
-    const functions = new Set();
-    const modules = new Set();
-    const building = (name) => api.calls.includes(name);
-    for (const statement of file.statements) {
-        if (isImportDeclaration(statement)) {
-            if (literalOf(statement.moduleSpecifier) !== api.module) {
-                continue;
-            }
-            const clause = statement.importClause;
-            if (clause?.name !== undefined) {
-                (building("default") ? functions : modules).add(clause.name.text);
-            }
-            const named = clause?.namedBindings;
-            if (named !== undefined && isNamespaceImport(named)) {
-                modules.add(named.name.text);
-            }
-            else if (named !== undefined && isNamedImports(named)) {
-                for (const element of named.elements) {
-                    if (building((element.propertyName ?? element.name).text)) {
-                        functions.add(element.name.text);
-                    }
-                }
-            }
-        }
-        else if (isVariableStatement(statement)) {
-            for (const declaration of statement.declarationList.declarations) {
-                const { name, initializer } = declaration;
-                if (initializer === undefined || !requires(initializer, api.module)) {
-                    continue;
-                }
-                if (isIdentifier(name)) {
-                    (building("default") ? functions : modules).add(name.text);
-                }
-                else if (isObjectBindingPattern(name)) {
-                    for (const element of name.elements) {
-                        const local = element.name;
-                        const key = element.propertyName ?? local;
-                        if (key !== undefined &&
-                            local !== undefined &&
-                            isIdentifier(key) &&
-                            isIdentifier(local) &&
-                            building(key.text)) {
-                            functions.add(local.text);
-                        }
-                    }
-                }
-            }
-        }
-    }
-    return { functions, modules };
-}
-/** Whether one call's callee is a building function of a bundler the file binds, `shadowed` naming none. */
-function builds(callee, api, bindings, shadowed) {
-    const at = unwrapped(callee);
-    if (isIdentifier(at)) {
-        return bindings.functions.has(at.text) && !shadowed.has(at.text);
-    }
-    if (!isPropertyAccessExpression(at) ||
-        !isIdentifier(at.name) ||
-        !api.calls.includes(at.name.text)) {
-        return false;
-    }
-    const holder = unwrapped(at.expression);
-    return ((isIdentifier(holder) && bindings.modules.has(holder.text) && !shadowed.has(holder.text)) ||
-        requires(holder, api.module));
-}
-/** The top-level `const` initializers one file declares, by name. */
-function constants(file) {
-    const found = new Map();
-    for (const statement of file.statements) {
-        if (isVariableStatement(statement) &&
-            (statement.declarationList.flags & NodeFlags.Const) !== 0) {
-            for (const { name, initializer } of statement.declarationList.declarations) {
-                if (isIdentifier(name) && initializer !== undefined) {
-                    found.set(name.text, initializer);
-                }
-            }
-        }
-    }
-    return found;
-}
-/** The value one object literal writes for one member as `name: value`. */
-function member(object, name) {
-    if (!isObjectLiteralExpression(object)) {
-        return undefined;
-    }
-    for (const property of object.properties) {
-        if (isPropertyAssignment(property) && literalOrName(property.name) === name) {
-            return property.initializer;
-        }
-    }
-    return undefined;
-}
-function literalOrName(node) {
-    return isIdentifier(node) ? node.text : literalOf(node);
-}
-/** Whether one expression is the script's own directory: `__dirname` or `import.meta.dirname`. */
-function isOwnDirectory(node) {
-    const at = unwrapped(node);
-    if (isIdentifier(at)) {
-        return at.text === "__dirname";
-    }
-    return (isPropertyAccessExpression(at) &&
-        isMetaProperty(at.expression) &&
-        isIdentifier(at.name) &&
-        at.name.text === "dirname");
-}
-/**
- * The path one entry value writes, read against `dir`: a literal, or a `resolve` or
- * `join` call, of `path` or bound from it, whose first argument is the script's own
- * directory and whose others are literals.
- */
-function pathOf(node, dir, scriptDir) {
-    const at = unwrapped(node);
-    const text = literalOf(at);
-    if (text !== undefined) {
-        const request = !text.startsWith("./") && !text.startsWith("../") && !text.startsWith("/");
-        return { path: resolvePath(dir, text), text, request };
-    }
-    if (!isCallExpression(at)) {
-        return undefined;
-    }
-    const callee = unwrapped(at.expression);
-    const name = isPropertyAccessExpression(callee) ? callee.name : callee;
-    if (!isIdentifier(name) || (name.text !== "resolve" && name.text !== "join")) {
-        return undefined;
-    }
-    const [first, ...rest] = at.arguments;
-    const parts = rest.map(literalOf);
-    if (first === undefined || !isOwnDirectory(first) || parts.some((part) => part === undefined)) {
-        return undefined;
-    }
-    const joined = parts.join("/");
-    return { path: resolvePath(scriptDir, joined), text: joined, request: false };
-}
-/** The entry values one entries option writes: a value, an array of them, an object of them. */
-function entryValues(node) {
-    const at = unwrapped(node);
-    if (isArrayLiteralExpression(at)) {
-        return at.elements.flatMap(entryValues);
-    }
-    if (isObjectLiteralExpression(at)) {
-        const imported = member(at, "import") ?? member(at, "in");
-        if (imported !== undefined) {
-            return entryValues(imported);
-        }
-        return at.properties.flatMap((property) => isPropertyAssignment(property) ? entryValues(property.initializer) : []);
-    }
-    return [at];
-}
-/** The own files one entry string names, read as `api` reads it. */
-function entriesNamed(files, api, entry) {
-    if (!api.paths && entry.request) {
-        return [];
-    }
-    if (api.paths && /[*?[{]/u.test(entry.text)) {
-        const expression = globExpression(entry.path);
-        return [...files.byName.values()].filter((file) => expression.test(file.fileName));
-    }
-    const dir = dirnamePath(entry.path);
-    return filesNamedBy(files, dir, entry.path.slice(dir.length + 1));
-}
-/** Whether one node is a function, whose body runs only where something calls it. */
-function isFunction(node) {
-    return (isFunctionDeclaration(node) ||
-        isFunctionExpression(node) ||
-        isArrowFunction(node) ||
-        isMethodDeclaration(node) ||
-        isConstructorDeclaration(node) ||
-        isGetAccessorDeclaration(node) ||
-        isSetAccessorDeclaration(node));
-}
-/** The names one binding name binds: an identifier, or each name a pattern holds. */
-function boundNames(name, into) {
-    if (isIdentifier(name)) {
-        into.add(name.text);
-    }
-    else if (isObjectBindingPattern(name) || isArrayBindingPattern(name)) {
-        name.forEachChild((element) => {
-            const bound = element.name;
-            if (bound !== undefined) {
-                boundNames(bound, into);
-            }
-        });
-    }
-}
-/** The names one function binds of its own: its parameters and the declarations its body holds outside nested functions. */
-function ownBindings(fn) {
-    const found = new Set();
-    const visit = (node) => {
-        if (node !== fn && isFunction(node)) {
-            if (isFunctionDeclaration(node) && node.name !== undefined) {
-                found.add(node.name.text);
-            }
-            return;
-        }
-        if (isVariableDeclaration(node)) {
-            boundNames(node.name, found);
-        }
-        node.forEachChild(visit);
-    };
-    for (const parameter of fn
-        .parameters ?? []) {
-        boundNames(parameter.name, found);
-    }
-    fn.forEachChild(visit);
-    return found;
-}
-/** The functions one file declares under a name: a function declaration, or a variable bound to a function. */
-function namedFunctions(file) {
-    const found = new Map();
-    const add = (name, fn) => {
-        found.set(name, [...(found.get(name) ?? []), fn]);
-    };
-    const visit = (node) => {
-        if (isFunctionDeclaration(node) && node.name !== undefined) {
-            add(node.name.text, node);
-        }
-        else if (isVariableDeclaration(node) &&
-            isIdentifier(node.name) &&
-            node.initializer !== undefined &&
-            isFunction(unwrapped(node.initializer))) {
-            add(node.name.text, unwrapped(node.initializer));
-        }
-        node.forEachChild(visit);
-    };
-    file.forEachChild(visit);
-    return found;
-}
-/**
- * The calls one build script runs: those of its top level, and those of each function
- * a call it runs calls or passes on, as a callee, an argument or a function called where
- * it is written. `shadowed` is the names a function running them binds of its own, which
- * hide the file's bindings of the same names.
- */
-function runCalls(file, each) {
-    const named = namedFunctions(file);
-    const ran = new Set();
-    const run = (fn, outer) => {
-        if (ran.has(fn)) {
-            return;
-        }
-        ran.add(fn);
-        const shadowed = new Set([...outer, ...ownBindings(fn)]);
-        fn.forEachChild((child) => {
-            visit(child, shadowed);
-        });
-    };
-    const runs = (node, shadowed) => {
-        const at = unwrapped(node);
-        if (isFunction(at)) {
-            run(at, shadowed);
-        }
-        else if (isIdentifier(at) && !shadowed.has(at.text)) {
-            for (const fn of named.get(at.text) ?? []) {
-                run(fn, new Set());
-            }
-        }
-    };
-    const visit = (node, shadowed) => {
-        if (isFunction(node)) {
-            return;
-        }
-        if (isCallExpression(node) || isNewExpression(node)) {
-            if (isCallExpression(node)) {
-                each(node, shadowed);
-            }
-            runs(node.expression, shadowed);
-            for (const argument of node.arguments ?? []) {
-                runs(argument, shadowed);
-            }
-        }
-        node.forEachChild((child) => {
-            visit(child, shadowed);
-        });
-    };
-    file.forEachChild((child) => {
-        visit(child, new Set());
-    });
-}
-/** The entries every bundler call one build script runs names, read against `dir`. */
-function scriptEntries(file, dir, files) {
-    const found = [];
-    const declared = constants(file);
-    const scriptDir = dirnamePath(file.fileName);
-    const bound = BUNDLERS.map((api) => ({ api, bindings: bindingsOf(file, api) }));
-    runCalls(file, (call, shadowed) => {
-        for (const { api, bindings } of bound) {
-            if (!builds(call.expression, api, bindings, shadowed)) {
-                continue;
-            }
-            const [argument] = call.arguments;
-            let options = argument === undefined ? undefined : unwrapped(argument);
-            if (options !== undefined && isIdentifier(options)) {
-                options = shadowed.has(options.text) ? undefined : declared.get(options.text);
-                options = options === undefined ? undefined : unwrapped(options);
-            }
-            const entries = options === undefined ? undefined : member(options, api.option);
-            const base = options === undefined || api.base === "" ? undefined : member(options, api.base);
-            const against = base === undefined ? { path: dir } : pathOf(base, dir, scriptDir);
-            if (entries === undefined || against === undefined) {
-                continue;
-            }
-            for (const value of entryValues(entries)) {
-                const named = pathOf(value, against.path, scriptDir);
-                if (named === undefined) {
-                    continue;
-                }
-                for (const entry of entriesNamed(files, api, named)) {
-                    found.push({ file: entry, source: named.text });
-                }
-            }
-        }
-    });
-    return found;
-}
-/** The modules one manifest's command strings run or name, by absolute path, each below the target root. */
-function scriptModules(host, root, dir) {
-    const manifest = manifestAt(host, dir);
-    const found = new Set();
-    for (const { command } of manifest === undefined ? [] : manifestCommands(host, dir, manifest)) {
-        for (const { path } of pathsNamed(readCommands(command, dir))) {
-            if (MODULE_EXTENSION.test(path) &&
-                relativePath(root, path) !== undefined &&
-                !inInstalledPackages(path) &&
-                host.kindOf(path) === "file") {
-                found.add(path);
-            }
-        }
-    }
-    return [...found].sort(bytewise);
-}
-/**
- * Every own file of one project a build script names as a bundler's entry: a module a
- * script of a manifest at or above an own file runs, below the target root, read from
- * the program where it holds the module and parsed alone otherwise, where a parser is given.
- */
-export function buildScriptEntries(host, targetRoot, files, parse) {
-    const root = resolvePath(host.workingDirectory(), targetRoot);
-    const dirs = new Set([root]);
-    for (const file of files.byName.values()) {
-        for (const dir of ancestors(dirnamePath(file.fileName), root)) {
-            if (dirs.has(dir)) {
-                break;
-            }
-            dirs.add(dir);
-        }
-    }
-    const found = [];
-    for (const dir of [...dirs].sort(bytewise)) {
-        if (!holdsManifest(host, dir)) {
-            continue;
-        }
-        for (const path of scriptModules(host, root, dir)) {
-            let script = files.byName.get(path);
-            if (script === undefined && parse !== undefined) {
-                try {
-                    script = parse(path, host.readFile(path));
-                }
-                catch {
-                    continue;
-                }
-            }
-            if (script !== undefined) {
-                found.push(...scriptEntries(script, dir, files));
-            }
-        }
-    }
-    return found;
-}