@vutex/vutex 0.0.0 → 0.0.2

package/src/index.ts

@@ -1,36 +1,36 @@
-import { loadVuTeXNode } from "./node/load.js";
-import { createVuTeXRuntime } from "./runtime.js";
-import type { CreateVuTeXOptions, VuTeXRuntime } from "./types.js";
-
-export type {
-    CreateVuTeXOptions,
-    FormulaDiagnostic,
-    FormulaMetrics,
-    FormulaRender,
-    FormulaRenderOptions,
-    InspectDocumentResult,
-    PackageDoctorReport,
-    PackageInstallOptions,
-    PackageRecord,
-    RenderDocumentOptions,
-    RenderDocumentResult,
-    VuTeXBackend,
-    VuTeXBindings,
-    VuTeXDiagnostic,
-    VuTeXHost,
-    VuTeXRuntime,
-} from "./types.js";
-
-export { loadVuTeXNode } from "./node/index.js";
-export { createVuTeXRuntime } from "./runtime.js";
-
-/** Create a VuTeX runtime for Node hosts (native binding). */
-export async function createVuTeX(options: CreateVuTeXOptions = {}): Promise<VuTeXRuntime> {
-    const backend = options.backend ?? "auto";
-    const host = options.host ?? "node";
-    if (host !== "node" && backend !== "native") {
-        throw new Error("createVuTeX scaffold currently supports Node native hosts only");
-    }
-    const bindings = loadVuTeXNode();
-    return createVuTeXRuntime(bindings, options);
-}
+import { loadVuTeXNode } from "./node/load.js";
+import { createVuTeXRuntime } from "./runtime.js";
+import type { CreateVuTeXOptions, VuTeXRuntime } from "./types.js";
+
+export type {
+    CreateVuTeXOptions,
+    FormulaDiagnostic,
+    FormulaMetrics,
+    FormulaRender,
+    FormulaRenderOptions,
+    InspectDocumentResult,
+    PackageDoctorReport,
+    PackageInstallOptions,
+    PackageRecord,
+    RenderDocumentOptions,
+    RenderDocumentResult,
+    VuTeXBackend,
+    VuTeXBindings,
+    VuTeXDiagnostic,
+    VuTeXHost,
+    VuTeXRuntime,
+} from "./types.js";
+
+export { loadVuTeXNode } from "./node/index.js";
+export { createVuTeXRuntime } from "./runtime.js";
+
+/** Create a VuTeX runtime for Node hosts (native binding). */
+export async function createVuTeX(options: CreateVuTeXOptions = {}): Promise<VuTeXRuntime> {
+    const backend = options.backend ?? "auto";
+    const host = options.host ?? "node";
+    if (host !== "node" && backend !== "native") {
+        throw new Error("createVuTeX scaffold currently supports Node native hosts only");
+    }
+    const bindings = loadVuTeXNode();
+    return createVuTeXRuntime(bindings, options);
+}

package/src/node/index.ts

@@ -1 +1 @@
-export { loadVuTeXNode } from "./load.js";
+export { loadVuTeXNode } from "./load.js";

package/src/node/load.ts

