@vizejs/native 0.101.0 → 0.104.0

package/types/lint.d.ts

@@ -0,0 +1,60 @@
+/* eslint-disable */
+
+/** Lint options for NAPI */
+export interface LintOptionsNapi {
+  /** Output format: "text" or "json" */
+  format?: string;
+  /** Maximum number of warnings before failing */
+  maxWarnings?: number;
+  /** Quiet mode - only show summary */
+  quiet?: boolean;
+  /** Automatically fix problems (not yet implemented) */
+  fix?: boolean;
+  /** Help display level: "full", "short", "none" */
+  helpLevel?: string;
+  /** Lint preset: "general-recommended", "essential", "incremental", "opinionated", or "nuxt" */
+  preset?: string;
+}
+
+/** Lint result for NAPI */
+export interface LintResultNapi {
+  /** Formatted output string */
+  output: string;
+  /** Total number of errors */
+  errorCount: number;
+  /** Total number of warnings */
+  warningCount: number;
+  /** Number of files linted */
+  fileCount: number;
+  /** Time in milliseconds */
+  timeMs: number;
+}
+
+/** Single-file Patina lint options for NAPI */
+export interface PatinaLintOptionsNapi {
+  /** Filename used for diagnostics */
+  filename?: string;
+  /** Locale code: "en", "ja", or "zh" */
+  locale?: string;
+  /** Help display level: "full", "short", or "none" */
+  helpLevel?: string;
+  /** Lint preset: "general-recommended", "essential", "incremental", "opinionated", or "nuxt" */
+  preset?: string;
+  /** Optional list of Patina rule names to enable */
+  enabledRules?: Array<string>;
+}
+
+/** Get Patina's currently registered rule metadata. */
+export declare function getPatinaRules(): any;
+
+/** Lint Vue SFC files matching patterns (native multithreading, .gitignore-aware) */
+export declare function lint(
+  patterns: Array<string>,
+  options?: LintOptionsNapi | undefined | null,
+): LintResultNapi;
+
+/** Lint a single Vue SFC with Patina and return structured diagnostics. */
+export declare function lintPatinaSfc(
+  source: string,
+  options?: PatinaLintOptionsNapi | undefined | null,
+): any;

package/types/sfc.d.ts

@@ -0,0 +1,234 @@
+/* eslint-disable */
+
+/** Batch compile options for NAPI */
+export interface BatchCompileOptionsNapi {
+  ssr?: boolean;
+  vapor?: boolean;
+  customRenderer?: boolean;
+  /** Preserve TypeScript in output when true */
+  isTs?: boolean;
+  threads?: number;
+}
+
+/** Batch compile result for NAPI */
+export interface BatchCompileResultNapi {
+  /** Number of files compiled successfully */
+  success: number;
+  /** Number of files that failed */
+  failed: number;
+  /** Total input bytes */
+  inputBytes: number;
+  /** Total output bytes */
+  outputBytes: number;
+  /** Compilation time in milliseconds */
+  timeMs: number;
+}
+
+/** Batch compile result with per-file results */
+export interface BatchCompileResultWithFilesNapi {
+  /** Per-file compilation results */
+  results: Array<BatchFileResultNapi>;
+  /** Number of files compiled successfully */
+  successCount: number;
+  /** Number of files that failed */
+  failedCount: number;
+  /** Compilation time in milliseconds */
+  timeMs: number;
+}
+
+/** Input file for batch compilation with results */
+export interface BatchFileInputNapi {
+  /** File path */
+  path: string;
+  /** Source code */
+  source: string;
+}
+
+/** Per-file result from batch compilation */
+export interface BatchFileResultNapi {
+  /** File path */
+  path: string;
+  /** Generated JavaScript code */
+  code: string;
+  /** Generated CSS (if any) */
+  css?: string;
+  /** Scope ID for scoped styles */
+  scopeId: string;
+  /** Whether the file has scoped styles */
+  hasScoped: boolean;
+  /** Compilation errors */
+  errors: Array<string>;
+  /** Compilation warnings */
+  warnings: Array<string>;
+  /** Hash of template content (for HMR) */
+  templateHash?: string;
+  /** Hash of style content (for HMR) */
+  styleHash?: string;
+  /** Hash of script content (for HMR) */
+  scriptHash?: string;
+  /** Per-block style metadata */
+  styles: Array<StyleBlockNapi>;
+  /** Custom block metadata */
+  customBlocks: Array<CustomBlockNapi>;
+  /** Compile-time macro artifacts */
+  macroArtifacts: Array<MacroArtifactNapi>;
+}
+
+export interface CustomBlockNapi {
+  blockType: string;
+  content: string;
+  src?: string;
+  attrs: Array<SfcBlockAttributeNapi>;
+  index: number;
+}
+
+export interface MacroArtifactNapi {
+  kind: string;
+  name: string;
+  source: string;
+  content: string;
+  moduleCode?: string;
+  start: number;
+  end: number;
+}
+
+export interface SfcBlockAttributeNapi {
+  name: string;
+  value?: string;
+}
+
+/** SFC compile options for NAPI */
+export interface SfcCompileOptionsNapi {
+  filename?: string;
+  sourceMap?: boolean;
+  ssr?: boolean;
+  vapor?: boolean;
+  customRenderer?: boolean;
+  /** Preserve TypeScript in output when true */
+  isTs?: boolean;
+  /** Scope ID for scoped CSS (e.g., "data-v-abc123") */
+  scopeId?: string;
+}
+
+/** SFC compile result for NAPI */
+export interface SfcCompileResultNapi {
+  /** Generated JavaScript code */
+  code: string;
+  /** Generated CSS (if any) */
+  css?: string;
+  /** Compilation errors */
+  errors: Array<string>;
+  /** Compilation warnings */
+  warnings: Array<string>;
+  /** Hash of template content (for HMR) */
+  templateHash?: string;
+  /** Hash of style content (for HMR) */
+  styleHash?: string;
+  /** Hash of script content (for HMR) */
+  scriptHash?: string;
+  /** Whether the file has scoped styles */
+  hasScoped: boolean;
+  /** Per-block style metadata */
+  styles: Array<StyleBlockNapi>;
+  /** Custom block metadata */
+  customBlocks: Array<CustomBlockNapi>;
+  /** Compile-time macro artifacts */
+  macroArtifacts: Array<MacroArtifactNapi>;
+}
+
+/** SFC parse options for NAPI */
+export interface SfcParseOptionsNapi {
+  filename?: string;
+}
+
+export interface SfcSrcInfoNapi {
+  scriptSrc?: string;
+  templateSrc?: string;
+}
+
+export interface StyleBlockNapi {
+  content: string;
+  src?: string;
+  lang?: string;
+  scoped: boolean;
+  module: boolean;
+  moduleName?: string;
+  index: number;
+}
+
+export interface TemplateAssetTagRuleNapi {
+  tag: string;
+  attrs: Array<string>;
+}
+
+export interface TemplateAssetUrlNapi {
+  url: string;
+  varName: string;
+}
+
+/** Compile SFC (.vue file) to JavaScript - main use case */
+export declare function compileSfc(
+  source: string,
+  options?: SfcCompileOptionsNapi | undefined | null,
+): SfcCompileResultNapi;
+
+/** Batch compile SFC files matching a glob pattern (native multithreading) */
+export declare function compileSfcBatch(
+  pattern: string,
+  options?: BatchCompileOptionsNapi | undefined | null,
+): BatchCompileResultNapi;
+
+/** Batch compile SFC files with per-file results (in-memory, native multithreading) */
+export declare function compileSfcBatchWithResults(
+  files: Array<BatchFileInputNapi>,
+  options?: BatchCompileOptionsNapi | undefined | null,
+): BatchCompileResultWithFilesNapi;
+
+export declare function collectSfcTemplateAssetUrls(
+  source: string,
+  rules?: Array<TemplateAssetTagRuleNapi> | undefined | null,
+  filename?: string | undefined | null,
+): Array<TemplateAssetUrlNapi>;
+
+export declare function extractSfcCustomBlocks(
+  source: string,
+  filename?: string | undefined | null,
+): Array<CustomBlockNapi>;
+
+export declare function extractSfcSrcInfo(
+  source: string,
+  filename?: string | undefined | null,
+): SfcSrcInfoNapi;
+
+export declare function extractSfcStyleBlocks(
+  source: string,
+  filename?: string | undefined | null,
+): Array<StyleBlockNapi>;
+
+export declare function generateSfcScopeId(
+  filename: string,
+  root?: string | undefined | null,
+  isProduction?: boolean | undefined | null,
+  source?: string | undefined | null,
+): string;
+
+export declare function hasSfcScopedStyle(
+  source: string,
+  filename?: string | undefined | null,
+): boolean;
+
+export declare function isSfcImportableAssetUrl(url: string): boolean;
+
+/** Parse SFC (.vue file) - returns lightweight result for speed */
+export declare function parseSfc(
+  source: string,
+  options?: SfcParseOptionsNapi | undefined | null,
+): any;
+
+export declare function stripSfcScopedCssComments(css: string): string;
+
+export declare function wrapSfcScopedPreprocessorStyle(
+  content: string,
+  scoped?: string | undefined | null,
+  lang?: string | undefined | null,
+): string;

