DanielXMoore / Civet / 23598229556

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

  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

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

  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

      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

            path.relative rootDir, extractCivetFilename(id, outExt).filename

            path.relative rootDir, 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

    }

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

        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 ?= {}

        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

        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

  }