DanielXMoore / Civet / 7944345156

{ compile, parse } from ./main.civet

{ findConfig, loadConfig } from ./config.civet

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

{rawPlugin} from ./unplugin

let unplugin:

  buildStart: () => void

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

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

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

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

  noCache?: boolean

  inlineMap?: boolean

  hits?: string

  trace?: string

  repl?: boolean

  typecheck?: boolean

  emitDeclaration?: boolean

interface ParsedArgs

  filenames: string[]

  scriptArgs: string[]

  options: Options

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

function repl(options: Options)

  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'

  vm := await import 'vm'

  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

        try

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

        catch error

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

          console.error error

          return callback null, undefined

        if options.compile or options.ast

          callback null, output

        else

          let result: string

          try

            result = vm.runInContext output, context, {filename}

          catch error

            return callback error as Error, undefined

          callback null, result

      else  // still reading

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

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

    unplugin = rawPlugin {

      ...options

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

      outputExtension: '.tsx'

    }, framework: 'civet-cli'

    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 = 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 --loader @danielx/civet/esm` 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'

        execArgv := [ '--loader', '@danielx/civet/esm' ]

        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 = 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 = +match[1]

      else

        process.exitCode = 1

        throw error

cli() if require.main is module