package/types/tokens.d.ts

@@ -0,0 +1,73 @@
+/* eslint-disable */
+
+export interface DesignTokenNapi {
+  value: string | number;
+  type?: string;
+  description?: string;
+  attributes?: any;
+  $tier?: "primitive" | "semantic";
+  $reference?: string;
+  $resolvedValue?: string | number;
+}
+
+export interface DesignTokenCategoryNapi {
+  name: string;
+  tokens: Record<string, DesignTokenNapi>;
+  subcategories?: Array<DesignTokenCategoryNapi>;
+}
+
+export interface DesignTokenValidationNapi {
+  valid: boolean;
+  error?: string;
+}
+
+export interface FlattenedDesignTokenNapi {
+  name: string;
+  path: string;
+  categoryPath: Array<string>;
+  value: string | number;
+  type?: string;
+  description?: string;
+}
+
+export interface ResolvedDesignTokensNapi {
+  categories: Array<DesignTokenCategoryNapi>;
+  tokenMap: Record<string, DesignTokenNapi>;
+  tokenCount: number;
+  primitiveCount: number;
+  semanticCount: number;
+}
+
+export declare function buildDesignTokenMap(
+  categories: Array<DesignTokenCategoryNapi>,
+): Record<string, DesignTokenNapi>;
+
+export declare function findDependentDesignTokens(
+  tokenMap: Record<string, DesignTokenNapi>,
+  targetPath: string,
+): Array<string>;
+
+export declare function flattenDesignTokenCategories(
+  categories: Array<DesignTokenCategoryNapi>,
+): Array<FlattenedDesignTokenNapi>;
+
+export declare function generateDesignTokensMarkdown(
+  categories: Array<DesignTokenCategoryNapi>,
+  generatedAt?: string | undefined | null,
+): string;
+
+export declare function parseDesignTokensFromJson(source: string): Array<DesignTokenCategoryNapi>;
+
+export declare function parseDesignTokensFromPath(
+  tokensPath: string,
+): Array<DesignTokenCategoryNapi>;
+
+export declare function resolveDesignTokenReferences(
+  categories: Array<DesignTokenCategoryNapi>,
+): ResolvedDesignTokensNapi;
+
+export declare function validateDesignTokenReference(
+  tokenMap: Record<string, DesignTokenNapi>,
+  reference: string,
+  selfPath?: string | undefined | null,
+): DesignTokenValidationNapi;

package/types/typecheck.d.ts

@@ -0,0 +1,87 @@
+/* eslint-disable */
+
+/** Batch type check result for NAPI */
+export interface BatchTypeCheckResultNapi {
+  filesChecked: number;
+  filesWithErrors: number;
+  totalErrors: number;
+  totalWarnings: number;
+  timeMs: number;
+}
+
+/** Related location for diagnostic (NAPI) */
+export interface RelatedLocationNapi {
+  message: string;
+  start: number;
+  end: number;
+  filename?: string;
+}
+
+/** Type check capabilities result */
+export interface TypeCheckCapabilitiesNapi {
+  mode: string;
+  description: string;
+  checks: Array<TypeCheckCapabilityNapi>;
+  notes: Array<string>;
+}
+
+/** Type check capabilities info */
+export interface TypeCheckCapabilityNapi {
+  name: string;
+  description: string;
+  severity: string;
+}
+
+/** Type diagnostic for NAPI */
+export interface TypeDiagnosticNapi {
+  severity: string;
+  message: string;
+  start: number;
+  end: number;
+  code?: string;
+  help?: string;
+  related: Array<RelatedLocationNapi>;
+}
+
+/** Type check options for NAPI */
+export interface TypeCheckOptionsNapi {
+  filename?: string;
+  strict?: boolean;
+  includeVirtualTs?: boolean;
+  checkProps?: boolean;
+  checkEmits?: boolean;
+  checkTemplateBindings?: boolean;
+  checkReactivity?: boolean;
+  checkSetupContext?: boolean;
+  checkInvalidExports?: boolean;
+  checkFallthroughAttrs?: boolean;
+}
+
+/** Type check result for NAPI */
+export interface TypeCheckResultNapi {
+  diagnostics: Array<TypeDiagnosticNapi>;
+  virtualTs?: string;
+  errorCount: number;
+  warningCount: number;
+  analysisTimeMs?: number;
+}
+
+/** Get type checking capabilities info */
+export declare function getTypeCheckCapabilities(): TypeCheckCapabilitiesNapi;
+
+/**
+ * Perform type checking on a Vue SFC
+ *
+ * This performs AST-based type analysis without requiring a TypeScript compiler.
+ * For full type checking, use the CLI with Corsa integration.
+ */
+export declare function typeCheck(
+  source: string,
+  options?: TypeCheckOptionsNapi | undefined | null,
+): TypeCheckResultNapi;
+
+/** Batch type check SFC files matching a glob pattern (native multithreading) */
+export declare function typeCheckBatch(
+  pattern: string,
+  options?: TypeCheckOptionsNapi | undefined | null,
+): BatchTypeCheckResultNapi;

