@mxpicture/gcp-functions-code 0.2.0

package/dist/deps/IFixWorkspaceDeps.d.ts

@@ -0,0 +1,21 @@
+import { MapEntry, ProcessMode, PackageEntry } from "../changelog/changelog.util.js";
+export interface FixWorkspaceDepsMain {
+    mapEntries: MapEntry[];
+    consumingPkg: PackageEntry;
+    versionMap: Map<string, string>;
+    workspacePackages: Set<string>;
+}
+export interface FixWorkspaceDepsParams extends FixWorkspaceDepsMain {
+    pkg: string;
+    version: string;
+}
+export declare abstract class IFixWorkspaceDeps {
+    readonly repoRoot: string;
+    readonly mode: ProcessMode;
+    constructor(repoRoot: string, mode: ProcessMode);
+    protected abstract fixVersion(p: FixWorkspaceDepsParams): string | null;
+    protected abstract restoreVersion(p: FixWorkspaceDepsParams): string | null;
+    run(): Promise<void>;
+    protected handleDependencies(deps: Record<string, string> | undefined, p: FixWorkspaceDepsMain): boolean;
+    protected runSingle(p: FixWorkspaceDepsMain): boolean;
+}

package/dist/deps/IFixWorkspaceDeps.js

@@ -0,0 +1,76 @@
+import { buildMapEntries, readPackageJsons, writePackageJsons, } from "../changelog/changelog.util.js";
+export class IFixWorkspaceDeps {
+    repoRoot;
+    mode;
+    constructor(repoRoot, mode) {
+        this.repoRoot = repoRoot;
+        this.mode = mode;
+    }
+    async run() {
+        if (this.mode === "fix")
+            console.log("🔧 Fixing workspace dependencies...\n");
+        else
+            console.log("🔧 Restoring workspace dependencies...\n");
+        const pkgs = await readPackageJsons(this.repoRoot);
+        const mapEntries = buildMapEntries(pkgs);
+        const versionMap = new Map();
+        const workspacePackages = new Set();
+        for (const pkg of pkgs) {
+            versionMap.set(pkg.content.name, pkg.content.version);
+            workspacePackages.add(pkg.content.name);
+        }
+        console.log("📋 Version map:");
+        for (const map of mapEntries)
+            console.log(`  ${map.fromPkg.content.name} --> ${map.toPkg.content.name}: ${map.relPath}`);
+        console.log();
+        for (const consumingPkg of pkgs) {
+            console.log(`📦 Processing ${consumingPkg.content.name}...`);
+            try {
+                consumingPkg.modified = this.runSingle({
+                    consumingPkg,
+                    mapEntries,
+                    versionMap,
+                    workspacePackages,
+                });
+            }
+            catch (err) {
+                console.error(`\nError processing ${consumingPkg.content.name}:`, err);
+                throw err;
+            }
+        }
+        await writePackageJsons(pkgs);
+        if (this.mode === "fix")
+            console.log("✅ Done fixing workspace dependencies!");
+        else
+            console.log("✅ Done restoring workspace dependencies!");
+    }
+    // Replace workspace:* with file:...
+    handleDependencies(deps, p) {
+        if (!deps)
+            return false;
+        const handler = this.mode === "fix" ? this.fixVersion : this.restoreVersion;
+        let modified = false;
+        for (const [name, version] of Object.entries(deps)) {
+            const newVersion = handler({ ...p, pkg: name, version });
+            if (!newVersion)
+                continue;
+            console.log(`  ✓ Replaced ${name}: ${version} → ${newVersion}`);
+            deps[name] = newVersion;
+            modified = true;
+        }
+        return modified;
+    }
+    runSingle(p) {
+        let modified = false;
+        modified =
+            this.handleDependencies(p.consumingPkg.content.dependencies, p) ||
+                modified;
+        modified =
+            this.handleDependencies(p.consumingPkg.content.devDependencies, p) ||
+                modified;
+        modified =
+            this.handleDependencies(p.consumingPkg.content.peerDependencies, p) ||
+                modified;
+        return modified;
+    }
+}

package/dist/deps/fixWorkspaceDeps.d.ts

