VSCode JSON Language Server

https://github.com/sublimelsp/lsp-json
Admin
VSCode JSON Language Server provides language-specific features for editing, validating, and...
Tokens:22,895
Snippets:332
Trust Score:9.8
License:MIT
Update:1 month ago
Show doc for...
Tokens:
Raw
### Example of ContributionsSchema usage

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/types.md

Demonstrates how to structure the contributions dictionary with settings.

```python
contributions: ContributionsSchema = {
    "settings": [
        {
            "file_patterns": ["/MyPackage.sublime-settings"],
            "schema": {...}
        }
    ]
}
```

--------------------------------

### Schema association update and path resolution examples

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/api-reference/LspJSONPlugin.md

Examples illustrating how schema associations are updated and how relative paths are resolved.

```python
# When bundled schemas are loaded or workspace settings change
# Plugin combines:
# 1. Built-in schemas from schema_store
# 2. User schemas from LSP-json.sublime-settings userSchemas setting
# 3. Resolves relative paths (e.g., "./my-schema.json") to absolute file URIs
# 4. Sends the full list to the language server via json/schemaAssociations notification
```

```python
# If a user schema has uri: "./schemas/my-schema.json"
# and workspace folder is "/home/user/project"
# Plugin converts it to: file:///home/user/project/schemas/my-schema.json
```

--------------------------------

### Install JSON Language Server

Source: https://github.com/sublimelsp/lsp-json/blob/master/language-server/README.md

Install the vscode-json-languageserver npm module globally.

```bash
npm install -g vscode-json-languageserver
```

--------------------------------

### Example of ContributionSettingsSchema with patterns

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/types.md

Shows a schema contribution that applies to specific file patterns.

```python
schema_with_patterns: ContributionSettingsSchema = {
    "file_patterns": ["/MyPackage.sublime-settings"],
    "schema": {
        "type": "object",
        "properties": {"enabled": {"type": "boolean"}}
    }
}
```

--------------------------------

### Syntax discovery example

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/api-reference/SchemaStore.md

Shows the mapping of discovered syntax definitions to generated settings file patterns.

```python
# Available syntaxes discovered:
# - Python.sublime-syntax
# - JSON.sublime-syntax
# - Markdown.sublime-syntax

# Generated patterns:
# ["/Python.sublime-settings", "/JSON.sublime-settings", "/Markdown.sublime-settings"]

# Each pattern registered with syntax.sublime-settings schema
```

--------------------------------

### Sort JSON document example

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/api-reference/LspJSONPlugin.md

Describes the execution flow when the json.sort command is invoked.

```python
# User invokes "LSP-json: Sort Document" from command palette
# Plugin receives the json.sort command from the server
# Executes lsp_json_sort_document in the active view
# The sort is performed via the language server's json/sort request
```

--------------------------------

### Example SublimePackageSchema Usage

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/types.md

Shows the structure of a package schema including contributions and settings.

```python
package_schema: SublimePackageSchema = {
    "contributions": {
        "settings": [
            {
                "file_patterns": ["/MyPackage.sublime-settings"],
                "schema": {
                    "type": "object",
                    "properties": {
                        "debug_mode": {"type": "boolean"}
                    }
                }
            }
        ]
    }
}
```

--------------------------------

### Define File Patterns

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/api-reference/QuickStart.md

Syntax examples for matching files using exact matches, wildcards, and exclusions.

```python
# Exact match
"package.json"  # Matches exactly "package.json"

# Single segment wildcard
"*.json"        # Matches "config.json", "package.json" (but not "dir/config.json")

# Multi-segment wildcard
"**/*.json"     # Matches any .json file in any depth

# Exclusion (must be last match to exclude)
["*.json", "!.cache/*.json"]  # Matches .json files except in .cache folder
```

--------------------------------

### Example Initialization Options

Source: https://github.com/sublimelsp/lsp-json/blob/master/language-server/README.md

This JSON object demonstrates the structure of initialization options that can be sent to the language server. It includes settings for HTTP proxy, JSON formatting, and schema configuration.

```json
{
    "http": {
        "proxy": "",
        "proxyStrictSSL": true
    },
    "json": {
        "format": {
            "enable": true
        },
        "schemas": [
            {
                "fileMatch": [
                    "foo.json",
                    "*.superfoo.json"
                ],
                "url": "http://www.schemastore.org/foo",
                "schema": {
                    "type": "array"
                }
            }
        ]
    }
}
```

--------------------------------

### Send Standard LSP Requests

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/api-reference/QuickStart.md

Examples of standard LSP requests for formatting and completion.

```python
# textDocument/formatting - Format document
Request("textDocument/formatting", {
    "textDocument": {"uri": "..."},
    "options": {"tabSize": 2, "insertSpaces": True}
})

# textDocument/rangeFormatting - Format range
Request("textDocument/rangeFormatting", {
    "textDocument": {"uri": "..."},
    "range": {"start": {"line": 0, "character": 0}, "end": {"line": 10, "character": 0}},
    "options": {"tabSize": 2, "insertSpaces": True}
})

# textDocument/completion - Get completions
Request("textDocument/completion", {
    "textDocument": {"uri": "..."},
    "position": {"line": 5, "character": 10}
})
```

--------------------------------

### Project settings schema generation example

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/api-reference/SchemaStore.md

Illustrates the transformation of an input schema into a wrapped schema compatible with .sublime-project files.

```python
# Input schema (from global preferences):
{
    "type": "object",
    "properties": { "my_setting": { ... } }
}

# Generated schema for .sublime-project:
{
    "$schema": "http://json-schema.org/draft-07/schema#",
    "$id": "sublime://auto-generated/sublime-project/0",
    "allowComments": True,
    "allowTrailingCommas": True,
    "type": "object",
    "properties": {
        "settings": {
            "type": "object",
            "properties": { "my_setting": { ... } }
        }
    }
}
# Now user can access my_setting in .sublime-project files
```

--------------------------------

### Schema URI handling example

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/api-reference/LspJSONPlugin.md