package/types/vite.d.ts

@@ -0,0 +1,216 @@
+/* eslint-disable */
+
+export interface CssAliasRuleNapi {
+  find: string;
+  replacement: string;
+  isRegex: boolean;
+  flags?: string;
+}
+
+export interface DefineReplacementNapi {
+  key: string;
+  value: string;
+}
+
+export interface DynamicImportAliasRuleNapi {
+  fromPrefix: string;
+  toPrefix: string;
+}
+
+export interface HmrHashesNapi {
+  scriptHash?: string;
+  templateHash?: string;
+  styleHash?: string;
+}
+
+export interface ViteIdPartsNapi {
+  request: string;
+  querySuffix: string;
+}
+
+export interface ViteDevMiddlewareRewriteNapi {
+  cleanedUrl: string;
+  fsPath: string;
+}
+
+export interface VitePluginRequestNapi {
+  /** Path segment before the query string. */
+  path: string;
+  /** Query suffix including the leading `?`, or an empty string. */
+  querySuffix: string;
+  /** Path normalized for macro virtual modules (`.vue.ts` -> `.vue`). */
+  normalizedVuePath: string;
+  /** For `\0...` virtual macro IDs, the real path without the virtual prefix. */
+  strippedVirtualPath?: string;
+  /** Whether this ID is a Vize-compiled virtual Vue module. */
+  isVizeVirtual: boolean;
+  /** Whether this ID is a Vize SSR virtual Vue module. */
+  isVizeSsrVirtual: boolean;
+  /** Real `.vue` path extracted from a Vize virtual Vue module ID. */
+  vizeVirtualPath?: string;
+  /** Build-safe ID with Vite's `/@fs` prefix removed when present. */
+  normalizedFsId?: string;
+  /** Whether the query contains `macro=true`. */
+  hasMacroQuery: boolean;
+  /** Whether the query contains `definePage`. */
+  hasDefinePageQuery: boolean;
+  /** Whether this is a `\0` virtual ID carrying a macro query. */
+  isMacroVirtualId: boolean;
+  /** Whether the request points at a Vue SFC after macro normalization. */
+  isVueSfcPath: boolean;
+  /** Whether the request is a Vite Vue style virtual query. */
+  isVueStyleQuery: boolean;
+  /** Style block language, defaulting to `css` for style virtual queries. */
+  styleLang?: string;
+  /** Style block index for style virtual queries. */
+  styleIndex?: number;
+  /** Scoped attribute value for style virtual queries. */
+  styleScoped?: string;
+  /** Whether the style query carries a CSS modules marker. */
+  hasStyleModule: boolean;
+  /** Extension suffix Vite should see for the style pipeline. */
+  styleVirtualSuffix?: string;
+  /** Vue boundary file kind: `client`, `server`, or undefined. */
+  boundaryKind?: string;
+}
+
+export interface VitePrecompileChunkOptionsNapi {
+  maxBytes?: number;
+  metadata?: Array<VitePrecompileFileMetadataEntryNapi>;
+}
+
+export interface VitePrecompileDiffNapi {
+  changedFiles: Array<string>;
+  deletedFiles: Array<string>;
+}
+
+export interface VitePrecompileFileMetadataEntryNapi {
+  path: string;
+  mtimeMs: number;
+  size: number;
+}
+
+export interface VitePrecompileFileMetadataNapi {
+  mtimeMs: number;
+  size: number;
+}
+
+export declare function applyViteDefineReplacements(
+  code: string,
+  defines: Array<DefineReplacementNapi>,
+): string;
+
+export declare function chunkVitePrecompileFiles(
+  files: Array<string>,
+  batchSize?: number | undefined | null,
+  options?: VitePrecompileChunkOptionsNapi | undefined | null,
+): Array<Array<string>>;
+
+/**
+ * Classify a Vite plugin module request using the native Vize request model.
+ * This keeps pure query parsing and virtual module categorization in Rust while
+ * JavaScript keeps Vite hook orchestration and filesystem interactions.
+ */
+export declare function classifyVitePluginRequest(id: string): VitePluginRequestNapi;
+
+export declare function createViteBareImportBases(
+  root: string,
+  importer?: string | undefined | null,
+): Array<string>;
+
+export declare function createViteBareImportCandidates(
+  id: string,
+  aliasRules: Array<CssAliasRuleNapi>,
+  resolvedId?: string | undefined | null,
+): Array<string>;
+
+export declare function createViteVirtualId(
+  realPath: string,
+  ssr?: boolean | undefined | null,
+): string;
+
+export declare function detectViteHmrUpdateType(
+  prev: HmrHashesNapi | undefined | null,
+  next: HmrHashesNapi,
+): string;
+
+export declare function diffVitePrecompileFiles(
+  files: Array<string>,
+  currentMetadata: Array<VitePrecompileFileMetadataEntryNapi>,
+  previousMetadata: Array<VitePrecompileFileMetadataEntryNapi>,
+): VitePrecompileDiffNapi;
+
+export declare function fromViteVirtualId(virtualId: string): string;
+
+export declare function generateViteHmrCode(scopeId: string, updateType: string): string;
+
+export declare function hasViteHmrChanges(
+  prev: HmrHashesNapi | undefined | null,
+  next: HmrHashesNapi,
+): boolean;
+
+export declare function hasVitePrecompileFileMetadataChanged(
+  previous: VitePrecompileFileMetadataNapi | undefined | null,
+  next: VitePrecompileFileMetadataNapi,
+): boolean;
+
+export declare function isBuiltinViteDefine(key: string): boolean;
+
+export declare function isViteBareSpecifier(id: string): boolean;
+
+export declare function normalizeViteFsIdForBuild(id: string): string;
+
+export declare function normalizeViteCssModuleFilename(filename: string): string;
+
+export declare function normalizeViteDevMiddlewareUrl(
+  reqUrl: string,
+): ViteDevMiddlewareRewriteNapi | null;
+
+export declare function normalizeVitePrecompileBatchSize(value?: number | undefined | null): number;
+
+export declare function normalizeViteRequireBase(
+  importer?: string | undefined | null,
+): string | null;
+
+export declare function normalizeViteResolvedVuePath(id: string): string | null;
+
+export declare function normalizeViteVirtualVueModuleId(id: string): string;
+
+export declare function resolveViteAliasRequest(
+  id: string,
+  aliasRules: Array<CssAliasRuleNapi>,
+): string | null;
+
+export declare function resolveViteCssImports(
+  css: string,
+  importer: string,
+  aliasRules: Array<CssAliasRuleNapi>,
+  isDev?: boolean | undefined | null,
+  devUrlBase?: string | undefined | null,
+): string;
+
+export declare function resolveViteRelativeImport(id: string, importer: string): string | null;
+
+export declare function resolveViteVuePath(
+  root: string,
+  id: string,
+  importer?: string | undefined | null,
+): string;
+
+export declare function rewriteViteDynamicTemplateImports(
+  code: string,
+  aliasRules: Array<DynamicImportAliasRuleNapi>,
+): string;
+
+export declare function rewriteViteStaticAssetUrls(
+  code: string,
+  aliasRules: Array<DynamicImportAliasRuleNapi>,
+): string;
+
+export declare function scopeViteCssForPipeline(css: string, scopeId: string): string;
+
+export declare function shouldApplyViteDefineInVirtualModule(key: string): boolean;
+
+export declare function splitViteIdQuery(id: string): ViteIdPartsNapi;
+
+export declare function toViteBrowserImportPrefix(replacement: string): string;