tsifdef 1.1.8

package/dist/cli/main.js

@@ -0,0 +1,165 @@
+#!/usr/bin/env node
+"use strict";
+// Copyright (C) 2026 Tencent. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CliExitCode = void 0;
+exports.runCli = runCli;
+const node_path_1 = require("node:path");
+const build_js_1 = require("./build.js");
+const config_js_1 = require("./config.js");
+const precompile_js_1 = require("./precompile.js");
+const watch_js_1 = require("./watch.js");
+exports.CliExitCode = {
+    success: 0,
+    diagnostics: 1,
+    failure: 2,
+};
+/** Run the TSIfDef CLI: `build` for projected compilation, else legacy precompile. */
+async function runCli(args, cwd = process.cwd()) {
+    if (args[0] === "build") {
+        return runBuild(args.slice(1), cwd);
+    }
+    return runPrecompile(args, cwd);
+}
+/**
+ * `tsifdef build [--watch] [--emit-projection <dir>] [-p <tsconfig>] [-- <tsc flags>]`.
+ * Flags after `--` are parsed as tsc compiler-option overrides (e.g.
+ * `-- --module commonjs --outDir dist`), mirroring how a build pipeline would
+ * pass per-invocation options to `tsc`.
+ */
+async function runBuild(args, cwd) {
+    const separatorIndex = args.indexOf("--");
+    const ownArgs = separatorIndex >= 0 ? args.slice(0, separatorIndex) : args;
+    const overrideArgs = separatorIndex >= 0 ? args.slice(separatorIndex + 1) : [];
+    const watch = ownArgs.includes("--watch");
+    let emitProjectionDir;
+    const rest = [];
+    for (let index = 0; index < ownArgs.length; index += 1) {
+        const arg = ownArgs[index];
+        if (arg === "--watch")
+            continue;
+        if (arg === "--emit-projection") {
+            const value = ownArgs[index + 1];
+            if (value === undefined || value.trim() === "") {
+                process.stderr.write("Usage: tsifdef build [--emit-projection <dir>]\n");
+                return exports.CliExitCode.failure;
+            }
+            emitProjectionDir = (0, node_path_1.resolve)(cwd, value);
+            index += 1;
+            continue;
+        }
+        rest.push(arg);
+    }
+    try {
+        const project = parseProjectOption(rest, "Usage: tsifdef build [--watch] [--emit-projection <dir>] [-p <tsconfig>] [-- <tsc flags>]");
+        const compilerOptionsOverride = await (0, build_js_1.parseTscOverride)(overrideArgs, cwd);
+        const projectRoot = (0, node_path_1.resolve)(cwd);
+        const configuration = await (0, config_js_1.loadProjectConfiguration)(projectRoot);
+        const profile = await (0, config_js_1.loadProfileFile)(configuration.profilePath);
+        if (watch) {
+            await (0, watch_js_1.watchProject)({
+                projectRoot,
+                project: project ?? "tsconfig.json",
+                profilePath: configuration.profilePath,
+                compilerOptionsOverride,
+                ...(emitProjectionDir === undefined ? {} : { emitProjectionDir }),
+                onBuild: (info) => {
+                    process.stdout.write(info.hasErrors
+                        ? `Rebuilt with errors (${info.macroDiagnostics.size} macro issue(s)).\n`
+                        : `Rebuilt ${info.outputFiles.length} file(s).\n`);
+                },
+                onProfileReload: (reloaded) => {
+                    process.stdout.write(`Profile changed to ${reloaded.fileName}; rebuilding.\n`);
+                },
+            });
+            // Watch mode runs until the process is terminated.
+            return await new Promise(() => { });
+        }
+        const result = await (0, build_js_1.buildProject)({
+            projectRoot,
+            project: project ?? "tsconfig.json",
+            profile,
+            compilerOptionsOverride,
+            ...(emitProjectionDir === undefined ? {} : { emitProjectionDir }),
+        });
+        if (result.hasErrors) {
+            return exports.CliExitCode.diagnostics;
+        }
+        process.stdout.write(`Built ${result.outputFiles.length} file(s) with ${profile.fileName}.\n`);
+        return exports.CliExitCode.success;
+    }
+    catch (error) {
+        if (error instanceof build_js_1.BuildMacroDiagnosticsError) {
+            for (const file of error.files) {
+                for (const diagnostic of file.diagnostics) {
+                    process.stderr.write(`${file.file}:${diagnostic.range.start}: ${diagnostic.message}\n`);
+                }
+            }
+            return exports.CliExitCode.diagnostics;
+        }
+        if (error instanceof build_js_1.BuildUnsupportedError) {
+            process.stderr.write(`${error.message}\n`);
+            return exports.CliExitCode.failure;
+        }
+        process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+        return exports.CliExitCode.failure;
+    }
+}
+/** Legacy `tsifdef [--project <tsconfig>]`: emit the auditable projected project. */
+async function runPrecompile(args, cwd) {
+    try {
+        const project = parseProjectOption(args, "Usage: tsifdef [--project <tsconfig>]");
+        const projectRoot = (0, node_path_1.resolve)(cwd);
+        const configuration = await (0, config_js_1.loadProjectConfiguration)(projectRoot);
+        const profile = await (0, config_js_1.loadProfileFile)(configuration.profilePath);
+        const result = await (0, precompile_js_1.precompileProject)({
+            projectRoot,
+            project: project ?? "tsconfig.json",
+            profile,
+        });
+        process.stdout.write(`Precompiled ${result.manifest.files.length} file(s) with ${profile.fileName} to ${result.outputRoot}\n`);
+        return exports.CliExitCode.success;
+    }
+    catch (error) {
+        if (error instanceof precompile_js_1.PrecompileDiagnosticsError) {
+            for (const file of error.files) {
+                for (const diagnostic of file.diagnostics) {
+                    process.stderr.write(`${file.file}:${diagnostic.range.start}: ${diagnostic.message}\n`);
+                }
+            }
+            return exports.CliExitCode.diagnostics;
+        }
+        process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+        return exports.CliExitCode.failure;
+    }
+}
+/** Accept both `--project <path>` and `-p <path>`; otherwise no override. */
+function parseProjectOption(args, usage) {
+    if (args.length === 0)
+        return undefined;
+    if (args.length === 2 &&
+        (args[0] === "--project" || args[0] === "-p") &&
+        args[1] !== undefined &&
+        args[1].trim() !== "") {
+        return args[1];
+    }
+    throw new Error(usage);
+}
+if (require.main === module) {
+    void runCli(process.argv.slice(2)).then((code) => {
+        process.exitCode = code;
+    });
+}
+//# sourceMappingURL=main.js.map