Describes the behavior when a json-schema:// URI is encountered.

```python
# If a json-schema:// URI is encountered, logs:
# LSP-json: Unhandled URI: json-schema://...
# Returns None to indicate no sheet was created
```

--------------------------------

### Start JSON Language Server with Different Channels

Source: https://github.com/sublimelsp/lsp-json/blob/master/language-server/README.md

Launch the JSON language server using the command line, specifying the communication channel.

```bash
vscode-json-languageserver --node-ipc
```

```bash
vscode-json-languageserver --stdio
```

```bash
vscode-json-languageserver --socket=<port>
```

--------------------------------

### Pattern Compilation Examples

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/api-reference/LspJSONPlugin.md

Illustrates how various glob-like patterns are transformed into compiled regular expressions.

```python
# Input: ".eslintrc.json"
# Output: re.compile(r'\.eslintrc\.json$')
# Matches: "file:///project/.eslintrc.json" ✓

# Input: "**/*.json"
# Output: re.compile(r'.*/.*\.json$')
# Matches: "file:///project/nested/dir/config.json" ✓

# Input: "buffer://*"
# Output: re.compile(r'buffer://.*$')
# Matches: "buffer://untitled" ✓
```

--------------------------------

### Configure server_path

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/configuration.md

Set the path for the JSON language server binary. Use 'auto' for managed installation or provide an absolute path for a custom binary.

```json
{
    "server_path": "auto"
}
```

```json
{
    "server_path": "/usr/local/bin/vscode-json-languageserver"
}
```

--------------------------------

### Parse bundled schema example

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/api-reference/SchemaStore.md

Demonstrates how to use _parse_schema to load different types of JSON resources safely.

```python
# Parsing a list of schema entries:
resource = ResourcePath("Packages/lsp-json/lsp-json-schemas.json")
schemas = store._parse_schema(resource, 'list')
# Returns: list[SchemaEntry] if valid, None if parsing fails

# Parsing a package schema object:
resource = ResourcePath("Packages/MyPackage/sublime-package.json")
package_schema = store._parse_schema(resource, 'dict')
# Returns: SublimePackageSchema if valid, None if parsing fails
```

--------------------------------

### json/schemaContent Notification Example

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/endpoints.md

Example payload for notifying the server that a specific schema's content has changed.

```json
{
    "jsonrpc": "2.0",
    "method": "json/schemaContent",
    "params": "sublime://settings/LSP-json"
}
```

--------------------------------

### Example Schema Definitions

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/types.md

Demonstrates various ways to define a JSON Schema using the Schema type alias.

```python
# Minimal schema
schema: Schema = {"type": "object"}

# With properties
schema: Schema = {
    "type": "object",
    "properties": {
        "name": {"type": "string"},
        "version": {"type": "string"}
    }
}

# With references
schema: Schema = {
    "type": "object",
    "properties": {
        "settings": {"$ref": "#/definitions/Settings"}
    },
    "definitions": {
        "Settings": {"type": "object"}
    }
}
```

--------------------------------

### vscode/content Request and Response

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/endpoints.md

Example of a vscode/content request to retrieve schema content and the corresponding response.

```json
{
    "jsonrpc": "2.0",
    "method": "vscode/content",
    "params": "sublime://settings/LSP-json",
    "id": 2
}
```

```json
{
    "jsonrpc": "2.0",
    "id": 2,
    "result": "{\"$id\":\"sublime://settings/LSP-json\",\"type\":\"object\",\"properties\":{...}}"
}
```

--------------------------------

### Initialize JsonSortDocumentParams

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/types.md

Example usage of the JsonSortDocumentParams dictionary structure.

```python
params: JsonSortDocumentParams = {
    "uri": "file:///home/user/package.json",
    "options": {
        "tabSize": 4,
        "insertSpaces": True,
        "trimTrailingWhitespace": True
    }
}
```

--------------------------------

### json/schemaAssociations Notification Example

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/endpoints.md

Example payload for informing the server about JSON schema associations.

```json
{
    "jsonrpc": "2.0",
    "method": "json/schemaAssociations",
    "params": [
        {
            "uri": "https://json.schemastore.org/package.json",
            "fileMatch": ["package.json"]
        },
        {
            "uri": "sublime://settings/LSP-json",
            "fileMatch": ["/LSP-json.sublime-settings"]
        }
    ]
}
```

--------------------------------

### Retrieve internal schema example

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/api-reference/LspJSONPlugin.md

Demonstrates how the plugin handles a request for an internal schema URI.

```python
# Language server requests a schema via vscode/content
# URI: sublime://settings/LSP-json
# Plugin returns the schema definition from the schema store

uri = 'sublime://settings/LSP-json'
schema_content = plugin.handle_vscode_content((uri,))
# schema_content resolves to the JSON schema string
```

--------------------------------

### Package Schema Discovery Configuration

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/api-reference/SchemaStore.md

Example of a sublime-package.json file structure containing schema contributions.

```json
# A package's sublime-package.json:
{
    "contributions": {
        "settings": [
            {
                "file_patterns": ["/MyPackage.sublime-settings"],
                "schema": {
                    "type": "object",
                    "properties": { ... }
                }
            }
        ]
    }
}
# Schema is registered and cached under sublime://settings/0 (or existing $id)
```

--------------------------------

### Example of pattern-less ContributionSettingsSchema

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/types.md

Shows a schema contribution without file patterns, intended for use via $ref references.

```python
referenceable_schema: ContributionSettingsSchema = {
    "schema": {
        "$id": "sublime://settings/foo/base",
        "definitions": {
            "MyType": {"type": "string"}
        }
    }
}
```

--------------------------------

### Implement LspJSONPlugin with StoreListener

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/api-reference/StoreListener.md

Example of a plugin class implementing StoreListener to handle schema updates and notify the language server.

```python
@final
class LspJSONPlugin(LspPlugin, StoreListener):
    schema_store = SchemaStore()

    def on_initialized_async(self) -> None:
        self.schema_store.add_listener(self)
        self.schema_store.initialize()

    @override
    def on_store_changed_async(self, schemas: list[SchemaEntry]) -> None:
        if session := self.weaksession():
            all_schemas: list[SchemaEntry] = schemas + deepcopy(session.config.settings.get('userSchemas') or [])
            if folders := session.get_workspace_folders():
                for schema in all_schemas:
                    if schema['uri'].startswith(('.', '/')):
                        absolute_path = Path(folders[0].path, schema['uri'])
                        schema['uri'] = filename_to_uri(str(absolute_path))
            session.send_notification(Notification('json/schemaAssociations', [all_schemas]))
```

--------------------------------

### Unknown Schema URI Error Output

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/errors.md

Example of the console output when a schema URI cannot be resolved by the schema store.

```text
lsp-json: Unknown schema URI "custom://invalid/schema"
```

--------------------------------

### Bundled Schema JSON Structure

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/api-reference/SchemaStore.md

Example of the expected JSON structure for bundled schema definitions.

```json
# lsp-json-schemas.json structure:
[
    {
        "fileMatch": ["package.json"],
        "uri": "https://json.schemastore.org/package.json"
    },
    {
        "fileMatch": [".eslintrc.json"],
        "uri": "https://json.schemastore.org/eslintrc.json"
    }
]
# All entries are loaded and registered
```

--------------------------------

### Configure JSON validation settings

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/configuration.md

Example configuration for LSP-json settings within the Sublime Text settings file.

```json
{
    "settings": {
        "json.validate.enable": true,
        "json.validate.comments": "warning",
        "json.validate.trailingCommas": "error",
        "json.validate.schemaValidation": "error",
        "json.validate.schemaRequest": "warning"
    }
}
```

--------------------------------

### Send LSP-JSON Request Types

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/api-reference/QuickStart.md

Examples of sending specific JSON-related requests to the language server.

```python
# json/sort - Sort JSON keys
Request("json/sort", JsonSortDocumentParams)

# vscode/content - Get schema content
Request("vscode/content", "sublime://settings/LSP-json")

# json/validate - Force validation
Request("json/validate", {"uri": "file:///path/to/file.json"})
```

--------------------------------

### json/sort Request and Response

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/endpoints.md

Example of a json/sort request to alphabetize keys and the corresponding response containing text edits.

```json
{
    "jsonrpc": "2.0",
    "method": "json/sort",
    "params": {
        "uri": "file:///home/user/project/package.json",
        "options": {
            "tabSize": 4,
            "insertSpaces": true
        }
    },
    "id": 1
}
```

```json
{
    "jsonrpc": "2.0",
    "id": 1,
    "result": [
        {
            "range": {
                "start": {"line": 0, "character": 0},
                "end": {"line": 50, "character": 0}
            },
            "newText": "{ \"a\": 1, \"b\": 2, \"c\": 3 }"
        }
    ]
}
```

--------------------------------

### Send LSP-JSON Notification Types

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/api-reference/QuickStart.md

Examples of sending notifications to update schema associations or content.

```python
# json/schemaAssociations - Update schema associations
Notification("json/schemaAssociations", [SchemaEntry(...)])

# json/schemaContent - Notify schema changed
Notification("json/schemaContent", "sublime://settings/LSP-json")
```

--------------------------------

### Custom JSONC Patterns Configuration

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/configuration.md

Example of overriding the default patterns to include specific files like tsconfig.json or custom file extensions.

```json
{
    "jsonc.patterns": [
        ".babelrc",
        ".eslintrc.json",
        "/tsconfig.json",       // Treat tsconfig.json as JSONC
        "/**/*.comments.json"   // All *.comments.json files
    ]
}
```

--------------------------------

### Schema Parsing Error Output

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/errors.md

Example of the console output when a schema file contains invalid JSON syntax.

```text
lsp-json: Failed parsing schema "Packages/MyPackage/sublime-package.json"
```

--------------------------------

### Execute Full Reload Cycle

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/api-reference/SchemaStore.md

Demonstrates initializing the store, adding a listener, and triggering a full schema discovery cycle.

```python
store = SchemaStore()
store.add_listener(plugin)
store.reload_schemas()
# Discovers all schemas and notifies plugin of the changes
```

--------------------------------

### Initialize SchemaEntry instances

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/types.md

Demonstrates creating SchemaEntry objects with and without inline schema definitions.

```python
schema_entry: SchemaEntry = {
    "uri": "https://json.schemastore.org/package.json",
    "fileMatch": ["package.json"]
}

# With inline schema:
schema_entry_inline: SchemaEntry = {
    "uri": "sublime://settings/mypackage",
    "fileMatch": ["/MyPackage.sublime-settings"],
    "schema": {
        "type": "object",
        "properties": {
            "enabled": {"type": "boolean"}
        }
    }
}
```

--------------------------------

### Enable Logging

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/api-reference/QuickStart.md

Configure LSP settings to increase verbosity for debugging purposes.

```json
# In LSP settings
{
    "log_debug": true,
    "log_stderr": true,
    "log_server": true
}
```

--------------------------------

### Configure server command

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/configuration.md

Define the command used to launch the language server process.

```json
{
    "command": ["${node_bin}", "${server_path}", "--stdio"]
}
```

--------------------------------

### Implement run Method

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/api-reference/LspJsonAutoComplete.md

The run method implementation for the command.

```python
@override
def run(self, _: sublime.Edit) -> None:
```

--------------------------------

### Load syntax schemas

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/api-reference/SchemaStore.md

Defines the method signature for discovering syntax highlighting definitions and creating associated settings schemas.

```python
def _load_syntax_schemas(self, global_preferences_schemas: list[Schema]) -> None:
```

--------------------------------

### Map source files to documentation

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/INDEX.md

Lists the relationship between project source files and their generated documentation pages.

