@enjoys/context-engine 1.1.0 → 1.1.2

package/data/defination/dart.json

@@ -0,0 +1,360 @@
+{
+  "language": "dart",
+  "definitions": {
+    "String": {
+      "signature": "abstract class String implements Comparable<String>, Pattern",
+      "description": "A sequence of UTF-16 code units representing text in Dart. Strings are immutable and support interpolation with $variable and ${expression} syntax. The String class provides comprehensive methods for searching, splitting, trimming, padding, and transforming text.",
+      "type": "class",
+      "module": "dart:core",
+      "members": {
+        "length": {
+          "signature": "int get length",
+          "description": "Returns the number of UTF-16 code units in the string, which may differ from the number of visible characters for non-BMP code points.",
+          "type": "property"
+        },
+        "contains": {
+          "signature": "bool contains(Pattern other, [int startIndex = 0])",
+          "description": "Returns true if this string contains a match of the specified pattern (string or RegExp) starting from the given index.",
+          "type": "method"
+        },
+        "split": {
+          "signature": "List<String> split(Pattern pattern)",
+          "description": "Splits the string at each match of the pattern and returns a list of substrings.",
+          "type": "method"
+        },
+        "substring": {
+          "signature": "String substring(int start, [int? end])",
+          "description": "Returns the substring from start index (inclusive) to end index (exclusive), or to the end if omitted.",
+          "type": "method"
+        },
+        "trim": {
+          "signature": "String trim()",
+          "description": "Returns a new string with leading and trailing whitespace removed.",
+          "type": "method"
+        },
+        "replaceAll": {
+          "signature": "String replaceAll(Pattern from, String replace)",
+          "description": "Replaces all matches of the pattern in the string with the replacement string.",
+          "type": "method"
+        },
+        "toUpperCase": {
+          "signature": "String toUpperCase()",
+          "description": "Converts all characters in the string to uppercase according to the locale-independent rules.",
+          "type": "method"
+        },
+        "startsWith": {
+          "signature": "bool startsWith(Pattern pattern, [int index = 0])",
+          "description": "Returns true if the string begins with a match of the pattern at the specified index.",
+          "type": "method"
+        }
+      }
+    },
+    "int": {
+      "signature": "abstract class int extends num",
+      "description": "An integer number type in Dart. On native platforms, values can be from -2^63 to 2^63-1. On the web, values are represented as JavaScript numbers with up to 53 bits of precision. Supports standard arithmetic operations, bitwise operations, and conversion methods.",
+      "type": "class",
+      "module": "dart:core",
+      "members": {
+        "parse": {
+          "signature": "static int parse(String source, {int? radix, int onError(String source)?})",
+          "description": "Parses a string as an integer literal in the given radix (default 10), throwing FormatException if invalid.",
+          "type": "method"
+        },
+        "tryParse": {
+          "signature": "static int? tryParse(String source, {int? radix})",
+          "description": "Parses a string as an integer, returning null instead of throwing if the string is not a valid integer.",
+          "type": "method"
+        },
+        "toDouble": {
+          "signature": "double toDouble()",
+          "description": "Converts this integer to a double-precision floating-point representation.",
+          "type": "method"
+        },
+        "toString": {
+          "signature": "String toString()",
+          "description": "Returns the decimal string representation of this integer.",
+          "type": "method"
+        },
+        "toRadixString": {
+          "signature": "String toRadixString(int radix)",
+          "description": "Converts this integer to a string representation in the given radix (base 2-36).",
+          "type": "method"
+        }
+      }
+    },
+    "double": {
+      "signature": "abstract class double extends num",
+      "description": "A double-precision 64-bit IEEE 754 floating-point number in Dart. Doubles are used for all floating-point arithmetic and include special values like double.infinity, double.negativeInfinity, and double.nan for handling edge cases.",
+      "type": "class",
+      "module": "dart:core",
+      "members": {
+        "parse": {
+          "signature": "static double parse(String source, [double onError(String source)?])",
+          "description": "Parses the source string as a double literal, throwing FormatException if it is not a valid representation.",
+          "type": "method"
+        },
+        "toStringAsFixed": {
+          "signature": "String toStringAsFixed(int fractionDigits)",
+          "description": "Returns the decimal string representation with exactly fractionDigits digits after the decimal point.",
+          "type": "method"
+        },
+        "round": {
+          "signature": "int round()",
+          "description": "Returns the integer closest to this double, rounding half-values away from zero.",
+          "type": "method"
+        }
+      }
+    },
+    "List": {
+      "signature": "abstract class List<E> implements EfficientLengthIterable<E>",
+      "description": "An indexable collection of objects with a zero-based integer index. Lists are the most commonly used collection type in Dart for ordered data. They can be fixed-length (created with List.filled) or growable (created with [] literal or List.empty(growable: true)).",
+      "type": "class",
+      "module": "dart:core",
+      "members": {
+        "add": {
+          "signature": "void add(E value)",
+          "description": "Appends a single element to the end of the list, increasing its length by one.",
+          "type": "method"
+        },
+        "addAll": {
+          "signature": "void addAll(Iterable<E> iterable)",
+          "description": "Appends all objects of the iterable to the end of this list.",
+          "type": "method"
+        },
+        "where": {
+          "signature": "Iterable<E> where(bool test(E element))",
+          "description": "Returns a lazy iterable of all elements that satisfy the given predicate test function.",
+          "type": "method"
+        },
+        "map": {
+          "signature": "Iterable<T> map<T>(T toElement(E e))",
+          "description": "Returns a lazy iterable with each element transformed by the given function.",
+          "type": "method"
+        },
+        "sort": {
+          "signature": "void sort([int compare(E a, E b)?])",
+          "description": "Sorts the list in-place according to the compare function, or natural ordering if omitted.",
+          "type": "method"
+        },
+        "contains": {
+          "signature": "bool contains(Object? element)",
+          "description": "Returns true if the collection contains an element equal to the given element.",
+          "type": "method"
+        },
+        "removeAt": {
+          "signature": "E removeAt(int index)",
+          "description": "Removes and returns the element at the given index, shifting subsequent elements down.",
+          "type": "method"
+        },
+        "forEach": {
+          "signature": "void forEach(void action(E element))",
+          "description": "Applies the given function to each element of the list in iteration order.",
+          "type": "method"
+        }
+      }
+    },
+    "Map": {
+      "signature": "abstract class Map<K, V>",
+      "description": "A collection of key-value pairs from which values are retrieved using their associated keys. Maps in Dart support generic key and value types, iteration over entries, and various constructors including Map.from, Map.of, and Map.fromIterables.",
+      "type": "class",
+      "module": "dart:core",
+      "members": {
+        "containsKey": {
+          "signature": "bool containsKey(Object? key)",
+          "description": "Returns true if this map contains the given key.",
+          "type": "method"
+        },
+        "putIfAbsent": {
+          "signature": "V putIfAbsent(K key, V ifAbsent())",
+          "description": "Looks up the value for the key, or adds a new entry if the key is absent by calling ifAbsent.",
+          "type": "method"
+        },
+        "remove": {
+          "signature": "V? remove(Object? key)",
+          "description": "Removes the key and its associated value from the map and returns the value.",
+          "type": "method"
+        },
+        "forEach": {
+          "signature": "void forEach(void action(K key, V value))",
+          "description": "Applies the given function to each key-value pair in the map.",
+          "type": "method"
+        },
+        "entries": {
+          "signature": "Iterable<MapEntry<K, V>> get entries",
+          "description": "Returns an iterable of all key-value pairs as MapEntry objects.",
+          "type": "property"
+        },
+        "keys": {
+          "signature": "Iterable<K> get keys",
+          "description": "Returns an iterable of all keys in the map.",
+          "type": "property"
+        }
+      }
+    },
+    "Set": {
+      "signature": "abstract class Set<E> extends EfficientLengthIterable<E>",
+      "description": "A collection of unique objects where each object can occur only once. Sets provide efficient membership testing (contains) and support union, intersection, and difference operations for combining sets.",
+      "type": "class",
+      "module": "dart:core",
+      "members": {
+        "add": {
+          "signature": "bool add(E value)",
+          "description": "Adds the value to the set. Returns true if the value was not already in the set.",
+          "type": "method"
+        },
+        "contains": {
+          "signature": "bool contains(Object? value)",
+          "description": "Returns true if the set contains the specified value.",
+          "type": "method"
+        },
+        "union": {
+          "signature": "Set<E> union(Set<E> other)",
+          "description": "Returns a new set containing all elements from both sets.",
+          "type": "method"
+        },
+        "intersection": {
+          "signature": "Set<E> intersection(Set<Object?> other)",
+          "description": "Returns a new set with only the elements present in both sets.",
+          "type": "method"
+        },
+        "difference": {
+          "signature": "Set<E> difference(Set<Object?> other)",
+          "description": "Returns a new set with elements in this set that are not in the other set.",
+          "type": "method"
+        }
+      }
+    },
+    "Future": {
+      "signature": "abstract class Future<T>",
+      "description": "An object representing a delayed computation whose result will be available at some later time. Futures are the foundation of Dart's asynchronous programming model, used with async/await syntax for non-blocking I/O, network requests, file operations, and any operation that takes time to complete.",
+      "type": "class",
+      "module": "dart:async",
+      "members": {
+        "then": {
+          "signature": "Future<R> then<R>(FutureOr<R> onValue(T value), {Function? onError})",
+          "description": "Registers a callback to be called when this future completes with a value, returning a new future for chaining.",
+          "type": "method"
+        },
+        "catchError": {
+          "signature": "Future<T> catchError(Function onError, {bool test(Object error)?})",
+          "description": "Handles errors emitted by this future, optionally filtering by error type with the test function.",
+          "type": "method"
+        },
+        "whenComplete": {
+          "signature": "Future<T> whenComplete(FutureOr<void> action())",
+          "description": "Registers a function to be called when the future completes, whether with a value or an error (like finally).",
+          "type": "method"
+        },
+        "timeout": {
+          "signature": "Future<T> timeout(Duration timeLimit, {FutureOr<T> onTimeout()?})",
+          "description": "Returns a future that completes with a timeout error if this future does not complete within the time limit.",
+          "type": "method"
+        },
+        "wait": {
+          "signature": "static Future<List<T>> wait<T>(Iterable<Future<T>> futures, {bool eagerError = false})",
+          "description": "Waits for multiple futures to complete and returns their results as a list in the same order.",
+          "type": "method"
+        }
+      }
+    },
+    "Stream": {
+      "signature": "abstract class Stream<T>",
+      "description": "A source of asynchronous data events that delivers a sequence of values over time. Streams are used for handling continuous data sources like user input events, WebSocket messages, file reads, and timer ticks. Supports single-subscription and broadcast stream types.",
+      "type": "class",
+      "module": "dart:async",
+      "members": {
+        "listen": {
+          "signature": "StreamSubscription<T> listen(void onData(T event)?, {Function? onError, void onDone()?, bool? cancelOnError})",
+          "description": "Subscribes to events from this stream, providing callbacks for data, error, and completion events.",
+          "type": "method"
+        },
+        "map": {
+          "signature": "Stream<S> map<S>(S convert(T event))",
+          "description": "Creates a new stream that transforms each data event from this stream using the given function.",
+          "type": "method"
+        },
+        "where": {
+          "signature": "Stream<T> where(bool test(T event))",
+          "description": "Creates a new stream that only includes data events that satisfy the predicate.",
+          "type": "method"
+        },
+        "first": {
+          "signature": "Future<T> get first",
+          "description": "Returns a future that completes with the first element of the stream.",
+          "type": "property"
+        },
+        "toList": {
+          "signature": "Future<List<T>> toList()",
+          "description": "Collects all data events from the stream into a list, returned when the stream closes.",
+          "type": "method"
+        }
+      }
+    },
+    "Iterable": {
+      "signature": "abstract class Iterable<E>",
+      "description": "A collection of values that can be accessed sequentially. Iterable is the base interface for all collections in Dart and defines lazy operations like map, where, expand, take, and skip that are only evaluated when the result is iterated.",
+      "type": "class",
+      "module": "dart:core",
+      "members": {
+        "map": {
+          "signature": "Iterable<T> map<T>(T toElement(E e))",
+          "description": "Returns a lazy iterable where each element is the result of applying the given function.",
+          "type": "method"
+        },
+        "where": {
+          "signature": "Iterable<E> where(bool test(E element))",
+          "description": "Returns a lazy iterable of elements that satisfy the predicate test function.",
+          "type": "method"
+        },
+        "fold": {
+          "signature": "T fold<T>(T initialValue, T combine(T previousValue, E element))",
+          "description": "Reduces the collection to a single value by iteratively combining the elements with an accumulator.",
+          "type": "method"
+        },
+        "toList": {
+          "signature": "List<E> toList({bool growable = true})",
+          "description": "Creates a List containing the elements of this iterable in iteration order.",
+          "type": "method"
+        }
+      }
+    },
+    "DateTime": {
+      "signature": "class DateTime implements Comparable<DateTime>",
+      "description": "An instant in time representing a date and time-of-day with microsecond precision. DateTime objects can represent UTC or local time and provide methods for date arithmetic, comparison, formatting, and extracting components like year, month, day, hour, minute, and second.",
+      "type": "class",
+      "module": "dart:core",
+      "members": {
+        "now": {
+          "signature": "DateTime.now()",
+          "description": "Creates a DateTime object representing the current date and time in the local time zone.",
+          "type": "method"
+        },
+        "parse": {
+          "signature": "static DateTime parse(String formattedString)",
+          "description": "Parses a string conforming to a subset of ISO 8601 format into a DateTime object.",
+          "type": "method"
+        },
+        "difference": {
+          "signature": "Duration difference(DateTime other)",
+          "description": "Returns the difference between this and another DateTime as a Duration object.",
+          "type": "method"
+        },
+        "add": {
+          "signature": "DateTime add(Duration duration)",
+          "description": "Returns a new DateTime with the given duration added to this one.",
+          "type": "method"
+        },
+        "isBefore": {
+          "signature": "bool isBefore(DateTime other)",
+          "description": "Returns true if this DateTime occurs before the other DateTime.",
+          "type": "method"
+        },
+        "toIso8601String": {
+          "signature": "String toIso8601String()",
+          "description": "Returns an ISO-8601 full-precision extended format representation of this DateTime.",
+          "type": "method"
+        }
+      }
+    }
+  }
+}