14696205467

Committed 27 Apr 2025 09:16PM UTC coverage: 91.652% (+0.01%) from 91.64%

Build # 14696205467

Build Type

Pull #1734

github

Committed by

web-flow

Commit Message

Merge aef507707 into 0039cdd9c

Pull Request Pull Request #1734: ESM loader supports civetconfig by default, and overriding configuration

Run Details

3643 of 3962 branches covered (91.95%)

Branch coverage included in aggregate %.

47 of 49 new or added lines in 2 files covered. (95.92%)

3 existing lines in 2 files now uncovered.

18808 of 20534 relevant lines covered (91.59%)

16289.58 hits per line

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

35.95

/source/cli.civet

{ compile, generate, parse, lib, isCompileError, SourceMap } from ./main.civet
type { ASTError, BlockStatement, ParseError, ParseErrors } from ./main.civet
{ findConfig, loadConfig } from ./config.civet

// unplugin ends up getting installed in the same dist directory
{rawPlugin} from ./unplugin/unplugin.civet
let unplugin:
  buildStart: () => Promise<void>
  buildEnd: (this: {emitFile: (data: {source: string, fileName: string, type: string}) => void}, useConfigFileNames?: boolean) => Promise<void>
  load: (this: {addWatchFile: (filename: string) => void}, filename: string) => Promise<{code: string, map: unknown}>

export function version: Promise<string>
  // Once import assertions (with form) are universal, we can switch to this:
  //import package from "../package.json" with type: "json"
  //package.version
  if import.meta.url  // ESM mode (e.g. testing)
    { createRequire } from node:module
    createRequire(import.meta.url)('../package.json').version
  else
    require('../package.json').version

encoding .= "utf8" as BufferEncoding

fs from node:fs/promises
type { Stats } from node:fs
path from node:path

// TODO: Once the types are exported within the Civet source code,
// we should import them directly here, instead of looking at an old release.
type { CompileOptions } from @danielx/civet

export interface Options extends CompileOptions
  version?: boolean
  help?: boolean
  run?: boolean
  compile?: boolean
  output?: string
  outputDir?: string
  outputExt?: string
  outputPath?: path.ParsedPath
  eval?: string
  config?: string | boolean | undefined
  ast?: boolean | "raw"
  repl?: boolean
  typecheck?: boolean
  emitDeclaration?: boolean
  typescript?: boolean

export interface ParsedArgs
  filenames: string[]
  scriptArgs: string[]
  options: Options