package/dist/cli/precompile.d.ts

@@ -0,0 +1,38 @@
+import type { ProfileFile } from "./config.js";
+export interface PrecompileOptions {
+    readonly projectRoot: string;
+    readonly project: string;
+    readonly profile: ProfileFile;
+}
+export interface PrecompileManifestFile {
+    readonly source: string;
+    readonly projected: string;
+    readonly sourceHash: string;
+    readonly projectedHash: string;
+}
+export interface PrecompileManifest {
+    readonly schemaVersion: 1;
+    readonly toolVersion: string;
+    readonly profileFile: string;
+    readonly profileHash: string;
+    readonly sourceProject: string;
+    readonly generatedProject: string;
+    readonly files: readonly PrecompileManifestFile[];
+}
+export interface PrecompileResult {
+    readonly outputRoot: string;
+    readonly projectPath: string;
+    readonly manifest: PrecompileManifest;
+}
+export interface PrecompileFileDiagnostic {
+    readonly file: string;
+    readonly diagnostics: readonly import("../core/index.js").MacroDiagnostic[];
+}
+export declare class PrecompileDiagnosticsError extends Error {
+    readonly files: readonly PrecompileFileDiagnostic[];
+    readonly code: "precompile-diagnostics";
+    constructor(files: readonly PrecompileFileDiagnostic[]);
+}
+/** Emit an auditable projected project derived from the original TypeScript Program. */
+export declare function precompileProject(options: PrecompileOptions): Promise<PrecompileResult>;
+//# sourceMappingURL=precompile.d.ts.map

package/dist/cli/precompile.js

