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

package/src/load/load.ts

@@ -0,0 +1,73 @@
+import type { PartialConfig } from "../config.ts";
+import type { Host } from "../host.ts";
+import { resolvePath } from "../paths.ts";
+import type { UnansweredQuestion } from "../query.ts";
+import type { Scope } from "../scope.ts";
+import { openSession, type Engine } from "../session.ts";
+import { classify, type Classified } from "./classify.ts";
+import { planRun, programBuilds, type RunPlan } from "./plan.ts";
+
+/** The run as the load phase opens it, valid only inside the reader it is handed to. */
+interface OpenedRun {
+  readonly plan: RunPlan;
+  readonly classified: Classified;
+  /**
+   * Every file a configuration read from a file holds, absolute, so a file another
+   * configuration compiles is no outside file. A program the run forms resolves no emitted
+   * output back to its source, so its files are read as outside files too.
+   */
+  readonly runFiles: ReadonlySet<string>;
+}
+
+/** What one loaded run answered, beside its plan and its classification. */
+export interface LoadedRun<Result> extends Omit<OpenedRun, "runFiles"> {
+  readonly result: Result;
+  /** Every question the checker could not answer, each once, in the order first asked. */
+  readonly unanswered: readonly UnansweredQuestion[];
+}
+
+/**
+ * Plans the run, opens every configuration in one snapshot of one client, classifies every
+ * project, and hands the analyzed and the consumer projects to `read` while the client answers.
+ * A run that cannot be analyzed ends with one {@link FailureExit} before `read` is called.
+ */
+export function loadRun<Result>(
+  engine: Engine,
+  host: Host,
+  scope: Scope,
+  config: PartialConfig,
+  read: (opened: OpenedRun) => Result,
+): LoadedRun<Result> {
+  const plan = planRun(engine, host, scope, config);
+  return openSession(
+    engine,
+    plan.plans.map((one) => one.configFile),
+    { programs: programBuilds(host, plan.plans) },
+    (session, unanswered) => {
+      const classified = classify(
+        engine,
+        host,
+        plan,
+        new Map(session.views.map((view) => [view.configFile, view])),
+      );
+      const formed = new Set(
+        plan.plans.filter((one) => one.written !== undefined).map((one) => one.configFile),
+      );
+      const runFiles = new Set(
+        session.views
+          .filter((view) => !formed.has(view.configFile))
+          .flatMap((view) =>
+            view
+              .ownSourceFiles()
+              .map((file) => resolvePath(host.workingDirectory(), file.fileName)),
+          ),
+      );
+      return {
+        plan,
+        classified,
+        result: read({ plan, classified, runFiles }),
+        unanswered: unanswered(),
+      };
+    },
+  );
+}

package/src/load/module-lookup.ts

@@ -0,0 +1,50 @@
+/**
+ * Where a package an import names is installed and which manifests above an importer declare
+ * it: the leaf both the expected-module reading and the workspace resolution read.
+ */
+
+import { DEPENDENCY_SECTIONS, INSTALLED_PACKAGES, manifestAt } from "../fs/manifest.ts";
+import type { Host } from "../host.ts";
+import { isRecord } from "../json-document.ts";
+import { ancestors, joinPath } from "../paths.ts";
+
+/**
+ * The directory `node_modules/<name>` holds for an importer in `dir`: the nearest one at or
+ * above `dir`, above any target root too, that is a directory, a link to one included, as the
+ * compiler looks a package up. Undefined where no ancestor installs it.
+ */
+export function installedPackage(host: Host, dir: string, name: string): string | undefined {
+  return ancestors(dir)
+    .map((at) => joinPath(at, INSTALLED_PACKAGES, name))
+    .find((candidate) => host.kindOf(candidate) === "directory");
+}
+
+export interface ManifestAt {
+  readonly dir: string;
+  readonly manifest: Record<string, unknown>;
+}
+
+/**
+ * The manifests at or above `dir` and no higher than `top`, nearest first; a directory outside
+ * `top` reads its own manifest alone.
+ */
+export function* manifestsAbove(host: Host, dir: string, top: string): Generator<ManifestAt> {
+  const chain = ancestors(dir, top);
+  for (const at of chain.length > 0 ? chain : [dir]) {
+    const manifest = manifestAt(host, at);
+    if (manifest !== undefined) {
+      yield { dir: at, manifest };
+    }
+  }
+}
+
+/** The specifiers one manifest depends on `name` with, one per dependency section naming it. */
+export function dependencySpecifiers(
+  manifest: Readonly<Record<string, unknown>>,
+  name: string,
+): readonly unknown[] {
+  return DEPENDENCY_SECTIONS.flatMap((section) => {
+    const declared = manifest[section];
+    return isRecord(declared) && Object.hasOwn(declared, name) ? [declared[name]] : [];
+  });
+}

package/src/load/package-scope.ts

@@ -0,0 +1,74 @@
+import { manifestAt } from "../fs/manifest.ts";
+import type { Host } from "../host.ts";
+import { dirnamePath, joinPath } from "../paths.ts";
+import type { Module } from "../ref.ts";
+
+/** One manifest that names a package, and the directory below the root that holds it. */
+interface Named {
+  readonly name: string;
+  readonly at: string;
+}
+
+/**
+ * Resolves each file's package scope: the name of the nearest manifest at or above its
+ * directory up to the target root, and the file's path below that manifest. Where no
+ * manifest up to the root carries a name, the package is a single dot and the path is read
+ * from the root, which cannot collide, because a package name never starts with a dot. One
+ * directory is read at most once.
+ */
+export function packageScope(host: Host, root: string): (path: string) => Module {
+  const named = new Map<string, Named | undefined>();
+
+  const manifestName = (dir: string): string | undefined => {
+    const name = manifestAt(host, joinPath(root, dir))?.["name"];
+    return typeof name === "string" && name !== "" ? name : undefined;
+  };
+
+  const nearest = (dir: string): Named | undefined => {
+    if (named.has(dir)) {
+      return named.get(dir);
+    }
+    const name = manifestName(dir);
+    const found =
+      name !== undefined ? { name, at: dir } : dir === "" ? undefined : nearest(parentOf(dir));
+    named.set(dir, found);
+    return found;
+  };
+
+  return (path) => {
+    const found = nearest(parentOf(path));
+    if (found === undefined) {
+      return { package: ".", path };
+    }
+    return { package: found.name, path: found.at === "" ? path : path.slice(found.at.length + 1) };
+  };
+}
+
+/**
+ * Whether Node reads each file's `.js` siblings as ECMAScript modules: the `type` of the
+ * nearest manifest at or above its directory up to the target root is `module`
+ * (https://nodejs.org/api/packages.html#type). One directory is read at most once.
+ */
+export function packageTypeIsModule(host: Host, root: string): (path: string) => boolean {
+  const typed = new Map<string, boolean>();
+
+  const nearest = (dir: string): boolean => {
+    const known = typed.get(dir);
+    if (known !== undefined) {
+      return known;
+    }
+    const manifest = manifestAt(host, joinPath(root, dir));
+    const found =
+      manifest !== undefined ? manifest["type"] === "module" : dir !== "" && nearest(parentOf(dir));
+    typed.set(dir, found);
+    return found;
+  };
+
+  return (path) => nearest(parentOf(path));
+}
+
+/** The directory one path below the root sits in, and the root itself as the empty path. */
+function parentOf(path: string): string {
+  const dir = dirnamePath(path);
+  return dir === "." ? "" : dir;
+}