tsifdef 1.1.8

package/dist/tsserver/plugin.d.ts

@@ -0,0 +1,15 @@
+import type * as ts from "typescript";
+/**
+ * tsserver plugin entry. tsserver calls this with the live `typescript` module
+ * and, per project, invokes `create(info)` to let the plugin wrap the language
+ * service host.
+ *
+ * The plugin resolves one externally selected, read-only Profile and projects
+ * every macro file's snapshot through the shared core. It returns the original
+ * language service unchanged; only the host's view of the source is altered.
+ */
+declare function init(modules: {
+    typescript: typeof ts;
+}): ts.server.PluginModule;
+export = init;
+//# sourceMappingURL=plugin.d.ts.map

package/dist/tsserver/plugin.js

@@ -0,0 +1,129 @@
+"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.
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const config_js_1 = require("../cli/config.js");
+const host_projection_js_1 = require("./host-projection.js");
+const project_controller_js_1 = require("./project-controller.js");
+/**
+ * tsserver plugin entry. tsserver calls this with the live `typescript` module
+ * and, per project, invokes `create(info)` to let the plugin wrap the language
+ * service host.
+ *
+ * The plugin resolves one externally selected, read-only Profile and projects
+ * every macro file's snapshot through the shared core. It returns the original
+ * language service unchanged; only the host's view of the source is altered.
+ */
+function init(modules) {
+    const typescript = modules.typescript;
+    let externalConfig = {};
+    const reloaders = new Set();
+    return {
+        create(info) {
+            const projectConfig = (info.config ?? {});
+            const config = () => ({ ...projectConfig, ...externalConfig });
+            const profilePath = () => resolveProfilePath(config(), info);
+            const log = (message) => info.project.projectService.logger.info(message);
+            const controller = new project_controller_js_1.ProfileProjectionController({
+                resolve: () => resolveProfile(profilePath(), log),
+                log,
+            });
+            const reloader = () => {
+                controller.reload();
+            };
+            reloaders.add(reloader);
+            (0, host_projection_js_1.wrapHostWithProjection)(typescript, info.languageServiceHost, {
+                getProfile: () => controller.getProfile(),
+            });
+            // Keep the in-process Profile current. The VSCode extension reloads
+            // TypeScript projects after a semantic Profile change.
+            const selectedPath = profilePath();
+            const configWatcher = selectedPath === undefined
+                ? undefined
+                : watchConfigDirectory(info, selectedPath, reloader);
+            // Drop this project's reloader when its language service is disposed so
+            // stale controllers/watchers do not accumulate and reload on every change.
+            const languageService = info.languageService;
+            const originalDispose = languageService.dispose.bind(languageService);
+            languageService.dispose = () => {
+                reloaders.delete(reloader);
+                configWatcher?.close();
+                originalDispose();
+            };
+            return languageService;
+        },
+        onConfigurationChanged(config) {
+            externalConfig = config ?? {};
+            for (const reload of reloaders) {
+                reload();
+            }
+        },
+    };
+}
+function resolveProfilePath(config, info) {
+    const projectName = info.project.getProjectName();
+    const projectRoot = projectName ? (0, node_path_1.dirname)(projectName) : info.project.getCurrentDirectory();
+    const selected = config.profileFile;
+    if (selected === undefined || selected.trim() === "")
+        return undefined;
+    return (0, node_path_1.isAbsolute)(selected) ? selected : (0, node_path_1.join)(projectRoot, selected);
+}
+function resolveProfile(profilePath, log) {
+    if (profilePath === undefined)
+        return { kind: "none" };
+    let text;
+    try {
+        text = (0, node_fs_1.readFileSync)(profilePath, "utf8");
+    }
+    catch {
+        // The file could not be read this instant. An atomic writer (temp + rename)
+        // briefly hides it; treat this as transient so the controller keeps the
+        // current Profile instead of flapping to none and triggering a reload storm.
+        return { kind: "unavailable" };
+    }
+    try {
+        const definitions = (0, config_js_1.parseProfileFile)(text, profilePath).definitions;
+        // The version ties the AST cache to the Profile name and its content, so
+        // editing or switching the Profile produces a new version and invalidation.
+        return { kind: "profile", profile: { definitions, version: `${profilePath}:${text.length}:${hashText(text)}` } };
+    }
+    catch (error) {
+        // A parse failure during an external rewrite is almost always a half-written
+        // file (the writer has not finished / renamed yet). Treat it as transient and
+        // keep the current Profile rather than flapping to none; the next watcher
+        // event re-reads the completed file. A genuinely malformed Profile simply
+        // keeps the last good one until it is fixed, which is the safe behavior.
+        log(`[tsifdef] Profile '${profilePath}' not parseable this read (likely mid-write); keeping current: ${error instanceof Error ? error.message : String(error)}`);
+        return { kind: "unavailable" };
+    }
+}
+function watchConfigDirectory(info, configPath, onChange) {
+    const serverHost = info.serverHost;
+    if (typeof serverHost.watchDirectory !== "function") {
+        return undefined;
+    }
+    return serverHost.watchDirectory((0, node_path_1.dirname)(configPath), () => onChange(), /* recursive */ false);
+}
+/** Small deterministic content hash; only used for AST-cache versioning. */
+function hashText(text) {
+    let hash = 2166136261;
+    for (let index = 0; index < text.length; index += 1) {
+        hash ^= text.charCodeAt(index);
+        hash = Math.imul(hash, 16777619);
+    }
+    return (hash >>> 0).toString(16);
+}
+module.exports = init;
+//# sourceMappingURL=plugin.js.map