```text
plugin.py                         → [api-reference/LspJSONPlugin.md](api-reference/LspJSONPlugin.md)
schema_store.py                   → [api-reference/SchemaStore.md](api-reference/SchemaStore.md), [types.md](types.md)
commands.py                       → [api-reference/LspJsonSortDocument.md](api-reference/LspJsonSortDocument.md)
autocomplete-command.py           → [api-reference/LspJsonAutoComplete.md](api-reference/LspJsonAutoComplete.md)
LSP-json.sublime-settings         → [configuration.md](configuration.md)
sublime-package.json              → [configuration.md](configuration.md)
language-server/out/jsonServer.js → [endpoints.md](endpoints.md)
```

--------------------------------

### Registering a StoreListener

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/api-reference/StoreListener.md

Implement the StoreListener interface by overriding on_store_changed_async and register it with the SchemaStore instance.

```python
from schema_store import SchemaStore, StoreListener, SchemaEntry

class MyListener(StoreListener):
    def on_store_changed_async(self, schemas: list[SchemaEntry]) -> None:
        # Handle schema changes
        pass

# Create store and listener
store = SchemaStore()
listener = MyListener()

# Register listener
store.add_listener(listener)

# Initialize to load schemas and trigger first notification
store.initialize()
```

--------------------------------

### Implement a basic schema listener

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/api-reference/StoreListener.md

A simple implementation that prints the total count and URIs of updated schemas.

```python
class MySchemaListener(StoreListener):
    def on_store_changed_async(self, schemas: list[SchemaEntry]) -> None:
        print(f"Schemas updated: {len(schemas)} total")
        for schema in schemas:
            print(f"  - {schema.get('uri', 'unknown')}")
```

--------------------------------

### Implement SafeListener for Schema Updates

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/api-reference/StoreListener.md

Demonstrates defensive programming practices when implementing on_store_changed_async, including error handling and avoiding input mutation.

```python
class SafeListener(StoreListener):
    def on_store_changed_async(self, schemas: list[SchemaEntry]) -> None:
        try:
            # Filter to the schemas we care about
            my_schemas = [
                s for s in schemas
                if 'sublime' in s.get('uri', '')
            ]
            
            # Process or store them
            self._cached_schemas = my_schemas
            
            # Log for debugging
            print(f"Cached {len(my_schemas)} Sublime schemas")
            
            # Don't modify the input list
            # my_schemas = sorted(my_schemas)  # Wrong! Creates a new list
            
        except Exception as e:
            # Handle errors gracefully
            print(f"Error processing schemas: {e}")
            # Listener continues to work; error doesn't break the store
```

--------------------------------

### Configure Handled Schema Protocols

Source: https://github.com/sublimelsp/lsp-json/blob/master/language-server/README.md

Set the `handledSchemaProtocols` initialization option to specify which URL protocols the language server should handle directly. If not set, the server defaults to handling 'http', 'https', and 'file' URLs.

```typescript
let clientOptions: LanguageClientOptions = {
  initializationOptions: {
   handledSchemaProtocols: ['file'] // language server should only try to load file URLs
  }
        ...
}
```

--------------------------------

### Use Pattern-Specific Schemas

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/api-reference/QuickStart.md

Prefer specific file matches over broad patterns to improve performance.

```python
# Good: Specific pattern
{"fileMatch": ["package.json"], "uri": "..."}

# Avoid: Broad pattern on every request
{"fileMatch": ["**/*.json"], "uri": "..."}
```

--------------------------------

### Enable JSONC for Custom File

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/README.md

Register specific file patterns to be treated as JSON with comments (JSONC) in the settings.

```json
{
    "jsonc.patterns": [
        ".eslintrc",
        "my-custom-config.json"
    ]
}
```

--------------------------------

### Generate project settings schemas

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/api-reference/SchemaStore.md

Defines the method signature for creating wrapper schemas for .sublime-project files.

```python
def _generate_project_settings_schemas(self, global_preferences_schemas: list[Schema]) -> None:
```

--------------------------------

### Add a New Command

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/MODULE_ORGANIZATION.md

Create a new command by extending LspTextCommand and implementing the run method.

```python
class MyCommand(LspTextCommand):
    def run(self, edit):
        session = self.session_by_name(self.session_name)
        # Implement command
```

--------------------------------

### Implement and Test a Mock StoreListener

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/api-reference/StoreListener.md

Defines a custom listener to capture schema notifications and demonstrates its usage within a test case.

```python
from typing import List

class TestListener(StoreListener):
    def __init__(self):
        self.notifications: List[list[SchemaEntry]] = []
    
    def on_store_changed_async(self, schemas: list[SchemaEntry]) -> None:
        self.notifications.append(schemas)

# Usage in tests
def test_schema_notifications():
    store = SchemaStore()
    listener = TestListener()
    
    store.add_listener(listener)
    store.reload_schemas()
    
    assert len(listener.notifications) == 1
    assert len(listener.notifications[0]) > 0
```

--------------------------------

### Define plugin_loaded function

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/api-reference/LspJSONPlugin.md

Defines the entry point for registering the plugin with the LSP framework upon loading.

```python
def plugin_loaded() -> None:
```

--------------------------------

### Reload All Schemas

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/api-reference/QuickStart.md

Trigger a full discovery process to load bundled schemas, scan packages, and notify listeners.

```python
# Trigger full schema discovery from all sources
store.reload_schemas()

# This:
# 1. Loads bundled schemas
# 2. Scans packages for sublime-package.json
# 3. Discovers all syntax definitions
# 4. Generates .sublime-project wrapper schemas
# 5. Notifies all listeners
```

--------------------------------

### Enable Debug Logging in LSP-json

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/errors.md

Add these settings to LSP.sublime-settings to enable detailed server and client communication logs in the LSP panel.

```json
{
    "log_debug": true,
    "log_stderr": true,
    "log_server": true
}
```

--------------------------------

### Define a StoreListener class

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/api-reference/StoreListener.md

The base class definition for creating custom schema store listeners.

```python
from abc import ABC
from abc import abstractmethod

class StoreListener(ABC):

    @abstractmethod
    def on_store_changed_async(self, schemas: list[SchemaEntry]) -> None:
        pass
```

--------------------------------

### Add a New Listener

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/MODULE_ORGANIZATION.md