@@ -1,50 +1,50 @@
-import { createRequire } from "node:module";
-
-import type { VuTeXBindings } from "../types.js";
-
-type NativeBinding = {
-    vutexVersion: () => string;
-    measureFormula: (source: string, optionsJson?: string) => string;
-    renderFormulaSvg: (source: string, optionsJson?: string) => string;
-    renderFormulaMathml: (source: string, optionsJson?: string) => string;
-    renderFormula: (source: string, optionsJson?: string) => string;
-    inspectDocument: (inputPath: string) => {
-        inputFormat: string;
-        path: string;
-        reportJson: string;
-    };
-    renderDocument: (inputPath: string, optionsJson?: string) => {
-        exitCode: number;
-        outputFormat: string;
-        svg?: string;
-        reportJson: string;
-    };
-};
-
-const PLATFORM_PACKAGES: Record<string, string> = {
-    "win32-x64": "@vutex/vutex-win32-x64",
-    "linux-x64": "@vutex/vutex-linux-x64",
-    "linux-arm64": "@vutex/vutex-linux-arm64",
-    "darwin-x64": "@vutex/vutex-darwin-x64",
-    "darwin-arm64": "@vutex/vutex-darwin-arm64",
-};
-
-/** Load the platform-specific Node-API binary from `@vutex/vutex-<platform>`. */
-export function loadVuTeXNode(): VuTeXBindings {
-    const key = `${process.platform}-${process.arch}`;
-    const pkg = PLATFORM_PACKAGES[key];
-    if (!pkg) {
-        throw new Error(`Unsupported platform for VuTeX native bindings: ${key}`);
-    }
-    const require = createRequire(import.meta.url);
-    const binding = require(pkg).default as NativeBinding;
-    return {
-        vutexVersion: () => binding.vutexVersion(),
-        measureFormula: (source, optionsJson) => binding.measureFormula(source, optionsJson),
-        renderFormulaSvg: (source, optionsJson) => binding.renderFormulaSvg(source, optionsJson),
-        renderFormulaMathml: (source, optionsJson) => binding.renderFormulaMathml(source, optionsJson),
-        renderFormula: (source, optionsJson) => binding.renderFormula(source, optionsJson),
-        inspectDocument: (inputPath) => binding.inspectDocument(inputPath),
-        renderDocument: (inputPath, optionsJson) => binding.renderDocument(inputPath, optionsJson),
-    };
-}
+import { createRequire } from "node:module";
+
+import type { VuTeXBindings } from "../types.js";
+
+type NativeBinding = {
+    vutexVersion: () => string;
+    measureFormula: (source: string, optionsJson?: string) => string;
+    renderFormulaSvg: (source: string, optionsJson?: string) => string;
+    renderFormulaMathml: (source: string, optionsJson?: string) => string;
+    renderFormula: (source: string, optionsJson?: string) => string;
+    inspectDocument: (inputPath: string) => {
+        inputFormat: string;
+        path: string;
+        reportJson: string;
+    };
+    renderDocument: (inputPath: string, optionsJson?: string) => {
+        exitCode: number;
+        outputFormat: string;
+        svg?: string;
+        reportJson: string;
+    };
+};
+
+const PLATFORM_PACKAGES: Record<string, string> = {
+    "win32-x64": "@vutex/vutex-win32-x64",
+    "linux-x64": "@vutex/vutex-linux-x64",
+    "linux-arm64": "@vutex/vutex-linux-arm64",
+    "darwin-x64": "@vutex/vutex-darwin-x64",
+    "darwin-arm64": "@vutex/vutex-darwin-arm64",
+};
+
+/** Load the platform-specific Node-API binary from `@vutex/vutex-<platform>`. */
+export function loadVuTeXNode(): VuTeXBindings {
+    const key = `${process.platform}-${process.arch}`;
+    const pkg = PLATFORM_PACKAGES[key];
+    if (!pkg) {
+        throw new Error(`Unsupported platform for VuTeX native bindings: ${key}`);
+    }
+    const require = createRequire(import.meta.url);
+    const binding = require(pkg).default as NativeBinding;
+    return {
+        vutexVersion: () => binding.vutexVersion(),
+        measureFormula: (source, optionsJson) => binding.measureFormula(source, optionsJson),
+        renderFormulaSvg: (source, optionsJson) => binding.renderFormulaSvg(source, optionsJson),
+        renderFormulaMathml: (source, optionsJson) => binding.renderFormulaMathml(source, optionsJson),
+        renderFormula: (source, optionsJson) => binding.renderFormula(source, optionsJson),
+        inspectDocument: (inputPath) => binding.inspectDocument(inputPath),
+        renderDocument: (inputPath, optionsJson) => binding.renderDocument(inputPath, optionsJson),
+    };
+}

package/src/packages/lockfile.ts

@@ -1,35 +1,35 @@
-import { readFile, writeFile } from "node:fs/promises";
-import { join } from "node:path";
-
-import TOML from "@iarna/toml";
-
-export type LockedPackage = {
-    name: string;
-    version: string;
-    source: string;
-    contentHash: string;
-    dependencies: string[];
-};
-
-export type VuTeXLockfile = {
-    version: number;
-    packages: LockedPackage[];
-};
-
-export async function readLockfile(projectRoot: string): Promise<VuTeXLockfile | null> {
-    const path = join(projectRoot, "vutex.lock");
-    try {
-        const raw = await readFile(path, "utf8");
-        return TOML.parse(raw) as VuTeXLockfile;
-    } catch (error) {
-        if ((error as NodeJS.ErrnoException).code === "ENOENT") {
-            return null;
-        }
-        throw error;
-    }
-}
-
-export async function writeLockfile(projectRoot: string, lockfile: VuTeXLockfile): Promise<void> {
-    const path = join(projectRoot, "vutex.lock");
-    await writeFile(path, `${TOML.stringify(lockfile)}\n`, "utf8");
-}
+import { readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+
+import TOML from "@iarna/toml";
+
+export type LockedPackage = {
+    name: string;
+    version: string;
+    source: string;
+    contentHash: string;
+    dependencies: string[];
+};
+
+export type VuTeXLockfile = {
+    version: number;
+    packages: LockedPackage[];
+};
+
+export async function readLockfile(projectRoot: string): Promise<VuTeXLockfile | null> {
+    const path = join(projectRoot, "vutex.lock");
+    try {
+        const raw = await readFile(path, "utf8");
+        return TOML.parse(raw) as VuTeXLockfile;
+    } catch (error) {
+        if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+            return null;
+        }
+        throw error;
+    }
+}
+
+export async function writeLockfile(projectRoot: string, lockfile: VuTeXLockfile): Promise<void> {
+    const path = join(projectRoot, "vutex.lock");
+    await writeFile(path, `${TOML.stringify(lockfile)}\n`, "utf8");
+}

package/src/packages/manager.ts

