@mxpicture/build-api 0.2.4

package/dist/types/types.common.d.ts

@@ -0,0 +1,25 @@
+export type Logger = (...data: any[]) => void;
+export interface PnpmWorkspace {
+    packages: string[];
+}
+export interface PackageJson {
+    name: string;
+    version: string;
+    exports?: Record<string, string>;
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+    peerDependencies?: Record<string, string>;
+    [key: string]: unknown;
+}
+export interface PackageEntry {
+    jsonPath: string;
+    repoPath: string;
+    wsName: string;
+    content: PackageJson;
+    modified: boolean;
+}
+export interface MapEntry {
+    fromPkg: PackageEntry;
+    toPkg: PackageEntry;
+    relPath: string;
+}

package/dist/types/types.common.js

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

package/dist/types/types.deps.d.ts

@@ -0,0 +1,8 @@
+export declare enum DepsProcessMode {
+    fix = "fix",
+    restore = "restore"
+}
+export declare enum DepsReplacementMode {
+    version = "version",
+    file = "file"
+}

package/dist/types/types.deps.js

@@ -0,0 +1,10 @@
+export var DepsProcessMode;
+(function (DepsProcessMode) {
+    DepsProcessMode["fix"] = "fix";
+    DepsProcessMode["restore"] = "restore";
+})(DepsProcessMode || (DepsProcessMode = {}));
+export var DepsReplacementMode;
+(function (DepsReplacementMode) {
+    DepsReplacementMode["version"] = "version";
+    DepsReplacementMode["file"] = "file";
+})(DepsReplacementMode || (DepsReplacementMode = {}));

package/dist/types/types.os.d.ts

@@ -0,0 +1,7 @@
+export interface OSInfo {
+    homedir: string;
+    username: string;
+    platform: NodeJS.Platform;
+    configDir: string;
+    isWSL?: boolean;
+}

package/dist/types/types.os.js

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

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

@@ -0,0 +1,27 @@
+export interface PackageVersion {
+    major: number;
+    minor: number | null;
+    patch: number | null;
+    prefix: string | null;
+}
+export interface PackageJson {
+    name: string;
+    version: string;
+    exports?: Record<string, string>;
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+    peerDependencies?: Record<string, string>;
+    [key: string]: unknown;
+}
+export interface PackageEntry {
+    jsonPath: string;
+    repoPath: string;
+    wsName: string;
+    content: PackageJson;
+    modified: boolean;
+}
+export interface MapEntry {
+    fromPkg: PackageEntry;
+    toPkg: PackageEntry;
+    relPath: string;
+}

package/dist/types/types.package.js

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

package/dist/types/types.vscode.d.ts

@@ -0,0 +1,36 @@
+export interface VSCodeProfile {
+    location: string;
+    name: string;
+    settingsPath: string;
+}
+export interface VSCodeStorage {
+    userDataProfiles: {
+        location: string;
+        name: string;
+        icon: string;
+        useDefaultFlags?: {
+            settings?: boolean;
+            keybindings?: boolean;
+            snippets?: boolean;
+            tasks?: boolean;
+            extensions?: boolean;
+        };
+    }[];
+    profileAssociations: {
+        workspaces: {
+            [key: string]: string;
+        };
+    };
+}
+export type VSCodeSettings = Record<string, unknown>;
+export interface VSCodeWorkspaceFolder {
+    path: string;
+    name?: string;
+    uri?: string;
+}
+export interface VSCodeWorkspace {
+    folders: VSCodeWorkspaceFolder[];
+    settings?: Record<string, unknown>;
+    launch?: Record<string, unknown>;
+    extensions?: Record<string, unknown>;
+}

package/dist/types/types.vscode.js

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

package/dist/types/types.workspace.d.ts