Implement a listener by subclassing StoreListener and registering it with the SchemaStore.

```python
class MyListener(StoreListener):
    def on_store_changed_async(self, schemas: list[SchemaEntry]) -> None:
        # React to schema changes
        pass

store = SchemaStore()
store.add_listener(MyListener())
```

--------------------------------

### Define Python method signatures

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/INDEX.md

Standard format for documenting Python method signatures including parameter and return types.

```python
def method(param: Type) -> ReturnType:
```

--------------------------------

### Asynchronous Trigger Logic

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/api-reference/LspJsonAutoComplete.md

Demonstration of why a delay is required for accurate LSP suggestions.

```python
# Without set_timeout delay:
view.run_command("insert_snippet", {"contents": '"$0"'})
view.run_command("auto_complete")
# LSP may not have processed " yet

# With set_timeout (one tick later):
sublime.set_timeout(lambda: view.run_command("auto_complete"))
# LSP has updated, suggestions are accurate
```

--------------------------------

### Configure Performance Limits

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/configuration.md

Adjust resource limits for symbols, folding ranges, and color decorators to handle large JSON files.

```json
{
    "settings": {
        "json.resultLimit": 10000,
        "json.jsonFoldingLimit": 10000,
        "json.jsoncFoldingLimit": 10000,
        "json.jsonColorDecoratorLimit": 2000,
        "json.jsoncColorDecoratorLimit": 2000
    }
}
```

--------------------------------

### Inspect Schema Store

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/api-reference/QuickStart.md

Access and iterate through the internal schema store for diagnostic purposes.

```python
store = SchemaStore()
store.initialize()

print(f"Total schemas: {len(store._schema_list)}")
for schema in store._schema_list:
    print(f"  {schema['uri']}: {schema.get('fileMatch', [])}")

print(f"Cached URIs: {len(store._schema_uri_to_content)}")
```

--------------------------------

### Configure Local User-Defined Schemas

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/configuration.md

Use this configuration to map file patterns to local schema files, supporting absolute paths or paths relative to the workspace.

```json
{
    "settings": {
        "userSchemas": [
            {
                "fileMatch": ["some-file.json"],
                "uri": "file:///Users/me/some-schema.json"
            },
            {
                "fileMatch": ["/.config/myapp/**/*.json"],
                "uri": "./schemas/myapp-config.json"  // Relative to workspace
            }
        ]
    }
}
```

--------------------------------

### Implement StoreListener Interface

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/api-reference/SchemaStore.md

Defines a listener class to handle schema store updates. Implementations should avoid long-running operations as the method is called synchronously.

```python
class MySchemaListener(StoreListener):
    def on_store_changed_async(self, schemas: list[SchemaEntry]) -> None:
        print(f"Store now has {len(schemas)} schemas")
        for schema in schemas:
            print(f"  - {schema.get('uri', 'unknown')}")
            
store = SchemaStore()
store.add_listener(MySchemaListener())
store.reload_schemas()  # Calls the listener
```

--------------------------------

### Custom Schema Configuration

Source: https://github.com/sublimelsp/lsp-json/blob/master/README.md

Configure custom JSON schemas by specifying file patterns and the schema URI in the 'userSchemas' setting.

```json
{
  "fileMatch": [
    "/my-file.json"
  ],
  "uri": "./my-file-schema.json"
}
```

--------------------------------

### Send schema updates to a language server

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/api-reference/StoreListener.md

A real-world implementation that combines store schemas with user schemas and notifies the language server.

```python
class LspJSONPlugin(StoreListener):
    def on_store_changed_async(self, schemas: list[SchemaEntry]) -> None:
        if session := self.weaksession():
            # Combine store schemas with user schemas
            all_schemas = schemas + self.user_schemas
            
            # Send to language server
            session.send_notification(
                Notification('json/schemaAssociations', [all_schemas])
            )
```

--------------------------------

### Handle Async Timing Issues

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/api-reference/QuickStart.md

Defer commands that rely on text synchronization to the next tick to avoid race conditions.

```python
# Wrong: Completion runs before text is synced
view.run_command("insert_snippet", {"contents": '"$0"'})
view.run_command("auto_complete")

# Right: Defer completion to next tick
view.run_command("insert_snippet", {"contents": '"$0"'})
sublime.set_timeout(lambda: view.run_command("auto_complete"))
```

--------------------------------

### Configure LSP-json in .sublime-project

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/configuration.md

Use this structure within your project file to define custom settings, patterns, and schemas for the LSP-json server.

```json
{
    "folders": [
        {"path": "."}
    ],
    "settings": {
        "LSP": {
            "LSP-json": {
                "settings": {
                    "json.resultLimit": 2000,
                    "jsonc.patterns": [
                        "/custom-config.json"
                    ],
                    "userSchemas": [
                        {
                            "fileMatch": ["/*.schema.json"],
                            "uri": "./schemas/project-schema.json"
                        }
                    ]
                }
            }
        }
    }
}
```

--------------------------------

### Resource Path Abstraction

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/README.md

Accessing package resources using the ResourcePath API for safe path handling.

```python
resource = ResourcePath('Packages/lsp-json/schemas/sublime-build.json')
content = resource.read_text()
```

--------------------------------

### Pattern Escaping Logic

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/README.md

Demonstration of how file patterns are converted into regex strings to prevent injection.

```python
# Input: ".config.json"
# Regex: r'\.config\.json$'

# Input: "*.json"
# Regex: r'.*\.json$'
```

--------------------------------

### Load Bundled Schemas

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/api-reference/SchemaStore.md

Defines the method signature for loading schemas from internal package files.

```python
def _load_bundled_schemas(self) -> None:
```

--------------------------------

### vscode/content

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/api-reference/QuickStart.md

Retrieves the content of a schema from the specified URI.

```APIDOC
## vscode/content

### Description
Fetches schema content for a given URI.

### Request
Request("vscode/content", "sublime://settings/LSP-json")
```

--------------------------------

