@cplieger/deadset-ts 8.0.0-dev.2 → 8.0.0-dev.21

package/dist/src/exempt.js

@@ -1,209 +0,0 @@
-/**
- * The exemption framework: the classes of reason for which a declaration the reference
- * graph alone would report is live all the same. A class is policy over what one
- * project's checker answers, and its detector names the declarations it holds back;
- * this module runs the detectors, decides which of their records stand, and answers
- * which records held something back. It names no class's detector: the composition
- * hands it the table of the classes it has.
- */
-import { ConfigError } from "./config.js";
-import { EXEMPTION_CLASSES, isExemptionClass, TS_EXEMPTION_CLASSES, typescriptVisibilityOf, } from "./exempt-classes.js";
-import { byPosition, positionKey } from "./position.js";
-import { Unanswerable } from "./query.js";
-import { sweep } from "./sweep.js";
-/**
- * The classes `exemptions.disabled` switches off. A name is refused unless the
- * vocabulary holds it; a class that runs on another language only is admitted and
- * switches nothing off here, so one configuration serves every analyzer.
- */
-export function disabledClasses(config) {
-    const disabled = new Set();
-    for (const name of config.exemptionsDisabled) {
-        if (!isExemptionClass(name)) {
-            const known = EXEMPTION_CLASSES.map((row) => row.class).join(", ");
-            throw new ConfigError("malformed", "exemptions.disabled", `exemptions.disabled: ${JSON.stringify(name)} is not an exemption class: the classes are ${known}`);
-        }
-        disabled.add(name);
-    }
-    return disabled;
-}
-/**
- * Whether a class whose row states `allowed` may retain a member of one visibility. A
- * declaration the inventory does not hold has no visibility to refuse it by.
- */
-function retainable(allowed, visibility) {
-    if (visibility === "private") {
-        return allowed.private;
-    }
-    if (visibility === "private-name") {
-        return allowed.privateName;
-    }
-    return true;
-}
-/**
- * The kinds of declaration each class can hold back, which a detector that stops holds
- * back whole. A class with no row here holds back every declaration but a file.
- */
-const RETAINABLE = new Map([
-    ["interface-satisfaction", new Set(["method", "class-member"])],
-    ["enum-group", new Set(["enum-member"])],
-    ["injection-container", new Set(["method", "class-member"])],
-    ["framework-lifecycle", new Set(["method", "class-member"])],
-    [
-        "serialization-contract",
-        new Set(["method", "class-member", "interface-method", "type-member"]),
-    ],
-]);
-/** The detail of a record a detector that could not finish holds. */
-const UNANSWERED_DETAIL = "kept live by a question the checker did not answer";
-/** Whether one record is held by a detector that could not finish. */
-export function isUnansweredRecord(record) {
-    return record.detail === UNANSWERED_DETAIL;
-}
-/**
- * What one detector holds back over one project. A detector that stops because the
- * checker left a question it needs unanswered holds back every declaration of the
- * project its class could hold back, each recorded at its own position, so the gap
- * never yields a finding.
- */
-function detected(exemptionClass, detect, input) {
-    try {
-        return detect(input);
-    }
-    catch (error) {
-        if (!(error instanceof Unanswerable)) {
-            throw error;
-        }
-        const kinds = RETAINABLE.get(exemptionClass);
-        return input.held.symbols
-            .filter((symbol) => (kinds === undefined ? symbol.kind !== "file" : kinds.has(symbol.kind)))
-            .map((symbol) => ({ id: symbol.id, detail: UNANSWERED_DETAIL, site: symbol.position }));
-    }
-}
-/**
- * Every record one project's detectors found, one per piece of evidence, before the
- * mode decides which of them hold: what {@link heldRecords} reads. Classes run in the
- * vocabulary's order and a switched-off class runs not at all; evidence on a private
- * member the class's row says it cannot retain is dropped, whatever the detector found.
- */
-export function evidenceRecords(input, detectors, disabled) {
-    const visibility = new Map(input.held.symbols.map((symbol) => [symbol.id, symbol.visibility]));
-    const found = [];
-    for (const exemptionClass of TS_EXEMPTION_CLASSES) {
-        const detect = detectors.get(exemptionClass);
-        if (detect === undefined || disabled.has(exemptionClass)) {
-            continue;
-        }
-        const allowed = typescriptVisibilityOf(exemptionClass);
-        for (const evidence of detected(exemptionClass, detect, input)) {
-            if (!retainable(allowed, visibility.get(evidence.id))) {
-                continue;
-            }
-            found.push({
-                id: evidence.id,
-                class: exemptionClass,
-                detail: evidence.detail,
-                site: evidence.site,
-                ...(evidence.whileLive === undefined ? {} : { whileLive: evidence.whileLive }),
-                ...(evidence.implementing === undefined ? {} : { implementing: evidence.implementing }),
-            });
-        }
-    }
-    return found;
-}
-/** The records that hold under one mode, beside the evidence a production mode found in a test file. */
-export function heldRecords(records, holding) {
-    const found = [];
-    const inTestFiles = [];
-    for (const record of records) {
-        if (holding.mode.production && holding.testFiles.has(record.site.path)) {
-            inTestFiles.push(record);
-        }
-        else {
-            found.push(record);
-        }
-    }
-    return { records: exemptionsOf(found), inTestFiles };
-}
-/** Two strings ordered bytewise. */
-function compare(a, b) {
-    if (a === b) {
-        return 0;
-    }
-    return a < b ? -1 : 1;
-}
-/**
- * Records as a run holds them: ordered by site, then class, then declaration, and one
- * per declaration, class, detail and file it holds while live, the one at the first
- * site. A fact found at many sites, or by several projects, is one record.
- */
-export function exemptionsOf(found) {
-    const ordered = [...found].sort((a, b) => byPosition(a.site, b.site) || compare(a.class, b.class) || compare(a.id, b.id));
-    const seen = new Set();
-    return ordered.filter((record) => {
-        const fact = [record.id, record.class, record.detail, record.whileLive ?? ""].join("\u0000");
-        if (seen.has(fact)) {
-            return false;
-        }
-        seen.add(fact);
-        return true;
-    });
-}
-/**
- * The records that hold while the component files at `live` are live: every record that
- * holds whatever is live, and each one a live file's markup holds, as a record of the run.
- */
-export function holdingWhile(records, live) {
-    return exemptionsOf(records.flatMap(({ whileLive, ...record }) => whileLive === undefined || live.has(whileLive) ? [record] : []));
-}
-/** The records per declaration, each declaration's in the order given. */
-function byDeclaration(records) {
-    const grouped = new Map();
-    for (const record of records) {
-        const held = grouped.get(record.id);
-        if (held === undefined) {
-            grouped.set(record.id, [record]);
-        }
-        else {
-            held.push(record);
-        }
-    }
-    return grouped;
-}
-/**
- * The records that held back a declaration: one some configuration's graph, swept
- * again with no exemption and its marks, judges a candidate, whatever another
- * configuration answers, or one in `writeOnly`, which the run would report as written
- * and never read without the record's read. A declaration a relation or a mark holds
- * live in every configuration is held back by no record. The order is the
- * declarations' site order, and for one declaration the input's.
- */
-export function retainedIn(matrix, input, writeOnly = new Set()) {
-    const exempt = input.exempt ?? [];
-    if (exempt.length === 0) {
-        return [];
-    }
-    const bare = { marked: input.marked, mode: input.mode };
-    const dead = new Set(matrix.graphs.flatMap((graph) => sweep(graph, bare).candidates.map((candidate) => candidate.id)));
-    const held = byDeclaration(exempt.filter((record) => dead.has(record.id) || writeOnly.has(record.id)));
-    return matrix.union.symbols.flatMap((symbol) => held.get(symbol.id) ?? []);
-}
-/**
- * One line per held-back declaration, in site order: its reference, then each record's
- * class, site and detail, all separated by tabs.
- */
-export function retainedLines(symbols, retained) {
-    const held = byDeclaration(retained);
-    return symbols.flatMap((symbol) => {
-        const records = held.get(symbol.id);
-        if (records === undefined) {
-            return [];
-        }
-        const fields = records.flatMap((record) => [
-            record.class,
-            positionKey(record.site),
-            record.detail,
-        ]);
-        return [[symbol.ref, ...fields].join("\t")];
-    });
-}