@@ -0,0 +1,12 @@
+import { ProcessMode } from "../changelog/changelog.util.js";
+import { FixWorkspaceDepsParams, IFixWorkspaceDeps } from "./IFixWorkspaceDeps.js";
+export declare const runFixDepsByVersion: (repoRoot: string, mode: ProcessMode) => Promise<void>;
+export declare const runFixDepsByFile: (repoRoot: string, mode: ProcessMode) => Promise<void>;
+export declare class FixWorkspaceDepsVersion extends IFixWorkspaceDeps {
+    protected fixVersion(p: FixWorkspaceDepsParams): string | null;
+    protected restoreVersion(p: FixWorkspaceDepsParams): string | null;
+}
+export declare class FixWorkspaceDepsFile extends IFixWorkspaceDeps {
+    protected fixVersion(p: FixWorkspaceDepsParams): string | null;
+    protected restoreVersion(p: FixWorkspaceDepsParams): string | null;
+}

package/dist/deps/fixWorkspaceDeps.js

@@ -0,0 +1,43 @@
+import { IFixWorkspaceDeps, } from "./IFixWorkspaceDeps.js";
+export const runFixDepsByVersion = async (repoRoot, mode) => new FixWorkspaceDepsVersion(repoRoot, mode).run();
+export const runFixDepsByFile = async (repoRoot, mode) => new FixWorkspaceDepsFile(repoRoot, mode).run();
+export class FixWorkspaceDepsVersion extends IFixWorkspaceDeps {
+    fixVersion(p) {
+        if (p.version !== "workspace:*")
+            return null;
+        const actualVersion = p.versionMap.get(p.pkg);
+        if (!actualVersion) {
+            console.error(`  ERROR: Could not find version for workspace dependency ${p.pkg}`);
+            throw new Error(`Cannot resolve workspace dependency: ${p.pkg}`);
+        }
+        return `^${actualVersion}`;
+    }
+    restoreVersion(p) {
+        if (p.workspacePackages.has(p.pkg) && p.version.startsWith("^")) {
+            // Verify the version matches what fix script would have created
+            const actualVersion = p.versionMap.get(p.pkg);
+            if (actualVersion && p.version === `^${actualVersion}`) {
+                return "workspace:*";
+            }
+        }
+        return null;
+    }
+}
+export class FixWorkspaceDepsFile extends IFixWorkspaceDeps {
+    fixVersion(p) {
+        if (p.version !== "workspace:*")
+            return null;
+        const mapEntry = p.mapEntries.find((mapEntry) => mapEntry.fromPkg.content.name === p.consumingPkg.content.name &&
+            mapEntry.toPkg.content.name === p.pkg);
+        if (!mapEntry) {
+            console.error(`  ERROR: Could not find version for workspace dependency ${p.pkg}`);
+            throw new Error(`Cannot resolve workspace dependency: ${p.pkg}`);
+        }
+        return `file:${mapEntry.relPath}`;
+    }
+    restoreVersion(p) {
+        if (!p.version.startsWith("file:"))
+            return null;
+        return "workspace:*";
+    }
+}

package/dist/deps/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./IFixWorkspaceDeps.js";
+export * from "./fixWorkspaceDeps.js";

package/dist/deps/index.js

@@ -0,0 +1,3 @@
+// This file is auto-generated. Do not edit manually.
+export * from "./IFixWorkspaceDeps.js";
+export * from "./fixWorkspaceDeps.js";

package/dist/git/GitChanges.d.ts

@@ -0,0 +1,33 @@
+import { GitChangedResult, GitChangedContentsResult } from "./types.git.js";
+export declare class GitChanges {
+    readonly rootDir: string;
+    protected _sinceCommit: string | null;
+    constructor(rootDir: string);
+    set sinceCommit(sinceCommit: string);
+    get sinceCommit(): string;
+    /**
+     * Checks if a specific file or directory has been changed since a given git commit.
+     * Includes both committed and uncommitted changes (staged + unstaged).
+     *
+     * @param target - Relative path to the file or directory to check.
+     * @param sinceCommit - The git commit hash (or ref like a tag/branch) to compare against.
+     * @returns A result object indicating whether changes were detected.
+     */
+    hasChanged(path: string): Promise<GitChangedResult>;
+    /**
+     * Reads the current content of all files that have changed since a given git commit
+     * within a specific file or directory scope.
+     * Includes both committed and uncommitted changes (staged + unstaged).
+     *
+     * Deleted files are excluded from the result since they no longer exist on disk.
+     *
+     * @param target - Relative path to the file or directory to check.
+     * @param sinceCommit - The git commit hash (or ref like a tag/branch) to compare against.
+     * @param cwd - The working directory of the git repository (defaults to process.cwd()).
+     * @returns A result object containing the current content of each changed file.
+     */
+    readChangedFiles(readContent?: boolean): Promise<GitChangedContentsResult>;
+}
+export declare class GitChangesCommit extends GitChanges {
+    constructor(rootDir: string, sinceCommit: string);
+}