@@ -0,0 +1,27 @@
+import { MapEntry, PackageEntry } from "./types.package.js";
+export type Logger = (...data: any[]) => void;
+export interface PnpmWorkspace {
+    packages: string[];
+}
+export declare enum WorkspaceFileType {
+    package = "package",
+    workspace = "workspace",
+    other = "other"
+}
+export interface WorkspaceFile {
+    filePath: string;
+    dirPath: string;
+    filename: string;
+    level: number;
+    type: WorkspaceFileType;
+}
+export interface FixWorkspaceDepsMain {
+    mapEntries: MapEntry[];
+    consumingPkg: PackageEntry;
+    versionMap: Map<string, string>;
+    workspacePackages: Set<string>;
+}
+export interface FixWorkspaceDepsParams extends FixWorkspaceDepsMain {
+    pkg: string;
+    version: string;
+}

package/dist/types/types.workspace.js

@@ -0,0 +1,6 @@
+export var WorkspaceFileType;
+(function (WorkspaceFileType) {
+    WorkspaceFileType["package"] = "package";
+    WorkspaceFileType["workspace"] = "workspace";
+    WorkspaceFileType["other"] = "other";
+})(WorkspaceFileType || (WorkspaceFileType = {}));

package/dist/vscode/OSUser.d.ts

