@enjoys/context-engine 1.3.1 → 1.4.2

package/data/definition/apex.json

@@ -289,6 +289,102 @@
           "type": "property"
         }
       }
+    },
+    "SOQL": {
+      "signature": "[SELECT fields FROM object WHERE condition]",
+      "description": "Salesforce Object Query Language. Used to query Salesforce data from Apex.",
+      "type": "keyword",
+      "module": "Salesforce"
+    },
+    "HttpRequest": {
+      "signature": "class HttpRequest",
+      "description": "Use HttpRequest to programmatically create HTTP requests like GET, POST, PUT, DELETE.",
+      "type": "class",
+      "module": "System",
+      "members": {
+        "setEndpoint": {
+          "signature": "setEndpoint(url) -> void",
+          "description": "Sets the endpoint URL.",
+          "type": "method",
+          "returns": "void"
+        },
+        "setMethod": {
+          "signature": "setMethod(method) -> void",
+          "description": "Sets the HTTP method (GET, POST, PUT, DELETE).",
+          "type": "method",
+          "returns": "void"
+        },
+        "setHeader": {
+          "signature": "setHeader(key, value) -> void",
+          "description": "Sets the HTTP header.",
+          "type": "method",
+          "returns": "void"
+        },
+        "setBody": {
+          "signature": "setBody(body) -> void",
+          "description": "Sets the body of the request.",
+          "type": "method",
+          "returns": "void"
+        }
+      }
+    },
+    "HttpResponse": {
+      "signature": "class HttpResponse",
+      "description": "Use HttpResponse to handle the HTTP response returned by an HTTP request.",
+      "type": "class",
+      "module": "System",
+      "members": {
+        "getBody": {
+          "signature": "getBody() -> String",
+          "description": "Returns the body of the response.",
+          "type": "method",
+          "returns": "String"
+        },
+        "getStatusCode": {
+          "signature": "getStatusCode() -> Integer",
+          "description": "Returns the status code.",
+          "type": "method",
+          "returns": "Integer"
+        },
+        "getHeader": {
+          "signature": "getHeader(key) -> String",
+          "description": "Returns the value for the specified header.",
+          "type": "method",
+          "returns": "String"
+        }
+      }
+    },
+    "JSON": {
+      "signature": "class JSON",
+      "description": "Contains methods for serializing/deserializing Apex objects in JSON format.",
+      "type": "class",
+      "module": "System",
+      "members": {
+        "serialize": {
+          "signature": "JSON.serialize(objectToSerialize) -> String",
+          "description": "Serializes Apex objects into JSON content.",
+          "type": "method",
+          "returns": "String"
+        },
+        "deserialize": {
+          "signature": "JSON.deserialize(jsonString, apexType) -> Object",
+          "description": "Deserializes JSON string into an Apex object of the specified type.",
+          "type": "method",
+          "returns": "Object"
+        },
+        "deserializeUntyped": {
+          "signature": "JSON.deserializeUntyped(jsonString) -> Object",
+          "description": "Deserializes JSON into collections of primitive data types.",
+          "type": "method",
+          "returns": "Object"
+        },
+        "serializePretty": {
+          "signature": "JSON.serializePretty(objectToSerialize) -> String",
+          "description": "Serializes Apex objects into JSON with indentation.",
+          "type": "method",
+          "returns": "String"
+        }
+      }
     }
   }
-}
+}

package/data/definition/coffee.json

@@ -187,6 +187,56 @@
       "description": "Declares a class in CoffeeScript with optional inheritance using 'extends'. CoffeeScript classes compile to JavaScript prototypal inheritance and support a constructor method, instance methods, static methods (prefixed with @), and the super keyword for calling parent class methods. Class bodies use significant indentation.",
       "type": "keyword",
       "module": "CoffeeScript"
