@vizejs/native 0.101.0 → 0.104.0

package/native-binding.js

@@ -0,0 +1,98 @@
+/* eslint-disable */
+// @ts-nocheck
+
+const { loadTarget, nativeTargets } = require("./native-targets");
+
+const loadErrors = [];
+
+function tryRequire(specifier) {
+  try {
+    return require(specifier);
+  } catch (error) {
+    loadErrors.push(error);
+    return null;
+  }
+}
+
+function loadConfiguredBinding() {
+  if (!process.env.NAPI_RS_NATIVE_LIBRARY_PATH) {
+    return null;
+  }
+  return tryRequire(process.env.NAPI_RS_NATIVE_LIBRARY_PATH);
+}
+
+function loadNativeBinding() {
+  const configured = loadConfiguredBinding();
+  if (configured) {
+    return configured;
+  }
+
+  for (const target of nativeTargets(loadErrors)) {
+    const binding = loadTarget(target, loadErrors);
+    if (binding) {
+      return binding;
+    }
+  }
+
+  return null;
+}
+
+function loadWasiBinding() {
+  let wasiBinding = null;
+  let wasiBindingError = null;
+
+  wasiBinding = tryRequire("./vize-vitrine.wasi.cjs");
+  if (!wasiBinding && process.env.NAPI_RS_FORCE_WASI) {
+    wasiBindingError = loadErrors[loadErrors.length - 1];
+  }
+
+  if (!wasiBinding) {
+    wasiBinding = tryRequire("@vizejs/native-wasm32-wasi");
+    if (!wasiBinding && process.env.NAPI_RS_FORCE_WASI) {
+      const error = loadErrors[loadErrors.length - 1];
+      if (!wasiBindingError) {
+        wasiBindingError = error;
+      } else if (wasiBindingError !== error) {
+        wasiBindingError.cause = error;
+      }
+    }
+  }
+
+  if (process.env.NAPI_RS_FORCE_WASI === "error" && !wasiBinding) {
+    const error = new Error("WASI binding not found and NAPI_RS_FORCE_WASI is set to error");
+    error.cause = wasiBindingError;
+    throw error;
+  }
+
+  return wasiBinding;
+}
+
+function buildLoadError() {
+  if (loadErrors.length === 0) {
+    return new Error("Failed to load native binding");
+  }
+
+  return new Error(
+    `Cannot find native binding. ` +
+      `npm has a bug related to optional dependencies (https://github.com/npm/cli/issues/4828). ` +
+      "Please try `npm i` again after removing both package-lock.json and node_modules directory.",
+    {
+      cause: loadErrors.reduce((error, current) => {
+        current.cause = error;
+        return current;
+      }),
+    },
+  );
+}
+
+let nativeBinding = loadNativeBinding();
+
+if (!nativeBinding || process.env.NAPI_RS_FORCE_WASI) {
+  nativeBinding = loadWasiBinding() || nativeBinding;
+}
+
+if (!nativeBinding) {
+  throw buildLoadError();
+}
+
+module.exports = nativeBinding;

package/native-targets.js