### _register_schemas(schemas: list[SchemaEntry])

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/api-reference/SchemaStore.md

Registers a list of schema entries in the store's internal registry, ensuring fileMatch patterns are properly URL-encoded.

```APIDOC
## _register_schemas(schemas: list[SchemaEntry])

### Description
Registers a list of schema entries in the store's internal lists. Adds each schema entry to the internal registry and URL-encodes fileMatch patterns.

### Parameters
- **schemas** (list[SchemaEntry]) - Required - List of schema entries to register

### Example
```python
schemas = [
    {
        "fileMatch": ["/package.json", "!.git/package.json"],
        "uri": "https://json.schemastore.org/package.json"
    }
]
store._register_schemas(schemas)
```
```

--------------------------------

### handle_vscode_content

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/api-reference/LspJSONPlugin.md

Handles requests from the language server for schema content identified by custom URIs, such as sublime:// URLs.

```APIDOC
## handle_vscode_content

### Description
Handles requests from the language server for schema content identified by custom URIs. This is a custom LSP extension that allows the plugin to provide schema content for URIs that the server cannot load directly.

### Parameters
- **params** (tuple[str]) - Required - A tuple containing a single string: the URI of the schema to retrieve.

### Return
- **Promise[str | None]** - A promise resolving to the schema content as a JSON string, or None if the schema cannot be found.
```

--------------------------------

### Access Plugin Settings

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/api-reference/QuickStart.md

Retrieve plugin-specific configuration values from the active session settings.

```python
# From plugin
session = self.weaksession()
if session:
    settings = session.config.settings
    
    # Get plugin-specific settings
    json_validate = settings.get('json.validate.enable', True)
    jsonc_patterns = settings.get('jsonc.patterns', [])
    user_schemas = settings.get('userSchemas', [])
```

--------------------------------

### Graceful Degradation

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/api-reference/QuickStart.md

Use try-except blocks to prevent schema parsing failures from crashing the plugin.

```python
# Try to load schema, continue if it fails
def safe_parse_schema(resource):
    try:
        return sublime.decode_value(resource.read_text())
    except ValueError:
        print(f"Failed to parse {resource}")
        return None  # Schema skipped, others continue
```

--------------------------------

### textDocument/formatting

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/api-reference/QuickStart.md

Formats the entire JSON document based on provided options.

```APIDOC
## textDocument/formatting

### Description
Formats the document content.

### Request
Request("textDocument/formatting", {
    "textDocument": {"uri": "..."},
    "options": {"tabSize": 2, "insertSpaces": True}
})
```

--------------------------------

### Import LSP Plugin Dependencies

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/MODULE_ORGANIZATION.md

Required imports from the LSP plugin framework.

```python
# From LSP plugin
from LSP.plugin import (
    ClientNotification, LspPlugin, LspTextCommand,
    command_handler, request_handler, uri_handler,
    filename_to_uri, uri_from_view, apply_text_edits,
    Error, Request, Notification, Promise,
    OnPreStartContext
)

# From LSP protocol
from LSP.protocol import DocumentUri, FormattingOptions, TextEdit

# From lsp_utils
from lsp_utils import NodeManager

# From sublime_lib
from sublime_lib import ResourcePath

# From sublime
import sublime
import sublime_plugin
```

--------------------------------

### Check LSP Session Availability

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/errors.md

Pattern for verifying the existence of an LSP session before executing commands to prevent silent failures.

```python
if session is None:
    return
```

--------------------------------

### Load Package Schemas

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/api-reference/SchemaStore.md

Defines the method signature for discovering schemas within Sublime packages.

```python
def _load_package_schemas(self) -> list[Schema]:
```

--------------------------------

### Define TypedDict structures

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/INDEX.md

Standard format for documenting TypedDict definitions in Python.

```python
class MyType(TypedDict):
    field: FieldType
```

--------------------------------

### Define LspJsonAutoCompleteCommand Class

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/api-reference/LspJsonAutoComplete.md

The class definition for the command, extending sublime_plugin.TextCommand.

```python
@final
class LspJsonAutoCompleteCommand(sublime_plugin.TextCommand):
```

--------------------------------

### Define ContributionSettingsSchema

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/types.md

Represents a single settings schema contribution within a package.

```python
class ContributionSettingsSchema(TypedDict):
    file_patterns: NotRequired[list[str]]
    schema: Schema
```

--------------------------------

### Define _create_pattern_regexp method

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/api-reference/LspJSONPlugin.md

Defines the method signature for converting glob-like patterns into regex for URI matching.

```python
def _create_pattern_regexp(self, pattern: str) -> re.Pattern[str]:
```

--------------------------------

### Configure Remote User-Defined Schemas

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/configuration.md

Use this configuration to map file patterns to remote JSON schema URLs.

```json
{
    "settings": {
        "userSchemas": [
            {
                "fileMatch": ["/tasks.yaml"],
                "uri": "http://json.schemastore.org/ansible-stable-2.9"
            },
            {
                "fileMatch": ["**/config.json"],
                "uri": "https://example.com/schemas/config.json"
            }
        ]
    }
}
```

--------------------------------

### Add a Custom Schema

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/README.md

Define custom schemas in LSP-json.sublime-settings by adding entries to the userSchemas array.

```json
{
    "userSchemas": [
        {
            "fileMatch": ["my-config.json"],
            "uri": "https://example.com/schemas/config.json"
        }
    ]
}
```

--------------------------------

### Define the on_store_changed_async method

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/api-reference/StoreListener.md

The abstract method signature required for all StoreListener implementations.

```python
@abstractmethod
def on_store_changed_async(self, schemas: list[SchemaEntry]) -> None:
```

--------------------------------

### Find Schemas by Pattern

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/api-reference/QuickStart.md

Filter a list of schema entries based on matching file patterns.

```python
# Find all schemas matching a file pattern
def find_schemas_by_pattern(schemas: list[SchemaEntry], pattern: str) -> list[SchemaEntry]:
    return [
        s for s in schemas
        if any(pattern in fm for fm in s.get('fileMatch', []))
    ]

# Usage
json_schemas = find_schemas_by_pattern(schemas, ".json")
```