+    },
+    "Promise": {
+      "signature": "class Promise",
+      "description": "Represents the eventual completion or failure of an asynchronous operation.",
+      "type": "class",
+      "module": "global",
+      "members": {
+        "then": {
+          "signature": "then(onFulfilled, onRejected) -> Promise",
+          "description": "Appends fulfillment and rejection handlers.",
+          "type": "method",
+          "returns": "Promise"
+        },
+        "catch": {
+          "signature": "catch(onRejected) -> Promise",
+          "description": "Appends a rejection handler callback.",
+          "type": "method",
+          "returns": "Promise"
+        },
+        "finally": {
+          "signature": "finally(onFinally) -> Promise",
+          "description": "Appends a handler to be called when the promise is settled.",
+          "type": "method",
+          "returns": "Promise"
+        },
+        "all": {
+          "signature": "Promise.all(iterable) -> Promise",
+          "description": "Returns a promise that resolves when all of the promises resolve.",
+          "type": "method",
+          "returns": "Promise"
+        },
+        "race": {
+          "signature": "Promise.race(iterable) -> Promise",
+          "description": "Returns a promise that fulfills or rejects as soon as one of the promises fulfills or rejects.",
+          "type": "method",
+          "returns": "Promise"
+        },
+        "resolve": {
+          "signature": "Promise.resolve(value) -> Promise",
+          "description": "Returns a Promise object that is resolved with the given value.",
+          "type": "method",
+          "returns": "Promise"
+        },
+        "reject": {
+          "signature": "Promise.reject(reason) -> Promise",
+          "description": "Returns a Promise object that is rejected with the given reason.",
+          "type": "method",
+          "returns": "Promise"
+        }
+      }
     }
   }
-}
+}

package/data/definition/dart.json

@@ -355,6 +355,110 @@
           "type": "method"
         }
       }
+    },
+    "Widget": {
+      "signature": "abstract class Widget extends DiagnosticableTree",
+      "description": "Describes the configuration for an Element. Widgets are the central class hierarchy in the Flutter framework.",
+      "type": "class",
+      "module": "flutter:widgets"
+    },
+    "StatelessWidget": {
+      "signature": "abstract class StatelessWidget extends Widget",
+      "description": "A widget that does not require mutable state. Describes a part of the user interface by building a constellation of other widgets.",
+      "type": "class",
+      "module": "flutter:widgets",
+      "members": {
+        "build": {
+          "signature": "Widget build(BuildContext context)",
+          "description": "Describes the part of the user interface represented by this widget.",
+          "type": "method",
+          "returns": "Widget"
+        }
+      }
+    },
+    "StatefulWidget": {
+      "signature": "abstract class StatefulWidget extends Widget",
+      "description": "A widget that has mutable state.",
+      "type": "class",
+      "module": "flutter:widgets",
+      "members": {
+        "createState": {
+          "signature": "State createState()",
+          "description": "Creates the mutable state for this widget.",
+          "type": "method",
+          "returns": "State"
+        }
+      }
+    },
+    "File": {
+      "signature": "abstract class File implements FileSystemEntity",
+      "description": "A reference to a file on the file system.",
+      "type": "class",
+      "module": "dart:io",
+      "members": {
+        "readAsString": {
+          "signature": "Future<String> readAsString({Encoding encoding = utf8})",
+          "description": "Read the entire file contents as a string.",
+          "type": "method",
+          "returns": "Future<String>"
+        },
+        "writeAsString": {
+          "signature": "Future<File> writeAsString(String contents)",
+          "description": "Write a string to a file.",
+          "type": "method",
+          "returns": "Future<File>"
+        },
+        "exists": {
+          "signature": "Future<bool> exists()",
+          "description": "Checks whether the file system entity with this path exists.",
+          "type": "method",
+          "returns": "Future<bool>"
+        },
+        "delete": {
+          "signature": "Future<FileSystemEntity> delete({bool recursive = false})",
+          "description": "Deletes this file system entity.",
+          "type": "method",
+          "returns": "Future<FileSystemEntity>"
+        },
+        "readAsBytes": {
+          "signature": "Future<Uint8List> readAsBytes()",
+          "description": "Read the entire file contents as a list of bytes.",
+          "type": "method",
+          "returns": "Future<Uint8List>"
+        },
+        "length": {
+          "signature": "Future<int> length()",
+          "description": "The length of the file.",
+          "type": "method",
+          "returns": "Future<int>"
+        }
+      }
+    },
+    "RegExp": {
+      "signature": "abstract class RegExp implements Pattern",
+      "description": "A regular expression pattern.",
+      "type": "class",
+      "module": "dart:core",
+      "members": {
+        "hasMatch": {
+          "signature": "bool hasMatch(String input)",
+          "description": "Whether the regular expression has a match in the string input.",
+          "type": "method",
+          "returns": "bool"
+        },
+        "firstMatch": {
+          "signature": "RegExpMatch? firstMatch(String input)",
+          "description": "Returns the first match of the regular expression in the string.",
+          "type": "method",
+          "returns": "RegExpMatch?"
+        },
+        "allMatches": {
+          "signature": "Iterable<RegExpMatch> allMatches(String input, [int start = 0])",
+          "description": "Returns an iterable of all matches.",
+          "type": "method",
+          "returns": "Iterable<RegExpMatch>"
+        }
+      }
     }
   }
