24008166752

Committed 05 Apr 2026 06:53PM UTC coverage: 95.341% (+0.9%) from 94.461%

Build # 24008166752

Build Type

Pull #1921

github

Committed by

web-flow

Commit Message

Merge 9db8b8539 into db5b0cc95

Pull Request Pull Request #1921: Icrease CLI and unplugin test coverage

Coverage Stats

6173 of 6555 branches covered (94.17%)

Branch coverage included in aggregate %.

7 of 12 new or added lines in 1 file covered. (58.33%)

4 existing lines in 1 file now uncovered.

25649 of 26822 relevant lines covered (95.63%)

37085.31 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

58.08

/source/unplugin/unplugin.civet

import { type TransformResult, createUnplugin } from 'unplugin'
import civet, { decode, lib, SourceMap, type CompileOptions, type ParseOptions } from '@danielx/civet'
import { findInDir, loadConfig } from '@danielx/civet/config'
import {
  remapRange,
  flattenDiagnosticMessageText,
  // @ts-ignore
  // using ts-ignore because the version of @danielx/civet typescript is checking against
  // is the one published to npm, not the one in the repo
} from '@danielx/civet/ts-diagnostic'
import * as fs from 'fs'
import path from 'path'
import type { FormatDiagnosticsHost, Diagnostic, System } from 'typescript'
import { createFSBackedSystem, createVirtualCompilerHost } from '@typescript/vfs'
import type { UserConfig } from 'vite'
import type { BuildOptions } from 'esbuild'
import os from 'os'
// From vite/src/node/constants.ts (no stable export path in vite 8)
DEFAULT_EXTENSIONS := [".mjs",".js",".mts",".ts",".jsx",".tsx",".json"]

// Copied from typescript to avoid importing the whole package
enum DiagnosticCategory
  Warning = 0
  Error = 1
  Suggestion = 2
  Message = 3

export type PluginOptions
  implicitExtension?: boolean
  outputExtension?: string
  transformOutput?: (
    code: string
    id: string
  ) => TransformResult | Promise<TransformResult>
  emitDeclaration?: boolean
  declarationExtension?: string
  typecheck?: boolean | string
  ts?: 'civet' | 'esbuild' | 'tsc' | 'preserve'
  /** @deprecated Use "ts" option instead */
  js?: boolean
  /** @deprecated Use "emitDeclaration" instead */
  dts?: boolean
  /** Number of parallel threads to compile with (Node only) */
  threads?: number
  /** Cache compilation results based on file mtime (useful for serve or watch mode) */
  cache?: boolean
  /** config filename, or false/null to not look for default config file */
  config?: string | false | null
  parseOptions?: ParseOptions

type CacheEntry
  mtime: number
  result?: TransformResult
  promise?: Promise<void>