package/dist/src/generated-file.js

@@ -1,95 +0,0 @@
-/**
- * The generated-file class on TypeScript: every declaration in a file that marks itself
- * generated, or below a directory an applied convention row names as generated, is
- * retained, because a generator owns the file and a deletion there is undone at the next
- * generation.
- */
-/** The generated-code header, matched against each line of a leading comment. */
-const HEADER_LINE = /^\/\/ Code generated .* DO NOT EDIT\.$/u;
-/** The documentation tag `@generated` as a word of a comment. */
-const GENERATED_TAG = /(?<![\w@$])@generated(?![\w$-])/u;
-/** A first comment naming the tool that wrote the file. */
-const GENERATED_BY = /^\/\/ Generated by \S/u;
-/** The word a generator's notice holds, beside one of {@link KEEP_OUT}. */
-const GENERATED_WORD = /\bgenerated\b/iu;
-/** The phrases a generator's notice asks a reader not to edit the file by. */
-const KEEP_OUT = /\b(?:do not edit|will be overwritten|should not make any changes)\b/iu;
-/** The comments before a text's first token, a leading hashbang line skipped. */
-function leadingComments(text) {
-    const comments = [];
-    let at = text.startsWith("\uFEFF") ? 1 : 0;
-    if (text.startsWith("#!", at)) {
-        const end = text.indexOf("\n", at);
-        at = end === -1 ? text.length : end + 1;
-    }
-    for (;;) {
-        while (at < text.length && /\s/u.test(text.charAt(at))) {
-            at++;
-        }
-        if (text.startsWith("//", at)) {
-            const end = text.slice(at).search(/[\r\n\u2028\u2029]/u);
-            const stop = end === -1 ? text.length : at + end;
-            comments.push(text.slice(at, stop));
-            at = stop;
-        }
-        else if (text.startsWith("/*", at)) {
-            const end = text.indexOf("*/", at + 2);
-            if (end === -1) {
-                return comments;
-            }
-            comments.push(text.slice(at, end + 2));
-            at = end + 2;
-        }
-        else {
-            return comments;
-        }
-    }
-}
-/** The detail a file's leading comments mark it generated by, or undefined where they mark nothing. */
-export function generatedByComment(text) {
-    const comments = leadingComments(text);
-    if (comments.some((one) => one.split(/\r?\n/u).some((line) => HEADER_LINE.test(line)))) {
-        return "generated by the header line its leading comments hold";
-    }
-    if (comments.some((one) => GENERATED_TAG.test(one))) {
-        return "generated by the @generated tag its leading comments hold";
-    }
-    const notice = comments.join("\n");
-    if (GENERATED_BY.test(comments[0] ?? "") ||
-        (GENERATED_WORD.test(notice) && KEEP_OUT.test(notice))) {
-        return "generated by the notice its leading comments hold";
-    }
-    return undefined;
-}
-/**
- * Every own file of one project that is generated, by its path below the target root,
- * with the detail a retention in it names: its leading comments' mark, else the row
- * naming its directory as generated.
- */
-export function generatedFilesOf(files, byRow) {
-    const found = new Map();
-    for (const [path, file] of files.byPath) {
-        const row = byRow.get(path);
-        const detail = generatedByComment(file.text) ??
-            (row === undefined
-                ? undefined
-                : `generated below a directory the convention row ${row} names`);
-        if (detail !== undefined) {
-            found.set(path, detail);
-        }
-    }
-    return found;
-}
-/** The generated-file detector, recording each file's first line. */
-export function generatedFile(input) {
-    const generated = input.generated;
-    if (generated === undefined || generated.size === 0) {
-        return [];
-    }
-    return input.held.symbols.flatMap((symbol) => {
-        const detail = generated.get(symbol.position.path);
-        return symbol.kind === "file" || detail === undefined
-            ? []
-            : [{ id: symbol.id, detail, site: { path: symbol.position.path, line: 1, column: 1 } }];
-    });
-}