package/dist/tsserver/project-controller.d.ts

@@ -0,0 +1,37 @@
+import type { ActiveProfile } from "./host-projection.js";
+/** Outcome of resolving the Profile: a value, none configured, or a transient failure. */
+export type ProfileResolution = {
+    readonly kind: "profile";
+    readonly profile: ActiveProfile;
+} | {
+    readonly kind: "none";
+} | {
+    readonly kind: "unavailable";
+};
+/** Hooks used to resolve and log Profile changes. */
+export interface ProjectControllerHooks {
+    /**
+     * Re-resolve the active Profile. Return `{kind:"profile"}` with the loaded
+     * Profile, `{kind:"none"}` when no Profile is configured, or
+     * `{kind:"unavailable"}` when the file could not be read this instant (an
+     * atomic write may briefly hide it). On `unavailable` the controller keeps the
+     * current Profile rather than flapping to none.
+    */
+    resolve: () => ProfileResolution;
+    log?: (message: string) => void;
+}
+/**
+ * Owns the current Profile for one project.
+ */
+export declare class ProfileProjectionController {
+    private readonly hooks;
+    private current;
+    constructor(hooks: ProjectControllerHooks);
+    /** The active Profile read live by the host wrapper. */
+    getProfile(): ActiveProfile | undefined;
+    /**
+     * Re-resolve the Profile. A transient read failure keeps the current value.
+     */
+    reload(): boolean;
+}
+//# sourceMappingURL=project-controller.d.ts.map

package/dist/tsserver/project-controller.js

@@ -0,0 +1,60 @@
+"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.ProfileProjectionController = void 0;
+/**
+ * Owns the current Profile for one project.
+ */
+class ProfileProjectionController {
+    hooks;
+    current;
+    constructor(hooks) {
+        this.hooks = hooks;
+        const initial = hooks.resolve();
+        this.current = initial.kind === "profile" ? initial.profile : undefined;
+        this.hooks.log?.(`[tsifdef] initial profile ${describe(this.current)}.`);
+    }
+    /** The active Profile read live by the host wrapper. */
+    getProfile() {
+        return this.current;
+    }
+    /**
+     * Re-resolve the Profile. A transient read failure keeps the current value.
+     */
+    reload() {
+        const resolution = this.hooks.resolve();
+        if (resolution.kind === "unavailable") {
+            return false;
+        }
+        const next = resolution.kind === "profile" ? resolution.profile : undefined;
+        if (sameProfile(this.current, next)) {
+            return false;
+        }
+        this.hooks.log?.(`[tsifdef] profile changed ${describe(this.current)} -> ${describe(next)}.`);
+        this.current = next;
+        return true;
+    }
+}
+exports.ProfileProjectionController = ProfileProjectionController;
+function sameProfile(left, right) {
+    if (left === undefined || right === undefined) {
+        return left === right;
+    }
+    return left.version === right.version;
+}
+function describe(profile) {
+    return profile === undefined ? "(none)" : `'${profile.version}'`;
+}
+//# sourceMappingURL=project-controller.js.map

