@enjoys/context-engine 1.1.2 → 1.2.0

package/data/signatureHelp/scala.json

@@ -0,0 +1,97 @@
+{
+  "language": "scala",
+  "triggerCharacters": ["(", ","],
+  "retriggerCharacters": [","],
+  "signatures": [
+    {
+      "label": "println(x: Any): Unit",
+      "documentation": { "value": "Prints a value to the standard output followed by a newline." },
+      "parameters": [
+        { "label": "x", "documentation": { "value": "The value to print" } }
+      ]
+    },
+    {
+      "label": "List.map[B](f: A => B): List[B]",
+      "documentation": { "value": "Builds a new list by applying a function to all elements of this list." },
+      "parameters": [
+        { "label": "f", "documentation": { "value": "The function to apply to each element" } }
+      ]
+    },
+    {
+      "label": "List.filter(p: A => Boolean): List[A]",
+      "documentation": { "value": "Selects all elements of this list which satisfy a predicate." },
+      "parameters": [
+        { "label": "p", "documentation": { "value": "The predicate used to test elements" } }
+      ]
+    },
+    {
+      "label": "List.foldLeft[B](z: B)(op: (B, A) => B): B",
+      "documentation": { "value": "Applies a binary operator to a start value and all elements of this list, going left to right." },
+      "parameters": [
+        { "label": "z", "documentation": { "value": "The start/initial value" } },
+        { "label": "op", "documentation": { "value": "The binary operator to apply" } }
+      ]
+    },
+    {
+      "label": "Option.getOrElse[B >: A](default: => B): B",
+      "documentation": { "value": "Returns the option's value if it is nonempty, or the default value otherwise." },
+      "parameters": [
+        { "label": "default", "documentation": { "value": "The default value to return if the option is `None`" } }
+      ]
+    },
+    {
+      "label": "Future.apply[T](body: => T)(implicit executor: ExecutionContext): Future[T]",
+      "documentation": { "value": "Starts an asynchronous computation and returns a `Future` object with the result." },
+      "parameters": [
+        { "label": "body", "documentation": { "value": "The asynchronous computation to execute" } },
+        { "label": "executor", "documentation": { "value": "The implicit execution context for the computation" } }
+      ]
+    },
+    {
+      "label": "Try.apply[T](r: => T): Try[T]",
+      "documentation": { "value": "Constructs a `Try` using the by-name parameter. Returns `Success` or `Failure`." },
+      "parameters": [
+        { "label": "r", "documentation": { "value": "The computation that may throw an exception" } }
+      ]
+    },
+    {
+      "label": "Map.getOrElse[V1 >: V](key: K, default: => V1): V1",
+      "documentation": { "value": "Returns the value associated with a key, or a default value if the key is not contained in the map." },
+      "parameters": [
+        { "label": "key", "documentation": { "value": "The key to look up" } },
+        { "label": "default", "documentation": { "value": "A computation of the default value" } }
+      ]
+    },
+    {
+      "label": "String.format(args: Any*): String",
+      "documentation": { "value": "Uses this string as a format string, returning a string obtained by substituting the given arguments." },
+      "parameters": [
+        { "label": "args", "documentation": { "value": "The arguments referenced by the format specifiers" } }
+      ]
+    },
+    {
+      "label": "Array.fill[T](n: Int)(elem: => T): Array[T]",
+      "documentation": { "value": "Returns an array that contains the results of some element computation a number of times." },
+      "parameters": [
+        { "label": "n", "documentation": { "value": "The number of elements in the array" } },
+        { "label": "elem", "documentation": { "value": "The element computation" } }
+      ]
+    },
+    {
+      "label": "Set.contains(elem: A): Boolean",
+      "documentation": { "value": "Tests if some element is contained in this set." },
+      "parameters": [
+        { "label": "elem", "documentation": { "value": "The element to test for membership" } }
+      ]
+    },
+    {
+      "label": "Range.apply(start: Int, end: Int, step: Int): Range",
+      "documentation": { "value": "Creates a range of integers from start (inclusive) to end (exclusive) with the given step." },
+      "parameters": [
+        { "label": "start", "documentation": { "value": "The start value of the range (inclusive)" } },
+        { "label": "end", "documentation": { "value": "The end value of the range (exclusive)" } },
+        { "label": "step", "documentation": { "value": "The step value between elements" } }
+      ]
+    }
+  ]
+}