--------------------------------

### Demonstrating Weak Reference Behavior

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/api-reference/StoreListener.md

Listeners are stored in a WeakSet, so they are garbage-collected if no other references exist.

```python
store = SchemaStore()

listener = MyListener()
store.add_listener(listener)

# Listener still exists, will be notified
store.reload_schemas()

# Delete local reference
del listener

# On next reload, listener won't be notified (already garbage-collected)
store.reload_schemas()
```

--------------------------------

### Configure Sort Document Key Binding

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/README.md

Define a custom key binding to trigger the JSON sorting command.

```json
{
    "keys": ["ctrl+k", "ctrl+s"],
    "command": "lsp_json_sort_document"
}
```

--------------------------------

### Define Language Server Dependencies

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/MODULE_ORGANIZATION.md

NPM package dependencies for the language server.

```json
{
    "vscode-json-languageservice": "^6.0.0-next.2",
    "vscode-languageserver": "^10.0.0-next.18",
    "jsonc-parser": "^4.0.0-next.1",
    "request-light": "^0.8.0",
    "vscode-uri": "^3.1.0",
    "@vscode/l10n": "^0.0.18"
}
```

--------------------------------

### vscode/content

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/endpoints.md

Requests schema content for a custom URI, allowing the client to provide schema data the server cannot load directly.

```APIDOC
## vscode/content

### Description
Requests schema content for a custom URI. This is a client-side request handler for the server to retrieve schema content that the server cannot load directly.

### Parameters
- **uri** (string) - Required - The schema URI to resolve

### Request Example
{
    "jsonrpc": "2.0",
    "method": "vscode/content",
    "params": "sublime://settings/LSP-json",
    "id": 2
}

### Response
- **Success** (string) - The schema content as a JSON string
- **Failure** (null) - Schema not found

### Response Example
{
    "jsonrpc": "2.0",
    "id": 2,
    "result": "{\"$id\":\"sublime://settings/LSP-json\",\"type\":\"object\",\"properties\":{...}}"
}
```

--------------------------------

### Import Transitive Dependencies

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/MODULE_ORGANIZATION.md

Standard library and typing imports required for the project.

```python
# Python standard library
from pathlib import Path
from weakref import WeakSet
from typing import Any, Dict, overload, TYPE_CHECKING, TypedDict, TypeAlias
from typing_extensions import override, NotRequired
import re
import contextlib
```

--------------------------------

### Default JSONC Patterns Configuration

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/configuration.md

The default configuration for identifying JSONC files, including common configuration files and in-memory buffers.

```json
{
    "jsonc.patterns": [
        "buffer://*",           // In-memory buffers
        ".babelrc",             // Babel configuration
        ".eslintrc",            // ESLint configuration
        ".eslintrc.json",
        ".hintrc",              // HTMLHint configuration
        ".jsfmtrc",             // JSCS configuration
        ".jshintrc",            // JSHint configuration
        ".jsonc",               // Explicit JSONC files
        ".swcrc",               // SWC compiler configuration
        "/.ember-cli",          // Ember CLI configuration
        "/.vscode/*.json",      // VS Code settings and extensions
        "/babel.config.json",
        "/bun.lock"             // Bun package lock file
    ]
}
```

--------------------------------

### Configure JSON Formatting

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/configuration.md

Enable or disable JSON formatting support within the plugin settings.

```json
{
    "settings": {
        "json.format.enable": true
    }
}
```

--------------------------------

### Define TextEdit Interface

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/endpoints.md

Defines the structure for text replacement operations returned by the server.

```typescript
interface TextEdit {
    range: Range;              // The range of text to replace
    newText: string;           // The new text to insert
}
```

--------------------------------

### plugin_loaded

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/api-reference/LspJSONPlugin.md

Lifecycle function called by Sublime Text when the plugin is first loaded to register the LspJSONPlugin.

```APIDOC
## plugin_loaded

### Description
Called by Sublime when the plugin is first loaded. Registers the LspJSONPlugin with the LSP framework.

### Signature
`def plugin_loaded() -> None:`
```

--------------------------------

### Reload SchemaStore

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/api-reference/SchemaStore.md

Defines the method signature for clearing and reloading all schema sources.

```python
def reload_schemas(self) -> None:
```

--------------------------------

### Define Key Binding for Auto-Complete

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/api-reference/LspJsonAutoComplete.md

The JSON key binding configuration to trigger the command in Sublime Text.

```json
{
    "keys": ["\""],
    "command": "lsp_json_auto_complete",
    "context": [
        {"key": "setting.auto_match_enabled", "operator": "equal", "operand": true},
        {"key": "selection_empty", "operator": "equal", "operand": true, "match_all": true},
        {"key": "following_text", "operator": "regex_contains", "operand": "^(?:	| |\\)|]|\}|>|$)", "match_all": true},
        {"key": "preceding_text", "operator": "not_regex_contains", "operand": "[\"a-zA-Z0-9_]$", "match_all": true},
        {"key": "eol_selector", "operator": "not_equal", "operand": "string.quoted.double - punctuation.definition.string.end", "match_all": true},
        {"key": "selector", "operator": "equal", "operand": "source.json", "match_all": true}
    ]
}
```

--------------------------------

### Check Session Availability

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/api-reference/QuickStart.md

Verify that a session is active before attempting to send notifications.

```python
if (session := self.weaksession()) is None:
    return  # No active session

# Safe to use session
session.send_notification(...)
```

--------------------------------

### LSP Protocol Endpoints

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/endpoints.md

A collection of standard LSP methods implemented by the server for JSON and JSONC document support.