package/dist/src/glob.js

@@ -1,65 +0,0 @@
-/**
- * Glob patterns over the paths of the target's own files, as the configuration
- * writes them. Both `ts.test_files` and `ts.entry_files` name files this way, and
- * one grammar answers for both.
- *
- * A configured root is not written in this grammar. It names a symbol reference
- * rather than a path, `*` there spans the solidus and a brace list means nothing,
- * so that rule is written where it is read.
- */
-/**
- * One literal run of a pattern, with every character the expression syntax claims
- * escaped.
- *
- * The set is the syntax characters and the solidus, and it is closed: an escape of any
- * other character is refused outright by the expression syntax under the unicode flag,
- * so escaping a hyphen, which needs none outside a character class, would refuse every
- * pattern that names a hyphenated path.
- */
-function quoted(text) {
-    return text.replaceAll(/[.*+?^${}()|[\]\\/]/gu, (character) => `\\${character}`);
-}
-/**
- * The expression one glob pattern denotes. `**` spans path separators while `*` and `?`
- * do not, a brace list is an alternation of its members, and every other character
- * stands for itself.
- */
-export function globExpression(pattern) {
-    let source = "^";
-    let at = 0;
-    while (at < pattern.length) {
-        const rest = pattern.slice(at);
-        if (rest.startsWith("**/")) {
-            source += "(?:[^/]*/)*";
-            at += 3;
-            continue;
-        }
-        if (rest.startsWith("**")) {
-            source += ".*";
-            at += 2;
-            continue;
-        }
-        const character = pattern[at] ?? "";
-        at += 1;
-        if (character === "*") {
-            source += "[^/]*";
-            continue;
-        }
-        if (character === "?") {
-            source += "[^/]";
-            continue;
-        }
-        if (character === "{") {
-            const close = pattern.indexOf("}", at);
-            if (close < 0) {
-                source += "\\{";
-                continue;
-            }
-            source += `(?:${pattern.slice(at, close).split(",").map(quoted).join("|")})`;
-            at = close + 1;
-            continue;
-        }
-        source += quoted(character);
-    }
-    return new RegExp(`${source}$`, "u");
-}