package/dist/version.d.ts

@@ -0,0 +1,3 @@
+export declare const VERSION = "1.1.8";
+export declare const VERSION_TAG = "v1.1.8";
+//# sourceMappingURL=version.d.ts.map

package/dist/version.js

@@ -0,0 +1,20 @@
+"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.VERSION_TAG = exports.VERSION = void 0;
+// Generated by scripts/sync-version.cjs from package.json. Do not edit.
+exports.VERSION = "1.1.8";
+exports.VERSION_TAG = `v${exports.VERSION}`;
+//# sourceMappingURL=version.js.map

package/dist/vscode/document-analysis.d.ts

@@ -0,0 +1,62 @@
+import { type MacroDiagnostic } from "../core/index.js";
+import type { MacroDefinitions } from "../core/expression.js";
+import type { SourceRange } from "../core/scanner.js";
+/** Zero-based editor position. `character` counts UTF-16 code units, like VSCode. */
+export interface DocumentPosition {
+    readonly line: number;
+    readonly character: number;
+}
+export interface DocumentRange {
+    readonly start: DocumentPosition;
+    readonly end: DocumentPosition;
+}
+/** Severity levels mirroring `vscode.DiagnosticSeverity` ordinals. */
+export declare const DiagnosticSeverity: {
+    readonly error: 0;
+    readonly warning: 1;
+};
+export type DiagnosticSeverityValue = (typeof DiagnosticSeverity)[keyof typeof DiagnosticSeverity];
+export interface DocumentDiagnostic {
+    readonly code: MacroDiagnostic["code"];
+    readonly message: string;
+    readonly range: DocumentRange;
+    readonly severity: DiagnosticSeverityValue;
+}
+export interface DocumentAnalysis {
+    readonly diagnostics: readonly DocumentDiagnostic[];
+    readonly inactiveRanges: readonly DocumentRange[];
+}
+/** Inclusive, zero-based line range to collapse, mirroring `vscode.FoldingRange`. */
+export interface FoldingRange {
+    readonly start: number;
+    readonly end: number;
+}
+/**
+ * Map UTF-16 source offsets onto zero-based editor positions.
+ *
+ * `\r\n`, lone `\r`, and lone `\n` each advance one line, matching how VSCode
+ * counts lines. `character` is a UTF-16 code-unit count, so surrogate pairs are
+ * preserved exactly as TypeScript and VSCode positions expect.
+ */
+export declare class PositionMapper {
+    private readonly source;
+    private readonly lineStarts;
+    constructor(source: string);
+    positionAt(offset: number): DocumentPosition;
+    rangeOf(range: SourceRange): DocumentRange;
+}
+/**
+ * Analyze one document's source for the selected Profile, reusing the shared
+ * core. Returns editor-ready diagnostics and inactive ranges without scanning,
+ * evaluating, or projecting macros independently.
+ */
+export declare function analyzeDocument(source: string, definitions: MacroDefinitions): DocumentAnalysis;
+/**
+ * Compute foldable regions for inactive code in the selected Profile.
+ *
+ * Folds are inclusive zero-based line ranges. A range that begins and ends on
+ * the same editor line spans nothing foldable and is omitted, matching how
+ * VSCode treats single-line folds.
+ */
+export declare function computeFoldingRanges(source: string, definitions: MacroDefinitions): readonly FoldingRange[];
+//# sourceMappingURL=document-analysis.d.ts.map

package/dist/vscode/document-analysis.js

