vize 0.41.0 → 0.42.0

package/src/config.ts

@@ -1,6 +1,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { pathToFileURL } from "node:url";
+import { execFileSync } from "node:child_process";
+import { fileURLToPath, pathToFileURL } from "node:url";
 import { transform } from "oxc-transform";
 import type {
   VizeConfig,
@@ -11,18 +12,29 @@ import type {
   GlobalTypeDeclaration,
 } from "./types/index.js";
 
-const CONFIG_FILE_NAMES = [
+export const CONFIG_FILE_NAMES = [
   "vize.config.ts",
   "vize.config.js",
   "vize.config.mjs",
+  "vize.config.pkl",
   "vize.config.json",
-];
+] as const;
 
 const DEFAULT_CONFIG_ENV: ConfigEnv = {
   mode: "development",
   command: "serve",
 };
 
+const PACKAGE_ROOT = path.resolve(fileURLToPath(new URL(".", import.meta.url)), "..");
+
+export const VIZE_CONFIG_JSON_SCHEMA_PATH = path.join(
+  PACKAGE_ROOT,
+  "schemas",
+  "vize.config.schema.json",
+);
+
+export const VIZE_CONFIG_PKL_SCHEMA_PATH = path.join(PACKAGE_ROOT, "pkl", "vize.pkl");
+
 /**
  * Define a Vize configuration with type checking.
  * Accepts a plain object or a function that receives ConfigEnv.
@@ -32,7 +44,7 @@ export function defineConfig(config: UserConfigExport): UserConfigExport {
 }
 
 /**
- * Load vize.config file from the specified directory
+ * Load `vize.config.*` from the specified directory.
  */
 export async function loadConfig(
   root: string,
@@ -44,7 +56,6 @@ export async function loadConfig(
     return null;
   }
 
-  // Custom config file path
   if (configFile) {
     const absolutePath = path.isAbsolute(configFile) ? configFile : path.resolve(root, configFile);
     if (fs.existsSync(absolutePath)) {
@@ -53,7 +64,6 @@ export async function loadConfig(
     return null;
   }
 
-  // Search for config file
   if (mode === "auto") {
     const configPath = findConfigFileAuto(root);
     if (!configPath) {
@@ -62,17 +72,14 @@ export async function loadConfig(
     return loadConfigFile(configPath, env);
   }
 
-  // mode === "root"
   const configPath = findConfigFileInDir(root);
   if (!configPath) {
     return null;
   }
+
   return loadConfigFile(configPath, env);
 }
 
-/**
- * Find config file in a specific directory
- */
 function findConfigFileInDir(dir: string): string | null {
   for (const name of CONFIG_FILE_NAMES) {
     const filePath = path.join(dir, name);
@@ -83,27 +90,24 @@ function findConfigFileInDir(dir: string): string | null {
   return null;
 }
 
-/**
- * Find config file by searching from cwd upward
- */
 function findConfigFileAuto(startDir: string): string | null {
   let currentDir = path.resolve(startDir);
-  const root = path.parse(currentDir).root;
 
-  while (currentDir !== root) {
+  while (true) {
     const configPath = findConfigFileInDir(currentDir);
     if (configPath) {
       return configPath;
     }
-    currentDir = path.dirname(currentDir);
-  }
 
-  return null;
+    const parentDir = path.dirname(currentDir);
+    if (parentDir === currentDir) {
+      return null;
+    }
+
+    currentDir = parentDir;
+  }
 }
 
-/**
- * Load and evaluate a config file
- */
 async function loadConfigFile(filePath: string, env?: ConfigEnv): Promise<VizeConfig | null> {
   if (!fs.existsSync(filePath)) {
     return null;
@@ -113,20 +117,20 @@ async function loadConfigFile(filePath: string, env?: ConfigEnv): Promise<VizeCo
 
   if (ext === ".json") {
     const content = fs.readFileSync(filePath, "utf-8");
-    return JSON.parse(content);
+    return parseJsonConfig(content, filePath);
+  }
+
+  if (ext === ".pkl") {
+    return loadPklConfig(filePath);
   }
 
   if (ext === ".ts") {
     return loadTypeScriptConfig(filePath, env);
   }
 
-  // .js, .mjs - ESM
   return loadESMConfig(filePath, env);
 }
 
-/**
- * Resolve a UserConfigExport to a VizeConfig
- */
 async function resolveConfigExport(
   exported: UserConfigExport,
   env?: ConfigEnv,
@@ -134,12 +138,10 @@ async function resolveConfigExport(
   if (typeof exported === "function") {
     return exported(env ?? DEFAULT_CONFIG_ENV);
   }
+
   return exported;
 }
 
-/**
- * Load TypeScript config file using oxc-transform
- */
 async function loadTypeScriptConfig(filePath: string, env?: ConfigEnv): Promise<VizeConfig> {
   const source = fs.readFileSync(filePath, "utf-8");
   const result = transform(filePath, source, {
@@ -148,32 +150,89 @@ async function loadTypeScriptConfig(filePath: string, env?: ConfigEnv): Promise<
     },
   });
 
-  const code = result.code;
-
-  // Write to temp file and import (use Date.now() to avoid race conditions)
   const tempFile = filePath.replace(/\.ts$/, `.temp.${Date.now()}.mjs`);
-  fs.writeFileSync(tempFile, code);
+  fs.writeFileSync(tempFile, result.code);
 
   try {
-    const fileUrl = pathToFileURL(tempFile).href;
-    const module = await import(fileUrl);
+    const module = await importFresh(tempFile);
     const exported: UserConfigExport = module.default || module;
     return resolveConfigExport(exported, env);
   } finally {
-    fs.unlinkSync(tempFile);
+    fs.rmSync(tempFile, { force: true });
   }
 }
 
-/**
- * Load ESM config file
- */
 async function loadESMConfig(filePath: string, env?: ConfigEnv): Promise<VizeConfig> {
-  const fileUrl = pathToFileURL(filePath).href;
-  const module = await import(fileUrl);
+  const module = await importFresh(filePath);
   const exported: UserConfigExport = module.default || module;
   return resolveConfigExport(exported, env);
 }
 
+function loadPklConfig(filePath: string): VizeConfig {
+  try {
+    const output = execFileSync("pkl", ["eval", "--format", "json", filePath], {
+      cwd: path.dirname(filePath),
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+    return parseJsonConfig(output, filePath);
+  } catch (error) {
+    throw new Error(
+      `Failed to evaluate PKL config at ${filePath}. Make sure the 'pkl' CLI is installed and on PATH. ${getErrorMessage(error)}`,
+    );
+  }
+}
+
+async function importFresh(filePath: string): Promise<Record<string, unknown>> {
+  const fileUrl = pathToFileURL(filePath);
+  fileUrl.searchParams.set("t", String(fs.statSync(filePath).mtimeMs));
+  return import(fileUrl.href);
+}
+
+function parseJsonConfig(content: string, filePath: string): VizeConfig {
+  try {
+    return normalizeLoadedConfig(JSON.parse(content));
+  } catch (error) {
+    throw new Error(`Failed to parse vize config JSON at ${filePath}: ${getErrorMessage(error)}`);
+  }
+}
+
+function normalizeLoadedConfig(config: unknown): VizeConfig {
+  const normalized = stripNullish(config);
+  return (normalized ?? {}) as VizeConfig;
+}
+
+function stripNullish(value: unknown): unknown {
+  if (value === null) {
+    return undefined;
+  }
+
+  if (Array.isArray(value)) {
+    return value.map((entry) => stripNullish(entry)).filter((entry) => entry !== undefined);
+  }
+
+  if (typeof value === "object" && value !== null) {
+    const result: Record<string, unknown> = {};
+    for (const [key, entry] of Object.entries(value)) {
+      const normalizedEntry = stripNullish(entry);
+      if (normalizedEntry !== undefined) {
+        result[key] = normalizedEntry;
+      }
+    }
+    return result;
+  }
+
+  return value;
+}
+
+function getErrorMessage(error: unknown): string {
+  if (error instanceof Error) {
+    return error.message;
+  }
+
+  return String(error);
+}
+
 /**
  * Normalize GlobalTypesConfig shorthand strings to GlobalTypeDeclaration objects
  */

package/src/index.ts

@@ -31,4 +31,11 @@ export type {
 } from "./types/index.js";
 
 // Config utilities
-export { defineConfig, loadConfig, normalizeGlobalTypes } from "./config.js";
+export {
+  CONFIG_FILE_NAMES,
+  VIZE_CONFIG_JSON_SCHEMA_PATH,
+  VIZE_CONFIG_PKL_SCHEMA_PATH,
+  defineConfig,
+  loadConfig,
+  normalizeGlobalTypes,
+} from "./config.js";

package/src/types/core.ts

@@ -36,6 +36,11 @@ export type LintPreset = "happy-path" | "opinionated" | "essential" | "nuxt";
  * Vize configuration options
  */
 export interface VizeConfig {
+  /**
+   * JSON Schema reference for editor autocompletion.
+   */
+  $schema?: string;
+
   /**
    * Vue compiler options
    */