@@ -0,0 +1,9 @@
+import { OSInfo } from "../types/types.os.js";
+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 @@
+import { VSCodeSettingsContent } from "../types/types.vscode.js";
+export declare class VSCodeSettings {
+    protected static instance: VSCodeSettings | undefined;
+    protected content: VSCodeSettingsContent;
+    static load(): Promise<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 async load() {
+        if (this.instance)
+            return this.instance;
+        let settingsPath;
+        try {
+            // check profile
+            settingsPath = (await 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,9 @@
+import { VSCodeWorkspaceContent } from "../types/types.vscode.js";
+export declare class VSCodeWorkspace {
+    readonly workspaceFile: string;
+    readonly content: VSCodeWorkspaceContent;
+    protected static instances: VSCodeWorkspace[];
+    static load(workspaceFile?: string): Promise<VSCodeWorkspace>;
+    protected constructor(workspaceFile: string, content: VSCodeWorkspaceContent);
+    get root(): string;
+}

package/dist/vscode/VSCodeWorkspace.js

@@ -0,0 +1,29 @@
+import { dirname } from "path";
+import pkg from "json5";
+import { readFile } from "fs/promises";
+import { findWorkspaceRoot } from "../workspace/workspace.common.js";
+export class VSCodeWorkspace {
+    workspaceFile;
+    content;
+    static instances = [];
+    static async load(workspaceFile) {
+        if (!workspaceFile) {
+            const foundWorkspaceFile = await findWorkspaceRoot();
+            workspaceFile = foundWorkspaceFile.filePath;
+        }
+        let found = this.instances.find((inst) => inst.workspaceFile === workspaceFile);
+        if (!found) {
+            const workspaceContent = await readFile(workspaceFile, "utf-8");
+            found = new VSCodeWorkspace(workspaceFile, pkg.parse(workspaceContent));
+            this.instances.push(found);
+        }
+        return found;
+    }
+    constructor(workspaceFile, content) {
+        this.workspaceFile = workspaceFile;
+        this.content = content;
+    }
+    get root() {
+        return dirname(this.workspaceFile);
+    }
+}

package/dist/vscode/common.vscode.d.ts

@@ -0,0 +1,21 @@
+import { WorkspaceFileType } from "./types.vscode.js";
+import { z } from "zod";
+export declare const DEFAULT_WORKSPACE_FILE_ENDING = ".code-workspace";
+export declare const removeLastPathElement: (path: string) => string | undefined;
+export declare const getFileType: (filename: string) => WorkspaceFileType;
+export interface PackageVersion {
+    major: number;
+    minor: number | null;
+    patch: number | null;
+    prefix: string | null;
+}
+export declare const packageVersionSchema: z.ZodObject<{
+    major: z.ZodNumber;
+    minor: z.ZodXor<readonly [z.ZodNumber, z.ZodNull]>;
+    patch: z.ZodXor<readonly [z.ZodNumber, z.ZodNull]>;
+    prefix: z.ZodXor<readonly [z.ZodString, z.ZodNull]>;
+}, z.core.$strip>;
+export declare const splitVersion: (version: string) => PackageVersion;
+export declare const concatVersion: (version: PackageVersion) => string;
+export declare const compareVersions: (a: PackageVersion | string, b: PackageVersion | string) => number;
+export declare const compareVersionsGT: (a: PackageVersion | string, b: PackageVersion | string) => boolean;

package/dist/vscode/common.vscode.js

@@ -0,0 +1,65 @@
+import { join, sep } from "path";
+import { WorkspaceFileType } from "./types.vscode.js";
+import { z } from "zod";
+export const DEFAULT_WORKSPACE_FILE_ENDING = ".code-workspace";
+export const removeLastPathElement = (path) => {
+    const parts = path.split(sep);
+    parts.pop();
+    if (parts.length <= 1)
+        return;
+    if (parts[0] === "")
+        parts[0] = "/";
+    return join(...parts);
+};
+export const getFileType = (filename) => filename.endsWith(DEFAULT_WORKSPACE_FILE_ENDING)
+    ? WorkspaceFileType.workspace
+    : filename === "package.json"
+        ? WorkspaceFileType.package
+        : WorkspaceFileType.other;
+export const packageVersionSchema = z.object({
+    major: z.number().min(0),
+    minor: z.xor([z.number(), z.null()]),
+    patch: z.xor([z.number(), z.null()]),
+    prefix: z.xor([z.string(), z.null()]),
+});
+export const splitVersion = (version) => {
+    const parts = version.split(".");
+    let major = parts.shift();
+    const prefix = major.startsWith("v") ? "v" : null;
+    if (major.startsWith("v"))
+        major = major.substring(1);
+    const minor = parts.shift();
+    const patch = parts.shift();
+    return {
+        major: Number(major),
+        minor: minor ? Number(minor) : null,
+        patch: patch ? Number(patch) : null,
+        prefix,
+    };
+};
+export const concatVersion = (version) => {
+    let result = version.major.toString();
+    if (version.prefix)
+        result = version.prefix + result;
+    if (version.minor)
+        result += "." + version.minor.toString();
+    if (version.patch)
+        result += "." + version.patch.toString();
+    return result;
+};
+export const compareVersions = (a, b) => {
+    a = typeof a === "string" ? splitVersion(a) : a;
+    b = typeof b === "string" ? splitVersion(b) : b;
+    if (a.major !== b.major)
+        return a.major - b.major;
+    if (a.minor === null || b.minor === null)
+        return 0;
+    if (a.minor !== b.minor)
+        return a.minor - b.minor;
+    if (a.patch === null || b.patch === null)
+        return 0;
+    if (a.patch !== b.patch)
+        return a.patch - b.patch;
+    return 0;
+};
+export const compareVersionsGT = (a, b) => compareVersions(a, b) > 0;

package/dist/vscode/config.vscode.d.ts

@@ -0,0 +1,2 @@
+export declare const configPath: () => string;
+export declare const configUserPath: () => string;

package/dist/vscode/config.vscode.js

@@ -0,0 +1,4 @@
+import { join } from "path";
+import { OSUser } from "./OSUser.js";
+export const configPath = () => join(OSUser.getInfo().configDir, "Code");
+export const configUserPath = () => join(configPath(), "User");

package/dist/vscode/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./vscode.config.js";
+export * from "./vscode.profiles.js";
+export * from "./vscode.settings.js";
+export * from "./vscode.storage.js";
+export * from "./vscode.workspace.js";

package/dist/vscode/index.js

@@ -0,0 +1,6 @@
+// This file is auto-generated. Do not edit manually.
+export * from "./vscode.config.js";
+export * from "./vscode.profiles.js";
+export * from "./vscode.settings.js";
+export * from "./vscode.storage.js";
+export * from "./vscode.workspace.js";

package/dist/vscode/profiles.vscode.d.ts

@@ -0,0 +1,5 @@
+import { VSCodeProfile } from "../types/types.vscode.js";
+export declare const profiles: () => VSCodeProfile[];
+export declare const activeProfile: () => Promise<VSCodeProfile>;
+export declare const profileSettingsPath: (profile: string) => string;
+export declare const defaultSettingsPath: () => string;

package/dist/vscode/profiles.vscode.js

@@ -0,0 +1,29 @@
+import { join } from "path";
+import { storage } from "./storage.vscode.js";
+import { configUserPath } from "./config.vscode.js";
+import { findWorkspaceRoot } from "./workspace.vscode.js";
+export const profiles = () => storage().userDataProfiles.map((prof) => ({
+    name: prof.name,
+    location: prof.location,
+    settingsPath: profileSettingsPath(prof.location),
+}));
+export const activeProfile = async () => {
+    const foundWS = await findWorkspaceRoot();
+    const storageContent = storage();
+    const profs = profiles();
+    let foundProfile;
+    // eslint-disable-next-line prefer-const
+    for (let [path, profile] of Object.entries(storageContent.profileAssociations.workspaces)) {
+        path = path.replace("file://", "");
+        if (foundWS.filePath !== path)
+            continue;
+        foundProfile = profs.find((prof) => prof.location === profile);
+        if (foundProfile)
+            break;
+    }
+    if (!foundProfile)
+        throw new Error("No active profile found");
+    return foundProfile;
+};
+export const profileSettingsPath = (profile) => join(configUserPath(), "profiles", profile, "settings.json");
+export const defaultSettingsPath = () => join(configUserPath(), "settings.json");

package/dist/vscode/storage.vscode.d.ts

@@ -0,0 +1,3 @@
+import { VSCodeStorage } from "../types/types.vscode.js";
+export declare const storagePath: () => string;
+export declare const storage: () => VSCodeStorage;

package/dist/vscode/storage.vscode.js

@@ -0,0 +1,15 @@
+import * as fs from "fs";
+import { join } from "path";
+import pkg from "json5";
+import { configUserPath } from "./config.vscode.js";
+export const storagePath = () => join(configUserPath(), "globalStorage", "storage.json");
+let __storage;
+export const storage = () => {
+    if (__storage)
+        return __storage;
+    const content = fs.readFileSync(storagePath()).toString();
+    __storage = pkg.parse(content);
+    if (!__storage)
+        throw new Error("VS Code storage.json could not be loaded");
+    return __storage;
+};

package/dist/vscode/types.vscode.d.ts

@@ -0,0 +1,37 @@
+export interface VSCodeProfile {
+    location: string;
+    name: string;
+    settingsPath: string;
+}
+export interface VSCodeStorage {
+    userDataProfiles: {
+        location: string;
+        name: string;
+        icon: string;
+        useDefaultFlags?: {
+            settings?: boolean;
+            keybindings?: boolean;
+            snippets?: boolean;
+            tasks?: boolean;
+            extensions?: boolean;
+        };
+    }[];
+    profileAssociations: {
+        workspaces: {
+            [key: string]: string;
+        };
+    };
+}
+export declare enum WorkspaceFileType {
+    package = "package",
+    workspace = "workspace",
+    other = "other"
+}
+export interface WorkspaceFile {
+    filePath: string;
+    dirPath: string;
+    filename: string;
+    level: number;
+    type: WorkspaceFileType;
+}
+export type ProcessMode = "fix" | "restore";

package/dist/vscode/types.vscode.js

@@ -0,0 +1,6 @@
+export var WorkspaceFileType;
+(function (WorkspaceFileType) {
+    WorkspaceFileType["package"] = "package";
+    WorkspaceFileType["workspace"] = "workspace";
+    WorkspaceFileType["other"] = "other";
+})(WorkspaceFileType || (WorkspaceFileType = {}));

package/dist/vscode/vscode.config.d.ts

@@ -0,0 +1,2 @@
+export declare const configPath: () => string;
+export declare const configUserPath: () => string;

package/dist/vscode/vscode.config.js

@@ -0,0 +1,4 @@
+import { join } from "path";
+import { osInfo } from "../osInfo/osInfo.common.js";
+export const configPath = () => join(osInfo().configDir, "Code");
+export const configUserPath = () => join(configPath(), "User");

package/dist/vscode/vscode.profiles.d.ts

@@ -0,0 +1,5 @@
+import { VSCodeProfile } from "../types/types.vscode.js";
+export declare const profiles: () => VSCodeProfile[];
+export declare const activeProfile: (dir?: string) => Promise<VSCodeProfile>;
+export declare const profileSettingsPath: (profile: string) => string;
+export declare const defaultSettingsPath: () => string;

package/dist/vscode/vscode.profiles.js

@@ -0,0 +1,30 @@
+import { join } from "path";
+import { storage } from "./vscode.storage.js";
+import { configUserPath } from "./vscode.config.js";
+import { findWorkspaceRoot } from "../workspace/workspace.common.js";
+import { cwd } from "process";
+export const profiles = () => storage().userDataProfiles.map((prof) => ({
+    name: prof.name,
+    location: prof.location,
+    settingsPath: profileSettingsPath(prof.location),
+}));
+export const activeProfile = async (dir) => {
+    const foundWS = await findWorkspaceRoot(dir ?? cwd());
+    const storageContent = storage();
+    const profs = profiles();
+    let foundProfile;
+    // eslint-disable-next-line prefer-const
+    for (let [path, profile] of Object.entries(storageContent.profileAssociations.workspaces)) {
+        path = path.replace("file://", "");
+        if (foundWS.filePath !== path)
+            continue;
+        foundProfile = profs.find((prof) => prof.location === profile);
+        if (foundProfile)
+            break;
+    }
+    if (!foundProfile)
+        throw new Error("No active profile found");
+    return foundProfile;
+};
+export const profileSettingsPath = (profile) => join(configUserPath(), "profiles", profile, "settings.json");
+export const defaultSettingsPath = () => join(configUserPath(), "settings.json");

package/dist/vscode/vscode.settings.d.ts

@@ -0,0 +1,3 @@
+import { VSCodeSettings } from "../types/types.vscode.js";
+export declare const vscodeSettings: (dir?: string) => Promise<VSCodeSettings>;
+export declare const clangFormatStyle: (cwd: string) => Promise<string>;

package/dist/vscode/vscode.settings.js

@@ -0,0 +1,26 @@
+import { activeProfile, defaultSettingsPath } from "./vscode.profiles.js";
+import { readFile } from "fs/promises";
+import pkg from "json5";
+let __settings = null;
+export const vscodeSettings = async (dir) => {
+    if (!__settings) {
+        let settingsPath;
+        try {
+            settingsPath = (await activeProfile(dir)).settingsPath;
+        }
+        catch {
+            settingsPath = defaultSettingsPath();
+        }
+        const raw = await readFile(settingsPath, "utf-8");
+        __settings = pkg.parse(raw);
+        if (!__settings)
+            throw new Error("No settings found");
+    }
+    return { ...__settings };
+};
+export const clangFormatStyle = async (cwd) => {
+    const settings = await vscodeSettings(cwd);
+    if (!("C_Cpp.clang_format_style" in settings))
+        throw new Error("C_Cpp.clang_format_style not found in settings.json");
+    return settings["C_Cpp.clang_format_style"];
+};

package/dist/vscode/vscode.storage.d.ts

@@ -0,0 +1,3 @@
+import { VSCodeStorage } from "../types/types.vscode.js";
+export declare const storagePath: () => string;
+export declare const storage: () => VSCodeStorage;

package/dist/vscode/vscode.storage.js

@@ -0,0 +1,15 @@
+import * as fs from "fs";
+import { join } from "path";
+import pkg from "json5";
+import { configUserPath } from "./vscode.config.js";
+export const storagePath = () => join(configUserPath(), "globalStorage", "storage.json");
+let __storage;
+export const storage = () => {
+    if (__storage)
+        return __storage;
+    const content = fs.readFileSync(storagePath()).toString();
+    __storage = pkg.parse(content);
+    if (!__storage)
+        throw new Error("VS Code storage.json could not be loaded");
+    return __storage;
+};