-}
+}

package/data/definition/elixir.json

@@ -239,6 +239,120 @@
           "type": "function"
         }
       }
+    },
+    "File": {
+      "signature": "defmodule File",
+      "description": "Contains functions to manipulate files.",
+      "type": "module",
+      "module": "Elixir",
+      "members": {
+        "read": {
+          "signature": "File.read(path) :: {:ok, binary} | {:error, posix}",
+          "description": "Returns {:ok, binary} with the contents of the given filename, or {:error, reason}.",
+          "type": "function",
+          "returns": "{:ok, binary} | {:error, posix}"
+        },
+        "write": {
+          "signature": "File.write(path, content) :: :ok | {:error, posix}",
+          "description": "Writes content to the file at path.",
+          "type": "function",
+          "returns": ":ok | {:error, posix}"
+        },
+        "exists?": {
+          "signature": "File.exists?(path) :: boolean",
+          "description": "Returns true if the given path exists.",
+          "type": "function",
+          "returns": "boolean"
+        },
+        "rm": {
+          "signature": "File.rm(path) :: :ok | {:error, posix}",
+          "description": "Tries to delete the file at path.",
+          "type": "function",
+          "returns": ":ok | {:error, posix}"
+        },
+        "mkdir_p": {
+          "signature": "File.mkdir_p(path) :: :ok | {:error, posix}",
+          "description": "Tries to create the directory path. Missing parent directories are created.",
+          "type": "function",
+          "returns": ":ok | {:error, posix}"
+        },
+        "ls": {
+          "signature": "File.ls(path) :: {:ok, list(String.t)} | {:error, posix}",
+          "description": "Returns {:ok, list} with the list of files in the given directory.",
+          "type": "function",
+          "returns": "{:ok, list(String.t)} | {:error, posix}"
+        },
+        "stat": {
+          "signature": "File.stat(path) :: {:ok, File.Stat.t} | {:error, posix}",
+          "description": "Returns information about the path.",
+          "type": "function",
+          "returns": "{:ok, File.Stat.t} | {:error, posix}"
+        }
+      }
+    },
+    "Supervisor": {
+      "signature": "defmodule Supervisor",
+      "description": "A behaviour module for implementing supervisors. A supervisor is a process which supervises other processes, called child processes.",
+      "type": "module",
+      "module": "Elixir",
+      "members": {
+        "start_link": {
+          "signature": "Supervisor.start_link(children, options) :: {:ok, pid}",
+          "description": "Starts a supervisor with the given children.",
+          "type": "function",
+          "returns": "{:ok, pid}"
+        },
+        "init": {
+          "signature": "Supervisor.init(children, options) :: {:ok, tuple}",
+          "description": "Receives a list of children to initialize.",
+          "type": "callback",
+          "returns": "{:ok, tuple}"
+        },
+        "which_children": {
+          "signature": "Supervisor.which_children(supervisor) :: list",
+          "description": "Returns a list with information about all children.",
+          "type": "function",
+          "returns": "list"
+        },
+        "count_children": {
+          "signature": "Supervisor.count_children(supervisor) :: map",
+          "description": "Returns a map containing count values for the supervisor.",
+          "type": "function",
+          "returns": "map"
+        }
+      }
+    },
+    "Process": {
+      "signature": "defmodule Process",
+      "description": "Conveniences for working with processes and the process dictionary.",
+      "type": "module",
+      "module": "Elixir",
+      "members": {
+        "spawn": {
+          "signature": "Process.spawn(fun, options) :: pid",
+          "description": "Spawns the given function according to the given options.",
+          "type": "function",
+          "returns": "pid"
+        },
+        "send": {
+          "signature": "Process.send(dest, msg, options) :: :ok",
+          "description": "Sends a message to the given process.",
+          "type": "function",
+          "returns": ":ok"
+        },
+        "alive?": {
+          "signature": "Process.alive?(pid) :: boolean",
+          "description": "Tells whether the given process is alive on the local node.",
+          "type": "function",
+          "returns": "boolean"
+        },
+        "sleep": {
+          "signature": "Process.sleep(timeout) :: :ok",
+          "description": "Sleeps the current process for the given timeout.",
+          "type": "function",
+          "returns": ":ok"
+        }
+      }
     }
   }
