DanielXMoore / Civet / 8861221723

{ compile, generate, parse, parseProgram, lib } from ./main.civet

{ findConfig, loadConfig } from ./config.civet

// unplugin ends up getting installed in the same dist directory

{rawPlugin} from ./unplugin

let unplugin:

  buildStart: () => Promise<void>

  buildEnd: (this: {emitFile: (data: {source: string, fileName: string, type: string}) => void}) => Promise<void>

  load: (this: {addWatchFile: (filename: string) => void}, filename: string) => Promise<{code: string, map: unknown}>

export function version: string

  require("../package.json").version

if process.argv.includes "--version"

  console.log version()

  process.exit(0)

if process.argv.includes "--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)

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

    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)

encoding .= "utf8" as BufferEncoding

fs from "fs/promises"

type { Stats } from fs

path from "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"

interface Options extends CompileOptions

  run?: boolean

  compile?: boolean

  output?: string

  config?: string | boolean | undefined

  ast?: boolean

  repl?: boolean

  typecheck?: boolean

  emitDeclaration?: boolean

interface ParsedArgs

  filenames: string[]

  scriptArgs: string[]

  options: Options

export function parseArgs(args: string[]): ParsedArgs

  options: Options := {}

  Object.defineProperty options, 'run',

    get: (this: Options) -> not (@ast or @compile or @typecheck or @emitDeclaration)

  filenames: string[] := []

  scriptArgs: string[] .= []

  i .= 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 '-c', '--compile'

        options.compile = true

      when '-o', '--output'

        options.output = args[++i]

      when '--config'

        options.config = args[++i]

      when '--no-config'

        options.config = false

      when '--civet'

        Object.assign options.parseOptions ??= {},

          parse `civet ${args[++i]}`,

            startRule: 'CivetPrologueContent'

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

          throw new Error `Invalid command-line argument ${arg}`

        if options.run

          endOfArgs i  // remaining arguments are arguments to the script

        else

          filenames.push arg

    i++

  {filenames, scriptArgs, options}

type ReadFile = (

  filename: string

  stdin: boolean

  content?: string

  error?: unknown

) & ((content: string) | (error: unknown))