@@ -0,0 +1,111 @@
+"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.PositionMapper = exports.DiagnosticSeverity = void 0;
+exports.analyzeDocument = analyzeDocument;
+exports.computeFoldingRanges = computeFoldingRanges;
+const index_js_1 = require("../core/index.js");
+/** Severity levels mirroring `vscode.DiagnosticSeverity` ordinals. */
+exports.DiagnosticSeverity = {
+    error: 0,
+    warning: 1,
+};
+// Every current macro diagnostic is a hard structural or semantic error.
+const warningCodes = new Set();
+/**
+ * Map UTF-16 source offsets onto zero-based editor positions.
+ *
+ * `\r\n`, lone `\r`, and lone `\n` each advance one line, matching how VSCode
+ * counts lines. `character` is a UTF-16 code-unit count, so surrogate pairs are
+ * preserved exactly as TypeScript and VSCode positions expect.
+ */
+class PositionMapper {
+    source;
+    lineStarts = [0];
+    constructor(source) {
+        this.source = source;
+        for (let offset = 0; offset < source.length; offset += 1) {
+            const code = source.charCodeAt(offset);
+            if (code === 0x0d /* \r */) {
+                if (source.charCodeAt(offset + 1) === 0x0a /* \n */) {
+                    offset += 1;
+                }
+                this.lineStarts.push(offset + 1);
+            }
+            else if (code === 0x0a /* \n */) {
+                this.lineStarts.push(offset + 1);
+            }
+        }
+    }
+    positionAt(offset) {
+        const clamped = Math.max(0, Math.min(offset, this.source.length));
+        let low = 0;
+        let high = this.lineStarts.length - 1;
+        while (low < high) {
+            const mid = (low + high + 1) >> 1;
+            if (this.lineStarts[mid] <= clamped) {
+                low = mid;
+            }
+            else {
+                high = mid - 1;
+            }
+        }
+        return { line: low, character: clamped - this.lineStarts[low] };
+    }
+    rangeOf(range) {
+        return { start: this.positionAt(range.start), end: this.positionAt(range.end) };
+    }
+}
+exports.PositionMapper = PositionMapper;
+/**
+ * Analyze one document's source for the selected Profile, reusing the shared
+ * core. Returns editor-ready diagnostics and inactive ranges without scanning,
+ * evaluating, or projecting macros independently.
+ */
+function analyzeDocument(source, definitions) {
+    const analysis = (0, index_js_1.analyzeConditionals)(source, definitions);
+    const mapper = new PositionMapper(source);
+    return {
+        diagnostics: analysis.diagnostics.map((diagnostic) => ({
+            code: diagnostic.code,
+            message: diagnostic.message,
+            range: mapper.rangeOf(diagnostic.range),
+            severity: warningCodes.has(diagnostic.code)
+                ? exports.DiagnosticSeverity.warning
+                : exports.DiagnosticSeverity.error,
+        })),
+        inactiveRanges: analysis.inactiveRanges.map((range) => mapper.rangeOf(range)),
+    };
+}
+/**
+ * Compute foldable regions for inactive code in the selected Profile.
+ *
+ * Folds are inclusive zero-based line ranges. A range that begins and ends on
+ * the same editor line spans nothing foldable and is omitted, matching how
+ * VSCode treats single-line folds.
+ */
+function computeFoldingRanges(source, definitions) {
+    const folds = [];
+    for (const range of analyzeDocument(source, definitions).inactiveRanges) {
+        // An inactive range that ends at the start of a later line folds up to the
+        // last line it actually covers, never pulling in the following active line.
+        const end = range.end.character === 0 ? range.end.line - 1 : range.end.line;
+        if (end > range.start.line) {
+            folds.push({ start: range.start.line, end });
+        }
+    }
+    return folds;
+}
+//# sourceMappingURL=document-analysis.js.map

package/dist/vscode/extension.d.ts

@@ -0,0 +1,133 @@
+import type { Disposable, ExtensionHost, StatusBarItem } from "./host.js";
+/**
+ * The slice of the real `vscode` module the activation adapter consumes. It is
+ * declared locally so the package builds without `@types/vscode`; the module is
+ * resolved at runtime inside the extension host, never during CI or tests.
+ */
+interface VsRange {
+    new (startLine: number, startCharacter: number, endLine: number, endCharacter: number): unknown;
+}
+interface VsFoldingRange {
+    new (start: number, end: number): unknown;
+}
+interface VsUri {
+    parse(value: string): unknown;
+}
+interface VsTextDocument {
+    readonly uri: {
+        toString(): string;
+    };
+    readonly languageId: string;
+    readonly fileName: string;
+    getText(): string;
+}
+interface VsFoldingProvider {
+    provideFoldingRanges(document: VsTextDocument): readonly unknown[];
+}
+interface VsTextEditor {
+    readonly document: VsTextDocument;
+    setDecorations(decorationType: unknown, ranges: readonly unknown[]): void;
+}
+interface VsEvent<T> {
+    (listener: (event: T) => unknown): Disposable;
+}
+interface VsCodeApi {
+    readonly StatusBarAlignment: {
+        readonly Left: number;
+    };
+    readonly DiagnosticSeverity: {
+        readonly Error: number;
+        readonly Warning: number;
+    };
+    readonly Range: VsRange;
+    readonly FoldingRange: VsFoldingRange;
+    readonly Uri: VsUri;
+    Diagnostic: new (range: unknown, message: string, severity?: number) => {
+        code?: unknown;
+    };
+    readonly window: {
+        createStatusBarItem(alignment: number, priority?: number): StatusBarItem;
+        createTextEditorDecorationType(options: unknown): {
+            dispose(): void;
+        };
+        showInformationMessage(message: string): PromiseLike<unknown>;
+        showErrorMessage(message: string): PromiseLike<unknown>;
+        readonly visibleTextEditors: readonly VsTextEditor[];
+        readonly onDidChangeVisibleTextEditors: VsEvent<readonly VsTextEditor[]>;
+    };
+    readonly workspace: {
+        readonly workspaceFolders?: ReadonlyArray<{
+            readonly uri: {
+                readonly fsPath: string;
+            };
+        }>;
+        readonly textDocuments: readonly VsTextDocument[];
+        readonly onDidChangeConfiguration: VsEvent<{
+            affectsConfiguration(section: string): boolean;
+        }>;
+        readonly onDidChangeTextDocument: VsEvent<{
+            readonly document: VsTextDocument;
+        }>;
+        readonly onDidOpenTextDocument: VsEvent<VsTextDocument>;
+        readonly onDidCloseTextDocument: VsEvent<VsTextDocument>;
+        createFileSystemWatcher(glob: string): {
+            onDidChange: VsEvent<unknown>;
+            onDidCreate: VsEvent<unknown>;
+            onDidDelete: VsEvent<unknown>;
+            dispose(): void;
+        };
+    };
+    readonly languages: {
+        createDiagnosticCollection(name: string): {
+            set(uri: unknown, diagnostics: readonly unknown[]): void;
+            delete(uri: unknown): void;
+            clear(): void;
+            dispose(): void;
+        };
+        registerFoldingRangeProvider(selector: unknown, provider: VsFoldingProvider): Disposable;
+    };
+    readonly commands: {
+        registerCommand(command: string, handler: () => unknown | Promise<unknown>): Disposable;
+        executeCommand(command: string, ...args: readonly unknown[]): PromiseLike<unknown>;
+    };
+    readonly extensions: {
+        getExtension(id: string): {
+            readonly exports: unknown;
+            activate(): PromiseLike<unknown>;
+        } | undefined;
+    };
+}
+/** The shape VSCode passes to `activate`; only `subscriptions` is required here. */
+interface ExtensionContext {
+    readonly subscriptions: Disposable[];
+}
+/** Optional bridge to VSCode's built-in TypeScript language service. */
+export declare function createTypeScriptIntegration(vscode: {
+    readonly commands: {
+        executeCommand(command: string, ...args: readonly unknown[]): PromiseLike<unknown>;
+    };
+    readonly extensions: VsCodeApi["extensions"];
+}): {
+    configurePlugin(name: string, configuration: Readonly<Record<string, unknown>>): Promise<void>;
+    restartServer(): Promise<void>;
+    reloadProjects(): Promise<void>;
+};
+/** Adapt the real `vscode` API to the host interface the shell depends on. */
+export declare function createHost(vscode: VsCodeApi): ExtensionHost;
+/**
+ * Ensure the tsserver plugin is resolvable as `node_modules/tsifdef-tsserver`.
+ *
+ * tsserver loads a workspace plugin by resolving the module named in
+ * `typescriptServerPlugins` from the extension directory. vsce does not ship a
+ * `node_modules/` tree, so the compiled plugin would otherwise be unreachable
+ * and every `#if` would reach the parser as a syntax error. Recreate the tiny
+ * forwarder on activation so a fresh install (or a `--force` reinstall that
+ * wiped a previous shim) self-heals without manual steps.
+ */
+export declare function ensureTsserverPluginModule(): void;
+/** VSCode entry point. Binds the live API to the host and starts the shell. */
+export declare function activate(context: ExtensionContext): void;
+/** VSCode shutdown hook. */
+export declare function deactivate(): void;
+export {};
+//# sourceMappingURL=extension.d.ts.map