@@ -1,119 +1,119 @@
-import { mkdir, writeFile } from "node:fs/promises";
-import { join } from "node:path";
-
-import TOML from "@iarna/toml";
-
-import type { PackageDoctorReport, PackageInstallOptions, PackageRecord } from "../types.js";
-import { readLockfile, writeLockfile, type LockedPackage } from "./lockfile.js";
-import { readManifest } from "./manifest.js";
-
-function hashPlaceholder(name: string, version: string): string {
-    return `sha256:scaffold:${name}@${version}`;
-}
-
-export class PackageManager {
-    constructor(private readonly projectRoot: string) {}
-
-    async list(): Promise<PackageRecord[]> {
-        const lock = await readLockfile(this.projectRoot);
-        if (!lock) {
-            const manifest = await readManifest(this.projectRoot);
-            if (!manifest?.packages) {
-                return [];
-            }
-            return Object.entries(manifest.packages).map(([alias, version]) => ({
-                name: alias,
-                version,
-                source: "manifest",
-            }));
-        }
-        return lock.packages.map((item) => ({
-            name: item.name,
-            version: item.version,
-            source: item.source,
-        }));
-    }
-
-    async add(name: string, options: PackageInstallOptions = {}): Promise<void> {
-        const manifest = (await readManifest(this.projectRoot)) ?? {};
-        const packages = { ...(manifest.packages ?? {}) };
-        const alias = name.includes("/") ? name.split("/").pop() ?? name : name;
-        packages[alias] = options.version ?? "latest";
-        const next = {
-            ...manifest,
-            packages,
-        };
-        await writeFile(join(this.projectRoot, "vutex.toml"), `${TOML.stringify(next)}\n`, "utf8");
-    }
-
-    async remove(name: string): Promise<void> {
-        const manifest = await readManifest(this.projectRoot);
-        if (!manifest?.packages) {
-            return;
-        }
-        const packages = { ...manifest.packages };
-        delete packages[name];
-        const next = { ...manifest, packages };
-        await writeFile(join(this.projectRoot, "vutex.toml"), `${TOML.stringify(next)}\n`, "utf8");
-    }
-
-    async install(options: PackageInstallOptions = {}): Promise<void> {
-        const manifest = await readManifest(this.projectRoot);
-        const cacheDir = join(this.projectRoot, ".vutex", "packages");
-        await mkdir(cacheDir, { recursive: true });
-
-        const entries: LockedPackage[] = [];
-        const sourcePackages = manifest?.packages ?? {};
-        if (options.name) {
-            sourcePackages[options.name] = options.version ?? "latest";
-        }
-
-        for (const [alias, version] of Object.entries(sourcePackages)) {
-            entries.push({
-                name: alias,
-                version,
-                source: `@vutex/${alias}`,
-                contentHash: hashPlaceholder(alias, version),
-                dependencies: [],
-            });
-        }
-
-        await writeLockfile(this.projectRoot, {
-            version: 1,
-            packages: entries,
-        });
-    }
-
-    async update(): Promise<void> {
-        await this.install();
-    }
-
-    async doctor(): Promise<PackageDoctorReport> {
-        const checks: PackageDoctorReport["checks"] = [];
-        const manifest = await readManifest(this.projectRoot);
-        const lock = await readLockfile(this.projectRoot);
-
-        checks.push({
-            id: "manifest",
-            ok: manifest !== null,
-            message: manifest ? "vutex.toml present" : "vutex.toml missing (optional for scaffold)",
-        });
-
-        if (manifest?.packages && Object.keys(manifest.packages).length > 0) {
-            checks.push({
-                id: "lockfile",
-                ok: lock !== null && lock.packages.length > 0,
-                message: lock ? `vutex.lock tracks ${lock.packages.length} package(s)` : "vutex.lock missing",
-            });
-        } else {
-            checks.push({
-                id: "lockfile",
-                ok: true,
-                message: "no resource packages declared",
-            });
-        }
-
-        const ok = checks.every((check) => check.ok);
-        return { ok, checks };
-    }
-}
+import { mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+
+import TOML from "@iarna/toml";
+
+import type { PackageDoctorReport, PackageInstallOptions, PackageRecord } from "../types.js";
+import { readLockfile, writeLockfile, type LockedPackage } from "./lockfile.js";
+import { readManifest } from "./manifest.js";
+
+function hashPlaceholder(name: string, version: string): string {
+    return `sha256:scaffold:${name}@${version}`;
+}
+
+export class PackageManager {
+    constructor(private readonly projectRoot: string) {}
+
+    async list(): Promise<PackageRecord[]> {
+        const lock = await readLockfile(this.projectRoot);
+        if (!lock) {
+            const manifest = await readManifest(this.projectRoot);
+            if (!manifest?.packages) {
+                return [];
+            }
+            return Object.entries(manifest.packages).map(([alias, version]) => ({
+                name: alias,
+                version,
+                source: "manifest",
+            }));
+        }
+        return lock.packages.map((item) => ({
+            name: item.name,
+            version: item.version,
+            source: item.source,
+        }));
+    }
+
+    async add(name: string, options: PackageInstallOptions = {}): Promise<void> {
+        const manifest = (await readManifest(this.projectRoot)) ?? {};
+        const packages = { ...(manifest.packages ?? {}) };
+        const alias = name.includes("/") ? name.split("/").pop() ?? name : name;
+        packages[alias] = options.version ?? "latest";
+        const next = {
+            ...manifest,
+            packages,
+        };
+        await writeFile(join(this.projectRoot, "vutex.toml"), `${TOML.stringify(next)}\n`, "utf8");
+    }
+
+    async remove(name: string): Promise<void> {
+        const manifest = await readManifest(this.projectRoot);
+        if (!manifest?.packages) {
+            return;
+        }
+        const packages = { ...manifest.packages };
+        delete packages[name];
+        const next = { ...manifest, packages };
+        await writeFile(join(this.projectRoot, "vutex.toml"), `${TOML.stringify(next)}\n`, "utf8");
+    }
+
+    async install(options: PackageInstallOptions = {}): Promise<void> {
+        const manifest = await readManifest(this.projectRoot);
+        const cacheDir = join(this.projectRoot, ".vutex", "packages");
+        await mkdir(cacheDir, { recursive: true });
+
+        const entries: LockedPackage[] = [];
+        const sourcePackages = manifest?.packages ?? {};
+        if (options.name) {
+            sourcePackages[options.name] = options.version ?? "latest";
+        }
+
+        for (const [alias, version] of Object.entries(sourcePackages)) {
+            entries.push({
+                name: alias,
+                version,
+                source: `@vutex/${alias}`,
+                contentHash: hashPlaceholder(alias, version),
+                dependencies: [],
+            });
+        }
+
+        await writeLockfile(this.projectRoot, {
+            version: 1,
+            packages: entries,
+        });
+    }
+
+    async update(): Promise<void> {
+        await this.install();
+    }
+
+    async doctor(): Promise<PackageDoctorReport> {
+        const checks: PackageDoctorReport["checks"] = [];
+        const manifest = await readManifest(this.projectRoot);
+        const lock = await readLockfile(this.projectRoot);
+
+        checks.push({
+            id: "manifest",
+            ok: manifest !== null,
+            message: manifest ? "vutex.toml present" : "vutex.toml missing (optional for scaffold)",
+        });
+
+        if (manifest?.packages && Object.keys(manifest.packages).length > 0) {
+            checks.push({
+                id: "lockfile",
+                ok: lock !== null && lock.packages.length > 0,
+                message: lock ? `vutex.lock tracks ${lock.packages.length} package(s)` : "vutex.lock missing",
+            });
+        } else {
+            checks.push({
+                id: "lockfile",
+                ok: true,
+                message: "no resource packages declared",
+            });
+        }
+
+        const ok = checks.every((check) => check.ok);
+        return { ok, checks };
+    }
+}

package/src/packages/manifest.ts

@@ -1,28 +1,28 @@
-import { readFile } from "node:fs/promises";
-import { join } from "node:path";
-
-import TOML from "@iarna/toml";
-
-export type VuTeXManifest = {
-    document?: {
-        input?: string;
-        output?: string;
-    };
-    profile?: {
-        name?: string;
-    };
-    packages?: Record<string, string>;
-};
-
-export async function readManifest(projectRoot: string): Promise<VuTeXManifest | null> {
-    const path = join(projectRoot, "vutex.toml");
-    try {
-        const raw = await readFile(path, "utf8");
-        return TOML.parse(raw) as VuTeXManifest;
-    } catch (error) {
-        if ((error as NodeJS.ErrnoException).code === "ENOENT") {
-            return null;
-        }
-        throw error;
-    }
-}
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+
+import TOML from "@iarna/toml";
+
+export type VuTeXManifest = {
+    document?: {
+        input?: string;
+        output?: string;
+    };
+    profile?: {
+        name?: string;
+    };
+    packages?: Record<string, string>;
+};
+
+export async function readManifest(projectRoot: string): Promise<VuTeXManifest | null> {
+    const path = join(projectRoot, "vutex.toml");
+    try {
+        const raw = await readFile(path, "utf8");
+        return TOML.parse(raw) as VuTeXManifest;
+    } catch (error) {
+        if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+            return null;
+        }
+        throw error;
+    }
+}