function readFiles(filenames: string[]): AsyncGenerator<ReadFile>

  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('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(options: Options)

  vm := await import '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 } := await import 'url'

      importModuleDynamically = (specifier: string) =>

        if /^\.\.?[/\\]/.test specifier

          import pathToFileURL path.join process.cwd(), specifier

        else

          import specifier

    else

      // If not, run this script with `--experimental-vm-modules`.

      execArgv := [ '--experimental-vm-modules' ]

      { register } := await import 'module'

      /* This doesn't work; --loader seems to force ESM mode which breaks CLI.

      unless register

        // On Node <20.6.0, we need to use `--loader` for the ESM loader.

        execArgv.push '--loader', '@danielx/civet/esm'

      */

      if process.env.NODE_OPTIONS

        execArgv.push process.env.NODE_OPTIONS

      { fork } := await import 'child_process'

      fork __filename, process.argv[2..], {

        execArgv

        stdio: 'inherit'

      }

      return

  require '../register.js'

  console.log `Civet ${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

  nodeRepl := await import '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

        let output: string

        if options.compile or options.ast

          try

            output = await compile input, {...options, filename}

          catch error

            //console.error "Failed to transpile Civet:"

            console.error error

            return callback null, undefined

          return callback null, output

        ast .= await compile input, {...options, filename, ast: true}

        // Wrap in IIFE if there's a top-level await or import

        // Use Civet's async do, so Civet does implicit return of last value

        // (copied from playground.worker.js)

        topLevelAwait := lib.hasAwait(ast) or lib.hasImportDeclaration(ast)

        if topLevelAwait

          [prologue, rest] := parse input, startRule: 'ProloguePrefix'

          prefix := input.slice 0, -rest.length

          coffee := prologue.some (p) => p.type is "CivetPrologue" and

            (p.config.coffeeCompat or p.config.coffeeDo)

          ast = await compile

            prefix +

            (coffee ? '(do ->\n' : 'async do\n') +

            rest.replace(/^/gm, ' ') +

            (coffee ? ')' : ''),

            {...options, filename, ast: true}

          // Hoist top-level declarations outside the IIFE wrapper

          lib.gatherRecursive ast, .type is 'BlockStatement'

          .forEach (topBlock) =>

            lib.gatherRecursiveWithinFunction topBlock, .type is 'Declaration'

            .forEach (decl) =>

              type := decl.children.shift() // const/let/var

              ast = [ast] unless Array.isArray ast

              ast.unshift `var ${decl.names.join ','};`

        errors: unknown[] := []

        try

          output = generate ast, { errors }

        catch error

          //console.error "Failed to transpile Civet:"

          console.error error

          return callback null, undefined

        if errors.length

          // TODO: Better error display; copied from main.civet

          console.error `Parse errors: ${errors.map(.message).join("\n")}`

          return callback null, undefined

        let result: string

        try

          result = vm.runInContext output, context, {

            filename

            importModuleDynamically

          }

        catch error

          return callback error as Error, undefined

        if topLevelAwait

          // If there was a top-level await, the result is a promise

          // that we need to await before returning it.

          let threw = false

          try

            result = await result

          catch error

            threw = true

            callback error as Error, undefined

          callback null, result unless threw

        else

          callback null, result

      else  // still reading

        callback (new nodeRepl.Recoverable new Error "Enter a blank line to execute code."), null

export function cli

  argv := process.argv  // process.argv gets overridden when running scripts

  {filenames, scriptArgs, options} .= parseArgs argv[2..]

  if options.config is not false // --no-config

    options.config ?= await findConfig process.cwd()

  if options.config

    options = {

      ...await loadConfig options.config as string

      ...options

    }

  unless filenames.length

    if process.stdin.isTTY

      options.repl = true

    else

      // When piped, default to old behavior of transpiling stdin to stdout

      options.compile = true

      filenames = ['-']

  if options.typecheck or options.emitDeclaration

    unpluginOptions := {

      ...options

      ts: if options.js then 'civet' else 'preserve'

      outputExtension: '.tsx'

    }

    (unpluginOptions.parseOptions ??= {}).rewriteCivetImports = '.civet.tsx'

    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 options if options.repl

  // Parse `output` option into forced directory, extension, and/or full path

  let outputDir?: string, outputExt?: string, outputPath?: path.ParsedPath

  if options.output

    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

      outputDir = options.output

    else if /^(\.[^.]+)+$/.test optionsPath.base

      // -o .js or .ts or .civet.js or .civet.ts etc. to control extension

      outputExt = optionsPath.base

      // Can also be prefixed by a directory name

      outputDir = optionsPath.dir if optionsPath.dir

    else

      // -o filename fully specifies the output filename

      // (don't use this with multiple input files)

      outputPath = optionsPath

    // For CLI compilations, default to rewriting imports to output extension

    if options.output is not '-'

      (options.parseOptions ??= {}).rewriteCivetImports ??=

        outputExt ?? '.civet' + if options.js then ".jsx" else ".tsx"

  errors .= 0

  for await {filename, error, content, stdin} of readFiles filenames

    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 = outputDir if outputDir?

        targetPath.ext = outputExt if outputExt?

        targetPath = outputPath if outputPath?

        // Make output directory in case it doesn't already exist

        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 := /^\s*(import|export)\b/m.test output

      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 } := await import 'child_process'

        { register } := await import '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.

          execArgv = [ '--import', '@danielx/civet/register' ]

        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 process.env.NODE_OPTIONS

          execArgv.push 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

        require '../register.js'

        try

          module.filename = await fs.realpath filename

        catch

          module.filename = filename

        process.argv = ["civet", module.filename, ...scriptArgs]

        module.paths =

          require('module')._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

      }

    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

cli() if require.main is module