```APIDOC
## LSP Methods

### Text Synchronization
- `textDocument/didOpen`: Notifies the server that a document has been opened.
- `textDocument/didChange`: Notifies the server that document content has changed.
- `textDocument/didClose`: Notifies the server that a document has been closed.

### Diagnostics
- `textDocument/publishDiagnostics`: Server-pushed notification containing validation errors and warnings.

### Code Completion
- `textDocument/completion`: Requests completion suggestions for properties and values based on schema.

### Hover Information
- `textDocument/hover`: Requests hover descriptions derived from the schema.

### Symbol Navigation
- `textDocument/documentSymbol`: Requests a document outline for properties.
- `textDocument/semanticTokens/full`: Requests semantic highlighting information.

### Formatting
- `textDocument/formatting`: Requests formatting for the entire document.
- `textDocument/rangeFormatting`: Requests formatting for a specific selected range.

### Code Actions
- `textDocument/codeAction`: Requests available code actions, such as sorting JSON.

### Color Support
- `textDocument/documentColor`: Requests locations for color decorators.
- `textDocument/colorPresentation`: Requests formatting for color values.

### Folding
- `textDocument/foldingRange`: Requests folding ranges for the document.

### Go to Definition
- `textDocument/definition`: Requests navigation to schema $ref definitions.
```

--------------------------------

### Define on_store_changed_async listener

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/api-reference/LspJSONPlugin.md

Defines the callback triggered when the schema store changes.

```python
@override
def on_store_changed_async(self, schemas: list[SchemaEntry]) -> None:
```

--------------------------------

### Configure Supported URI Schemes

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/configuration.md

Defines the URI schemes supported by the LSP-json server, such as local files, buffers, and remote schemas.

```json
{
    "schemes": [
        "file",         // Regular files
        "buffer",       // In-memory buffers
        "res",          // Sublime resource files
        "json-schema"   // Remote schema URIs
    ]
}
```

--------------------------------

### Encode File Paths

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/api-reference/QuickStart.md

Use the provided utility to convert local file paths into valid URI strings.

```python
# Wrong: Raw file path
file_uri = "/home/user/file.json"

# Right: Encoded URI
from LSP.plugin import filename_to_uri
file_uri = filename_to_uri("/home/user/file.json")
# Result: "file:///home/user/file.json"
```

--------------------------------

### json/sort

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/api-reference/QuickStart.md

Requests the server to sort the keys in a JSON document.

```APIDOC
## json/sort

### Description
Sorts the keys within a JSON document.

### Request
Request("json/sort", JsonSortDocumentParams)
```

--------------------------------

### Internal Schema Notification Logic

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/api-reference/SchemaStore.md

Illustrates the internal notification flow triggered automatically during a reload.

```python
# Called automatically during reload_schemas():
# For each listener in self._listeners:
#   listener.on_store_changed_async(self._schema_list)
```

--------------------------------

### Disable PackageDev Conflicts

Source: https://github.com/sublimelsp/lsp-json/blob/master/README.md

To use LSP-json's strict schemas with PackageDev, disable auto-complete and tooltips in PackageDev settings.

```json
{
  "settings.auto_complete": false,
  "settings.tooltip": false
}
```

--------------------------------

### Define vscode/content request handler

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/api-reference/LspJSONPlugin.md

Defines the handler for custom vscode/content requests used to retrieve schema content.

```python
@request_handler('vscode/content')
def handle_vscode_content(self, params: tuple[str]) -> Promise[str | None]:
```

--------------------------------

### Filter schemas by file match

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/api-reference/StoreListener.md

An implementation that filters the schema list to process only those matching Sublime settings files.

```python
class SublimeSettingsListener(StoreListener):
    def on_store_changed_async(self, schemas: list[SchemaEntry]) -> None:
        # Only process schemas for Sublime settings files
        for schema in schemas:
            file_matches = schema.get('fileMatch', [])
            if any('.sublime-settings' in pattern for pattern in file_matches):
                print(f"Found Sublime settings schema: {schema['uri']}")
```

--------------------------------

### textDocument/completion

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/api-reference/QuickStart.md

Requests code completion suggestions at a specific position.

```APIDOC
## textDocument/completion

### Description
Retrieves completion items for the specified document position.

### Request
Request("textDocument/completion", {
    "textDocument": {"uri": "..."},
    "position": {"line": 5, "character": 10}
})
```

--------------------------------

### Define ClientNotification

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/types.md

Represents a notification sent from the client to the server, imported from LSP.plugin.

```python
class ClientNotification(TypedDict, total=False):
    method: str           # Notification method (e.g., 'textDocument/didOpen')
    params: dict[str, Any]  # Parameters for the notification
```

--------------------------------

### Register Schema Entries

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/api-reference/SchemaStore.md

Registers a list of schema entries into the internal store registry. File match patterns are automatically URL-encoded for URI compatibility.

```python
schemas = [
    {
        "fileMatch": ["/package.json", "!.git/package.json"],
        "uri": "https://json.schemastore.org/package.json"
    }
]
store._register_schemas(schemas)
# fileMatch patterns are URL-encoded for consistent matching
# Schema is added to the store's registry
```

--------------------------------

### Define SublimePackageSchema Class

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/types.md

The root structure for a sublime-package.json file.

```python
class SublimePackageSchema(TypedDict):
    contributions: ContributionsSchema
```

--------------------------------

### Define json-schema URI handler

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/api-reference/LspJSONPlugin.md

Defines the handler for json-schema:// URIs.

```python
@uri_handler('json-schema')
def handle_json_schema_uri(self, uri: DocumentUri, _flags: sublime.NewFileFlags) -> Promise[sublime.Sheet | None]:
```

--------------------------------

### Update JSONC Patterns

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/api-reference/QuickStart.md

Recompile pattern strings into regex objects when configuration settings change.

```python
# Recompile patterns when settings change
def update_patterns(pattern_strs: list[str]) -> list[re.Pattern[str]]:
    return [_create_pattern_regexp(p) for p in pattern_strs]

# Usage
new_patterns = update_patterns([".babelrc", "*.custom.json"])
```

--------------------------------

### Print to Console

Source: https://github.com/sublimelsp/lsp-json/blob/master/_autodocs/api-reference/QuickStart.md

Output debug messages to the Sublime Text console.

```python
# View → Show Console

print("Debug message here")
```
Tokens:
Raw