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

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

@@ -5,9 +5,9 @@
  */
 import { isExportDeclaration, isImportDeclaration, isStringLiteral, } from "@typescript/native/ast";
 import { resolveRelativeSpecifier } from "./configuration-files.js";
-import { ancestors, dirnamePath, joinPath, resolvePath } from "./paths.js";
-import { filesBelow } from "./fs/tree.js";
-import { holdsManifest } from "./fs/manifest.js";
+import { ancestors, dirnamePath, 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. */

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

@@ -4,8 +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";
-import { filesBelow } from "./fs/tree.js";
+import { dirnamePath, joinPath, resolvePath } 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. */

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,
+    };
+}