@@ -0,0 +1,192 @@
+"use strict";
+// Copyright (C) 2026 Tencent. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrecompileDiagnosticsError = void 0;
+exports.precompileProject = precompileProject;
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const index_js_1 = require("../core/index.js");
+const source_files_js_1 = require("./source-files.js");
+class PrecompileDiagnosticsError extends Error {
+    files;
+    code = "precompile-diagnostics";
+    constructor(files) {
+        super(`Cannot precompile because ${files.length} source file(s) have macro diagnostics.`);
+        this.files = files;
+        this.name = "PrecompileDiagnosticsError";
+    }
+}
+exports.PrecompileDiagnosticsError = PrecompileDiagnosticsError;
+const macroFilePattern = /(?:\.d)?\.(?:ts|tsx|mts|cts)$/i;
+/** Emit an auditable projected project derived from the original TypeScript Program. */
+async function precompileProject(options) {
+    const ts = (await import("typescript")).default;
+    const projectRoot = (0, node_path_1.resolve)(options.projectRoot);
+    const sourceProject = (0, node_path_1.resolve)(projectRoot, options.project);
+    const outputRoot = (0, node_path_1.resolve)(projectRoot, ".tsifdef", "Output");
+    const configFile = ts.readConfigFile(sourceProject, ts.sys.readFile);
+    if (configFile.error !== undefined)
+        throw new Error(formatDiagnostic(ts, configFile.error));
+    const parsed = ts.parseJsonConfigFileContent(configFile.config, ts.sys, (0, node_path_1.dirname)(sourceProject), undefined, sourceProject);
+    if (parsed.errors.length > 0)
+        throw new Error(parsed.errors.map((item) => formatDiagnostic(ts, item)).join("\n"));
+    const projected = new Map();
+    const failures = [];
+    const host = ts.createCompilerHost(parsed.options, true);
+    const readProjected = (fileName) => {
+        if (!macroFilePattern.test(fileName))
+            return ts.sys.readFile(fileName);
+        const absolute = (0, node_path_1.resolve)(fileName);
+        const cached = projected.get(absolute);
+        if (cached !== undefined)
+            return cached.projected;
+        const sourceBytes = (0, node_fs_1.readFileSync)(absolute);
+        const source = (0, source_files_js_1.decodeTypeScriptText)(sourceBytes);
+        const result = (0, index_js_1.projectSource)(source, options.profile.definitions);
+        if (result.diagnostics.length > 0) {
+            failures.push({ file: (0, node_path_1.relative)(projectRoot, absolute), diagnostics: result.diagnostics });
+        }
+        projected.set(absolute, { source, sourceHash: hash(sourceBytes), projected: result.projectedText });
+        return result.projectedText;
+    };
+    host.readFile = readProjected;
+    host.getSourceFile = (fileName, languageVersion, onError, shouldCreateNewSourceFile) => {
+        const text = readProjected(fileName);
+        if (text === undefined) {
+            onError?.(`Cannot read '${fileName}'.`);
+            return undefined;
+        }
+        return ts.createSourceFile(fileName, text, languageVersion, true);
+    };
+    ts.createProgram({
+        rootNames: parsed.fileNames,
+        options: parsed.options,
+        host,
+        ...(parsed.projectReferences === undefined ? {} : { projectReferences: parsed.projectReferences }),
+    });
+    if (failures.length > 0)
+        throw new PrecompileDiagnosticsError(failures);
+    const internalFiles = [...projected.entries()]
+        .filter(([path]) => isInside(projectRoot, path) && !(0, node_path_1.relative)(projectRoot, path).split(node_path_1.sep).includes("node_modules"))
+        .sort(([left], [right]) => left.localeCompare(right, "en"));
+    const staging = `${outputRoot}.tmp-${process.pid}-${Date.now()}`;
+    const generatedProject = (0, node_path_1.resolve)(outputRoot, "tsconfig.json");
+    const manifestFiles = [];
+    await (0, promises_1.rm)(staging, { recursive: true, force: true });
+    try {
+        for (const [sourcePath, texts] of internalFiles) {
+            const relativePath = (0, node_path_1.relative)(projectRoot, sourcePath);
+            const projectedPath = (0, node_path_1.resolve)(staging, "project", relativePath);
+            await (0, promises_1.mkdir)((0, node_path_1.dirname)(projectedPath), { recursive: true });
+            await (0, promises_1.writeFile)(projectedPath, texts.projected, "utf8");
+            manifestFiles.push({
+                source: relativePath.replaceAll("\\", "/"),
+                projected: `project/${relativePath.replaceAll("\\", "/")}`,
+                sourceHash: texts.sourceHash,
+                projectedHash: hash(texts.projected),
+            });
+        }
+        const generatedConfig = {
+            extends: sourceProject.replaceAll("\\", "/"),
+            files: manifestFiles.map((file) => `./${file.projected}`),
+            include: [],
+            compilerOptions: projectedPathOptions(parsed.options, projectRoot, outputRoot, sourceProject),
+        };
+        await (0, promises_1.writeFile)((0, node_path_1.resolve)(staging, "tsconfig.json"), `${JSON.stringify(generatedConfig, null, 2)}\n`, "utf8");
+        const profileBytes = await (0, promises_1.readFile)(options.profile.path);
+        const manifest = {
+            schemaVersion: 1,
+            toolVersion: String(index_js_1.coreApiVersion),
+            profileFile: options.profile.path,
+            profileHash: hash(profileBytes),
+            sourceProject,
+            generatedProject,
+            files: manifestFiles,
+        };
+        await (0, promises_1.writeFile)((0, node_path_1.resolve)(staging, "manifest.json"), `${JSON.stringify(manifest, null, 2)}\n`, "utf8");
+        await (0, promises_1.rm)(outputRoot, { recursive: true, force: true });
+        await (0, promises_1.mkdir)((0, node_path_1.dirname)(outputRoot), { recursive: true });
+        await (0, promises_1.rename)(staging, outputRoot);
+        return { outputRoot, projectPath: generatedProject, manifest };
+    }
+    finally {
+        await (0, promises_1.rm)(staging, { recursive: true, force: true });
+    }
+}
+function projectedPathOptions(options, projectRoot, outputRoot, sourceProject) {
+    const result = {};
+    const mapProjectTarget = (path) => {
+        const absolute = (0, node_path_1.resolve)(path);
+        return isInside(projectRoot, absolute)
+            ? (0, node_path_1.resolve)(outputRoot, "project", (0, node_path_1.relative)(projectRoot, absolute))
+            : absolute;
+    };
+    const mapOutputTarget = (path) => {
+        const absolute = (0, node_path_1.resolve)(path);
+        return isInside(projectRoot, absolute)
+            ? (0, node_path_1.resolve)(outputRoot, (0, node_path_1.relative)(projectRoot, absolute))
+            : absolute;
+    };
+    const mapProjectAbsolute = (path) => {
+        const mapped = mapProjectTarget(path);
+        let value = (0, node_path_1.relative)(outputRoot, mapped).replaceAll("\\", "/");
+        if (!value.startsWith("."))
+            value = `./${value}`;
+        return value;
+    };
+    const mapOutputAbsolute = (path) => {
+        const mapped = mapOutputTarget(path);
+        let value = (0, node_path_1.relative)(outputRoot, mapped).replaceAll("\\", "/");
+        if (!value.startsWith("."))
+            value = `./${value}`;
+        return value;
+    };
+    if (options.baseUrl !== undefined)
+        result.baseUrl = mapProjectAbsolute(options.baseUrl);
+    if (options.rootDir !== undefined)
+        result.rootDir = mapProjectAbsolute(options.rootDir);
+    if (options.rootDirs !== undefined)
+        result.rootDirs = options.rootDirs.map(mapProjectAbsolute);
+    if (options.typeRoots !== undefined)
+        result.typeRoots = options.typeRoots.map(mapProjectAbsolute);
+    if (options.mapRoot !== undefined)
+        result.mapRoot = "./";
+    if (options.tsBuildInfoFile !== undefined)
+        result.tsBuildInfoFile = mapOutputAbsolute(options.tsBuildInfoFile);
+    else if (options.incremental === true || options.composite === true)
+        result.tsBuildInfoFile = "./tsconfig.tsbuildinfo";
+    if (options.paths !== undefined) {
+        const base = options.baseUrl ?? (0, node_path_1.dirname)(sourceProject);
+        const mappedBase = mapProjectTarget(base);
+        result.paths = Object.fromEntries(Object.entries(options.paths).map(([key, values]) => [
+            key,
+            values.map((value) => (0, node_path_1.relative)(mappedBase, mapProjectTarget((0, node_path_1.resolve)(base, value))).replaceAll("\\", "/")),
+        ]));
+    }
+    return result;
+}
+function isInside(root, path) {
+    const value = (0, node_path_1.relative)(root, path);
+    return !value.startsWith(`..${node_path_1.sep}`) && value !== ".." && !(0, node_path_1.isAbsolute)(value);
+}
+function hash(content) {
+    return (0, node_crypto_1.createHash)("sha256").update(content).digest("hex");
+}
+function formatDiagnostic(ts, diagnostic) {
+    return `TS${diagnostic.code}: ${ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n")}`;
+}
+//# sourceMappingURL=precompile.js.map

