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

package/dist/src/{html-entries.js → entries/html-entries.js}

@@ -5,44 +5,17 @@
  */
 import { isExportDeclaration, isImportDeclaration, isStringLiteral, } from "@typescript/native/ast";
 import { resolveRelativeSpecifier } from "./configuration-files.js";
-import { dirnamePath, joinPath, relativePath, resolvePath } from "./paths.js";
-/** The directory no HTML file is read below. */
-const SKIPPED = "node_modules";
+import { ancestors, dirnamePath, hasURLScheme, isAbsolutePath, isExplicitPath, joinPath, resolvePath, } from "../paths.js";
+import { filesBelow } from "../fs/tree.js";
+import { holdsManifest } from "../fs/manifest.js";
 /** A `<script` start tag, its attribute text captured. */
 const SCRIPT_TAG = /<script(?=[\s>/])([^>]*)>/giu;
 /** The end tag an inline module script's content runs to. */
 const SCRIPT_END = /<\/script\s*>/iu;
 /** One attribute: a name, then a double-quoted, single-quoted or unquoted value. */
 const ATTRIBUTE = /([^\s"'=<>/]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+)))?/gu;
-/** A value that names a resource on another origin, or by another scheme. */
-const ELSEWHERE = /^(?:\/\/|[A-Za-z][A-Za-z\d+.-]*:)/u;
 /** The `type` values a classic script carries, compared in lowercase. */
 const CLASSIC_TYPES = new Set(["text/javascript", "application/javascript"]);
-/** The prefixes an inline script's specifier names a file of the target with. */
-const FILE_PREFIXES = ["/", "./", "../"];
-/** Every HTML file below `dir`, outside every `node_modules` directory, by absolute path. */
-function htmlFiles(host, dir) {
-    let entries;
-    try {
-        entries = host.readDirectory(dir);
-    }
-    catch {
-        return [];
-    }
-    const found = [];
-    for (const entry of entries) {
-        const path = joinPath(dir, entry.name);
-        if (entry.directory) {
-            if (entry.name !== SKIPPED) {
-                found.push(...htmlFiles(host, path));
-            }
-        }
-        else if (entry.name.endsWith(".html")) {
-            found.push(path);
-        }
-    }
-    return found.sort();
-}
 /** Each attribute of one start tag's attribute text, by its lowercase name. */
 function attributes(text) {
     const found = new Map();
@@ -92,18 +65,13 @@ function scriptValues(parse, path, text) {
         const rest = text.slice(start);
         const end = rest.search(SCRIPT_END);
         const content = end === -1 ? rest : rest.slice(0, end);
-        values.push(...specifiersOf(parse, `${path}.${String(start)}.ts`, content).filter((specifier) => FILE_PREFIXES.some((prefix) => specifier.startsWith(prefix))));
+        values.push(...specifiersOf(parse, `${path}.${String(start)}.ts`, content).filter(isExplicitPath));
     }
     return values;
 }
 /** The directory of the nearest `package.json` at or above `dir`, inside `root`, else `root`. */
 function manifestDirectory(host, root, dir) {
-    for (let at = dir; relativePath(root, at) !== undefined; at = dirnamePath(at)) {
-        if (host.kindOf(joinPath(at, "package.json")) === "file") {
-            return at;
-        }
-    }
-    return root;
+    return ancestors(dir, root).find((at) => holdsManifest(host, at)) ?? root;
 }
 /**
  * The own files the scripts of every HTML file below the target root load. A value
@@ -115,7 +83,8 @@ function manifestDirectory(host, root, dir) {
 export function htmlEntries(host, targetRoot, files, parse) {
     const root = resolvePath(host.workingDirectory(), targetRoot);
     const found = [];
-    for (const path of htmlFiles(host, root)) {
+    for (const below of filesBelow(host, root, (name) => name.endsWith(".html"))) {
+        const path = joinPath(root, below);
         let text;
         try {
             text = host.readFile(path);
@@ -125,18 +94,19 @@ export function htmlEntries(host, targetRoot, files, parse) {
         }
         const dir = dirnamePath(path);
         for (const value of scriptValues(parse, path, text)) {
-            if (ELSEWHERE.test(value)) {
+            // A value with a scheme, or one starting `//`, names a resource on another origin.
+            if (value.startsWith("//") || hasURLScheme(value)) {
                 continue;
             }
-            const base = value.startsWith("/") ? manifestDirectory(host, root, dir) : dir;
-            const relative = value.startsWith("/") ? `.${value}` : value;
+            const base = isAbsolutePath(value) ? manifestDirectory(host, root, dir) : dir;
+            const relative = isAbsolutePath(value) ? `.${value}` : value;
             const reached = resolveRelativeSpecifier(host, base, relative);
             const file = reached === undefined ? undefined : files.byName.get(reached);
             if (file !== undefined) {
                 found.push({ file, source: value });
                 continue;
             }
-            const served = value.startsWith("/")
+            const served = isAbsolutePath(value)
                 ? files.outputDirs.filter((outDir) => outDir === dir)
                 : [];
             const emitting = [base, ...served].flatMap((against) => files.named(resolvePath(against, relative)));

package/dist/src/{mdx-entries.js → entries/mdx-entries.js}

@@ -4,9 +4,8 @@
  * is an import declaration, which an MDX compiler hoists into the module it builds.
  */
 import { resolveRelativeSpecifier } from "./configuration-files.js";
-import { dirnamePath, joinPath, resolvePath } from "./paths.js";
-/** The directories no document is read below. */
-const SKIPPED = new Set(["node_modules", ".git"]);
+import { dirnamePath, joinPath, resolvePath, startsRelativePath } from "../paths.js";
+import { filesBelow } from "../fs/tree.js";
 /** The extensions of a document whose imports an MDX compiler reads. */
 const DOCUMENT = /\.mdx?$/u;
 /** A fence line, its marker run and what follows it captured. */
@@ -100,29 +99,6 @@ function clauseNames(clause) {
     }
     return names;
 }
-/** Every document below `dir`, outside every skipped directory, by absolute path. */
-function documents(host, dir) {
-    let entries;
-    try {
-        entries = host.readDirectory(dir);
-    }
-    catch {
-        return [];
-    }
-    const found = [];
-    for (const entry of entries) {
-        const path = joinPath(dir, entry.name);
-        if (entry.directory) {
-            if (!SKIPPED.has(entry.name)) {
-                found.push(...documents(host, path));
-            }
-        }
-        else if (DOCUMENT.test(entry.name)) {
-            found.push(path);
-        }
-    }
-    return found.sort();
-}
 /** The relative specifiers one document's import lines name, its fenced code blocks skipped. */
 function importedBy(text) {
     const found = [];
@@ -146,7 +122,7 @@ function importedBy(text) {
         }
         const matched = open === undefined ? IMPORT_LINE.exec(line) : null;
         const specifier = matched?.[2];
-        if (specifier?.startsWith("./") === true || specifier?.startsWith("../") === true) {
+        if (specifier !== undefined && startsRelativePath(specifier)) {
             found.push({ specifier, names: clauseNames(matched?.[1] ?? "") });
         }
     }
@@ -165,7 +141,8 @@ function documentImports(host, root) {
     if (known !== undefined) {
         return known;
     }
-    const found = documents(host, root).flatMap((path) => {
+    const found = filesBelow(host, root, (name) => DOCUMENT.test(name)).flatMap((below) => {
+        const path = joinPath(root, below);
         try {
             return [{ path, imports: importedBy(host.readFile(path)) }];
         }

package/dist/src/entries/run-directories.js

@@ -0,0 +1,77 @@
+import { membersNamed, staticModule, textsOf } from "./static-module.js";
+import { holdsManifest } from "../fs/manifest.js";
+import { ancestors, dirnamePath, joinPath, resolvePath } from "../paths.js";
+/** The configuration file names the bundler and its test runner read their root from. */
+const BUNDLER_CONFIGS = ["vite.config", "vitest.config"].flatMap((stem) => ["js", "mjs", "cjs", "ts", "mts", "cts"].map((extension) => `${stem}.${extension}`));
+/**
+ * The root the configurations of one directory state: the directory where none writes a
+ * `root`, the one literal they all write, or undefined where one cannot be read, writes a
+ * value that is not a literal, or two disagree.
+ */
+function statedRoot(host, parse, dir, configs) {
+    const roots = new Set();
+    for (const name of configs) {
+        const path = joinPath(dir, name);
+        let text;
+        try {
+            text = host.readFile(path);
+        }
+        catch {
+            return undefined;
+        }
+        const objects = staticModule(parse(path, text)).defaultExport;
+        if (objects.length === 0) {
+            return undefined;
+        }
+        for (const object of objects) {
+            const values = object.kind === "object" ? membersNamed(object, "root") : undefined;
+            if (values === undefined) {
+                return undefined;
+            }
+            for (const value of values) {
+                const [root] = textsOf(value, false) ?? [];
+                if (root === undefined) {
+                    return undefined;
+                }
+                roots.add(resolvePath(dir, root));
+            }
+        }
+    }
+    if (roots.size > 1) {
+        return undefined;
+    }
+    return [...roots][0] ?? dir;
+}
+/** The directories of one run below `top`, each read once per directory. */
+export function runDirectories(host, top, parse) {
+    const working = new Map();
+    const bundler = new Map();
+    const workingDirectoryOf = (fileName) => {
+        const dir = dirnamePath(fileName);
+        let found = working.get(dir);
+        if (found === undefined) {
+            found = ancestors(dir, top).find((at) => holdsManifest(host, at)) ?? top;
+            working.set(dir, found);
+        }
+        return found;
+    };
+    return {
+        workingDirectoryOf,
+        bundlerRootOf: (fileName) => {
+            const dir = dirnamePath(fileName);
+            if (bundler.has(dir)) {
+                return bundler.get(dir);
+            }
+            let found = workingDirectoryOf(fileName);
+            for (const at of ancestors(dir, top)) {
+                const configs = BUNDLER_CONFIGS.filter((name) => host.kindOf(joinPath(at, name)) === "file");
+                if (configs.length > 0) {
+                    found = statedRoot(host, parse, at, configs);
+                    break;
+                }
+            }
+            bundler.set(dir, found);
+            return found;
+        },
+    };
+}

package/dist/src/entries/sources.js

@@ -0,0 +1,144 @@
+/**
+ * The sources that enter a project's files with no import naming them, read once per
+ * project into one record every stage reads: the roots stage reads the files they enter,
+ * the dependency stage the configuration files' strings, and the reference pass the test
+ * files. A value a source does not find written out names nothing.
+ */
+import { buildScriptEntries } from "./build-scripts.js";
+import { configurationFiles, filesNamedBy, moduleStrings, } from "./configuration-files.js";
+import { conventionEntries, conventionTestFiles, generatedFiles, } from "./conventions.js";
+import { htmlEntries } from "./html-entries.js";
+import { documentEntries } from "./mdx-entries.js";
+import { dirnamePath } from "../paths.js";
+import { globExpression } from "../text/glob.js";
+import { workflowEntries } from "./workflow-steps.js";
+/**
+ * Each configuration module, with what it exports, and each own file a relative string of
+ * a configuration module or a JSON configuration file names, read against that file's
+ * directory. A string at a selection key of an applied convention row, or naming a test
+ * file, names no file here.
+ */
+const configurationSource = ({ files, configuration, conventions }) => {
+    const selected = conventions?.selected ?? new Map();
+    const found = [];
+    const unselected = (file) => {
+        const starts = selected.get(file.fileName)?.starts;
+        return moduleStrings(file)
+            .filter((one) => starts?.has(one.node.getStart()) !== true)
+            .map((one) => one.text);
+    };
+    const unselectedIn = (path, texts) => {
+        const left = [...(selected.get(path)?.texts ?? [])];
+        return texts.filter((text) => {
+            const at = left.indexOf(text);
+            if (at < 0) {
+                return true;
+            }
+            left.splice(at, 1);
+            return false;
+        });
+    };
+    const strings = (dir, texts) => {
+        for (const text of texts) {
+            for (const file of filesNamedBy(files, dir, text)) {
+                found.push({ file, rule: "configuration-string", source: text, exports: true });
+            }
+        }
+    };
+    for (const { file, form } of configuration.modules) {
+        found.push({ file, rule: "configuration-file", source: form, exports: true });
+        strings(dirnamePath(file.fileName), unselected(file));
+    }
+    for (const document of configuration.documents) {
+        strings(dirnamePath(document.path), unselectedIn(document.path, document.strings));
+    }
+    for (const { file } of configuration.outside) {
+        strings(dirnamePath(file.fileName), unselected(file));
+    }
+    return found;
+};
+const testSource = ({ tests }) => tests.map(({ file, source }) => ({ file, rule: "test-runner", source, exports: false }));
+const conventionSource = ({ files, conventions }) => conventions === undefined
+    ? []
+    : conventionEntries(conventions, files).map(({ file, row }) => ({
+        file,
+        rule: "convention",
+        source: row,
+        exports: true,
+    }));
+const htmlSource = ({ host, targetRoot, files, parse }) => htmlEntries(host, targetRoot, files, parse).map(({ file, source }) => ({
+    file,
+    rule: "html-entry",
+    source,
+    exports: true,
+}));
+const documentSource = ({ host, targetRoot, files }) => documentEntries(host, targetRoot, files).map(({ file, source, names }) => ({
+    file,
+    rule: "document-import",
+    source,
+    exports: true,
+    ...(names === undefined ? {} : { names }),
+}));
+const buildScriptSource = ({ host, targetRoot, files, parse }) => buildScriptEntries(host, targetRoot, files, parse).map(({ file, source }) => ({
+    file,
+    rule: "bundler-entry",
+    source,
+    exports: true,
+}));
+const workflowSource = ({ workflows, files }) => workflowEntries(workflows, files).map(({ file, source }) => ({
+    file,
+    rule: "workflow-step",
+    source,
+    exports: true,
+}));
+/** Every source, each read once per project. */
+const ENTRY_SOURCES = [
+    configurationSource,
+    conventionSource,
+    testSource,
+    htmlSource,
+    documentSource,
+    buildScriptSource,
+    workflowSource,
+];
+/**
+ * The files a test runner loads in one project: each `ts.test_files` pattern's matches
+ * below the target root, then each file an applied row names, once per pattern or row
+ * string that names it.
+ */
+function testFilesOf(context) {
+    const found = [];
+    for (const pattern of context.testFiles) {
+        const expression = globExpression(pattern);
+        for (const [path, file] of context.files.byPath) {
+            if (expression.test(path)) {
+                found.push({ file, source: pattern });
+            }
+        }
+    }
+    const named = context.conventions === undefined
+        ? []
+        : conventionTestFiles(context.conventions, context.files);
+    for (const [name, source] of named) {
+        const file = context.files.byName.get(name);
+        if (file !== undefined) {
+            found.push({ file, source });
+        }
+    }
+    return found;
+}
+/** Reads every source of one project once. */
+export function readSources(context) {
+    const configuration = configurationFiles(context.host, context.targetRoot, context.files, context.parse);
+    const tests = testFilesOf(context);
+    const input = { ...context, configuration, tests };
+    return {
+        entered: ENTRY_SOURCES.flatMap((source) => source(input)),
+        testFiles: new Set(tests.map(({ file }) => file.fileName)),
+        generated: context.conventions === undefined
+            ? new Map()
+            : generatedFiles(context.conventions, context.files),
+        configuration,
+        workflows: context.workflows,
+    };
+}