bridgedExtensions static method

List<BridgedExtensionDefinition> bridgedExtensions()

Returns all bridged extension definitions.

Implementation

static List<BridgedExtensionDefinition> bridgedExtensions() {
  return [
    BridgedExtensionDefinition(
      name: 'PlatformEx',
      onTypeName: 'Platform',
      getters: {'eol': (visitor, target) => (target as Platform).eol},
    ),
    BridgedExtensionDefinition(
      name: 'DigestHelper',
      onTypeName: 'Digest',
      methods: {
        'hexEncode': (visitor, target, positional, named, typeArgs) {
          final t = target as $crypto_1.Digest;
          return Function.apply(
            t.hexEncode,
            positional,
            named.map((k, v) => MapEntry(Symbol(k), v)),
          );
        },
      },
    ),
    BridgedExtensionDefinition(
      name: 'StringAsProcess',
      onTypeName: 'String',
      getters: {
        'run': (visitor, target) => (target as String).run,
        'firstLine': (visitor, target) => (target as String).firstLine,
        'lastLine': (visitor, target) => (target as String).lastLine,
      },
      methods: {
        'start': (visitor, target, positional, named, typeArgs) {
          final t = target as String;
          return Function.apply(
            t.start,
            positional,
            named.map((k, v) => MapEntry(Symbol(k), v)),
          );
        },
        'forEach': (visitor, target, positional, named, typeArgs) {
          final t = target as String;
          D4.requireMinArgs(positional, 1, 'forEach');
          if (positional.length <= 0) {
            throw ArgumentError(
              'forEach: Missing required argument "stdout" at position 0',
            );
          }
          final stdoutRaw = positional[0];
          final stdout = (String p0) {
            D4.callInterpreterCallback(visitor, stdoutRaw, [p0]);
          };
          final wrappedNamed = <Symbol, dynamic>{};
          final stderrRaw = named['stderr'];
          if (stderrRaw != null) {
            wrappedNamed[#stderr] = (String p0) {
              D4.callInterpreterCallback(visitor, stderrRaw, [p0]);
            };
          }
          if (named.containsKey('runInShell')) {
            wrappedNamed[#runInShell] = named['runInShell'];
          }
          if (named.containsKey('extensionSearch')) {
            wrappedNamed[#extensionSearch] = named['extensionSearch'];
          }
          if (named.containsKey('encoding')) {
            wrappedNamed[#encoding] = named['encoding'];
          }
          Function.apply(t.forEach, [stdout], wrappedNamed);
          return null;
        },
        'toList': (visitor, target, positional, named, typeArgs) {
          final t = target as String;
          return Function.apply(
            t.toList,
            positional,
            named.map((k, v) => MapEntry(Symbol(k), v)),
          );
        },
        'toParagraph': (visitor, target, positional, named, typeArgs) {
          final t = target as String;
          return Function.apply(
            t.toParagraph,
            positional,
            named.map((k, v) => MapEntry(Symbol(k), v)),
          );
        },
        'parser': (visitor, target, positional, named, typeArgs) {
          final t = target as String;
          return Function.apply(
            t.parser,
            positional,
            named.map((k, v) => MapEntry(Symbol(k), v)),
          );
        },
        'write': (visitor, target, positional, named, typeArgs) {
          final t = target as String;
          return Function.apply(
            t.write,
            positional,
            named.map((k, v) => MapEntry(Symbol(k), v)),
          );
        },
        'truncate': (visitor, target, positional, named, typeArgs) {
          final t = target as String;
          return Function.apply(
            t.truncate,
            positional,
            named.map((k, v) => MapEntry(Symbol(k), v)),
          );
        },
        'append': (visitor, target, positional, named, typeArgs) {
          final t = target as String;
          return Function.apply(
            t.append,
            positional,
            named.map((k, v) => MapEntry(Symbol(k), v)),
          );
        },
      },
    ),
  ];
}