[dart:js_interop] RegExp.

[ykmnkmi]

Add JSRegExp, RegExp.toJS and JSRegExp.toDart.

[lrhn]

Not hard to make.

If the JSRegExp.toDart should be able to create RegExps with flags that can't be set through Dart, then it may need more integration with the RegExp class.

import 'dart:js_interop';

@JS('RegExp')
extension type JSRegExp._(JSObject _) {
  @Deprecated("Do not use") // Or don't have these to begin with.
  external static String? get input;
  @Deprecated("Do not use")
  external static String? get lastMatch;
  @Deprecated("Do not use")
  external static String? get lastParen;
  @Deprecated("Do not use")
  external static String? get leftContext;
  @Deprecated("Do not use")
  external static String? get rightContext;
  @Deprecated("Do not use")
  external static String? get $1;
  @Deprecated("Do not use")
  external static String? get $2;
  @Deprecated("Do not use")
  external static String? get $3;
  @Deprecated("Do not use")
  external static String? get $4;
  @Deprecated("Do not use")
  external static String? get $5;
  @Deprecated("Do not use")
  external static String? get $6;
  @Deprecated("Do not use")
  external static String? get $7;
  @Deprecated("Do not use")
  external static String? get $8;
  @Deprecated("Do not use")
  external static String? get $9;
  @Deprecated("Do not use")
  external void compile(String pattern, [String flags]);

  external final String source;
  external final String flags;
  external final bool dotAll;
  external final bool global;
  external final bool hasIndices;
  external final bool ignoreCase;
  external final bool multiline;
  external final bool sticky;
  external final bool unicode;
  external final bool unicodeSets;

  external int lastIndex;

  external JSRegExp(String pattern, [String flags]);

  external JSRegExpMatch? exec(String input);
  external bool test(String input);

  RegExp get toDart => RegExp(
    this.source,
    multiLine: this.multiline,
    caseSensitive: !this.ignoreCase,
    unicode: this.unicode || this.unicodeSets,
    dotAll: this.dotAll,
  );
}

extension type JSRange._(JSArray _) implements JSArray {
  external int operator [](int index);
  int get start => _[0] as int;
  int get end => _[1] as int;
  (int, int) toPair() => (_[0] as int, _[1] as int);
}

extension ToJSRegExp on RegExp {
  JSRegExp get toJS => toJSRegExp();
  JSRegExp toJSRegExp([String flags = ""]) {
    var newFlags = StringBuffer(flags);
    if (this.isMultiLine && !flags.contains('m')) newFlags.write('m');
    if (!this.isCaseSensitive && !flags.contains('i')) newFlags.write('i');
    if (this.isUnicode && !flags.contains('u') && !flags.contains('v')) {
      newFlags.write('u');
    }
    if (this.isDotAll && !flags.contains('s')) newFlags.write('s');
    return JSRegExp(pattern, newFlags.toString());
  }
}

extension type JSRegExpMatch(JSArray _) implements JSArray {
  external int get index;
  external String get input;
  external String? operator [](int index);
  external JSRegExpNamedCaptures? get groups;
  external JSRegExpIndices? get indices;
}

extension type JSRegExpNamedCaptures(JSObject _) {
  external String? operator [](String name);
}

extension type JSRegExpIndices(JSArray _) implements JSArray {
  external JSRange? operator [](int index);
  external JSRegExpNamedPairs? get groups;
}

extension type JSRegExpNamedPairs(JSObject _) {
  external JSRange? operator [](String name);
}

void main() async {
  try {
    var re = JSRegExp(r"(?:(?<name>.)a)", "gimd");
    print("Start");
    while (true) {
      if (re.exec("banana") case var m?) {
        print("MATCH:");
        print(m.input);
        print(m.index);
        print(re.lastIndex);
        print(m.length);
        print(m[0]);
        print(m[1]);
        print(m.groups?['name']);
        print(m.indices?.length);
        print(m.indices?[0]);
        print(m.indices?[1]);
        print(m.indices?.groups?['name']);
        print(re.source);
      } else {
        break;
      }
    }
  } finally {
    print("Done");
  }
}