package/data/signatureHelp/scheme.json

@@ -0,0 +1,125 @@
+{
+  "language": "scheme",
+  "triggerCharacters": ["(", " "],
+  "retriggerCharacters": [" "],
+  "signatures": [
+    {
+      "label": "(display obj [port])",
+      "documentation": { "value": "Writes a representation of `obj` to the given port. If port is omitted, the current output port is used." },
+      "parameters": [
+        { "label": "obj", "documentation": { "value": "The object to display" } },
+        { "label": "port", "documentation": { "value": "Optional output port (defaults to current output port)" } }
+      ]
+    },
+    {
+      "label": "(newline [port])",
+      "documentation": { "value": "Writes a newline character to the given port." },
+      "parameters": [
+        { "label": "port", "documentation": { "value": "Optional output port (defaults to current output port)" } }
+      ]
+    },
+    {
+      "label": "(car pair): obj",
+      "documentation": { "value": "Returns the first element (the car) of a pair." },
+      "parameters": [
+        { "label": "pair", "documentation": { "value": "A pair (cons cell)" } }
+      ]
+    },
+    {
+      "label": "(cdr pair): obj",
+      "documentation": { "value": "Returns the second element (the cdr) of a pair." },
+      "parameters": [
+        { "label": "pair", "documentation": { "value": "A pair (cons cell)" } }
+      ]
+    },
+    {
+      "label": "(cons obj1 obj2): pair",
+      "documentation": { "value": "Returns a newly allocated pair whose car is `obj1` and whose cdr is `obj2`." },
+      "parameters": [
+        { "label": "obj1", "documentation": { "value": "The car of the new pair" } },
+        { "label": "obj2", "documentation": { "value": "The cdr of the new pair" } }
+      ]
+    },
+    {
+      "label": "(list obj ...): list",
+      "documentation": { "value": "Returns a newly allocated list of its arguments." },
+      "parameters": [
+        { "label": "obj", "documentation": { "value": "Zero or more objects to include in the list" } }
+      ]
+    },
+    {
+      "label": "(append list ...): list",
+      "documentation": { "value": "Returns a list consisting of the elements of the first list followed by the elements of the other lists." },
+      "parameters": [
+        { "label": "list", "documentation": { "value": "One or more lists to concatenate" } }
+      ]
+    },
+    {
+      "label": "(map proc list1 list2 ...): list",
+      "documentation": { "value": "Applies `proc` element-wise to the elements of the lists and returns a list of the results." },
+      "parameters": [
+        { "label": "proc", "documentation": { "value": "A procedure to apply to each element" } },
+        { "label": "list1", "documentation": { "value": "The first list" } },
+        { "label": "list2", "documentation": { "value": "Additional lists (optional, for multi-argument proc)" } }
+      ]
+    },
+    {
+      "label": "(filter pred list): list",
+      "documentation": { "value": "Returns a list of the elements of `list` that satisfy predicate `pred`." },
+      "parameters": [
+        { "label": "pred", "documentation": { "value": "A predicate procedure" } },
+        { "label": "list", "documentation": { "value": "The list to filter" } }
+      ]
+    },
+    {
+      "label": "(fold-left f init list): obj",
+      "documentation": { "value": "Applies `f` to `init` and the first element of `list`, then to that result and the next element, and so on." },
+      "parameters": [
+        { "label": "f", "documentation": { "value": "A binary procedure `(f accumulator element)`" } },
+        { "label": "init", "documentation": { "value": "The initial accumulator value" } },
+        { "label": "list", "documentation": { "value": "The list to fold over" } }
+      ]
+    },
+    {
+      "label": "(lambda (formals) body)",
+      "documentation": { "value": "Creates an anonymous procedure with the given formal parameters and body expressions." },
+      "parameters": [
+        { "label": "formals", "documentation": { "value": "The parameter list" } },
+        { "label": "body", "documentation": { "value": "One or more expressions forming the body" } }
+      ]
+    },
+    {
+      "label": "(define name expr)",
+      "documentation": { "value": "Binds `name` to the value of `expr` in the current environment." },
+      "parameters": [
+        { "label": "name", "documentation": { "value": "The variable name to bind" } },
+        { "label": "expr", "documentation": { "value": "The expression whose value will be bound" } }
+      ]
+    },
+    {
+      "label": "(let ((var expr) ...) body)",
+      "documentation": { "value": "Binds each `var` to the corresponding `expr`, then evaluates `body` in the extended environment." },
+      "parameters": [
+        { "label": "(var expr)", "documentation": { "value": "A list of variable-expression bindings" } },
+        { "label": "body", "documentation": { "value": "One or more expressions to evaluate" } }
+      ]
+    },
+    {
+      "label": "(cond (test expr ...) ... (else expr ...))",
+      "documentation": { "value": "Evaluates test expressions in order. When one evaluates to true, evaluates the corresponding expressions." },
+      "parameters": [
+        { "label": "(test expr ...)", "documentation": { "value": "A clause with a test and expressions to evaluate if the test is true" } },
+        { "label": "(else expr ...)", "documentation": { "value": "Optional else clause evaluated if no test is true" } }
+      ]
+    },
+    {
+      "label": "(if test consequent alternate)",
+      "documentation": { "value": "Evaluates `test`. If it yields a true value, `consequent` is evaluated; otherwise `alternate` is evaluated." },
+      "parameters": [
+        { "label": "test", "documentation": { "value": "The condition to evaluate" } },
+        { "label": "consequent", "documentation": { "value": "Expression evaluated when test is true" } },
+        { "label": "alternate", "documentation": { "value": "Expression evaluated when test is false (optional)" } }
+      ]
+    }
+  ]
+}