package/dist/cli/source-files.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Read source with the pinned TypeScript 5.5.4 `ts.sys.readFile` semantics.
+ * BOM-marked UTF-16/UTF-8 is recognized; every other byte stream is decoded as
+ * non-fatal UTF-8, including the same U+FFFD replacement behavior as stock tsc.
+ */
+export declare function readSourceText(file: string, _displayPath?: string): Promise<string>;
+export declare function decodeTypeScriptText(input: Uint8Array): string;
+/** Discover TypeScript-family files in deterministic relative-path order. */
+export declare function discoverSourceFiles(root: string, excludedRoot?: string): Promise<string[]>;
+//# sourceMappingURL=source-files.d.ts.map

package/dist/cli/source-files.js

@@ -0,0 +1,75 @@
+"use strict";
+// Copyright (C) 2026 Tencent. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readSourceText = readSourceText;
+exports.decodeTypeScriptText = decodeTypeScriptText;
+exports.discoverSourceFiles = discoverSourceFiles;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const sourceExtensionPattern = /(?:\.d)?\.(?:ts|tsx|mts|cts)$/i;
+const ignoredDirectories = new Set([".git", "node_modules"]);
+/**
+ * Read source with the pinned TypeScript 5.5.4 `ts.sys.readFile` semantics.
+ * BOM-marked UTF-16/UTF-8 is recognized; every other byte stream is decoded as
+ * non-fatal UTF-8, including the same U+FFFD replacement behavior as stock tsc.
+ */
+async function readSourceText(file, _displayPath = file) {
+    return decodeTypeScriptText(await (0, promises_1.readFile)(file));
+}
+function decodeTypeScriptText(input) {
+    const bytes = Buffer.from(input);
+    const length = bytes.length;
+    if (length >= 2 && bytes[0] === 0xfe && bytes[1] === 0xff) {
+        const evenLength = length & ~1;
+        const swapped = Buffer.from(bytes.subarray(0, evenLength));
+        for (let index = 0; index < evenLength; index += 2) {
+            const value = swapped[index];
+            swapped[index] = swapped[index + 1];
+            swapped[index + 1] = value;
+        }
+        return swapped.toString("utf16le", 2);
+    }
+    if (length >= 2 && bytes[0] === 0xff && bytes[1] === 0xfe) {
+        return bytes.toString("utf16le", 2);
+    }
+    if (length >= 3 && bytes[0] === 0xef && bytes[1] === 0xbb && bytes[2] === 0xbf) {
+        return bytes.toString("utf8", 3);
+    }
+    return bytes.toString("utf8");
+}
+/** Discover TypeScript-family files in deterministic relative-path order. */
+async function discoverSourceFiles(root, excludedRoot) {
+    const files = [];
+    const resolvedExcludedRoot = excludedRoot === undefined ? undefined : (0, node_path_1.resolve)(excludedRoot);
+    const visit = async (directory) => {
+        const entries = await (0, promises_1.readdir)(directory, { withFileTypes: true });
+        entries.sort((left, right) => left.name.localeCompare(right.name, "en"));
+        for (const entry of entries) {
+            const path = (0, node_path_1.join)(directory, entry.name);
+            if (entry.isDirectory()) {
+                if (ignoredDirectories.has(entry.name) || (0, node_path_1.resolve)(path) === resolvedExcludedRoot) {
+                    continue;
+                }
+                await visit(path);
+            }
+            else if (entry.isFile() && sourceExtensionPattern.test(entry.name)) {
+                files.push(path);
+            }
+        }
+    };
+    await visit((0, node_path_1.resolve)(root));
+    return files;
+}
+//# sourceMappingURL=source-files.js.map