@@ -0,0 +1,132 @@
+/* eslint-disable */
+// @ts-nocheck
+
+const { readFileSync } = require("node:fs");
+const { execSync } = require("node:child_process");
+
+const binaryName = "vize-vitrine";
+const packageVersion = require("./package.json").version;
+
+function isFileMusl(file) {
+  return file.includes("libc.musl-") || file.includes("ld-musl-");
+}
+
+function isMuslFromFilesystem() {
+  try {
+    return readFileSync("/usr/bin/ldd", "utf-8").includes("musl");
+  } catch {
+    return null;
+  }
+}
+
+function isMuslFromReport() {
+  let report = null;
+
+  if (typeof process.report?.getReport === "function") {
+    process.report.excludeNetwork = true;
+    report = process.report.getReport();
+  }
+
+  if (!report) {
+    return null;
+  }
+  if (report.header && report.header.glibcVersionRuntime) {
+    return false;
+  }
+  if (Array.isArray(report.sharedObjects)) {
+    return report.sharedObjects.some(isFileMusl);
+  }
+
+  return false;
+}
+
+function isMuslFromChildProcess() {
+  try {
+    return execSync("ldd --version", { encoding: "utf8" }).includes("musl");
+  } catch {
+    return false;
+  }
+}
+
+function isMusl() {
+  if (process.platform !== "linux") {
+    return false;
+  }
+
+  const fromFs = isMuslFromFilesystem();
+  if (fromFs !== null) {
+    return fromFs;
+  }
+
+  const fromReport = isMuslFromReport();
+  if (fromReport !== null) {
+    return fromReport;
+  }
+
+  return isMuslFromChildProcess();
+}
+
+function nativeTargets(loadErrors) {
+  if (process.platform === "darwin") {
+    if (process.arch === "arm64" || process.arch === "x64") {
+      return ["darwin-universal", `darwin-${process.arch}`];
+    }
+    loadErrors.push(new Error(`Unsupported architecture on macOS: ${process.arch}`));
+    return [];
+  }
+
+  if (process.platform === "linux") {
+    if (process.arch === "arm64" || process.arch === "x64") {
+      return [`linux-${process.arch}-${isMusl() ? "musl" : "gnu"}`];
+    }
+    loadErrors.push(new Error(`Unsupported architecture on Linux: ${process.arch}`));
+    return [];
+  }
+
+  if (process.platform === "win32") {
+    if (process.arch === "arm64" || process.arch === "x64") {
+      return [`win32-${process.arch}-msvc`];
+    }
+    loadErrors.push(new Error(`Unsupported architecture on Windows: ${process.arch}`));
+    return [];
+  }
+
+  loadErrors.push(new Error(`Unsupported OS: ${process.platform}, architecture: ${process.arch}`));
+  return [];
+}
+
+function requireTargetPackage(target) {
+  const packageName = `@vizejs/native-${target}`;
+  const binding = require(packageName);
+  const bindingPackageVersion = require(`${packageName}/package.json`).version;
+
+  if (
+    bindingPackageVersion !== packageVersion &&
+    process.env.NAPI_RS_ENFORCE_VERSION_CHECK &&
+    process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0"
+  ) {
+    throw new Error(
+      `Native binding package version mismatch, expected ${packageVersion} but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
+    );
+  }
+
+  return binding;
+}
+
+function loadTarget(target, loadErrors) {
+  try {
+    return require(`./${binaryName}.${target}.node`);
+  } catch (error) {
+    loadErrors.push(error);
+  }
+
+  try {
+    return requireTargetPackage(target);
+  } catch (error) {
+    loadErrors.push(error);
+  }
+
+  return null;
+}
+
+module.exports = { loadTarget, nativeTargets };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vizejs/native",
-  "version": "0.101.0",
+  "version": "0.104.0",
   "description": "High-performance Vue.js compiler - Native bindings",
   "keywords": [
     "compiler",
@@ -10,6 +10,10 @@
     "vize",
     "vue"
   ],
+  "homepage": "https://github.com/ubugeeei/vize",
+  "bugs": {
+    "url": "https://github.com/ubugeeei/vize/issues"
+  },
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -17,7 +21,10 @@
   },
   "files": [
     "index.js",
-    "index.d.ts"
+    "index.d.ts",
+    "native-binding.js",
+    "native-targets.js",
+    "types"
   ],
   "main": "index.js",
   "types": "index.d.ts",
@@ -28,14 +35,14 @@
     "@napi-rs/cli": "3.6.2"
   },
   "optionalDependencies": {
-    "@vizejs/native-darwin-arm64": "0.101.0",
-    "@vizejs/native-darwin-x64": "0.101.0",
-    "@vizejs/native-linux-arm64-gnu": "0.101.0",
-    "@vizejs/native-linux-arm64-musl": "0.101.0",
-    "@vizejs/native-linux-x64-gnu": "0.101.0",
-    "@vizejs/native-linux-x64-musl": "0.101.0",
-    "@vizejs/native-win32-arm64-msvc": "0.101.0",
-    "@vizejs/native-win32-x64-msvc": "0.101.0"
+    "@vizejs/native-darwin-arm64": "0.104.0",
+    "@vizejs/native-darwin-x64": "0.104.0",
+    "@vizejs/native-linux-arm64-gnu": "0.104.0",
+    "@vizejs/native-linux-arm64-musl": "0.104.0",
+    "@vizejs/native-linux-x64-gnu": "0.104.0",
+    "@vizejs/native-linux-x64-musl": "0.104.0",
+    "@vizejs/native-win32-arm64-msvc": "0.104.0",
+    "@vizejs/native-win32-x64-msvc": "0.104.0"
   },
   "napi": {
     "binaryName": "vize-vitrine",
@@ -50,6 +57,9 @@
       "aarch64-unknown-linux-musl"
     ]
   },
+  "engines": {
+    "node": ">=22"
+  },
   "scripts": {
     "build": "node ./scripts/build-local.mjs --release",
     "build:ci": "napi build --platform --profile ci --manifest-path ../../crates/vize_vitrine/Cargo.toml -p vize_vitrine --features napi --output-dir .",

package/types/art.d.ts

@@ -0,0 +1,239 @@
+/* eslint-disable */
+
+/** Art descriptor for NAPI */
+export interface ArtDescriptorNapi {
+  filename: string;
+  metadata: ArtMetadataNapi;
+  variants: Array<ArtVariantNapi>;
+  hasScriptSetup: boolean;
+  hasScript: boolean;
+  styleCount: number;
+}
+
+/** Art metadata for NAPI */
+export interface ArtMetadataNapi {
+  title: string;
+  description?: string;
+  component?: string;
+  category?: string;
+  tags: Array<string>;
+  status: string;
+  order?: number;
+}
+
+/** Art parse options for NAPI */
+export interface ArtParseOptionsNapi {
+  filename?: string;
+}
+
+/** Art variant for NAPI */
+export interface ArtVariantNapi {
+  name: string;
+  template: string;
+  isDefault: boolean;
+  skipVrt: boolean;
+}
+
+export interface AutogenConfigNapi {
+  maxVariants?: number;
+  includeDefault?: boolean;
+  includeBooleanToggles?: boolean;
+  includeEnumVariants?: boolean;
+  includeBoundaryValues?: boolean;
+  includeEmptyStrings?: boolean;
+}
+
+export interface AutogenOutputNapi {
+  variants: Array<GeneratedVariantNapi>;
+  artFileContent: string;
+  componentName: string;
+}
+
+/** Catalog entry for NAPI */
+export interface CatalogEntryNapi {
+  title: string;
+  description?: string;
+  category?: string;
+  tags: Array<string>;
+  status: string;
+  variantCount: number;
+  docPath: string;
+  sourcePath: string;
+}
+
+/** Catalog output for NAPI */
+export interface CatalogOutputNapi {
+  markdown: string;
+  filename: string;
+  componentCount: number;
+  categories: Array<string>;
+  tags: Array<string>;
+}
+
+/** CSF output for NAPI */
+export interface CsfOutputNapi {
+  code: string;
+  filename: string;
+}
+
+/** Declaration generation options for NAPI */
+export interface DeclarationOptionsNapi {
+  filename?: string;
+}
+
+/** Declaration generation result for NAPI */
+export interface DeclarationResultNapi {
+  code: string;
+}
+
+/** Doc options for NAPI */
+export interface DocOptionsNapi {
+  includeSource?: boolean;
+  includeTemplates?: boolean;
+  includeMetadata?: boolean;
+  includeToc?: boolean;
+  tocThreshold?: number;
+  basePath?: string;
+  title?: string;
+}
+
+/** Doc output for NAPI */
+export interface DocOutputNapi {
+  markdown: string;
+  filename: string;
+  title: string;
+  category?: string;
+  variantCount: number;
+}
+
+/** Format options for NAPI. */
+export interface FormatOptionsNapi {
+  printWidth?: number;
+  tabWidth?: number;
+  useTabs?: boolean;
+  semi?: boolean;
+  singleQuote?: boolean;
+  sortAttributes?: boolean;
+  singleAttributePerLine?: boolean;
+  maxAttributesPerLine?: number;
+  normalizeDirectiveShorthands?: boolean;
+}
+
+/** Format result for NAPI. */
+export interface FormatResultNapi {
+  code: string;
+  changed: boolean;
+}
+
+export interface GeneratedVariantNapi {
+  name: string;
+  isDefault: boolean;
+  props: any;
+  description?: string;
+}
+
+/** Palette options for NAPI */
+export interface PaletteOptionsNapi {
+  inferOptions?: boolean;
+  minSelectValues?: number;
+  maxSelectValues?: number;
+  groupByType?: boolean;
+}
+
+/** Palette output for NAPI */
+export interface PaletteOutputNapi {
+  title: string;
+  controls: Array<PropControlNapi>;
+  groups: Array<string>;
+  json: string;
+  typescript: string;
+}
+
+/** Prop control for NAPI */
+export interface PropControlNapi {
+  name: string;
+  control: string;
+  defaultValue?: any;
+  description?: string;
+  required: boolean;
+  options: Array<SelectOptionNapi>;
+  range?: RangeConfigNapi;
+  group?: string;
+}
+
+export interface PropDefinitionNapi {
+  name: string;
+  propType: string;
+  required: boolean;
+  defaultValue?: any;
+}
+
+/** Range config for NAPI */
+export interface RangeConfigNapi {
+  min: number;
+  max: number;
+  step?: number;
+}
+
+/** Select option for NAPI */
+export interface SelectOptionNapi {
+  label: string;
+  value: any;
+}
+
+/** Transform Art to Storybook CSF 3.0 */
+export declare function artToCsf(
+  source: string,
+  options?: ArtParseOptionsNapi | undefined | null,
+): CsfOutputNapi;
+
+/** Format a Vue SFC source string. */
+export declare function formatSfc(
+  source: string,
+  options?: FormatOptionsNapi | undefined | null,
+): FormatResultNapi;
+
+/** Generate catalog from multiple Art sources (high-performance batch) */
+export declare function generateArtCatalog(
+  sources: Array<string>,
+  docOptions?: DocOptionsNapi | undefined | null,
+): CatalogOutputNapi;
+
+/** Generate component documentation from Art source */
+export declare function generateArtDoc(
+  source: string,
+  artOptions?: ArtParseOptionsNapi | undefined | null,
+  docOptions?: DocOptionsNapi | undefined | null,
+): DocOutputNapi;
+
+/** Batch generate docs with parallel processing */
+export declare function generateArtDocsBatch(
+  sources: Array<string>,
+  docOptions?: DocOptionsNapi | undefined | null,
+): Array<DocOutputNapi>;
+
+/** Generate props palette from Art source */
+export declare function generateArtPalette(
+  source: string,
+  artOptions?: ArtParseOptionsNapi | undefined | null,
+  paletteOptions?: PaletteOptionsNapi | undefined | null,
+): PaletteOutputNapi;
+
+/** Generate a Vue SFC `.d.ts` declaration from Croquis analysis. */
+export declare function generateDeclaration(
+  source: string,
+  options?: DeclarationOptionsNapi | undefined | null,
+): DeclarationResultNapi;
+
+/** Generate .art.vue variants from component prop definitions */
+export declare function generateVariants(
+  componentPath: string,
+  props: Array<PropDefinitionNapi>,
+  config?: AutogenConfigNapi | undefined | null,
+): AutogenOutputNapi;
+
+/** Parse Art file (*.art.vue) */
+export declare function parseArt(
+  source: string,
+  options?: ArtParseOptionsNapi | undefined | null,
+): ArtDescriptorNapi;

package/types/cli.d.ts

@@ -0,0 +1,4 @@
+/* eslint-disable */
+
+/** Run the Rust Vize CLI with argv-style arguments. */
+export declare function runCli(args: Array<string>): void;

package/types/compiler.d.ts

@@ -0,0 +1,66 @@
+/* eslint-disable */
+
+/** Compile result */
+export interface CompileResult {
+  /** Generated code */
+  code: string;
+  /** Preamble code (imports) */
+  preamble: string;
+  /** AST (serialized as JSON) */
+  ast: any;
+  /** Source map */
+  map?: any;
+  /** Used helpers */
+  helpers: Array<string>;
+  /** Template strings for Vapor mode static parts */
+  templates?: Array<string>;
+}
+
+/** Compiler options for bindings */
+export interface CompilerOptions {
+  /** Output mode: "module" or "function" */
+  mode?: string;
+  /** Whether to prefix identifiers */
+  prefixIdentifiers?: boolean;
+  /** Whether to hoist static nodes */
+  hoistStatic?: boolean;
+  /** Whether to cache event handlers */
+  cacheHandlers?: boolean;
+  /** Scope ID for scoped CSS */
+  scopeId?: string;
+  /** Whether in SSR mode */
+  ssr?: boolean;
+  /** Whether to generate source map */
+  sourceMap?: boolean;
+  /** Filename for source map */
+  filename?: string;
+  /** Output mode: "vdom" or "vapor" */
+  outputMode?: string;
+  /** Whether the template contains TypeScript */
+  isTs?: boolean;
+  /** Whether the template targets a custom renderer instead of the DOM. */
+  customRenderer?: boolean;
+  /**
+   * Script extension handling: "preserve" (keep TypeScript) or "downcompile" (transpile to JS)
+   * Defaults to "downcompile"
+   */
+  scriptExt?: string;
+}
+
+/** Compile Vue template to VDom render function */
+export declare function compile(
+  template: string,
+  options?: CompilerOptions | undefined | null,
+): CompileResult;
+
+/** Compile Vue template to Vapor mode */
+export declare function compileVapor(
+  template: string,
+  options?: CompilerOptions | undefined | null,
+): CompileResult;
+
+/** Parse template to AST only */
+export declare function parseTemplate(
+  template: string,
+  options?: CompilerOptions | undefined | null,
+): any;

package/types/css.d.ts

@@ -0,0 +1,55 @@
+/* eslint-disable */
+
+/** CSS compile options for NAPI */
+export interface CssCompileOptionsNapi {
+  /** Filename for error reporting */
+  filename?: string;
+  /** Whether to apply scoped CSS transformation */
+  scoped?: boolean;
+  /** Scope ID for scoped CSS (e.g., "data-v-abc123"). Must be the full attribute name. */
+  scopeId?: string;
+  /** Whether to generate source maps */
+  sourceMap?: boolean;
+  /** Whether to minify the output */
+  minify?: boolean;
+  /** Whether to enable CSS Modules transforms */
+  cssModules?: boolean;
+  /** Whether to enable custom media query resolution */
+  customMedia?: boolean;
+  /** Browser targets for autoprefixing */
+  targets?: CssTargetsNapi;
+}
+
+/** CSS compile result for NAPI */
+export interface CssCompileResultNapi {
+  /** Compiled CSS code */
+  code: string;
+  /** Source map (if requested) */
+  map?: string;
+  /** CSS variables found (from v-bind()) */
+  cssVars: Array<string>;
+  /** Errors during compilation */
+  errors: Array<string>;
+  /** Warnings during compilation */
+  warnings: Array<string>;
+}
+
+/** Browser targets for CSS autoprefixing */
+export interface CssTargetsNapi {
+  chrome?: number;
+  firefox?: number;
+  safari?: number;
+  edge?: number;
+  ios?: number;
+  android?: number;
+}
+
+/**
+ * Compile a CSS string with scoped CSS, v-bind() extraction, and optional minification.
+ * Unlike `compileSfc`, the `scopeId` is used as-is without stripping the "data-v-" prefix.
+ * Callers must pass the full attribute name (e.g., "data-v-abc123").
+ */
+export declare function compileCss(
+  source: string,
+  options?: CssCompileOptionsNapi | undefined | null,
+): CssCompileResultNapi;