-}
+}

package/data/definition/flow9.json

@@ -151,6 +151,213 @@
       "description": "A Boolean type in Flow9 with two possible values: true and false. Supports logical operators && (and), || (or), and ! (not). Used in conditional expressions, filter predicates, and control flow statements.",
       "type": "class",
       "module": "Flow9 Runtime"
+    },
+    "list": {
+      "signature": "List<T>",
+      "description": "Immutable linked list. The primary collection type in Flow9.",
+      "type": "type",
+      "module": "ds/list",
+      "members": {
+        "Cons": {
+          "signature": "Cons(head: T, tail: List<T>)",
+          "description": "Constructs a list with a head element and a tail list.",
+          "type": "constructor"
+        },
+        "EmptyList": {
+          "signature": "EmptyList()",
+          "description": "The empty list.",
+          "type": "constructor"
+        }
+      }
+    },
+    "map": {
+      "signature": "map(a: [?], fn: (?) -> ??) -> [??]",
+      "description": "Applies fn to each element of array a and returns new array.",
+      "type": "function",
+      "module": "ds/array",
+      "returns": "[??]"
+    },
+    "filter": {
+      "signature": "filter(a: [?], fn: (?) -> bool) -> [?]",
+      "description": "Returns array of elements where fn returns true.",
+      "type": "function",
+      "module": "ds/array",
+      "returns": "[?]"
+    },
+    "fold": {
+      "signature": "fold(a: [?], init: ??, fn: (??, ?) -> ??) -> ??",
+      "description": "Left fold over an array.",
+      "type": "function",
+      "module": "ds/array",
+      "returns": "??"
+    },
+    "iter": {
+      "signature": "iter(a: [?], fn: (?) -> void) -> void",
+      "description": "Iterates over each element of the array applying fn.",
+      "type": "function",
+      "module": "ds/array",
+      "returns": "void"
+    },
+    "iteri": {
+      "signature": "iteri(a: [?], fn: (int, ?) -> void) -> void",
+      "description": "Iterates over each element with its index.",
+      "type": "function",
+      "module": "ds/array",
+      "returns": "void"
+    },
+    "mapi": {
+      "signature": "mapi(a: [?], fn: (int, ?) -> ??) -> [??]",
+      "description": "Maps with index.",
+      "type": "function",
+      "module": "ds/array",
+      "returns": "[??]"
+    },
+    "length": {
+      "signature": "length(a: [?]) -> int",
+      "description": "Returns the length of an array.",
+      "type": "function",
+      "module": "ds/array",
+      "returns": "int"
+    },
+    "concat": {
+      "signature": "concat(a: [?], b: [?]) -> [?]",
+      "description": "Concatenates two arrays.",
+      "type": "function",
+      "module": "ds/array",
+      "returns": "[?]"
+    },
+    "sort": {
+      "signature": "sort(a: [?], cmp: (?, ?) -> int) -> [?]",
+      "description": "Sorts an array using the comparison function.",
+      "type": "function",
+      "module": "ds/array",
+      "returns": "[?]"
+    },
+    "exists": {
+      "signature": "exists(a: [?], fn: (?) -> bool) -> bool",
+      "description": "Returns true if any element satisfies the predicate.",
+      "type": "function",
+      "module": "ds/array",
+      "returns": "bool"
+    },
+    "forall": {
+      "signature": "forall(a: [?], fn: (?) -> bool) -> bool",
+      "description": "Returns true if all elements satisfy the predicate.",
+      "type": "function",
+      "module": "ds/array",
+      "returns": "bool"
+    },
+    "find": {
+      "signature": "find(a: [?], fn: (?) -> bool) -> Maybe<?>",
+      "description": "Finds the first element that satisfies the predicate.",
+      "type": "function",
+      "module": "ds/array",
+      "returns": "Maybe<?>"
+    },
+    "makeTree": {
+      "signature": "makeTree() -> Tree<?, ??>",
+      "description": "Creates an empty balanced binary tree (map).",
+      "type": "function",
+      "module": "ds/tree",
+      "returns": "Tree<?, ??>"
+    },
+    "setTree": {
+      "signature": "setTree(tree: Tree<?, ??>, key: ?, value: ??) -> Tree<?, ??>",
+      "description": "Inserts or updates a key-value pair in the balanced tree.",
+      "type": "function",
+      "module": "ds/tree",
+      "returns": "Tree<?, ??>"
+    },
+    "lookupTree": {
+      "signature": "lookupTree(tree: Tree<?, ??>, key: ?) -> Maybe<??>",
+      "description": "Looks up a value by key in the balanced tree.",
+      "type": "function",
+      "module": "ds/tree",
+      "returns": "Maybe<??>"
+    },
+    "removeFromTree": {
+      "signature": "removeFromTree(tree: Tree<?, ??>, key: ?) -> Tree<?, ??>",
+      "description": "Removes a key-value pair from the tree.",
+      "type": "function",
+      "module": "ds/tree",
+      "returns": "Tree<?, ??>"
+    },
+    "makeSet": {
+      "signature": "makeSet() -> Set<?>",
+      "description": "Creates an empty set.",
+      "type": "function",
+      "module": "ds/set",
+      "returns": "Set<?>"
+    },
+    "insertSet": {
+      "signature": "insertSet(set: Set<?>, val: ?) -> Set<?>",
+      "description": "Inserts a value into the set.",
+      "type": "function",
+      "module": "ds/set",
+      "returns": "Set<?>"
+    },
+    "containsSet": {
+      "signature": "containsSet(set: Set<?>, val: ?) -> bool",
+      "description": "Checks if the set contains the value.",
+      "type": "function",
+      "module": "ds/set",
+      "returns": "bool"
+    },
+    "println": {
+      "signature": "println(s: string) -> void",
+      "description": "Prints a string followed by a newline.",
+      "type": "function",
+      "module": "runtime",
+      "returns": "void"
+    },
+    "i2s": {
+      "signature": "i2s(i: int) -> string",
+      "description": "Converts an integer to a string.",
+      "type": "function",
+      "module": "runtime",
+      "returns": "string"
+    },
+    "s2i": {
+      "signature": "s2i(s: string) -> int",
+      "description": "Converts a string to an integer.",
+      "type": "function",
+      "module": "runtime",
+      "returns": "int"
+    },
+    "d2s": {
+      "signature": "d2s(d: double) -> string",
+      "description": "Converts a double to a string.",
+      "type": "function",
+      "module": "runtime",
+      "returns": "string"
+    },
+    "s2d": {
+      "signature": "s2d(s: string) -> double",
+      "description": "Converts a string to a double.",
+      "type": "function",
+      "module": "runtime",
+      "returns": "double"
+    },
+    "strlen": {
+      "signature": "strlen(s: string) -> int",
+      "description": "Returns the length of a string.",
+      "type": "function",
+      "module": "runtime",
+      "returns": "int"
+    },
+    "strContainsAt": {
+      "signature": "strContainsAt(s: string, pos: int, sub: string) -> bool",
+      "description": "Checks if s contains sub at position pos.",
+      "type": "function",
+      "module": "runtime",
+      "returns": "bool"
+    },
+    "substring": {
+      "signature": "substring(s: string, start: int, len: int) -> string",
+      "description": "Returns a substring starting at start with length len.",
+      "type": "function",
+      "module": "runtime",
+      "returns": "string"
     }
   }
-}
+}