export function parseArgs(args: string[], isTTY = process.stdin.isTTY): Promise<ParsedArgs>
  options: Options := {}
  isRun := => not (or)
    options.ast
    options.compile
    options.typecheck
    options.emitDeclaration
  filenames: string[] .= []
  scriptArgs: string[] .= []

  options.version = true if args.includes '-version'
  options.help = true if args.includes '-help'
  return {filenames, scriptArgs, options} if options.version or options.help

  i .= 0
  errors .= 0
  function endOfArgs(j: number): void
    i = args.length  // trigger end of loop
    return if j >= args.length  // no more args
    if options.run
      filenames.push args[j]
      scriptArgs = args[j+1..]
    else
      filenames.push ...args[j..]
  while i < args.length
    arg := args[i]
    // Split -ab into -a -b
    if /^-\w{2,}$/.test arg
      args[i..i] =
        for each char of arg[1..]
          `-${char}`
      continue
    // Main argument handling
    switch arg
      when '-v', '--version'
        options.version = true
      when '-h', '--help'
        options.help = true
      when '-c', '--compile'
        options.compile = true
      when '-o', '--output'
        options.output = args[++i]
      when '-e', '--eval'
        options.eval = args[++i]
      when '--config'
        options.config = args[++i]
      when '--no-config'
        options.config = null
      when '--civet'
        Object.assign options.parseOptions ??= {},
          parse `civet ${args[++i]}`,
            startRule: 'CivetPrologueContent'
            filename: '--civet argument'
            events: // remove cache in case we've compiled Civet before
              enter: undefined
              exit: undefined
          |> .config
      when '--comptime'
        (options.parseOptions ??= {}).comptime = true
      when '--no-comptime'
        (options.parseOptions ??= {}).comptime = false
      when '--ast'
        options.ast = true
      when '--no-cache'
        options.noCache = true
      when '--inline-map'
        options.inlineMap = true
      when '--js'
        options.js = true
      when '--hits'
        options.hits = args[++i]
      when '--trace'
        options.trace = args[++i]
      when '--typecheck'
        options.typecheck = true
      when '--emit-declaration', '--emitDeclaration'
        options.emitDeclaration = true
      when '--'
        endOfArgs ++i  // remaining arguments are filename and/or arguments
      else
        if arg.startsWith('-') and arg is not '-'
          console.error `Invalid command-line argument: ${arg}`
          errors++
        else if (options.run = isRun())
          endOfArgs i  // remaining arguments are arguments to the script
        else
          filenames.push arg
    i++

  options.typescript = true if options.typecheck or options.emitDeclaration

  unless filenames.length or options.typescript or options.eval
    if isTTY
      options.repl = true
    else
      // When piped, default to old behavior of transpiling stdin to stdout
      options.compile = true
      options.run = false
      filenames = ['-']

  // Parse `output` option into forced directory, extension, and/or full path
  if options.output and options.output is not '-'
    optionsPath := path.parse options.output
    let stat: Stats | null
    try
      stat = await fs.stat options.output
    catch
      stat = null
    if stat?.isDirectory() or options.output.endsWith(path.sep) or
                              options.output.endsWith('/')
      // -o dir writes outputs into that directory with default name
      options.outputDir = options.output
    else if /^(\.[^]+)+$/.test optionsPath.base
      // -o .js or .ts or .civet.js or .civet.ts etc. to control extension
      options.outputExt = optionsPath.base
      // Can also be prefixed by a directory name
      options.outputDir = optionsPath.dir if optionsPath.dir
    else
      // -o filename fully specifies the output filename
      // (don't use this with multiple input files)
      options.outputPath = optionsPath
      options.outputExt = optionsPath.ext
  // For CLI compilations, default to rewriting imports to output extension,
  // with .jsx instead of .tsx to satisfy TypeScript.
  (options.parseOptions ??= {}).rewriteCivetImports ??=
    options.outputExt ?? '.civet.jsx'

  process.exit Math.min 255, errors if errors
  options.run = isRun()
  {filenames, scriptArgs, options}

type ReadFile = (
  filename: string
  stdin: boolean
  content?: string
  error?: unknown
) & ((content: string) | (error: unknown))

function readFiles(filenames: string[], evalString?: string): AsyncGenerator<ReadFile>
  if evalString?
    yield
      filename: '<eval>'
      content: evalString + '\n'
      stdin: true

  for each let filename of filenames
    stdin := filename is '-'
    try
      let content: string
      if stdin
        process.stdin.setEncoding encoding

        // Try to guess filename for stdin, such as /dev/fd/filename
        filename = "<stdin>"
        try
          filename = await fs.realpath '/dev/stdin'

        if process.stdin.isTTY
          // In interactive stdin, `readline` lets user end the file via ^D.
          lines: string[] := []
          rl := import('node:readline') |> await |> .createInterface process.stdin, process.stdout
          rl.on 'line', (buffer: string) => lines.push buffer + '\n'
          content = await new Promise (resolve, reject) =>
            rl.on 'SIGINT', =>
              reject '^C'
            rl.on 'close', =>
              resolve lines.join ''
        else
          // For piped stdin, read stdin directly to avoid potential echo.
          content = (chunk for await chunk of process.stdin).join ''
      else
        content = await fs.readFile filename, {encoding}
      yield {filename, content, stdin}
    catch error
      yield {filename, error, stdin}

declare global
  var quit: () => void, exit: () => void
  var v8debug: unknown

