@vobs/compiler 1.0.0

package/src/i18n-extractor.ts

@@ -0,0 +1,51 @@
+import ts from 'typescript'
+import type { CompilerPlugin } from './plugin'
+
+export interface I18nExtractorOptions {
+  readonly functions?: readonly string[]
+  readonly onKey?: (key: string, filename: string) => void
+}
+
+export interface I18nExtractor {
+  readonly plugin: CompilerPlugin
+  getKeys(): readonly string[]
+  reset(): void
+}
+
+/** Collects statically addressable translation keys without changing emitted code. */
+export function createI18nExtractor(options: I18nExtractorOptions = {}): I18nExtractor {
+  const names = new Set(options.functions ?? ['t'])
+  const keys = new Set<string>()
+  const plugin: CompilerPlugin = {
+    name: 'i18n-extractor',
+    analyze(program, context) {
+      const visit = (node: ts.Node): void => {
+        if (ts.isCallExpression(node) && isTranslationCall(node.expression, names)) {
+          const key = readStaticKey(node.arguments[0])
+          if (key) {
+            keys.add(key)
+            options.onKey?.(key, context.filename)
+          }
+        }
+        ts.forEachChild(node, visit)
+      }
+      visit(program)
+    }
+  }
+  return {
+    plugin,
+    getKeys: () => [...keys].sort(),
+    reset: () => keys.clear()
+  }
+}
+
+function isTranslationCall(expression: ts.LeftHandSideExpression, names: Set<string>): boolean {
+  if (ts.isIdentifier(expression)) return names.has(expression.text)
+  return ts.isPropertyAccessExpression(expression) && names.has(expression.name.text)
+}
+
+function readStaticKey(argument: ts.Expression | undefined): string | undefined {
+  if (!argument) return undefined
+  if (ts.isStringLiteral(argument) || ts.isNoSubstitutionTemplateLiteral(argument)) return argument.text
+  return undefined
+}

package/src/index.ts

@@ -0,0 +1,19 @@
+// @vobs/compiler 入口
+
+export { compile, compileWithSourceMap, createCompiler } from './compile.ts'
+export { createI18nExtractor } from './i18n-extractor.ts'
+export type { I18nExtractor, I18nExtractorOptions } from './i18n-extractor.ts'
+export type {
+  AnalyzeContext,
+  ASTNode,
+  CompileResult,
+  CompilerDiagnostic,
+  CompileOptions,
+  CompilerContext,
+  CompilerOptions,
+  CompilerPlugin,
+  Program,
+  TransformContext,
+  VobsCompiler,
+  VobsSourceMap
+} from './plugin.ts'

package/src/plugin.ts

@@ -0,0 +1,72 @@
+import ts from 'typescript'
+
+export type ASTNode = ts.Node
+export type Program = ts.SourceFile
+
+export interface CompilerContext {
+  readonly filename: string
+  readonly factory: typeof ts.factory
+  addRuntimeImport(name: string): void
+  /**
+   * Create a reference to a runtime helper in generated code. When the source
+   * binds the same name, the compiler imports the helper under an alias and
+   * this returns the aliased identifier, so plugin-generated calls never
+   * collide with user bindings.
+   */
+  helperRef(name: string): ts.Identifier
+}
+
+export type AnalyzeContext = CompilerContext
+export type TransformContext = CompilerContext
+
+export interface CompilerPlugin {
+  readonly name: string
+  analyze?: (program: Program, context: AnalyzeContext) => void
+  transform?: {
+    program?: (program: Program, context: TransformContext) => Program | undefined
+    node?: (node: ASTNode, context: TransformContext) => ASTNode | null | undefined
+  }
+  /** @deprecated Use transform.node for new plugins. */
+  transformNode?: (node: ASTNode, context: TransformContext) => ASTNode | null | undefined
+}
+
+export interface CompilerOptions {
+  plugins?: readonly CompilerPlugin[]
+}
+
+export interface CompileOptions extends CompilerOptions {
+  filename?: string
+}
+
+export interface VobsSourceMap {
+  readonly version: 3
+  readonly file: string
+  readonly sources: string[]
+  readonly sourcesContent: string[]
+  readonly names: string[]
+  readonly mappings: string
+}
+
+export interface CompileResult {
+  readonly code: string
+  readonly map: VobsSourceMap
+  readonly diagnostics: readonly CompilerDiagnostic[]
+}
+
+export interface CompilerDiagnostic {
+  readonly code: string
+  readonly severity: 'error' | 'warning'
+  readonly message: string
+  readonly location: {
+    readonly file: string
+    readonly line: number
+    readonly column: number
+  }
+  readonly codeFrame?: string
+  readonly fix?: string
+}
+
+export interface VobsCompiler {
+  compile(code: string, options?: CompileOptions): string
+  compileWithSourceMap(code: string, options?: CompileOptions): CompileResult
+}