package/dist/cli/watch.d.ts

@@ -0,0 +1,34 @@
+import { type MacroDiagnostic } from "../core/index.js";
+import { type ProfileFile } from "./config.js";
+export interface WatchBuildInfo {
+    /** Absolute paths written by the latest emit, sorted. */
+    readonly outputFiles: readonly string[];
+    /** Files whose macro structure is invalid this build; emit is skipped for them. */
+    readonly macroDiagnostics: ReadonlyMap<string, readonly MacroDiagnostic[]>;
+    readonly hasErrors: boolean;
+}
+export interface WatchOptions {
+    readonly projectRoot: string;
+    readonly project: string;
+    /** Path to the Profile file (already resolved from the package pointer). */
+    readonly profilePath: string;
+    /** Called after each compilation finishes (initial build and every rebuild). */
+    readonly onBuild?: (info: WatchBuildInfo) => void;
+    /** Called after the Profile file changes and the WatchProgram is rebuilt. */
+    readonly onProfileReload?: (profile: ProfileFile) => void;
+    /** Compiler options that override the tsconfig (parsed via `parseTscOverride`). */
+    readonly compilerOptionsOverride?: import("typescript").CompilerOptions;
+    /** Optional equal-length projection dump, matching `build --emit-projection`. */
+    readonly emitProjectionDir?: string;
+}
+export interface WatchHandle {
+    close(): void;
+}
+/**
+ * Watch mode for projected compilation. A `createWatchCompilerHost` drives
+ * incremental rebuilds with the same equal-length masking as one-shot builds.
+ * The Profile file is watched separately; any change tears down the current
+ * WatchProgram and rebuilds it in full under the new Profile.
+ */
+export declare function watchProject(options: WatchOptions): Promise<WatchHandle>;
+//# sourceMappingURL=watch.d.ts.map