ttsc 0.20.1 → 0.22.0

package/lib/launcher/internal/singleFileOutput.js

@@ -0,0 +1,103 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveSingleFileOutput = resolveSingleFileOutput;
+const node_path_1 = __importDefault(require("node:path"));
+const readProjectConfig_1 = require("../../compiler/internal/project/readProjectConfig");
+const schema_1 = require("../../flags/schema");
+/**
+ * Resolves the only file that positional `ttsc <source>` can materialize in the
+ * user's tree.
+ *
+ * The compiler itself emits into a private temporary directory. The launcher
+ * then copies one transformed JavaScript file to this path, so project-mode
+ * declaration, map, build-info, outFile, and broad outDir products are not
+ * positional outputs.
+ */
+function resolveSingleFileOutput(options) {
+    const project = readProjectSettings(options);
+    const extension = singleFileJavaScriptExtension(options.file, passthroughStringOption(options.passthrough, "--jsx") ?? project?.jsx);
+    const jsBasename = node_path_1.default.basename(options.file).replace(/\.(?:[cm]?tsx?|jsx)$/i, "") +
+        extension;
+    if (options.cliOutDir) {
+        const relative = node_path_1.default.relative(options.cwd, options.file);
+        const jsRelative = relative.slice(0, relative.length - node_path_1.default.extname(relative).length) +
+            extension;
+        return node_path_1.default.resolve(options.cwd, options.cliOutDir, jsRelative);
+    }
+    if (project?.outDir !== undefined) {
+        const fromRoot = node_path_1.default.relative(project.rootDir, options.file);
+        if (fromRoot !== "" && !isOutsideSingleFileLayout(fromRoot)) {
+            const jsRelative = fromRoot.slice(0, fromRoot.length - node_path_1.default.extname(fromRoot).length) +
+                extension;
+            return node_path_1.default.resolve(project.outDir, jsRelative);
+        }
+        return node_path_1.default.resolve(project.outDir, jsBasename);
+    }
+    return options.file.replace(/\.(?:[cm]?tsx?|jsx)$/i, extension);
+}
+function readProjectSettings(options) {
+    try {
+        const project = (0, readProjectConfig_1.readProjectConfig)({
+            cwd: options.cwd,
+            file: options.file,
+            tsconfig: options.tsconfig,
+        });
+        const outDir = project.compilerOptions.outDir;
+        const rawRoot = project.compilerOptions.rootDir;
+        const rootDir = typeof rawRoot === "string" && rawRoot.length !== 0
+            ? node_path_1.default.isAbsolute(rawRoot)
+                ? rawRoot
+                : node_path_1.default.resolve(project.root, rawRoot)
+            : project.root;
+        const rawJsx = project.compilerOptions.jsx;
+        return {
+            jsx: typeof rawJsx === "string" && rawJsx.length !== 0
+                ? rawJsx.toLowerCase()
+                : undefined,
+            outDir: typeof outDir === "string" && outDir.length !== 0 ? outDir : undefined,
+            rootDir,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function isOutsideSingleFileLayout(relative) {
+    return (relative === ".." ||
+        relative.startsWith(`..${node_path_1.default.sep}`) ||
+        node_path_1.default.isAbsolute(relative));
+}
+function singleFileJavaScriptExtension(file, jsx) {
+    switch (node_path_1.default.extname(file).toLowerCase()) {
+        case ".mts":
+            return ".mjs";
+        case ".cts":
+            return ".cjs";
+        case ".tsx":
+        case ".jsx":
+            return jsx === "preserve" ? ".jsx" : ".js";
+        default:
+            return ".js";
+    }
+}
+function passthroughStringOption(tokens, name) {
+    let value;
+    for (let index = 0; index < (tokens?.length ?? 0); index++) {
+        const token = tokens?.[index];
+        if (token === undefined ||
+            token.includes("=") ||
+            (0, schema_1.resolveFlagSpec)(token)?.name !== (0, schema_1.resolveFlagSpec)(name)?.name) {
+            continue;
+        }
+        const next = tokens?.[index + 1];
+        if (next !== undefined) {
+            value = next.toLowerCase();
+            index++;
+        }
+    }
+    return value;
+}
+//# sourceMappingURL=singleFileOutput.js.map

package/lib/launcher/internal/singleFileOutput.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"singleFileOutput.js","sourceRoot":"","sources":["../../../src/launcher/internal/singleFileOutput.ts"],"names":[],"mappings":"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"}

package/lib/launcher/internal/watchTopology.d.ts

@@ -1,13 +1,27 @@
+import { type ProjectInputPathIdentityContext } from "../../internal/projectInputPathIdentity";
+import type { ITtscProjectInputSnapshot } from "../../structures/internal/ITtscProjectInputSnapshot";
 import type { TtscBuildOptions } from "../../structures/internal/TtscBuildOptions";
-type WatchTopologyOptions = Pick<TtscBuildOptions, "binary" | "env" | "outDir" | "passthrough" | "projectRoot" | "tsconfig"> & {
+type WatchTopologyOptions = Pick<TtscBuildOptions, "binary" | "emit" | "env" | "outDir" | "passthrough" | "projectRoot" | "tsconfig"> & {
     cwd: string;
     files: readonly string[];
 };
 type WatchTopologyCallbacks = {
     onError(location: string, error: unknown): void;
-    onInputChange(): void;
+    onInputChange(change: WatchInputChange): void;
+    onProjectInputWatchRoots?(roots: readonly string[]): void;
     onTopologyChange(): void;
 };
+export type WatchInputChange = {
+    /** Keep the resident process but cold-load its compiler Program. */
+    invalidate?: boolean;
+    kind: "compiler" | "config" | "plugin" | "project";
+    path?: string;
+};
+export type CompilerDirectoryWatchEventPlan = {
+    changes: string[];
+    rearm: string[];
+    refresh: boolean;
+};
 /**
  * Keeps the launcher watch set aligned with the compiler's current program.
  *
@@ -19,25 +33,223 @@ type WatchTopologyCallbacks = {
 export declare class WatchTopology {
     private readonly options;
     private readonly callbacks;
+    private analysisOnly;
+    private closed;
     private directories;
     private directoryWatchers;
     private extraInputs;
     private extraWatchers;
+    private compilerFileStamps;
     private files;
     private fileWatchers;
     private observedDirectories;
+    private outputFiles;
     private outputs;
+    private projectInputFingerprints;
+    private projectInputMatches;
+    private projectInputs;
+    private declaredProjectInputs;
+    private projectInputRejectedWatchRoots;
+    private projectInputWatchRoots;
+    private projectInputWatchers;
+    private projectInputLinkWatchers;
+    private reloadFiles;
     constructor(options: WatchTopologyOptions, callbacks: WatchTopologyCallbacks);
     /** Re-resolve compiler inputs and notify only when their membership changed. */
     refresh(notify: boolean): void;
     /** Add Go plugin source trees discovered by the real build lane. */
     setExtraInputs(inputs: readonly string[]): void;
+    /**
+     * Reconcile project-rule dependencies, retaining absent files and empty glob
+     * populations as live topology.
+     */
+    setProjectInputs(inputs: ITtscProjectInputSnapshot): void;
     /** Close every watcher so SIGINT/SIGTERM can drain the event loop. */
     close(): void;
     private syncFileWatchers;
+    /** Whether a tracked file's bytes differ from the last stamp taken. */
+    private compilerFileMoved;
     private syncDirectoryWatchers;
+    /**
+     * Narrow a plan's changes to the tracked files that actually moved.
+     *
+     * A backend that cannot name what changed forces the plan to nominate every
+     * tracked file under the watched directory, which is the only safe answer it
+     * can give from an event carrying no filename. macOS delivers such events for
+     * ordinary activity elsewhere in the project, so the compiler lane would wake
+     * for sources nobody touched. Only a content notification passes through: it
+     * is the one event that claims the bytes moved. A rename claims the directory
+     * entry was rewritten and an unnamed event claims nothing, so both are
+     * decided from the bytes, which is the question neither of them answered.
+     */
+    private compilerChangesToReport;
+    private recordCompilerFileStamp;
+    private rearmFileWatchers;
     private syncExtraWatchers;
+    private syncProjectInputWatchers;
+    /**
+     * Watch the directory that holds a declaration which is itself a link.
+     *
+     * A recursive watcher cannot report the link being replaced. The backend that
+     * keys its handles by path skips an entry it already knows, and the handle it
+     * put on the entry followed the link to the target's inode, which unlinking
+     * and recreating the link never touches. A plain directory watch has neither
+     * property: it reports the entry by name the moment it moves. These are kept
+     * apart from the recursive roots because they are not roots — they observe
+     * one directory, they are never reported as watch roots, and an ancestor
+     * covering them does not make them redundant.
+     */
+    private syncProjectInputLinkWatchers;
+    /** Drop the watcher that just reported a directory replacement. */
+    private retireProjectInputWatcher;
+    private retainProjectInputWatchRoot;
+    /**
+     * One snapshot holding every spelling of every declaration.
+     *
+     * Consumers that decide from a population rather than from a single path have
+     * to see both, or half of them answer from the file a link pointed at when
+     * the snapshot was published while the event they are judging resolved to the
+     * file it points at now.
+     */
+    private projectInputPopulation;
+    /**
+     * Every spelling of one declaration that has to be anchored separately.
+     *
+     * The retained snapshot is normalized to physical identities, which is what
+     * every comparison needs but not what every watcher needs: a declaration
+     * reached through a symlink resolves to its target's directory, so anchoring
+     * the normalized form alone watches the bytes and never the link. Retargeting
+     * or replacing the link then goes unobserved, even though it is exactly what
+     * decides which bytes the declaration names next. Both spellings are planned
+     * through the same root selection, so the project-root hoist and the
+     * nearest-existing-ancestor boundary still bound each of them, and the active
+     * set drops one again whenever they coincide or share an ancestor.
+     */
+    private projectInputDeclarations;
+    private projectInputWatchRoot;
+    private refreshProjectInputs;
+    private collectProjectInputMatches;
     private refreshFromDirectory;
     private isCompilerOutputDirectory;
+    private isCompilerOutput;
+    private isProjectInputCompilerOutputDirectory;
+    private isProjectInputCompilerOutput;
+    private isProjectInputDirectory;
+    private classifyCompilerInput;
+    private isPluginInput;
 }
+export declare function reloadInputsForFailedTopologyRefresh(reloadFiles: Iterable<string>, changed?: string): string[];
+type SynchronizedWatcher = {
+    close(): void;
+    on(event: "error", listener: (error: Error) => void): unknown;
+};
+export declare function syncWatchers<T extends SynchronizedWatcher>(watchers: Map<string, T>, desired: ReadonlyMap<string, string>, create: (location: string, key: string) => T, onError: (location: string, error: unknown) => void): boolean;
+export declare function literalGlobRoot(pattern: string): string;
+/**
+ * Chooses the one stable recursive watcher root owned by a project-input
+ * declaration.
+ *
+ * Inputs inside the project share its physical root so directory replacement
+ * cannot strand a child handle. External inputs use the nearest existing
+ * ancestor of their declared parent, which is the explicit boundary for
+ * observing a currently missing external tree without polling every file --
+ * except that the boundary never rises to a directory holding the project,
+ * since such a root outranks the project's own in the active merge and leaves
+ * one handle over a shared system directory to carry everything. An external
+ * declaration that can only be owned that way falls back to its own tree, and
+ * is left unwatched when even that would contain the project.
+ */
+export declare function projectInputWatchDirectories(target: string, projectRoot: string): string[];
+/**
+ * Removes recursive roots already covered by an ancestor without rewriting the
+ * declaration-specific roots retained by WatchTopology.
+ */
+export declare function projectInputActiveWatchDirectories(directories: Iterable<string>, identities?: ProjectInputPathIdentityContext): string[];
+export declare function projectInputAvailableWatchDirectory(location: string, rejected: ReadonlySet<string>, identities?: ProjectInputPathIdentityContext, projectRoot?: string): string | undefined;
+/**
+ * Whether a replacement at this path leaves a recursive watcher bound to the
+ * object that was replaced.
+ *
+ * Only one backend needs the answer. Node routes a recursive watch to its own
+ * per-directory implementation when the platform is neither macOS nor Windows,
+ * and that implementation keys its handles by path: the handle for a directory
+ * renamed away stays bound to the object that left, and any child whose name
+ * survives the swap is skipped as already known. The native subtree backends
+ * both other platforms use follow the path, so retiring their watcher would buy
+ * nothing and would open a window in which no events are delivered.
+ *
+ * The answer is deliberately narrower than the rescan rule, because
+ * reinstalling a root costs one watch descriptor per entry beneath it, which an
+ * install storm would pay thousands of times. A directory appearing inside a
+ * glob root deserves a rescan but replaces nothing a root stands on, and a
+ * reload directory anchors the directory that contains it rather than itself,
+ * since its fingerprint is a digest of its own immediate entries and nothing
+ * below it can reach the declared corpus.
+ */
+export declare function projectInputReplacementStrandsWatchers(snapshot: ITtscProjectInputSnapshot, location: string, identities?: ProjectInputPathIdentityContext, platform?: NodeJS.Platform): boolean;
+/**
+ * Decide whether an event that named no declared input can still have moved
+ * one.
+ *
+ * The admitted set is the only bound on how often a watch session re-reads and
+ * re-hashes its declared corpus, and both directions cost: too narrow drops an
+ * atomic replacement, too wide re-fingerprints on every entry an install
+ * creates. Exported so that boundary is pinned directly instead of being
+ * inferred from a rebuild that a silent rescan and a skipped rescan produce
+ * identically.
+ */
+export declare function projectInputTopologyMayAffect(snapshot: ITtscProjectInputSnapshot, location: string, previous: ReadonlyMap<string, string>, identities?: ProjectInputPathIdentityContext): boolean;
+export declare function projectInputEventShouldNotify(input: {
+    contentChanged: boolean;
+    directlyMatched: boolean;
+    membershipChanged: boolean;
+}): boolean;
+/**
+ * Classify an exact execution-selection input ahead of ordinary project data.
+ *
+ * `changedInputs` carries fingerprint or membership deltas, so a filename-less
+ * event can still select the cold lane. A named exact event selects the cold
+ * lane only after the surrounding change detector admits the event; unchanged
+ * bytes remain quiet before this classifier is observed.
+ */
+export declare function projectInputReloadEventShouldNotify(input: {
+    changed?: string;
+    changedInputs: readonly string[];
+    reloadDirectories?: readonly string[];
+    reloadFiles: readonly string[];
+    globs?: readonly string[];
+}): boolean;
+/**
+ * Return whether a project-input population transition can reshape a Program.
+ *
+ * JSON is data to a ProjectRule but may simultaneously be a `resolveJsonModule`
+ * source. TypeScript and JavaScript paths can likewise overlap a project-input
+ * declaration. Their creation or deletion therefore requires a cold Program
+ * inside the existing resident process. A filename-less event cannot identify
+ * the changed member and is conservatively invalidating whenever the population
+ * moved.
+ */
+export declare function projectInputMembershipInvalidatesProgram(input: {
+    changed?: string;
+    changedInputs?: readonly string[];
+    contentChanged?: boolean;
+    next: ReadonlyMap<string, string>;
+    previous: ReadonlyMap<string, string>;
+}): boolean;
+/**
+ * Plan one compiler-directory event without relying on backend timing.
+ *
+ * POSIX file watchers own ordinary content changes. A named rename re-arms the
+ * replaced file; an unnamed event conservatively re-arms and reports every
+ * surviving tracked input below the watch root. Windows has no per-file
+ * watchers here, so both named and unnamed directory events report inputs.
+ */
+export declare function planCompilerDirectoryWatchEvent(input: {
+    changed?: string;
+    event: string;
+    exists(location: string): boolean;
+    location: string;
+    platform: NodeJS.Platform;
+    trackedFiles: ReadonlyMap<string, string>;
+}): CompilerDirectoryWatchEventPlan;
 export {};