opencode/packages/codemode/src/stdlib/regexp.ts

import { type AstNode, InterpreterRuntimeError } from "../interpreter/model.js"
import { isBlockedMember, type SafeObject } from "../tool-runtime.js"
import { CodeModeRegExp } from "../values.js"
import { coerceToNumber, coerceToString } from "./value.js"

type MatchValue = Array<unknown> & {
  index?: number
  groups?: SafeObject
  indices?: IndicesValue
}

type IndicesValue = Array<unknown> & {
  groups?: SafeObject
}

export const regexpMethods = new Set(["test", "exec", "toString"])

export const regexpStatics = new Set(["escape"])

export const regexpProperties = new Set([
  "source",
  "flags",
  "lastIndex",
  "hasIndices",
  "global",
  "ignoreCase",
  "multiline",
  "sticky",
  "unicode",
  "unicodeSets",
  "dotAll",
])

export const regexFailureReason = (error: unknown): string =>
  (error instanceof Error ? error.message : String(error)).replace(/^Invalid regular expression:\s*/i, "")

export const escapeRegexHint =
  'To match special characters like ( ) [ ] { } + * ? . literally, escape them with a backslash (e.g. "\\\\(") or test for them with String.includes instead.'

export const toHostRegex = (arg: unknown, method: string, node: AstNode, extraFlags = ""): RegExp => {
  // Native parity: an undefined pattern behaves as an empty pattern.
  if (arg === undefined) return new RegExp("", extraFlags)
  if (arg instanceof CodeModeRegExp) return arg.regex
  if (typeof arg === "string") {
    try {
      return new RegExp(arg, extraFlags)
    } catch (error) {
      throw new InterpreterRuntimeError(
        `String.${method} received the string ${JSON.stringify(arg)}, which is not a valid regular expression pattern (${regexFailureReason(error)}). ${escapeRegexHint}`,
        node,
      ).as("SyntaxError")
    }
  }
  throw new InterpreterRuntimeError(
    `String.${method} expects a regular expression (a /pattern/flags literal or new RegExp(...)) or a string pattern, not ${arg === null ? "null" : typeof arg}.`,
    node,
  )
}

export const matchToValue = (match: RegExpMatchArray): Array<unknown> => {
  const result: MatchValue = Array.from(match, (group) => group)
  if (match.index !== undefined) result.index = match.index
  if (match.groups) {
    const groups: SafeObject = Object.create(null) as SafeObject
    for (const [key, group] of Object.entries(match.groups)) {
      if (!isBlockedMember(key)) groups[key] = group
    }
    result.groups = groups
  }
  if (match.indices) result.indices = indicesToValue(match.indices)
  return result
}

export const invokeRegExpStatic = (name: string, args: Array<unknown>, node: AstNode): string => {
  if (name !== "escape") throw new InterpreterRuntimeError(`RegExp.${name} is not available.`, node)
  if (typeof args[0] !== "string") {
    throw new InterpreterRuntimeError("RegExp.escape expects a string.", node).as("TypeError")
  }
  return RegExp.escape(args[0])
}

export const invokeRegExpMethod = (
  value: CodeModeRegExp,
  name: string,
  args: Array<unknown>,
  node: AstNode,
): unknown => {
  switch (name) {
    case "test":
    case "exec": {
      const input = coerceToString(args[0])
      const lastIndex = value.lastIndex
      const stateful = value.regex.global || value.regex.sticky
      value.regex.lastIndex = toLength(lastIndex)
      if (name === "test") {
        const matched = value.regex.test(input)
        if (!stateful) value.lastIndex = lastIndex
        return matched
      }
      const matched = value.regex.exec(input)
      if (!stateful) value.lastIndex = lastIndex
      return matched === null ? null : matchToValue(matched)
    }
    case "toString":
      return coerceToString(value)
    default:
      throw new InterpreterRuntimeError(`RegExp method '${name}' is not available.`, node)
  }
}

const toLength = (value: unknown): number => {
  const number = coerceToNumber(value)
  if (Number.isNaN(number) || number <= 0) return 0
  return Math.min(Math.floor(number), Number.MAX_SAFE_INTEGER)
}

const indicesToValue = (indices: RegExpIndicesArray): IndicesValue => {
  const result: IndicesValue = Array.from(indices, (range) => (range === undefined ? undefined : [...range]))
  if (indices.groups) {
    const groups: SafeObject = Object.create(null) as SafeObject
    for (const [key, range] of Object.entries(indices.groups)) {
      if (!isBlockedMember(key)) groups[key] = range === undefined ? undefined : [...range]
    }
    result.groups = groups
    return result
  }
  result.groups = undefined
  return result
}