export function repl(args: string[], options: Options)
  * as vm from 'node:vm'
  // Node 21.7.0+ supports dynamic import() in vm calls via this constant:
  importModuleDynamically .= vm.constants?.USE_MAIN_CONTEXT_DEFAULT_LOADER
  unless importModuleDynamically
    // For older Node, we need to provide our own dynamic import function,
    // which requires `--experimental-vm-modules`.  Check if we did it already:
    if vm.SourceTextModule?
      { pathToFileURL } from node:url
      importModuleDynamically = (specifier: string) =>
        if /^\.\.?[/\\]/.test specifier
          import pathToFileURL(path.join process.cwd(), specifier).href
        else
          import specifier
    else
      // If not, run this script with `--experimental-vm-modules`.
      execArgv := [ '--experimental-vm-modules' ]
      /* This doesn't work; --loader seems to force ESM mode which breaks CLI.
      { register } from node:module
      unless register
        // On Node <20.6.0, we need to use `--loader` for the ESM loader.
        execArgv.push '--loader', '@danielx/civet/esm'
      */
      { fork } from node:child_process
      fork __filename, args, {
        execArgv
        stdio: 'inherit'
      }
      return

  await import '../register.js'
  console.log `Civet ${await version()} REPL.  Enter a blank line to ${
    switch
      when options.ast then 'parse'
      when options.compile then 'transpile'
      else 'execute'
  } code.`
  global.quit = global.exit = => process.exit 0
  import * as nodeRepl from node:repl
  r := nodeRepl.start
    prompt:
      switch
        when options.ast then '🌲> '
        when options.compile then '🐈> '
        else '🐱> '
    writer:
      if options.ast
        (obj: unknown) =>
          try
            JSON.stringify obj, null, 2
          catch e
            console.log `Failed to stringify: ${e}`
            ''
      else if options.compile
        (obj: unknown) =>
          if obj <? 'string'
            obj?.replace /\n*$/, ''
          else
            ''
    eval: (input: string, context, filename: string, callback) ->
      if input is '\n'  // blank input
        callback null, undefined
      else if input in ['quit\n', 'exit\n', 'quit()\n', 'exit()\n']
        process.exit 0
      else if input.endsWith '\n\n'  // finished input with blank line
        function showError(error: ???)
          console.error "Error while parsing Civet code:"
          if isCompileError error
            // Unwrap ParseErrors to first error
            if (error as ParseErrors).errors?
              error = (error as ParseErrors).errors[0]
            console.log ```
              ${input.split('\n')[0...(error as ParseError).line].join '\n'}
              ${' '.repeat (error as ParseError).column - 1}^ ${(error as ParseError).header}
            ```
          else
            console.error error

        let output: string
        if options.compile or options.ast
          try
            output = await compile input, {...options, filename}
          catch error
            showError error
            return callback null, undefined
          return callback null, output

        parseOptions := {...options.parseOptions,
          repl: true
        }

        let ast: BlockStatement
        try
          ast = await compile input, {...options, parseOptions, filename, ast: true}
        catch error
          showError error
          return callback null, undefined

        errors: ASTError[] .= []
        try
          output = generate ast, { ...options, errors, sourceMap: undefined }
        catch error
          //console.error "Failed to transpile Civet:"
          console.error error
          return callback null, undefined
        if errors#
          // Rerun with sourceMap
          errors = []
          generate ast, { ...options, errors, sourceMap: new SourceMap input }
          showError errors[0]
          return callback null, undefined

        let result: string
        try
          result = vm.runInContext output, context, {
            filename
            importModuleDynamically
          }
        catch error
          return callback error as Error, undefined

        if ast.topLevelAwait
          // If there was a top-level await, the result is a promise
          // that we need to await before returning it.
          try
            result = await result
          catch error
            callback error as Error, undefined
          else
            callback null, result
        else
          callback null, result
      else  // still reading
        callback (new nodeRepl.Recoverable new Error "Enter a blank line to execute code."), null

