DanielXMoore / Civet / 17922990240

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

    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..]

          console.error `Invalid command-line argument: ${arg}`

          errors++

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

      yield {filename, content, stdin}

    catch error

      yield {filename, error, stdin}

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) ->

      // Newer Node versions use \r for intermediate line endings

      input = input.replace /\r/g, '\n'

      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)

  if options.config is undefined

    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

        // Instead of default behavior of exiting, pass on signals to

        // child process and let it decide whether to exit

        for signal of ['SIGINT', 'SIGTERM', 'SIGHUP']

          process.on signal, => child.kill signal

      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