queryPostfixRE := /\?.*$/s
escapedHashRE := /\0#/g
isWindows := os.platform() is 'win32'
windowsSlashRE := /\\/g
civetSuffix := '.civet'
workerRE := /(?:\?|&)(?:worker|sharedworker)(?:&|$|#)/

/**
Extract a possible Civet filename from an id, after removing a possible
outputExtension and/or a query/hash (?/#) postfix.
Returns {filename, postfix} in case you need to add the postfix back.
You should check whether the filename ends in .civet extension,
or needs an implicit .civet extension, or isn't Civet-related at all.
*/
function extractCivetFilename(id: string, outputExtension: string): {filename: string, postfix: string}
  postfix .= ''
  // Webpack escapes literal `#` in `loaderContext.resource` as `\0#` so it
  // can distinguish path characters from fragment suffixes. Undo that first.
  id = id.replace escapedHashRE, '#'
  // `?` is always treated as a suffix. Raw `?` is impossible in Windows paths,
  // and we rely on query suffixes across bundlers.
  filename .= id.replace queryPostfixRE, (match) =>
    postfix = match
    ''
  // Normally the outputExtension (.jsx/.tsx by default) should be present,
  // but sometimes (e.g. esbuild's alias feature) load directly without resolve
  if filename.endsWith outputExtension
    filename = filename[< -outputExtension#]
  // `#` may be either a literal path character or a fragment-like suffix.
  // Keep it when the file exists as written; otherwise strip one rightmost
  // `#...` suffix and let later resolution check whether file exists.
  hashIndex := filename.lastIndexOf '#'
  if hashIndex >= 0 and not tryStatSync filename
    postfix = filename[hashIndex..] + postfix
    filename = filename[..<hashIndex]
    if filename.endsWith outputExtension
      filename = filename[< -outputExtension#]
  {filename, postfix}

function tryStatSync(file: string): fs.Stats?
  try
    // The "throwIfNoEntry" is a performance optimization for cases where the file does not exist
    return fs.statSync file, throwIfNoEntry: false

export function slash(p: string): string
  p.replace windowsSlashRE, '/'

function normalizePath(id: string): string
  path.posix.normalize isWindows ? slash(id) : id

function tryFsResolve(file: string): string?
  fileStat := tryStatSync file
  if fileStat?.isFile()
    normalizePath file

function resolveAbsolutePath(rootDir: string, id: string, implicitExtension: boolean)
  file := path.join rootDir, id
  // Check for existence of resolved file and unresolved id,
  // without and with implicit .civet extension, and return first existing
  (or)
    tryFsResolve(file)
    implicitExtension and implicitCivet file
    tryFsResolve id
    implicitExtension and implicitCivet id

function implicitCivet(file: string): string?
  return if tryFsResolve file
  civet := file + '.civet'
  return civet if tryFsResolve civet

export const rawPlugin: Parameters<typeof createUnplugin<PluginOptions>>[0] =
(options: PluginOptions = {}, meta) =>
  if (options.dts) options.emitDeclaration = options.dts
  compileOptions: CompileOptions .= {}

  ts .= options.ts
  if (options.js) ts = 'civet'
  unless ts?
    console.log 'WARNING: You are using the default mode for `options.ts` which is `"civet"`. This mode does not support all TS features. If this is intentional, you should explicitly set `options.ts` to `"civet"`, or choose a different mode.'
    ts = "civet"
  unless ts is in ["civet", "esbuild", "tsc", "preserve"]
    console.log `WARNING: Invalid option ts: ${JSON.stringify ts}; switching to "civet"`
    ts = "civet"

  transformTS := options.emitDeclaration or options.typecheck
  outExt :=
    options.outputExtension ?? (ts is "preserve" ? ".tsx" : ".jsx")
  implicitExtension := options.implicitExtension ?? true
  let aliasResolver: (id: string) => string

  fsMap: Map<string, string> .= new Map
  sourceMaps := new Map<string, SourceMap>
  let compilerOptions: any, compilerOptionsWithSourceMap: any
  rootDir .= process.cwd()
  outDir .= path.join rootDir, 'dist'
  let esbuildOptions: BuildOptions
  let configErrors: Diagnostic[]?
  let configFileNames: string[]
  skipWorker .= false

  tsPromise := if transformTS or ts is "tsc"
    import('typescript').then .default
  getFormatHost := (sys: System): FormatDiagnosticsHost =>
    return {
      getCurrentDirectory: => sys.getCurrentDirectory()
      getNewLine: => sys.newLine
      getCanonicalFileName: sys.useCaseSensitiveFileNames
        ? (f) => f
        : (f) => f.toLowerCase()
    }

  cache := new Map<string, CacheEntry> unless options.cache is false

  plugin: ReturnType<typeof rawPlugin> := {
    name: 'unplugin-civet'
    enforce: 'pre'

    async buildStart(): Promise<void>
      civetConfigPath .= options.config
      if civetConfigPath is undefined
        civetConfigPath = await findInDir process.cwd()
      if civetConfigPath
        compileOptions = await loadConfig civetConfigPath
      // Merge parseOptions, with plugin options taking priority
      compileOptions.parseOptions = {
        ...compileOptions.parseOptions
        ...options.parseOptions
      }
      compileOptions.threads = options.threads if options.threads?

      if transformTS or ts is "tsc"
        ts := await tsPromise!

        tsConfigPath := ts.findConfigFile process.cwd(), ts.sys.fileExists

        unless tsConfigPath
          throw new Error "Could not find 'tsconfig.json'"

        { config, error } := ts.readConfigFile
          tsConfigPath
          ts.sys.readFile

        if error
          console.error ts.formatDiagnostic error, getFormatHost ts.sys
          throw error

        // Mogrify tsconfig.json "files" field to use .civet.tsx
        function mogrify(key: string)
          if key in config and Array.isArray config[key]
            config[key] = config[key].map (item: unknown) =>
              return item unless item <? "string"
              return item.replace(/\.civet\b(?!\.)/g, '.civet.tsx')
        mogrify "files"

        // Override readDirectory (used for include/exclude matching)
        // to include .civet files, as .civet.tsx files
        system := {...ts.sys}
        {readDirectory: systemReadDirectory} := system
        system.readDirectory = (path: string, extensions?: readonly string[], excludes?: readonly string[], includes?: readonly string[], depth?: number): string[] =>
          extensions = [ ...(extensions ?? []), ".civet" ]
          systemReadDirectory(path, extensions, excludes, includes, depth)
          .map &.endsWith(".civet") ? & + ".tsx" : &

        configContents := ts.parseJsonConfigFileContent
          config
          system
          process.cwd()
        configErrors = configContents.errors
        configFileNames = configContents.fileNames

        compilerOptions = {
          ...configContents.options
          target: ts.ScriptTarget.ESNext
          composite: false
        }
        // We use .tsx extensions when type checking, so need to enable
        // JSX mode even if the user doesn't request/use it.
        compilerOptions.jsx ??= ts.JsxEmit.Preserve
        compilerOptionsWithSourceMap = {
          ...compilerOptions
          sourceMap: true
        }
        fsMap = new Map()

    async buildEnd(useConfigFileNames = false): Promise<void>
      if transformTS
        const ts = await tsPromise!

        // Create a virtual file system with all source files processed so far,
        // but which further resolves any Civet dependencies that are needed
        // just for typechecking (e.g. `import type` which get removed in JS).
        system := createFSBackedSystem fsMap, process.cwd(), ts
        {
          fileExists: systemFileExists
          readFile: systemReadFile
          readDirectory: systemReadDirectory
        } := system

        system.fileExists = (filename: string): boolean =>
          if (!filename.endsWith('.civet.tsx')) return systemFileExists(filename)
          if (fsMap.has(filename)) return true
          return systemFileExists filename[...-4]

        system.readDirectory = (path: string): string[] =>
          systemReadDirectory(path)
          .map &.endsWith('.civet') ? & + '.tsx' : &

        tsCompileOptions := {
          ...compileOptions
          rewriteCivetImports: false
          rewriteTsImports: true
        }
        system.readFile = (filename: string, encoding: BufferEncoding = 'utf-8'): string? =>
          // Mogrify package.json imports field to use .civet.tsx
          if path.basename(filename) is "package.json"
            json := systemReadFile filename, encoding
            return json unless json
            parsed: Record<string, unknown> := JSON.parse(json)
            modified .= false
            function recurse(node: unknown): void
              if node? <? "object"
                for key in node
                  value := (node as Record<string, unknown>)[key]
                  if value <? "string"
                    if value.endsWith ".civet"
                      (node as Record<string, unknown>)[key] = value + '.tsx'
                      modified = true
                  else if value
                    recurse value
            recurse parsed.imports
            return modified ? JSON.stringify(parsed) : json

          // Generate .civet.tsx files on the fly
          if (!filename.endsWith('.civet.tsx')) return systemReadFile(filename, encoding)
          if (fsMap.has(filename)) return fsMap.get(filename)
          civetFilename := filename[...-4]
          rawCivetSource := fs.readFileSync civetFilename, {encoding}
          { code: compiledTS, sourceMap } := civet.compile rawCivetSource, {
            ...tsCompileOptions
            filename
            js: false
            sourceMap: true
            sync: true // TS readFile API seems to need to be synchronous
          }
          fsMap.set filename, compiledTS
          sourceMaps.set filename, sourceMap
          return compiledTS

        host := createVirtualCompilerHost
          system
          compilerOptions
          ts

        program := ts.createProgram
          rootNames: useConfigFileNames ? configFileNames : [...fsMap.keys()]
          options: compilerOptions
          host: host.compilerHost

        diagnostics: Diagnostic[] := ts
          .getPreEmitDiagnostics(program)
          .map (diagnostic) =>
            file := diagnostic.file
            if (!file) return diagnostic

            sourceMap := sourceMaps.get file.fileName
            if (!sourceMap) return diagnostic

            sourcemapLines := sourceMap.lines ?? sourceMap.data.lines
            range := remapRange(
              {
                start: diagnostic.start || 0,
                end: (diagnostic.start || 0) + (diagnostic.length || 1),
              },
              sourcemapLines
            )

            {
              ...diagnostic,
              messageText: flattenDiagnosticMessageText(diagnostic.messageText),
              length: diagnostic.length,
              start: range.start,
            }

        if configErrors?#
          diagnostics.unshift ...configErrors

        if diagnostics# > 0
          console.error
            ts.formatDiagnosticsWithColorAndContext
              diagnostics
              getFormatHost ts.sys
          if options.typecheck
            failures: DiagnosticCategory[] .= []
            if options.typecheck <? "string"
              if (options.typecheck.includes('error')) failures.push(DiagnosticCategory.Error)
              if (options.typecheck.includes('warning')) failures.push(DiagnosticCategory.Warning)
              if (options.typecheck.includes('suggestion')) failures.push(DiagnosticCategory.Suggestion)
              if (options.typecheck.includes('message')) failures.push(DiagnosticCategory.Message)
              if (options.typecheck.includes('all'))
                failures = { includes: () => true } as any as DiagnosticCategory[]
            else
              // Default behavior: fail on errors
              failures.push(DiagnosticCategory.Error)
            count := diagnostics.filter((d) => failures.includes(d.category)).length
            if count
              reason :=
                (count is diagnostics# ? count : `${count} out of ${diagnostics#}`)
              throw new Error `Aborting build because of ${reason} TypeScript diagnostic${diagnostics.length > 1 ? 's' : ''} above`

        if options.emitDeclaration
          if meta.framework is 'esbuild' and not esbuildOptions.outdir
            throw new Error "Civet unplugin's `emitDeclaration` requires esbuild's `outdir` option to be set;"

          // Removed duplicate slashed (`\`) versions of the same file for emit
          for file of fsMap.keys()
            slashed := slash file
            unless file is slashed
              fsMap.delete slashed

          for file of fsMap.keys()
            sourceFile := program.getSourceFile(file)!
            program.emit
              sourceFile
              (filePath, content) =>
                if options.declarationExtension?
                  if filePath.endsWith '.d.ts'
                    filePath = filePath[< -5]
                  else
                    console.log `WARNING: No .d.ts extension in ${filePath}`
                  if filePath.endsWith civetSuffix
                    filePath = filePath[< -civetSuffix#]
                  else
                    console.log `WARNING: No .civet extension in ${filePath}`
                  filePath += options.declarationExtension

                pathFromDistDir .= path.relative
                  compilerOptions.outDir ?? process.cwd()
                  filePath

                this.emitFile
                  source: content
                  fileName: pathFromDistDir
                  type: 'asset'
              undefined
              true // emitDtsOnly
              undefined
              // @ts-ignore @internal interface
              true // forceDtsEmit

    resolveId(id, importer, options)
      id = aliasResolver id if aliasResolver?
      if (/\0/.test(id)) return null

      // Remove query/hash postfix to get actual path
      {filename, postfix} := extractCivetFilename id, outExt

      resolved .=
        if path.isAbsolute filename
          resolveAbsolutePath rootDir, filename, implicitExtension
        else
          path.resolve path.dirname(importer ?? ''), filename
      if (!resolved) return null

      // Implicit .civet extension
      unless resolved.endsWith civetSuffix
        if (!implicitExtension) return null
        implicitId := implicitCivet resolved
        if (!implicitId) return null
        resolved = implicitId

      // Tell Vite that this is a virtual module during dependency scanning
      if (options as! {scan?: boolean}).scan and meta.framework is 'vite'
        resolved = `\0${resolved}`

      // Add back the original postfix at the end
      return resolved + outExt + postfix

    loadInclude(id)
      {filename, postfix} := extractCivetFilename id, outExt
      return false if skipWorker and workerRE.test postfix
      filename.endsWith civetSuffix

    async load(id)
      {filename} .= extractCivetFilename id, outExt
      // We're guaranteed to have .civet extension here by loadInclude

      filename = path.resolve rootDir, filename
      @addWatchFile filename

      let mtime: number?, cached: CacheEntry?, resolve: =>?
      if cache?
        try
          mtime = fs.promises.stat(filename) |> await |> .mtimeMs
        // If we fail to stat file, ignore cache
        if mtime?
          cached = cache.get filename
          if cached and cached.mtime is mtime
            // If the file is currently being compiled, wait for it to finish
            await cached.promise if cached.promise
            if result? := cached.result
              return result
          // We're the first to compile this file with this mtime
          promise := new Promise<void> (r): void => resolve = r
          cache.set filename, cached = {mtime, promise}
      finally resolve?()

      let compiled: string
      let sourceMap: SourceMap | string | undefined
      civetOptions := {
        ...compileOptions
        filename: id
        errors: []
      }
      function checkErrors
        if civetOptions.errors#
          throw new civet.ParseErrors civetOptions.errors

      rawCivetSource := decode await fs.promises.readFile filename
      ast := await civet.compile rawCivetSource, {
        ...civetOptions
        ast: true
      }
      civetSourceMap := new SourceMap rawCivetSource,
        normalizePath path.relative outDir, filename

      if ts is "civet"
        compiled = await civet.generate ast, {
          ...civetOptions
          js: true
          sourceMap: civetSourceMap
        }
        sourceMap = civetSourceMap
        checkErrors()
      else
        compiledTS := await civet.generate ast, {
          ...civetOptions
          js: false
          sourceMap: civetSourceMap
        }
        checkErrors()

        switch ts
          when "esbuild"
            esbuildTransform := import("esbuild") |> await |> .transform
            result := await esbuildTransform compiledTS,
              jsx: "preserve"
              loader: "tsx"
              sourcefile: id
              sourcemap: "external"

            compiled = result.code
            sourceMap = result.map
          when "tsc"
            tsTranspile := tsPromise! |> await |> .transpileModule
            result := tsTranspile compiledTS,
              compilerOptions: compilerOptionsWithSourceMap

            compiled = result.outputText
            sourceMap = result.sourceMapText
          when "preserve"
            compiled = compiledTS
            sourceMap = civetSourceMap

      if transformTS
        // When working with TypeScript, disable rewriteCivetImports and
        // force rewriteTsImports by rewriting imports again.
        // See `ModuleSpecifier` in parser.hera
        for each _spec of lib.gatherRecursive ast, (
          ($) => ($ as {type: string}).type is "ModuleSpecifier"
        )
          spec := _spec as { module?: { token: string, input?: string } }
          if spec.module?.input
            spec.module.token = spec.module.input
            .replace /\.([mc])?ts(['"])$/, ".$1js$2"

        compiledTS := await civet.generate ast, {
          ...civetOptions
          js: false
          sourceMap: civetSourceMap
        }
        checkErrors()

        // Force .tsx extension for type checking purposes.
        // Otherwise, TypeScript complains about types in .jsx files.
        tsx := filename + '.tsx'
        fsMap.set tsx, compiledTS
        sourceMaps.set tsx, civetSourceMap
        // Vite and Rollup normalize filenames to use `/` instead of `\`.
        // We give the TypeScript VFS both versions just in case.
        slashed := slash tsx
        unless tsx is slashed
          fsMap.set slashed, compiledTS
          sourceMaps.set slashed, civetSourceMap

      jsonSourceMap := sourceMap and
        if sourceMap <? "string"
          JSON.parse(sourceMap)
        else
          sourceMap.json normalizePath path.relative outDir, id

      transformed: TransformResult .=
        code: compiled
        map: jsonSourceMap

      if options.transformOutput
        transformed = await options.transformOutput transformed.code, id

      if cached?
        cached.result = transformed
        delete cached.promise

      return transformed

    esbuild: {
      config(options: BuildOptions): void
        esbuildOptions = options
        outDir = options.outdir or path.dirname options.outfile!
    }
    vite: {
      config(config: UserConfig): void
        // Vite 7 requires us to skip processing ?worker
        // and instead process a followup request for ?worker_file
        // Luckily, Vite 7 introduced @meta.viteVersion for detection
        //@ts-ignore lacking type for this
        if @?meta?viteVersion and 7 <= Number @meta.viteVersion.split('.')[0]
          skipWorker = true

        rootDir = path.resolve process.cwd(), config.root ?? ''
        outDir = path.resolve rootDir, config.build?.outDir ?? 'dist'

        if implicitExtension
          config.resolve ??= {}
          config.resolve.extensions ??= DEFAULT_EXTENSIONS
          config.resolve.extensions.push '.civet'
      async transformIndexHtml(html)
        html.replace /<!--[^]*?-->|<[^<>]*>/g, (tag) =>
          tag.replace /<\s*script\b[^<>]*>/gi, (script) =>
            // https://html.spec.whatwg.org/multipage/syntax.html#attributes-2
            script.replace
              /([:_\p{ID_Start}][:\p{ID_Continue}]*)(\s*=\s*("[^"]*"|'[^']*'|[^\s"'=<>`]*))?/gu
              (attr, name, value) =>
                name.toLowerCase() === 'src' && value
                  ? attr.replace(
                      /(\.civet)(['"]?)$/,
                      (_, extension, endQuote) =>
                        `${extension}${outExt}?transform${endQuote}`
                    )
                  : attr
      handleHotUpdate({ file, server, modules })
        // `file` is an absolute path to the changed file on disk,
        // so for our case it should end with .civet extension
        return unless file.endsWith '.civet'
        // Convert into path as would be output by `resolveId`
        resolvedId := slash path.resolve(file) + outExt
        // Check for modules for this file
        if fileModules := server.moduleGraph.getModulesByFile resolvedId
          // Invalidate modules depending on this one
          server.moduleGraph.onFileChange resolvedId
          // Hot reload this module
          return [ ...modules, ...fileModules ]
        modules
    }

    rspack(compiler)
      if implicitExtension
        compiler.options ?= {}
        compiler.options.resolve ?= {}
        // Default from https://rspack.dev/config/resolve#resolveextensions
        compiler.options.resolve.extensions ?= ['', '.js', '.json', '.wasm']
        compiler.options.resolve.extensions.unshift ".civet"
    webpack(compiler)
      if implicitExtension
        compiler.options.resolve ?= {}
        // Default from https://webpack.js.org/configuration/resolve/#resolveextensions
        compiler.options.resolve.extensions ?= ['', '.js', '.json', '.wasm']
        compiler.options.resolve.extensions.unshift ".civet"
      aliasResolver = (id) =>
        // Based on normalizeAlias from
        // https://github.com/webpack/enhanced-resolve/blob/72999caf002f6f7bb4624e65fdeb7ba980b11e24/lib/ResolverFactory.js#L158
        // and AliasPlugin from
        // https://github.com/webpack/enhanced-resolve/blob/72999caf002f6f7bb4624e65fdeb7ba980b11e24/lib/AliasPlugin.js
        // @ts-expect-error TODO
        for key, value in compiler.options.resolve.alias
          if key.endsWith '$'
            if id is key[...-1]
              return value <? 'string' ? value : '\0'
          else
            if id is key or id.startsWith key + '/'
              return '\0' unless value <? 'string'
              return value + id[key.length..]
        id
  }

var unplugin = createUnplugin(rawPlugin)
export default unplugin

DanielXMoore / Civet / 24008166752

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous