@enjoys/context-engine 1.0.0 → 1.0.1

package/data/hover/php.json

@@ -0,0 +1,300 @@
+{
+  "language": "php",
+  "hovers": {
+    "echo": {
+      "contents": [
+        { "value": "```php\necho(string ...$expressions): void\n```\nOutputs one or more expressions. `echo` is not a function but a language construct, so parentheses are not required. It has no return value." }
+      ]
+    },
+    "print": {
+      "contents": [
+        { "value": "```php\nprint(string $expression): int\n```\nOutputs a string. `print` is a language construct that accepts a single argument and always returns `1`. Slightly slower than `echo`." }
+      ]
+    },
+    "var_dump": {
+      "contents": [
+        { "value": "```php\nvar_dump(mixed $value, mixed ...$values): void\n```\nDisplays structured information about one or more expressions including its type and value. Arrays and objects are explored recursively with values indented to show structure." }
+      ]
+    },
+    "print_r": {
+      "contents": [
+        { "value": "```php\nprint_r(mixed $value, bool $return = false): string|bool\n```\nPrints human-readable information about a variable. If `$return` is `true`, returns the output as a string instead of printing it." }
+      ]
+    },
+    "var_export": {
+      "contents": [
+        { "value": "```php\nvar_export(mixed $value, bool $return = false): ?string\n```\nOutputs or returns a parsable string representation of a variable. Differs from `var_dump()` in that the returned representation is valid PHP code." }
+      ]
+    },
+    "printf": {
+      "contents": [
+        { "value": "```php\nprintf(string $format, mixed ...$values): int\n```\nOutputs a formatted string. The format string may contain conversion specifications starting with `%` (e.g. `%s`, `%d`, `%f`). Returns the length of the outputted string." }
+      ]
+    },
+    "sprintf": {
+      "contents": [
+        { "value": "```php\nsprintf(string $format, mixed ...$values): string\n```\nReturns a string produced according to the formatting string `$format`. Uses the same format specifiers as `printf()`." }
+      ]
+    },
+    "strlen": {
+      "contents": [
+        { "value": "```php\nstrlen(string $string): int\n```\nReturns the length of the given string in bytes. For multi-byte characters, use `mb_strlen()` instead." }
+      ]
+    },
+    "strpos": {
+      "contents": [
+        { "value": "```php\nstrpos(string $haystack, string $needle, int $offset = 0): int|false\n```\nFinds the numeric position of the first occurrence of `$needle` in `$haystack`. Returns `false` if not found. Use `!== false` for comparison." }
+      ]
+    },
+    "strrpos": {
+      "contents": [
+        { "value": "```php\nstrrpos(string $haystack, string $needle, int $offset = 0): int|false\n```\nFinds the numeric position of the last occurrence of `$needle` in `$haystack`. Returns `false` if not found." }
+      ]
+    },
+    "substr": {
+      "contents": [
+        { "value": "```php\nsubstr(string $string, int $offset, ?int $length = null): string\n```\nReturns the portion of `$string` specified by the `$offset` and `$length` parameters. Negative offset counts from the end of the string." }
+      ]
+    },
+    "str_replace": {
+      "contents": [
+        { "value": "```php\nstr_replace(\n    array|string $search,\n    array|string $replace,\n    string|array $subject,\n    int &$count = null\n): string|array\n```\nReplaces all occurrences of `$search` with `$replace` in `$subject`. If `$search` and `$replace` are arrays, a mapping is applied." }
+      ]
+    },
+    "str_contains": {
+      "contents": [
+        { "value": "```php\nstr_contains(string $haystack, string $needle): bool\n```\n(PHP 8.0+) Performs a case-sensitive check to determine if `$haystack` contains `$needle`. Returns `true` if found, `false` otherwise." }
+      ]
+    },
+    "str_starts_with": {
+      "contents": [
+        { "value": "```php\nstr_starts_with(string $haystack, string $needle): bool\n```\n(PHP 8.0+) Performs a case-sensitive check to determine if `$haystack` begins with `$needle`." }
+      ]
+    },
+    "str_ends_with": {
+      "contents": [
+        { "value": "```php\nstr_ends_with(string $haystack, string $needle): bool\n```\n(PHP 8.0+) Performs a case-sensitive check to determine if `$haystack` ends with `$needle`." }
+      ]
+    },
+    "strtolower": {
+      "contents": [
+        { "value": "```php\nstrtolower(string $string): string\n```\nReturns a string with all ASCII alphabetic characters converted to lowercase. For Unicode, use `mb_strtolower()`." }
+      ]
+    },
+    "strtoupper": {
+      "contents": [
+        { "value": "```php\nstrtoupper(string $string): string\n```\nReturns a string with all ASCII alphabetic characters converted to uppercase. For Unicode, use `mb_strtoupper()`." }
+      ]
+    },
+    "trim": {
+      "contents": [
+        { "value": "```php\ntrim(string $string, string $characters = \" \\n\\r\\t\\v\\0\"): string\n```\nStrips whitespace (or other characters) from the beginning and end of a string. Without the second parameter, trims common whitespace characters." }
+      ]
+    },
+    "ltrim": {
+      "contents": [
+        { "value": "```php\nltrim(string $string, string $characters = \" \\n\\r\\t\\v\\0\"): string\n```\nStrips whitespace (or other characters) from the beginning of a string." }
+      ]
+    },
+    "rtrim": {
+      "contents": [
+        { "value": "```php\nrtrim(string $string, string $characters = \" \\n\\r\\t\\v\\0\"): string\n```\nStrips whitespace (or other characters) from the end of a string. `chop()` is an alias of this function." }
+      ]
+    },
+    "explode": {
+      "contents": [
+        { "value": "```php\nexplode(string $separator, string $string, int $limit = PHP_INT_MAX): array\n```\nReturns an array of strings split by `$separator`. If `$limit` is set, the returned array will contain a maximum of `$limit` elements." }
+      ]
+    },
+    "implode": {
+      "contents": [
+        { "value": "```php\nimplode(string $separator, array $array): string\n```\nJoins array elements with the `$separator` string and returns the resulting string. `join()` is an alias." }
+      ]
+    },
+    "htmlspecialchars": {
+      "contents": [
+        { "value": "```php\nhtmlspecialchars(\n    string $string,\n    int $flags = ENT_QUOTES | ENT_SUBSTITUTE,\n    ?string $encoding = null,\n    bool $double_encode = true\n): string\n```\nConverts special characters (`&`, `\"`, `'`, `<`, `>`) to HTML entities. Essential for preventing XSS attacks when outputting user data." }
+      ]
+    },
+    "urlencode": {
+      "contents": [
+        { "value": "```php\nurlencode(string $string): string\n```\nReturns a string in which all non-alphanumeric characters except `-_.` have been replaced with a percent sign followed by two hex digits, and spaces are encoded as `+`." }
+      ]
+    },
+    "base64_encode": {
+      "contents": [
+        { "value": "```php\nbase64_encode(string $string): string\n```\nEncodes the given data with Base64. This encoding is designed to make binary data survive transport through non-binary-safe channels." }
+      ]
+    },
+    "base64_decode": {
+      "contents": [
+        { "value": "```php\nbase64_decode(string $string, bool $strict = false): string|false\n```\nDecodes a Base64-encoded string. If `$strict` is `true`, returns `false` if input contains characters outside the Base64 alphabet." }
+      ]
+    },
+    "md5": {
+      "contents": [
+        { "value": "```php\nmd5(string $string, bool $binary = false): string\n```\nCalculates the MD5 hash of a string. Returns a 32-character hexadecimal number. **Not suitable for cryptographic purposes** — use `password_hash()` for passwords." }
+      ]
+    },
+    "number_format": {
+      "contents": [
+        { "value": "```php\nnumber_format(\n    float $num,\n    int $decimals = 0,\n    ?string $decimal_separator = '.',\n    ?string $thousands_separator = ','\n): string\n```\nFormats a number with grouped thousands and optional decimal places." }
+      ]
+    },
+    "array_push": {
+      "contents": [
+        { "value": "```php\narray_push(array &$array, mixed ...$values): int\n```\nPushes one or more elements onto the end of an array. Returns the new number of elements. Equivalent to `$array[] = $value` for a single value." }
+      ]
+    },
+    "array_pop": {
+      "contents": [
+        { "value": "```php\narray_pop(array &$array): mixed\n```\nPops and returns the last element of the array, shortening it by one element. Returns `null` if the array is empty." }
+      ]
+    },
+    "array_shift": {
+      "contents": [
+        { "value": "```php\narray_shift(array &$array): mixed\n```\nShifts the first value of the array off and returns it, shortening the array by one element and re-indexing numeric keys." }
+      ]
+    },
+    "array_unshift": {
+      "contents": [
+        { "value": "```php\narray_unshift(array &$array, mixed ...$values): int\n```\nPrepends one or more elements to the beginning of an array. Returns the new number of elements. All numerical keys are re-indexed starting from zero." }
+      ]
+    },
+    "array_merge": {
+      "contents": [
+        { "value": "```php\narray_merge(array ...$arrays): array\n```\nMerges one or more arrays. Values with numeric keys are appended and re-indexed; values with string keys are overwritten by later arrays." }
+      ]
+    },
+    "array_map": {
+      "contents": [
+        { "value": "```php\narray_map(?callable $callback, array $array, array ...$arrays): array\n```\nApplies the `$callback` to the elements of the given arrays and returns a new array containing the results. If `$callback` is `null`, creates an array of arrays." }
+      ]
+    },
+    "array_filter": {
+      "contents": [
+        { "value": "```php\narray_filter(array $array, ?callable $callback = null, int $mode = 0): array\n```\nFilters elements of an array using a callback function. If no callback is supplied, all falsy entries are removed. Keys are preserved." }
+      ]
+    },
+    "array_reduce": {
+      "contents": [
+        { "value": "```php\narray_reduce(array $array, callable $callback, mixed $initial = null): mixed\n```\nIteratively reduces the array to a single value using a callback. The callback receives `($carry, $item)` where `$carry` is the return value of the previous iteration." }
+      ]
+    },
+    "array_keys": {
+      "contents": [
+        { "value": "```php\narray_keys(array $array, mixed $filter_value = null, bool $strict = false): array\n```\nReturns all the keys or a subset of the keys of an array. If `$filter_value` is specified, only keys containing that value are returned." }
+      ]
+    },
+    "array_values": {
+      "contents": [
+        { "value": "```php\narray_values(array $array): array\n```\nReturns all the values from the array and indexes the array numerically. Useful for re-indexing after `array_filter()`." }
+      ]
+    },
+    "array_unique": {
+      "contents": [
+        { "value": "```php\narray_unique(array $array, int $flags = SORT_STRING): array\n```\nRemoves duplicate values from an array. The first occurrence of each value is kept and keys are preserved." }
+      ]
+    },
+    "array_key_exists": {
+      "contents": [
+        { "value": "```php\narray_key_exists(string|int $key, array $array): bool\n```\nReturns `true` if the given key/index exists in the array. Unlike `isset()`, returns `true` even if the value is `null`." }
+      ]
+    },
+    "in_array": {
+      "contents": [
+        { "value": "```php\nin_array(mixed $needle, array $haystack, bool $strict = false): bool\n```\nSearches for `$needle` in `$haystack`. If `$strict` is `true`, uses identity comparison (`===`). Returns `true` if found." }
+      ]
+    },
+    "count": {
+      "contents": [
+        { "value": "```php\ncount(Countable|array $value, int $mode = COUNT_NORMAL): int\n```\nCounts all elements in an array or a `Countable` object. If `$mode` is `COUNT_RECURSIVE`, counts elements of multidimensional arrays recursively." }
+      ]
+    },
+    "sort": {
+      "contents": [
+        { "value": "```php\nsort(array &$array, int $flags = SORT_REGULAR): true\n```\nSorts an array in ascending order by value. Existing keys are discarded and the array is re-indexed. Modifies the array in place." }
+      ]
+    },
+    "usort": {
+      "contents": [
+        { "value": "```php\nusort(array &$array, callable $callback): true\n```\nSorts an array by values using a user-defined comparison function. The callback must return an integer less than, equal to, or greater than zero." }
+      ]
+    },
+    "array_search": {
+      "contents": [
+        { "value": "```php\narray_search(mixed $needle, array $haystack, bool $strict = false): int|string|false\n```\nSearches the array for `$needle` and returns the corresponding key if found, `false` otherwise. Use `$strict = true` for type-safe comparison." }
+      ]
+    },
+    "array_column": {
+      "contents": [
+        { "value": "```php\narray_column(array $array, int|string|null $column_key, int|string|null $index_key = null): array\n```\nReturns the values from a single column of the input array. Optionally, an `$index_key` may be provided to index the returned array by that column." }
+      ]
+    },
+    "array_chunk": {
+      "contents": [
+        { "value": "```php\narray_chunk(array $array, int $length, bool $preserve_keys = false): array\n```\nSplits an array into chunks of `$length` size. The last chunk may contain fewer elements." }
+      ]
+    },
+    "compact": {
+      "contents": [
+        { "value": "```php\ncompact(array|string $var_name, array|string ...$var_names): array\n```\nCreates an array containing variables and their values. The variable names are passed as strings." }
+      ]
+    },
+    "range": {
+      "contents": [
+        { "value": "```php\nrange(string|int|float $start, string|int|float $end, int|float $step = 1): array\n```\nCreates an array containing a range of elements. Works with integers, floats, and single characters." }
+      ]
+    },
+    "json_encode": {
+      "contents": [
+        { "value": "```php\njson_encode(mixed $value, int $flags = 0, int $depth = 512): string|false\n```\nReturns the JSON representation of a value. Common flags: `JSON_PRETTY_PRINT`, `JSON_UNESCAPED_UNICODE`, `JSON_THROW_ON_ERROR`." }
+      ]
+    },
+    "json_decode": {
+      "contents": [
+        { "value": "```php\njson_decode(\n    string $json,\n    ?bool $associative = null,\n    int $depth = 512,\n    int $flags = 0\n): mixed\n```\nDecodes a JSON string. When `$associative` is `true`, JSON objects are returned as associative arrays instead of `stdClass` objects." }
+      ]
+    },
+    "file_get_contents": {
+      "contents": [
+        { "value": "```php\nfile_get_contents(\n    string $filename,\n    bool $use_include_path = false,\n    ?resource $context = null,\n    int $offset = 0,\n    ?int $length = null\n): string|false\n```\nReads entire file into a string. Preferred way to read file contents. Also supports HTTP/HTTPS URLs when `allow_url_fopen` is enabled." }
+      ]
+    },
+    "file_put_contents": {
+      "contents": [
+        { "value": "```php\nfile_put_contents(\n    string $filename,\n    mixed $data,\n    int $flags = 0,\n    ?resource $context = null\n): int|false\n```\nWrites data to a file. Equivalent to calling `fopen()`, `fwrite()`, and `fclose()`. Use `FILE_APPEND` flag to append instead of overwrite." }
+      ]
+    },
+    "isset": {
+      "contents": [
+        { "value": "```php\nisset(mixed $var, mixed ...$vars): bool\n```\nDetermines if a variable is declared and is different than `null`. If multiple parameters are supplied, returns `true` only if all of them are set. Does not generate a warning if the variable doesn't exist." }
+      ]
+    },
+    "empty": {
+      "contents": [
+        { "value": "```php\nempty(mixed $var): bool\n```\nDetermines whether a variable is considered empty. The following are empty: `\"\"`, `0`, `0.0`, `\"0\"`, `null`, `false`, `[]`, and unset variables." }
+      ]
+    },
+    "header": {
+      "contents": [
+        { "value": "```php\nheader(string $header, bool $replace = true, int $response_code = 0): void\n```\nSends a raw HTTP header. Must be called before any actual output is sent. Use `$replace = false` to send multiple headers of the same type." }
+      ]
+    },
+    "die": {
+      "contents": [
+        { "value": "```php\ndie(string|int $message = \"\"): never\n```\nEquivalent to `exit()`. Outputs a message and terminates the current script. If `$message` is an integer, it will be used as the exit status." }
+      ]
+    },
+    "date": {
+      "contents": [
+        { "value": "```php\ndate(string $format, ?int $timestamp = null): string\n```\nReturns a string formatted according to the given format using the given timestamp or the current time if no timestamp is given. Common format chars: `Y` (year), `m` (month), `d` (day), `H` (hour), `i` (minutes), `s` (seconds)." }
+      ]
+    },
+    "strtotime": {
+      "contents": [
+        { "value": "```php\nstrtotime(string $datetime, ?int $baseTimestamp = null): int|false\n```\nParses an English textual datetime description into a Unix timestamp. Supports relative formats like `'+1 day'`, `'next Monday'`, `'last month'`." }
+      ]
+    }
+  }
+}