export function cli(args = process.argv[2..])
  // process.argv gets overridden when running scripts, but gets saved here

  {filenames, scriptArgs, options} .= await parseArgs args

  if options.version
    console.log await version()
    process.exit(0)

  if options.help
    process.stderr.write """
       ▄▄· ▪   ▌ ▐·▄▄▄ .▄▄▄▄▄
      ▐█ ▌▪██ ▪█·█▌▀▄.▀·•██       _._     _,-'""`-._
      ██ ▄▄▐█·▐█▐█•▐▀▀▪▄ ▐█.▪    (,-.`._,'(       |\\`-/|
      ▐███▌▐█▌ ███ ▐█▄▄▌ ▐█▌·        `-.-' \\ )-`( , o o)
      ·▀▀▀ ▀▀▀. ▀   ▀▀▀  ▀▀▀               `-    \\`_`"'-


Usage:

    civet                                        # REPL for executing code
    civet -c                                     # REPL for transpiling code
    civet --ast                                  # REPL for parsing code
    civet [options] input.civet                  # run input.civet
    civet [options] -c input.civet               # -> input.civet.tsx
    civet [options] -c input.civet -o .ts        # -> input.ts
    civet [options] -c input.civet -o dir        # -> dir/input.civet.tsx
    civet [options] -c input.civet -o dir/.ts    # -> dir/input.ts
    civet [options] -c input.civet -o output.ts  # -> output.ts
    civet [options] < input.civet > output.ts    # pipe form

Options:
  --help           Show this help message
  --version        Show the version number
  -o / --output XX Specify output directory and/or extension, or filename
  -c / --compile   Compile input files to TypeScript (or JavaScript)
  -e / --eval XX   Evaluate specified code (or compile it with -c)
  --config XX      Specify a config file (default scans for a config.civet, civet.json, civetconfig.civet or civetconfig.json file, optionally in a .config directory, or starting with a .)
  --civet XX       Specify civet compiler flag, as in "civet XX" prologue
  --comptime       Enable execution of code during compilation via comptime
  --no-config      Don't scan for a config file
  --js             Strip out all type annotations; default to .jsx extension
  --ast            Print the AST instead of the compiled code
  --inline-map     Generate a sourcemap
  --no-cache       Disable compiler caching (slow, for debugging)
  --typecheck      Run TypeScript and output diagnostics
  --emit-declaration  Run TypeScript and emit .d.ts files (if no errors)
  --trace XX       Log detailed parsing notes to a file, for parser debugging

You can use - to read from stdin or (prefixed by -o) write to stdout.

By default, .civet imports get rewritten to use the output extension.
You can override this behavior via: --civet rewriteCivetImports=.ext


    """
    process.exit(0)

  unless options.config is null // --no-config
    options.config ?= await findConfig process.cwd()

  if options.config
    parsed := await loadConfig options.config as string
    options = {
      ...parsed
      ...options
    }
    // Deep merge
    if parsed.parseOptions and options.parseOptions
      options.parseOptions = {
        ...parsed.parseOptions
        ...options.parseOptions
      }

  if options.typescript
    unpluginOptions := {
      ...options
      ts: if options.js then 'civet' else 'preserve'
      outputExtension: '.tsx'
      declarationExtension:
        options.outputExt?.replace /\.[jt]sx?$/i, '.d.ts'
    }
    // TypeScript wants .civet.tsx files imported as .civet.jsx
    (unpluginOptions.parseOptions ??= {}).rewriteCivetImports = '.civet.jsx'
    unplugin = rawPlugin unpluginOptions, framework: 'civet-cli'
    await unplugin.buildStart()

  // In run mode, compile to JS with source maps
  if options.run
    options.js = true
    options.inlineMap = true

  return repl args, options if options.repl

  // Ignore EPIPE errors, e.g. when piping to `head`
  process.stdout.on "error", (e) =>
    if e.code is in ['EPIPE', 'EOF']
      process.exit 0
    else
      console.error e
      process.exit 1

  errors .= 0
  for await let {filename, error, content, stdin} of readFiles filenames, options.eval
    if error
      console.error `${filename} failed to load:`
      console.error error
      errors++
      continue

    // Transpile
    let output: string
    try
      if unplugin?
        output = unplugin.load.call {
          addWatchFile();
        }, `${filename}.tsx`
        |> await
        |> .code
      else
        output = await compile content!, {...options, filename}
    catch error
      //console.error `${filename} failed to transpile:`
      console.error error
      errors++
      continue

    if options.ast
      process.stdout.write JSON.stringify(output, null, 2)
    else if options.compile
      if (stdin and not options.output) or options.output is '-'
        process.stdout.write output
      else
        targetPath: path.FormatInputPathObject .= path.parse filename
        delete targetPath.base  // use name and ext
        // Default extension
        if options.js
          targetPath.ext += ".jsx"
        else
          targetPath.ext += ".tsx"
        // `output` option overrides
        targetPath.dir = options.outputDir if options.outputDir?
        targetPath.ext = options.outputExt if options.outputExt?
        targetPath = options.outputPath if options.outputPath?
        // Make output directory in case it doesn't already exist
        await fs.mkdir targetPath.dir, recursive: true if targetPath.dir
        targetFilename := path.format targetPath
        try
          await fs.writeFile targetFilename, output
        catch error
          console.error `${targetFilename} failed to write:`
          console.error error
          errors++
    else if options.run
      esm := do
        if output is like /\b(await|import|export)\b/  // potentially ESM
          ast := await compile content!, {...options, ast: true, filename}
          (or)
            lib.hasAwait ast
            lib.hasImportDeclaration ast
            lib.hasExportDeclaration ast
      if esm
        // Run ESM code via `node --import @danielx/civet/register` subprocess
        if stdin
          // If code was read on stdin via command-line argument "-", try to
          // save it in a temporary file in same directory so paths are correct.
          filename = `.stdin-${process.pid}.civet`
          try
            await fs.writeFile filename, content!, {encoding}
          catch e
            console.error `Could not write ${filename} for Civet ESM mode:`
            console.error e
            process.exit 1
        { fork } from node:child_process

        { register } from node:module
        let execArgv
        if register
          // On Node 20.6.0+, module.register does the work for us;
          // we just need to `--import` ESM/CJS registration.
          { join } from path
          { pathToFileURL } from node:url
          execArgv = [
            '--import'
            pathToFileURL(join __dirname, '../register.js').href
          ]
        else
          // On Node <20.6.0, we need to use `--loader` for the ESM loader.
          execArgv = [
            '--loader', '@danielx/civet/esm' // ESM
            '--require', '@danielx/civet/register' // CJS
          ]

        debugRe := /--debug|--inspect/
        isDebug := v8debug <? "object" or debugRe.test(process.execArgv.join(' ')) or debugRe.test(process.env.NODE_OPTIONS ?? '')
        if isDebug
          execArgv.push "--inspect=" + (process.debugPort + 1)
        child := fork filename, [
          ...scriptArgs
        ], {
          execArgv,
          stdio: 'inherit'
        }
        child.on 'exit', (code) =>
          if stdin
            // Delete temporary file
            await fs.unlink filename

          process.exit code ?? 1

      else
        await import '../register.js'
        try
          module.filename = await fs.realpath filename
        catch
          module.filename = filename
        process.argv = ["civet", module.filename, ...scriptArgs]
        module.paths =
          import 'node:module' |> await |> ._nodeModulePaths path.dirname module.filename
        try
          module._compile output, module.filename
        catch error
          console.error `${filename} crashed while running in CJS mode:`
          console.error error
          process.exit 1

  process.exitCode = Math.min 255, errors
  if unplugin?
    try
      await unplugin.buildEnd.call {
        emitFile({source, fileName})
          fs.writeFile fileName, source
      }, not filenames.length
    catch error
      if match := (error as Error).message.match /Aborting build because of (\d+) TypeScript diagnostic/
        process.exitCode = Math.min 255, errors + +match[1]
      else
        process.exitCode = 1
        throw error

// build/build.sh adds a call to cli() at the end here

DanielXMoore / Civet / 14696205467

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