package/dist/src/manifest.js

@@ -1,165 +0,0 @@
-/**
- * The entry points a package manifest names, which are roots because something
- * outside the analyzed program reaches them: a consumer importing the package, or a
- * shell running its command or one of its scripts. {@link readManifest} reads one
- * directory's manifest, {@link packageEntries} those of the packages below the target root.
- */
-import { isAbsolutePath, joinPath, relativePath, resolvePath } from "./paths.js";
-/** The manifest's own name. */
-const MANIFEST = "package.json";
-/** The three members that name an entry point beside `exports` and `bin`. */
-const LEGACY_MEMBERS = ["main", "module", "types"];
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-/**
- * Whether one member's value names a file of this package rather than another
- * package or a URL. A target written with no leading dot is a path too, which is
- * how the members that preceded `exports` are written.
- */
-function isTarget(value, requireDot) {
-    if (value === "" || isAbsolutePath(value) || value.includes("://")) {
-        return false;
-    }
-    return !requireDot || value.startsWith("./");
-}
-/** Where a script's command line splits into tokens: white space and the shell's operators. */
-const SCRIPT_SEPARATORS = /\s+|&&|\|\||;|\|/u;
-/** A token written inside one pair of quotes. */
-const QUOTED = /^(["'])(.*)\1$/su;
-/**
- * Every token one script's command line holds, each with one pair of enclosing quotes
- * removed. A token holding a wildcard is a pattern rather than a path, and names no
- * entry point.
- */
-export function scriptTokens(command) {
-    return command
-        .split(SCRIPT_SEPARATORS)
-        .map((token) => token.replace(QUOTED, "$2"))
-        .filter((token) => token !== "" && !token.includes("*"));
-}
-/** One member's spelling below another: `exports` then `exports["."]`. */
-function below(member, key) {
-    return `${member}[${JSON.stringify(key)}]`;
-}
-/**
- * Every target one `exports` value carries, at the member each is written under.
- *
- * The value nests strings, subpath or condition objects and alternative arrays to
- * any depth; a `null` blocks a subpath. Every level is walked, because each
- * condition names its own entry file, and a key's meaning is never read.
- */
-function exportTargets(value, member, found) {
-    if (typeof value === "string") {
-        if (isTarget(value, true)) {
-            found.push({ member, path: value, role: "import", published: true });
-        }
-        return;
-    }
-    if (Array.isArray(value)) {
-        value.forEach((alternative, index) => {
-            exportTargets(alternative, below(member, String(index)), found);
-        });
-        return;
-    }
-    if (!isRecord(value)) {
-        return;
-    }
-    for (const [key, held] of Object.entries(value)) {
-        exportTargets(held, below(member, key), found);
-    }
-}
-/** The manifest at the target root, decoded, or undefined where there is none to read. */
-function manifestOf(host, targetRoot) {
-    let text;
-    try {
-        text = host.readFile(joinPath(targetRoot, MANIFEST));
-    }
-    catch {
-        return undefined;
-    }
-    let value;
-    try {
-        value = JSON.parse(text);
-    }
-    catch {
-        // A manifest this program cannot read names no entry point, which is the same
-        // answer as an absent one. What a manifest's contents say is not refused here:
-        // the package manager owns that refusal, and an analysis of a tree it rejects
-        // is not the run's subject.
-        return undefined;
-    }
-    return isRecord(value) ? value : undefined;
-}
-/**
- * What the manifest in `targetRoot` declares about where its package is entered.
- *
- * A target is taken as written. It is not resolved to a source file here, because
- * which file a target names is a fact about the compiler configuration that emits
- * it and there is one such configuration per project, while there is one manifest.
- */
-export function readManifest(host, targetRoot) {
-    const manifest = manifestOf(host, targetRoot);
-    if (manifest === undefined) {
-        return { entries: [], declaresExports: false };
-    }
-    const found = [];
-    for (const member of LEGACY_MEMBERS) {
-        const value = manifest[member];
-        if (typeof value === "string" && isTarget(value, false)) {
-            found.push({ member, path: value, role: "import", published: true });
-        }
-    }
-    const bin = manifest["bin"];
-    if (typeof bin === "string" && isTarget(bin, false)) {
-        found.push({ member: "bin", path: bin, role: "run", published: false });
-    }
-    else if (isRecord(bin)) {
-        for (const [command, value] of Object.entries(bin)) {
-            if (typeof value === "string" && isTarget(value, false)) {
-                found.push({ member: below("bin", command), path: value, role: "run", published: false });
-            }
-        }
-    }
-    exportTargets(manifest["exports"], "exports", found);
-    const scripts = manifest["scripts"];
-    if (isRecord(scripts)) {
-        for (const [name, command] of Object.entries(scripts)) {
-            if (typeof command !== "string") {
-                continue;
-            }
-            for (const token of new Set(scriptTokens(command))) {
-                found.push({
-                    member: below("scripts", name),
-                    path: token,
-                    role: "script",
-                    published: false,
-                });
-            }
-        }
-    }
-    return {
-        entries: found.map((entry) => ({
-            ...entry,
-            path: resolvePath(targetRoot, entry.path),
-            dir: targetRoot,
-        })),
-        declaresExports: manifest["exports"] !== undefined,
-    };
-}
-/**
- * The entry points the manifests of the nested packages in `dirs` name. Each entry is
- * spelled under its manifest's path below the target root, and is published by its own
- * manifest's rule, as the target's own entries are.
- */
-export function packageEntries(host, targetRoot, dirs) {
-    return dirs.flatMap((dir) => {
-        const manifest = readManifest(host, dir);
-        const where = `${relativePath(targetRoot, dir) ?? dir}/${MANIFEST}`;
-        return manifest.entries.map((entry) => ({
-            ...entry,
-            member: `${where} ${entry.member}`,
-            published: entry.published && (!manifest.declaresExports || entry.member.startsWith("exports")),
-        }));
-    });
-}