package/dist/git/GitChanges.js

@@ -0,0 +1,85 @@
+import { readFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { verifiedGit } from "./git.util.js";
+export class GitChanges {
+    rootDir;
+    _sinceCommit = null;
+    constructor(rootDir) {
+        this.rootDir = rootDir;
+    }
+    set sinceCommit(sinceCommit) {
+        this._sinceCommit = sinceCommit;
+    }
+    get sinceCommit() {
+        if (!this._sinceCommit)
+            throw new Error("SinceCommit missing");
+        return this._sinceCommit;
+    }
+    /**
+     * Checks if a specific file or directory has been changed since a given git commit.
+     * Includes both committed and uncommitted changes (staged + unstaged).
+     *
+     * @param target - Relative path to the file or directory to check.
+     * @param sinceCommit - The git commit hash (or ref like a tag/branch) to compare against.
+     * @returns A result object indicating whether changes were detected.
+     */
+    async hasChanged(path) {
+        const sinceCommit = this.sinceCommit;
+        const resolvedTarget = resolve(this.rootDir, path);
+        if (!existsSync(resolvedTarget)) {
+            throw new Error(`Target path does not exist: ${resolvedTarget}`);
+        }
+        const git = await verifiedGit(this.rootDir, sinceCommit);
+        // Compare commit to working directory (includes uncommitted changes)
+        const diff = await git.diffSummary([sinceCommit, "--", path]);
+        const changedFiles = diff.files.map((file) => file.file);
+        return {
+            path,
+            sinceCommit,
+            hasChanged: changedFiles.length > 0,
+            changedFiles,
+        };
+    }
+    /**
+     * Reads the current content of all files that have changed since a given git commit
+     * within a specific file or directory scope.
+     * Includes both committed and uncommitted changes (staged + unstaged).
+     *
+     * Deleted files are excluded from the result since they no longer exist on disk.
+     *
+     * @param target - Relative path to the file or directory to check.
+     * @param sinceCommit - The git commit hash (or ref like a tag/branch) to compare against.
+     * @param cwd - The working directory of the git repository (defaults to process.cwd()).
+     * @returns A result object containing the current content of each changed file.
+     */
+    async readChangedFiles(readContent) {
+        const sinceCommit = this.sinceCommit;
+        const git = await verifiedGit(this.rootDir, sinceCommit);
+        // Compare commit to working directory (includes uncommitted changes)
+        const diff = await git.diffSummary([sinceCommit, "--", this.rootDir]);
+        const files = [];
+        for (const entry of diff.files) {
+            const repoFilePath = entry.file;
+            const absFilePath = resolve(this.rootDir, repoFilePath);
+            // Skip deleted files — they no longer exist on disk
+            if (!existsSync(absFilePath)) {
+                continue;
+            }
+            // Read from the file system to capture uncommitted changes
+            const content = readContent ? await readFile(absFilePath, "utf-8") : null;
+            files.push({ absFilePath, content, repoFilePath });
+        }
+        return {
+            path: this.rootDir,
+            sinceCommit,
+            files,
+        };
+    }
+}
+export class GitChangesCommit extends GitChanges {
+    constructor(rootDir, sinceCommit) {
+        super(rootDir);
+        this.sinceCommit = sinceCommit;
+    }
+}

package/dist/git/git.util.d.ts

@@ -0,0 +1,9 @@
+import { SimpleGit } from "simple-git";
+import { GitCommitHash } from "./types.git.js";
+/**
+ * Creates a SimpleGit instance and verifies the cwd is a repo
+ * and the commit ref is valid.
+ */
+export declare const verifiedGit: (rootDir: string, commitRef?: string) => Promise<SimpleGit>;
+export declare const lastCommitHash: (rootDir: string) => Promise<string | null>;
+export declare const commitHashs: (rootDir: string) => Promise<GitCommitHash[]>;

package/dist/git/git.util.js

@@ -0,0 +1,33 @@
+import { simpleGit } from "simple-git";
+const __entries = [];
+/**
+ * Creates a SimpleGit instance and verifies the cwd is a repo
+ * and the commit ref is valid.
+ */
+export const verifiedGit = async (rootDir, commitRef) => {
+    let found = __entries.find((entry) => entry.rootDir === rootDir && entry.commitRef === commitRef);
+    if (!found) {
+        found = await verifyGit(simpleGit(rootDir), rootDir, commitRef);
+        __entries.push(found);
+    }
+    return found.git;
+};
+const verifyGit = async (git, rootDir, commitRef) => {
+    if (!(await git.checkIsRepo()))
+        throw new Error(`Not a git repository: ${rootDir}`);
+    if (!commitRef)
+        return { git, rootDir, commitRef };
+    try {
+        await git.revparse(["--verify", commitRef]);
+    }
+    catch {
+        throw new Error(`Invalid git commit reference: "${commitRef}"`);
+    }
+    return { git, rootDir, commitRef };
+};
+export const lastCommitHash = async (rootDir) => (await (await verifiedGit(rootDir)).log()).latest?.hash ?? null;
+export const commitHashs = async (rootDir) => (await (await verifiedGit(rootDir)).log()).all.map((a) => ({
+    date: a.date,
+    hash: a.hash,
+    diff: a.diff,
+}));

package/dist/git/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./GitChanges.js";
+export * from "./git.util.js";
+export * from "./types.git.js";

package/dist/git/index.js

@@ -0,0 +1,4 @@
+// This file is auto-generated. Do not edit manually.
+export * from "./GitChanges.js";
+export * from "./git.util.js";
+export * from "./types.git.js";

package/dist/git/types.git.d.ts

@@ -0,0 +1,22 @@
+import { DiffResult } from "simple-git";
+export interface GitChangedResult {
+    path: string;
+    sinceCommit: string;
+    hasChanged: boolean;
+    changedFiles: string[];
+}
+export interface GitChangedContent {
+    absFilePath: string;
+    repoFilePath: string;
+    content: string | null;
+}
+export interface GitChangedContentsResult {
+    path: string;
+    sinceCommit: string;
+    files: GitChangedContent[];
+}
+export interface GitCommitHash {
+    hash: string;
+    date: string;
+    diff?: DiffResult;
+}

package/dist/git/types.git.js

@@ -0,0 +1 @@
+export {};

package/dist/scripts/fix-workspace-deps.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env ts-node
+export {};

package/dist/scripts/fix-workspace-deps.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env ts-node
+import { Argument, program } from "@commander-js/extra-typings";
+import { argv } from "node:process";
+import { runFixDepsByVersion } from "../deps/fixWorkspaceDeps.js";
+import { VSCodeWorkspace } from "../vscode/VSCodeWorkspace.js";
+program
+    .version("1.0.0")
+    .description("Fix/restore workspace dependencies CLI")
+    .addArgument(new Argument("<mode>", "fix / restore").choices(["fix", "restore"]))
+    .action(async (mode) => {
+    const repoRoot = (await VSCodeWorkspace.loadAsync()).root;
+    await runFixDepsByVersion(repoRoot, mode);
+});
+program.parse(argv);

package/dist/scripts/generate-barrels.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/scripts/generate-barrels.js

@@ -0,0 +1,81 @@
+import { basename, dirname, join } from "node:path";
+import { readdir, writeFile } from "node:fs/promises";
+import { VSCodeWorkspace } from "../vscode/VSCodeWorkspace.js";
+// ─── Configuration ───────────────────────────────────────────────────────────
+// /** File patterns to exclude from barrel exports */
+const EXCLUDED_PATTERNS = [
+    /\.test\.ts$/,
+    /\.spec\.ts$/,
+    /\.d\.ts$/,
+    /index\.ts$/,
+];
+// /** Header comment added to every generated barrel file */
+const HEADER = "// This file is auto-generated. Do not edit manually.\n";
+const isExcluded = (fileName) => EXCLUDED_PATTERNS.some((pattern) => pattern.test(fileName));
+// ─── Generator ───────────────────────────────────────────────────────────────
+const createBarrels = async () => {
+    const rootDir = (await VSCodeWorkspace.loadAsync()).root;
+    const packagesDir = join(rootDir, "packages");
+    const packages = (await readdir(packagesDir)).map((p) => join(packagesDir, p));
+    const promises = [];
+    for (const pkg of packages) {
+        try {
+            const baseDirPath = join(pkg, "src");
+            const items = (await readdir(baseDirPath, { recursive: true })).sort();
+            let currentGroup;
+            for (const item of items) {
+                const filename = basename(item);
+                if (isExcluded(filename) || !filename.endsWith(".ts"))
+                    continue;
+                const dirPath = join(baseDirPath, dirname(item));
+                if (dirPath !== currentGroup?.dirPath) {
+                    if (currentGroup)
+                        promises.push(persistBarrel({ ...currentGroup }));
+                    currentGroup = { dirPath, files: [] };
+                }
+                currentGroup.files.push(filename);
+            }
+            if (currentGroup)
+                promises.push(persistBarrel({ ...currentGroup }));
+        }
+        catch {
+            continue;
+        }
+    }
+    await Promise.all(promises);
+};
+const persistBarrel = async (group) => {
+    if (group.files.length === 0)
+        return;
+    const content = `${HEADER}${group.files
+        .sort()
+        .map((f) => `export * from "./${basename(f, ".ts")}.js";`)
+        .join("\n")}\n`;
+    const barrelPath = join(group.dirPath, "index.ts");
+    return writeFile(barrelPath, content);
+};
+// ─── Entry Point ─────────────────────────────────────────────────────────────
+const run = async () => {
+    await createBarrels();
+    // // Allow overriding paths via CLI arguments:
+    // //   npx tsx scripts/generate-barrels.ts ./src/hooks ./src/types
+    // const cliPaths = process.argv.slice(2);
+    // const paths = cliPaths.length > 0 ? cliPaths : BARREL_PATHS;
+    // console.log("🛢️  Generating barrel files...\n");
+    // console.log(
+    //   `📂 Target directories:\n${paths
+    //     .map((p) => `   - ${resolve(p)}`)
+    //     .join("\n")}\n`,
+    // );
+    // let generated = 0;
+    // for (const targetPath of paths) {
+    //   const resolved = resolve(targetPath);
+    //   if (await generateBarrel(resolved)) {
+    //     generated++;
+    //   }
+    // }
+    // console.log(
+    //   `\n🎉 Done! Barrels generated for ${generated}/${paths.length} directories.`,
+    // );
+};
+run().catch(console.error);

package/dist/scripts/generate-changelog.d.ts

@@ -0,0 +1 @@
+export declare const runGenerateChangelog: () => Promise<void>;

package/dist/scripts/generate-changelog.js

@@ -0,0 +1,13 @@
+import { Changelog } from "../changelog/Changelog.js";
+import { fileURLToPath } from "node:url";
+import { resolve } from "node:path";
+import { VSCodeWorkspace } from "../vscode/VSCodeWorkspace.js";
+import { GitChanges } from "../git/GitChanges.js";
+export const runGenerateChangelog = async () => {
+    const generator = new Changelog(new GitChanges((await VSCodeWorkspace.loadAsync()).root));
+    await generator.run();
+};
+const entryPath = process.argv[1] ? resolve(process.argv[1]) : "";
+const selfPath = fileURLToPath(import.meta.url);
+if (entryPath === selfPath)
+    await runGenerateChangelog();

package/dist/scripts/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./fix-workspace-deps.js";
+export * from "./generate-barrels.js";
+export * from "./generate-changelog.js";

package/dist/scripts/index.js

@@ -0,0 +1,4 @@
+// This file is auto-generated. Do not edit manually.
+export * from "./fix-workspace-deps.js";
+export * from "./generate-barrels.js";
+export * from "./generate-changelog.js";

package/dist/vscode/OSUser.d.ts

@@ -0,0 +1,15 @@
+export interface OSInfo {
+    homedir: string;
+    username: string;
+    platform: NodeJS.Platform;
+    configDir: string;
+    isWSL?: boolean;
+}
+export declare class OSUser {
+    protected static info?: OSInfo;
+    static getInfo(): OSInfo;
+    protected constructor();
+    protected static load(): void;
+    protected static getWSL(): OSInfo;
+    protected static getDefault(): OSInfo;
+}

package/dist/vscode/OSUser.js

@@ -0,0 +1,62 @@
+import { execSync } from "child_process";
+import * as os from "os";
+import { join, sep } from "path";
+export class OSUser {
+    static info;
+    static getInfo() {
+        this.load();
+        if (!this.info)
+            throw new Error("Load OS info failed");
+        return this.info;
+    }
+    constructor() { }
+    static load() {
+        if (this.info)
+            return;
+        const isWSL = os.release().toLowerCase().includes("microsoft");
+        this.info = isWSL ? this.getWSL() : this.getDefault();
+    }
+    static getWSL() {
+        const whoamiParts = execSync("whoami.exe").toString().split(sep);
+        if (whoamiParts.length === 0)
+            throw new Error("Windows user could not be determined");
+        // const winUser = process.env["WINUSER"] || process.env["USER"];
+        const platform = process.platform;
+        let username = whoamiParts[whoamiParts.length - 1];
+        // remove AD group
+        const userParts = username.split("\\");
+        username = userParts[userParts.length - 1];
+        username = username.replace("\r", "").replace("\n", "");
+        const parts = ["/mnt", "c", "Users", username];
+        const homedir = join(...parts);
+        const configDir = join(homedir, "AppData", "Roaming");
+        return {
+            username,
+            homedir,
+            configDir,
+            platform,
+            isWSL: true,
+        };
+    }
+    static getDefault() {
+        const platform = process.platform;
+        const homedir = os.homedir();
+        const configDirParts = [];
+        if (platform === "win32") {
+            if (process.env.APPDATA)
+                configDirParts.push(process.env.APPDATA);
+        }
+        else if (platform === "darwin") {
+            configDirParts.push(homedir, "Library", "Application Support");
+        }
+        else {
+            configDirParts.push(homedir, ".config");
+        }
+        return {
+            username: os.userInfo().username,
+            homedir,
+            platform,
+            configDir: join(...configDirParts),
+        };
+    }
+}

package/dist/vscode/VSCodeSettings.d.ts

@@ -0,0 +1,10 @@
+export type VSCodeSettingsContent = Record<string, unknown>;
+export declare class VSCodeSettings {
+    protected static instance: VSCodeSettings | undefined;
+    protected content: VSCodeSettingsContent;
+    static load(): VSCodeSettings;
+    protected constructor(content: VSCodeSettingsContent);
+    getProperty(name: string): unknown;
+    getContent(): VSCodeSettingsContent;
+    getClangFormatStyle(): string | undefined;
+}

package/dist/vscode/VSCodeSettings.js

@@ -0,0 +1,41 @@
+import * as fs from "fs";
+import pkg from "json5";
+import { activeProfile, defaultSettingsPath } from "./profiles.vscode.js";
+export class VSCodeSettings {
+    static instance;
+    content;
+    static load() {
+        if (this.instance)
+            return this.instance;
+        let settingsPath;
+        try {
+            // check profile
+            settingsPath = activeProfile().settingsPath;
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        }
+        catch (error) {
+            // check default
+            settingsPath = defaultSettingsPath();
+        }
+        if (!settingsPath)
+            throw new Error("No settings path found");
+        const raw = fs.readFileSync(settingsPath, "utf-8");
+        this.instance = new VSCodeSettings(pkg.parse(raw));
+        return this.instance;
+    }
+    constructor(content) {
+        this.content = content;
+    }
+    getProperty(name) {
+        return this.getContent()[name];
+    }
+    getContent() {
+        return { ...this.content };
+    }
+    getClangFormatStyle() {
+        const value = this.getProperty("C_Cpp.clang_format_style");
+        if (typeof value !== "string")
+            throw new Error("C_Cpp.clang_format_style not found in settings.json");
+        return value;
+    }
+}

package/dist/vscode/VSCodeWorkspace.d.ts

@@ -0,0 +1,20 @@
+export interface VSCodeWorkspaceFolder {
+    path: string;
+    name?: string;
+    uri?: string;
+}
+export interface VSCodeWorkspaceContent {
+    folders: VSCodeWorkspaceFolder[];
+    settings?: Record<string, unknown>;
+    launch?: Record<string, unknown>;
+    extensions?: Record<string, unknown>;
+}
+export declare class VSCodeWorkspace {
+    readonly workspaceFile: string;
+    readonly content: VSCodeWorkspaceContent;
+    protected static instances: VSCodeWorkspace[];
+    static load(workspaceFile?: string): VSCodeWorkspace;
+    static loadAsync(workspaceFile?: string): Promise<VSCodeWorkspace>;
+    protected constructor(workspaceFile: string, content: VSCodeWorkspaceContent);
+    get root(): string;
+}