package/data/signatureHelp/scss.json

@@ -0,0 +1,127 @@
+{
+  "language": "scss",
+  "triggerCharacters": ["(", ","],
+  "retriggerCharacters": [","],
+  "signatures": [
+    {
+      "label": "@mixin name($param1, $param2: default) { ... }",
+      "documentation": { "value": "Defines a reusable group of CSS declarations that can be included throughout the stylesheet." },
+      "parameters": [
+        { "label": "name", "documentation": { "value": "The name of the mixin" } },
+        { "label": "$param1", "documentation": { "value": "A required parameter" } },
+        { "label": "$param2: default", "documentation": { "value": "An optional parameter with a default value" } }
+      ]
+    },
+    {
+      "label": "@include name($args...)",
+      "documentation": { "value": "Includes a mixin's styles into the current rule." },
+      "parameters": [
+        { "label": "name", "documentation": { "value": "The name of the mixin to include" } },
+        { "label": "$args", "documentation": { "value": "Arguments to pass to the mixin" } }
+      ]
+    },
+    {
+      "label": "@function name($param1, $param2) { @return value; }",
+      "documentation": { "value": "Defines a custom function that can compute and return values." },
+      "parameters": [
+        { "label": "name", "documentation": { "value": "The name of the function" } },
+        { "label": "$param1", "documentation": { "value": "First parameter of the function" } },
+        { "label": "$param2", "documentation": { "value": "Second parameter of the function" } }
+      ]
+    },
+    {
+      "label": "@return expression",
+      "documentation": { "value": "Returns the result of an expression from a `@function`." },
+      "parameters": [
+        { "label": "expression", "documentation": { "value": "The value to return from the function" } }
+      ]
+    },
+    {
+      "label": "@extend selector",
+      "documentation": { "value": "Shares a set of CSS properties from one selector to another." },
+      "parameters": [
+        { "label": "selector", "documentation": { "value": "The selector whose styles should be extended" } }
+      ]
+    },
+    {
+      "label": "@use 'url' as namespace",
+      "documentation": { "value": "Loads mixins, functions, and variables from another stylesheet and makes them available namespaced." },
+      "parameters": [
+        { "label": "'url'", "documentation": { "value": "The URL of the module to load" } },
+        { "label": "namespace", "documentation": { "value": "Optional namespace alias (use `*` for no namespace)" } }
+      ]
+    },
+    {
+      "label": "@forward 'url' with ($config...)",
+      "documentation": { "value": "Loads a Sass stylesheet and makes its mixins, functions, and variables available when this stylesheet is loaded with `@use`." },
+      "parameters": [
+        { "label": "'url'", "documentation": { "value": "The URL of the module to forward" } },
+        { "label": "$config", "documentation": { "value": "Optional configuration values to pass" } }
+      ]
+    },
+    {
+      "label": "@if condition { ... } @else if condition { ... } @else { ... }",
+      "documentation": { "value": "Conditionally evaluates a block of styles based on the result of an expression." },
+      "parameters": [
+        { "label": "condition", "documentation": { "value": "A SassScript expression that evaluates to true or false" } }
+      ]
+    },
+    {
+      "label": "@each $var in list { ... }",
+      "documentation": { "value": "Iterates over each item in a list or each pair in a map." },
+      "parameters": [
+        { "label": "$var", "documentation": { "value": "The variable name for the current item" } },
+        { "label": "list", "documentation": { "value": "A Sass list or map to iterate over" } }
+      ]
+    },
+    {
+      "label": "@for $var from start through end { ... }",
+      "documentation": { "value": "Iterates from a start number to an end number (inclusive with `through`, exclusive with `to`)." },
+      "parameters": [
+        { "label": "$var", "documentation": { "value": "The counter variable" } },
+        { "label": "start", "documentation": { "value": "The starting number" } },
+        { "label": "end", "documentation": { "value": "The ending number" } }
+      ]
+    },
+    {
+      "label": "darken($color, $amount): color",
+      "documentation": { "value": "Makes a color darker by decreasing its lightness by the given amount." },
+      "parameters": [
+        { "label": "$color", "documentation": { "value": "The color to darken" } },
+        { "label": "$amount", "documentation": { "value": "A percentage between 0% and 100%" } }
+      ]
+    },
+    {
+      "label": "lighten($color, $amount): color",
+      "documentation": { "value": "Makes a color lighter by increasing its lightness by the given amount." },
+      "parameters": [
+        { "label": "$color", "documentation": { "value": "The color to lighten" } },
+        { "label": "$amount", "documentation": { "value": "A percentage between 0% and 100%" } }
+      ]
+    },
+    {
+      "label": "mix($color1, $color2, $weight: 50%): color",
+      "documentation": { "value": "Mixes two colors together. The weight specifies the amount of the first color to include." },
+      "parameters": [
+        { "label": "$color1", "documentation": { "value": "The first color" } },
+        { "label": "$color2", "documentation": { "value": "The second color" } },
+        { "label": "$weight", "documentation": { "value": "The proportion of the first color (default 50%)" } }
+      ]
+    },
+    {
+      "label": "percentage($number): percentage",
+      "documentation": { "value": "Converts a unitless number to a percentage." },
+      "parameters": [
+        { "label": "$number", "documentation": { "value": "A unitless number (e.g. 0.5 becomes 50%)" } }
+      ]
+    },
+    {
+      "label": "map-get($map, $key): value",
+      "documentation": { "value": "Returns the value in a map associated with the given key." },
+      "parameters": [
+        { "label": "$map", "documentation": { "value": "The map to search" } },
+        { "label": "$key", "documentation": { "value": "The key to look up" } }
+      ]
+    }
+  ]
+}

package/data/signatureHelp/shell.json

@@ -0,0 +1,104 @@
+{
+  "language": "shell",
+  "triggerCharacters": [" ", "("],
+  "retriggerCharacters": [" "],
+  "signatures": [
+    {
+      "label": "echo [option] [string ...]",
+      "documentation": { "value": "Displays a line of text to standard output." },
+      "parameters": [
+        { "label": "option", "documentation": { "value": "Options: `-n` suppress trailing newline, `-e` enable backslash escapes, `-E` disable backslash escapes" } },
+        { "label": "string", "documentation": { "value": "The string(s) to display" } }
+      ]
+    },
+    {
+      "label": "read [-p prompt] [-r] [-a array] [-d delim] [-t timeout] [name ...]",
+      "documentation": { "value": "Reads a line from standard input and splits it into fields, assigning to variables." },
+      "parameters": [
+        { "label": "-p prompt", "documentation": { "value": "Display prompt before reading input" } },
+        { "label": "-r", "documentation": { "value": "Do not treat backslash as an escape character" } },
+        { "label": "-a array", "documentation": { "value": "Read into an indexed array variable" } },
+        { "label": "name", "documentation": { "value": "Variable name(s) to assign the input fields to" } }
+      ]
+    },
+    {
+      "label": "printf format [arguments ...]",
+      "documentation": { "value": "Formats and prints data according to a format string, similar to C printf." },
+      "parameters": [
+        { "label": "format", "documentation": { "value": "A format string with specifiers like %s, %d, %f" } },
+        { "label": "arguments", "documentation": { "value": "Arguments to substitute into the format string" } }
+      ]
+    },
+    {
+      "label": "test expression | [ expression ]",
+      "documentation": { "value": "Evaluate a conditional expression. Returns 0 (true) or 1 (false)." },
+      "parameters": [
+        { "label": "expression", "documentation": { "value": "The conditional expression, e.g. `-f file`, `-d dir`, `str1 = str2`, `n1 -eq n2`" } }
+      ]
+    },
+    {
+      "label": "export [-fn] [name[=value] ...]",
+      "documentation": { "value": "Sets environment variables so they are available to child processes." },
+      "parameters": [
+        { "label": "name=value", "documentation": { "value": "Variable name and optional value to export" } },
+        { "label": "-n", "documentation": { "value": "Remove the export property from the named variable" } }
+      ]
+    },
+    {
+      "label": "source filename [arguments]",
+      "documentation": { "value": "Reads and executes commands from the given file in the current shell environment." },
+      "parameters": [
+        { "label": "filename", "documentation": { "value": "The file to source" } },
+        { "label": "arguments", "documentation": { "value": "Positional parameters passed to the sourced script" } }
+      ]
+    },
+    {
+      "label": "trap [-lp] [action] [signal ...]",
+      "documentation": { "value": "Defines actions to be taken when the shell receives a signal." },
+      "parameters": [
+        { "label": "action", "documentation": { "value": "A command string to execute when the signal is received, or `-` to reset" } },
+        { "label": "signal", "documentation": { "value": "Signal name or number (e.g. SIGINT, EXIT, ERR, SIGTERM)" } }
+      ]
+    },
+    {
+      "label": "set [--abefhkmnptuvxBCHP] [-o option-name] [arg ...]",
+      "documentation": { "value": "Sets or unsets shell options and positional parameters." },
+      "parameters": [
+        { "label": "-e", "documentation": { "value": "Exit immediately if a command exits with a non-zero status" } },
+        { "label": "-u", "documentation": { "value": "Treat unset variables as an error during parameter expansion" } },
+        { "label": "-x", "documentation": { "value": "Print commands and their arguments as they are executed" } },
+        { "label": "-o option-name", "documentation": { "value": "Set a named option like `pipefail`, `nounset`, `errexit`" } }
+      ]
+    },
+    {
+      "label": "shift [n]",
+      "documentation": { "value": "Shifts positional parameters to the left by n positions (default 1)." },
+      "parameters": [
+        { "label": "n", "documentation": { "value": "The number of positions to shift (default is 1)" } }
+      ]
+    },
+    {
+      "label": "getopts optstring name [args]",
+      "documentation": { "value": "Parses positional parameters as options. Used in while loops for option processing." },
+      "parameters": [
+        { "label": "optstring", "documentation": { "value": "The string of recognized option letters; a colon after a letter means it takes an argument" } },
+        { "label": "name", "documentation": { "value": "Variable name to store the current option letter" } }
+      ]
+    },
+    {
+      "label": "basename string [suffix]",
+      "documentation": { "value": "Strips the directory and optionally the suffix from a file path." },
+      "parameters": [
+        { "label": "string", "documentation": { "value": "The file path" } },
+        { "label": "suffix", "documentation": { "value": "An optional suffix to remove from the result" } }
+      ]
+    },
+    {
+      "label": "dirname string",
+      "documentation": { "value": "Strips the last component from a file path, returning the directory portion." },
+      "parameters": [
+        { "label": "string", "documentation": { "value": "The file path" } }
+      ]
+    }
+  ]
+}

package/data/signatureHelp/sol.json

@@ -0,0 +1,92 @@
+{
+  "language": "sol",
+  "triggerCharacters": ["(", ","],
+  "retriggerCharacters": [","],
+  "signatures": [
+    {
+      "label": "require(condition: bool, message: string)",
+      "documentation": { "value": "Reverts the transaction if the condition is false. Optionally provides an error message." },
+      "parameters": [
+        { "label": "condition", "documentation": { "value": "The boolean condition that must be true" } },
+        { "label": "message", "documentation": { "value": "Optional revert reason string" } }
+      ]
+    },
+    {
+      "label": "assert(condition: bool)",
+      "documentation": { "value": "Checks for internal errors and invariants. Should only fail due to bugs. Consumes all remaining gas on failure." },
+      "parameters": [
+        { "label": "condition", "documentation": { "value": "The invariant condition that should always be true" } }
+      ]
+    },
+    {
+      "label": "revert(reason: string)",
+      "documentation": { "value": "Aborts execution and reverts state changes, providing an optional explanation string." },
+      "parameters": [
+        { "label": "reason", "documentation": { "value": "The revert reason string" } }
+      ]
+    },
+    {
+      "label": "keccak256(data: bytes): bytes32",
+      "documentation": { "value": "Computes the Keccak-256 hash of the input data." },
+      "parameters": [
+        { "label": "data", "documentation": { "value": "The bytes input to hash (use `abi.encodePacked(...)` for multiple values)" } }
+      ]
+    },
+    {
+      "label": "abi.encode(values: ...): bytes",
+      "documentation": { "value": "ABI-encodes the given arguments with padding to 32 bytes per value." },
+      "parameters": [
+        { "label": "values", "documentation": { "value": "The values to ABI-encode" } }
+      ]
+    },
+    {
+      "label": "abi.encodePacked(values: ...): bytes",
+      "documentation": { "value": "Performs non-standard packed encoding of the given values. Does not pad to 32 bytes." },
+      "parameters": [
+        { "label": "values", "documentation": { "value": "The values to encode in packed format" } }
+      ]
+    },
+    {
+      "label": "abi.decode(data: bytes, types: (...)): (...)",
+      "documentation": { "value": "ABI-decodes the given data according to the specified types." },
+      "parameters": [
+        { "label": "data", "documentation": { "value": "The ABI-encoded bytes to decode" } },
+        { "label": "types", "documentation": { "value": "The tuple of types to decode into, e.g. `(uint256, address)`" } }
+      ]
+    },
+    {
+      "label": "address.transfer(amount: uint256)",
+      "documentation": { "value": "Sends the given amount of Wei to the address. Reverts on failure. Forwards 2300 gas." },
+      "parameters": [
+        { "label": "amount", "documentation": { "value": "The amount of Wei to transfer" } }
+      ]
+    },
+    {
+      "label": "address.send(amount: uint256): bool",
+      "documentation": { "value": "Sends the given amount of Wei to the address. Returns false on failure. Forwards 2300 gas." },
+      "parameters": [
+        { "label": "amount", "documentation": { "value": "The amount of Wei to send" } }
+      ]
+    },
+    {
+      "label": "address.call{value: uint256, gas: uint256}(data: bytes): (bool, bytes)",
+      "documentation": { "value": "Low-level call to an address. Returns success boolean and return data." },
+      "parameters": [
+        { "label": "data", "documentation": { "value": "The calldata to send" } }
+      ]
+    },
+    {
+      "label": "mapping(keyType => valueType)",
+      "documentation": { "value": "Declares a mapping type that maps keys of `keyType` to values of `valueType`." },
+      "parameters": [
+        { "label": "keyType", "documentation": { "value": "The key type (must be a value type, bytes, string, or contract)" } },
+        { "label": "valueType", "documentation": { "value": "The value type (can be any type including another mapping)" } }
+      ]
+    },
+    {
+      "label": "msg.sender: address",
+      "documentation": { "value": "The address of the account that sent the current call/transaction." },
+      "parameters": []
+    }
+  ]
+}