@redocly/openapi-language-server 0.0.3

package/lib/server/bundle.d.ts

@@ -0,0 +1,18 @@
+import { NormalizedProblem } from '@redocly/openapi-core';
+import type { TextDocument } from 'vscode-languageserver-textdocument';
+import type { NormalizedNodeType } from '@redocly/openapi-core/lib/types';
+export declare type DefinitionData = {
+    name: string;
+    uri: string;
+};
+export declare type BundleData = DefinitionData & {
+    definition: Record<string, any>;
+    rootType: NormalizedNodeType;
+    refTypes: [string, NormalizedNodeType][];
+    htmlTempalteStyles?: string | null;
+    errors?: NormalizedProblem[];
+};
+export declare function bundleOpenAPI(textDocument: TextDocument, errors: NormalizedProblem[]): Promise<void>;
+export declare function getBundle(path: string): any;
+export declare function getBundles(): BundleData[];
+export declare function getRefTypes(path: string): NormalizedNodeType | undefined | null;

package/lib/server/completion/yaml/KeyCompletion.d.ts

@@ -0,0 +1,17 @@
+import { CompletionItem, CompletionItemKind, InsertTextFormat, Command } from 'vscode-languageserver/browser';
+import type { CompletionItemOptions } from '../../types/completion';
+export interface KeyCompletionOptions extends CompletionItemOptions {
+    insertTextFormat?: InsertTextFormat;
+    data?: any;
+}
+export declare class KeyCompletion implements CompletionItem {
+    kind: CompletionItemKind;
+    label: string;
+    insertText: string;
+    filterText: string;
+    sortText?: string;
+    command?: Command;
+    insertTextFormat: InsertTextFormat;
+    data?: any;
+    constructor({ kind, label, insertText, insertTextFormat, filterText, sortText, data, }: KeyCompletionOptions);
+}

package/lib/server/completion/yaml/LocalFileCompletion.d.ts

@@ -0,0 +1,4 @@
+import { ValueCompletion, ValueCompletionOptions } from './ValueCompletion';
+export declare class LocalFileCompletion extends ValueCompletion {
+    constructor(completionOptions: ValueCompletionOptions);
+}

package/lib/server/completion/yaml/LocalFolderCompletion.d.ts

@@ -0,0 +1,6 @@
+import { Command } from 'vscode-languageserver/browser';
+import { ValueCompletion, ValueCompletionOptions } from './ValueCompletion';
+export declare class LocalFolderCompletion extends ValueCompletion {
+    command: Command;
+    constructor(completionOptions: ValueCompletionOptions);
+}

package/lib/server/completion/yaml/ValueCompletion.d.ts

@@ -0,0 +1,23 @@
+import { YAMLScalar } from '@redocly/yaml-language-server-parser';
+import { CompletionItem, CompletionItemKind, TextEdit, InsertReplaceEdit, Position, Command } from 'vscode-languageserver/browser';
+import type { CompletionItemOptions } from '../../types/completion';
+export interface ValueCompletionDataOptions {
+    position?: Position;
+    node?: YAMLScalar;
+    lineOffset?: number;
+}
+export interface ValueCompletionOptions extends CompletionItemOptions {
+    value?: string;
+    data: ValueCompletionDataOptions;
+}
+export declare class ValueCompletion implements CompletionItem {
+    kind: CompletionItemKind;
+    label: string;
+    insertText: string;
+    filterText: string;
+    sortText?: string;
+    command?: Command;
+    textEdit?: TextEdit | InsertReplaceEdit;
+    constructor({ kind, label, value, textEdit, filterText, sortText, data, }: ValueCompletionOptions);
+    getTextEdit(node: YAMLScalar, position: Position, lineOffset: number): TextEdit | InsertReplaceEdit;
+}

package/lib/server/completion/yaml/common.d.ts

@@ -0,0 +1,7 @@
+export declare const fieldNames: {
+    example: string;
+    default: string;
+    enum: string;
+    ref: string;
+};
+export declare const userEnumCompletionKeys: string[];

package/lib/server/completion/yaml/completion.d.ts

@@ -0,0 +1,9 @@
+import * as yamlAst from '@redocly/yaml-language-server-parser';
+import { CompletionItem, Position } from 'vscode-languageserver/browser';
+import { DocumentUri } from 'vscode-languageserver-textdocument';
+import { ValueCompletion } from './ValueCompletion';
+import { YamlCompletionContext } from './context';
+export declare function getCompletionKeys(completionContext: YamlCompletionContext): CompletionItem[];
+export declare function getCompletionValues(uri: DocumentUri, completionContext: YamlCompletionContext<yamlAst.YAMLScalar>): Promise<ValueCompletion[]>;
+export declare function getCompletion(uri: DocumentUri, position: Position): Promise<CompletionItem[]>;
+export declare function resolveCompletion(item: CompletionItem): CompletionItem;

package/lib/server/completion/yaml/context.d.ts

@@ -0,0 +1,25 @@
+import { DocumentUri, Position } from 'vscode-languageserver-textdocument';
+import { YAMLNode } from '@redocly/yaml-language-server-parser';
+import { URI } from 'vscode-uri';
+import { NodePath } from '../../types/context-core';
+import { ExtendedNormalizedNodeType } from '../../types/completion';
+export interface YamlCompletionContext<NodeType = YAMLNode> {
+    currentAst: YAMLNode;
+    node: NodeType;
+    nodePath: NodePath;
+    position: Position;
+    lineText: string;
+    lineOffset: number;
+    openApiType: ExtendedNormalizedNodeType | null;
+}
+export interface RefPathResolverContext {
+    docAbsolutePath: URI;
+    docAbsoluteDirPath: URI;
+    refPath: string;
+    refDirPath: URI;
+    refDirAbsolutePath: URI;
+    isAbsolutePath: boolean;
+    root: string;
+}
+export declare function createCompletionContext<NodeType = YAMLNode>(uri: DocumentUri, position: Position): Promise<YamlCompletionContext<NodeType>>;
+export declare function createRefPathResolverContext(uri: DocumentUri, refPath: string): Promise<RefPathResolverContext>;

package/lib/server/completion/yaml/insert-snippet-utils.d.ts

@@ -0,0 +1,15 @@
+import type { NormalizedNodeType } from '@redocly/openapi-core/lib/types';
+export declare type PartialNodeType = {
+    items?: NormalizedNodeType['items'];
+    required?: NormalizedNodeType['required'];
+};
+declare function getKeyValue(key: string, type?: PartialNodeType): string;
+declare function getBeforeKeyValue(key: string, value: string, beforeKey: string, type?: PartialNodeType): string;
+declare function getAfterKeyValue(key: string): "" | ": ";
+declare function getBeforeKey(lineText?: string): "" | " " | "\n  ";
+declare function getAfterValue(beforeKey: string, properties?: NormalizedNodeType['properties']): "" | "\n  " | "\n    ";
+declare function getInsertSnippet(key: string, data?: {
+    properties?: NormalizedNodeType['properties'];
+    lineText: string;
+} & PartialNodeType, addNewLine?: boolean): string;
+export { getInsertSnippet, getAfterKeyValue, getAfterValue, getKeyValue, getBeforeKey, getBeforeKeyValue, };

package/lib/server/completion/yaml/paths.d.ts

@@ -0,0 +1,26 @@
+import { DocumentUri } from 'vscode-languageserver-textdocument';
+import { YAMLScalar } from '@redocly/yaml-language-server-parser';
+import { SupportedLanguage } from '../../../config';
+import { LocalFolderCompletion } from './LocalFolderCompletion';
+import { LocalFileCompletion } from './LocalFileCompletion';
+import { YamlCompletionContext, RefPathResolverContext } from './context';
+export declare const LOCAL_FILES_SUPPORTED_SUGGESTIONS: SupportedLanguage[];
+export declare enum FsNodeType {
+    File = 0,
+    Folder = 1
+}
+export interface RefFileStat {
+    type: FsNodeType;
+    name: string;
+}
+export interface RefPathOption extends RefFileStat {
+    value: string;
+    matchBy: string;
+    sortBy: string;
+}
+export declare function getToTopOption(pathResolverContext: RefPathResolverContext): RefPathOption;
+export declare function getChildrenOfPath(files: string[], config: {
+    supportedFiles: SupportedLanguage[];
+}, pathResolverContext: RefPathResolverContext): Promise<RefFileStat[]>;
+export declare function getRefPathOptions(fileStats: RefFileStat[], pathResolverContext: RefPathResolverContext): RefPathOption[];
+export declare function getLocalFsRefs(uri: DocumentUri, completionContext: YamlCompletionContext<YAMLScalar>): Promise<(LocalFolderCompletion | LocalFileCompletion)[]>;

package/lib/server/context-core.d.ts

@@ -0,0 +1,20 @@
+import { OasVersion, OasMajorVersion } from '@redocly/openapi-core';
+import * as yamlAst from '@redocly/yaml-language-server-parser';
+import type { Position } from 'vscode-languageserver/browser';
+import type { NormalizedNodeType } from '@redocly/openapi-core/lib/types';
+import type { ContextData, ExistingValues } from './types/context-core';
+import type { OpenApiVersion, TextDocumentWithLineOffset, NodeWithPath, NodePath } from './types/context-core';
+export declare function getContextData(uri: string, position: Position): Promise<ContextData>;
+export declare function getAstNodeByPath(currentAst: yamlAst.YAMLNode | null, path: (number | string)[]): yamlAst.YAMLNode | null;
+export declare function getAstNodeByPosition(start: NodeWithPath, position: Position, document: TextDocumentWithLineOffset, isContextData?: boolean): NodeWithPath;
+export declare function getNodeLineIndent(node: yamlAst.YAMLNode | null | undefined, document: TextDocumentWithLineOffset): number;
+export declare function getTypesByNodePath(types: any, nodePath: NodePath): {
+    currentType: NormalizedNodeType | null;
+    parentType: NormalizedNodeType | null;
+    endPath: string | null;
+};
+export declare function getRootTypes(ast: yamlAst.YAMLNode, uri: string): NormalizedNodeType | null;
+export declare function getOASVersion(ast: yamlAst.YAMLNode): OpenApiVersion<OasVersion>;
+export declare function getOASMajorVersion(ast: yamlAst.YAMLNode): OpenApiVersion<OasMajorVersion>;
+export declare function getChildNodes(node?: yamlAst.YAMLNode | null): yamlAst.YAMLNode[];
+export declare function getExistingValues(node: yamlAst.YAMLSequence, values?: ExistingValues, indent?: number): ExistingValues;

package/lib/server/documents.d.ts

@@ -0,0 +1,16 @@
+import { DocumentUri } from 'vscode-languageserver/browser';
+import { TextDocument } from 'vscode-languageserver-textdocument';
+export declare type DocumentStats = {
+    dependencyPaths: Set<string>;
+    durationMS: number;
+};
+export declare type DependencyStats = {
+    documentPath: string;
+    durationMS: number;
+};
+export declare function updateDependencyMap(path: string, stats: DocumentStats): Map<string, DocumentStats>;
+export declare function getPathsByDependency(depPath: string): DependencyStats[];
+export declare function getDocumentLanguageId(uri: DocumentUri): string;
+export declare function getDocumentByURI(uri: DocumentUri): Promise<TextDocument>;
+export declare function isJsonFile(uri: DocumentUri): boolean;
+export declare function isYamlFile(uri: DocumentUri): boolean;

package/lib/server/external-resolver.d.ts

@@ -0,0 +1,5 @@
+import { BaseResolver, Source } from '@redocly/openapi-core';
+export declare class ExternalResolver extends BaseResolver {
+    resolveExternalRef(base: string, ref: string): string;
+    loadExternalRef(absoluteRef: string): Promise<Source>;
+}

package/lib/server/hints.d.ts

@@ -0,0 +1,7 @@
+import { CompletionItem } from 'vscode-languageserver/browser';
+import { ExtendedNormalizedNodeType } from './types/completion';
+export declare const START_SEQ_LABEL = "newItem";
+export declare const START_MAP_LABEL = "propertyName";
+export declare const ADD_NEW_LINE = "newLine";
+export declare function hasHints(type: ExtendedNormalizedNodeType): boolean;
+export declare function getAdditionalCompletionItem(name: string): CompletionItem[];

package/lib/server/openapi-config.d.ts

@@ -0,0 +1,7 @@
+import { Config as OpenAPIConfig } from '@redocly/openapi-core';
+export { CONFIG_FILE_NAMES } from '@redocly/openapi-core';
+export declare function isConfigFile(uri: string): boolean;
+export declare function getOpenAPIConfig({ cache }?: {
+    cache?: boolean;
+}): Promise<OpenAPIConfig>;
+export declare function updateOpenApiConfig(): Promise<OpenAPIConfig>;

package/lib/server/openapi-extensions.d.ts

@@ -0,0 +1,76 @@
+import { ExtendedNormalizedNodeType } from './types/completion';
+import { mapTypeToComponent } from '@redocly/openapi-core';
+declare const typeExtensions: {
+    Schema: {
+        name: string;
+        value: {
+            type: string;
+            name: string;
+        };
+    }[];
+    PathItem: {
+        name: string;
+        value: {
+            type: string;
+            name: string;
+        };
+    }[];
+    Parameter: {
+        name: string;
+        value: {
+            type: string;
+            name: string;
+        };
+    }[];
+    Response: {
+        name: string;
+        value: {
+            type: string;
+            name: string;
+        };
+    }[];
+    Example: {
+        name: string;
+        value: {
+            type: string;
+            name: string;
+        };
+    }[];
+    RequestBody: {
+        name: string;
+        value: {
+            type: string;
+            name: string;
+        };
+    }[];
+    Header: {
+        name: string;
+        value: {
+            type: string;
+            name: string;
+        };
+    }[];
+    SecuritySchema: {
+        name: string;
+        value: {
+            type: string;
+            name: string;
+        };
+    }[];
+    Link: {
+        name: string;
+        value: {
+            type: string;
+            name: string;
+        };
+    }[];
+    Callback: {
+        name: string;
+        value: {
+            type: string;
+            name: string;
+        };
+    }[];
+};
+declare function extendOASType(type: ExtendedNormalizedNodeType): ExtendedNormalizedNodeType;
+export { typeExtensions, extendOASType, mapTypeToComponent };

package/lib/server/path.d.ts

@@ -0,0 +1,8 @@
+import { DocumentUri } from 'vscode-languageserver/browser';
+import { URI } from 'vscode-uri';
+export declare function parseUri(path: string): URI;
+export declare function isHttpPath(path: string): boolean;
+export declare function uriBaseName(uri: DocumentUri): string;
+export declare function getFileExtension(uri: DocumentUri): string;
+export declare function noTrailingSlash(path: string): string;
+export declare function getClosestExistingDir(uri: URI, baseDir?: string): Promise<URI>;

package/lib/server/sort.d.ts

@@ -0,0 +1,43 @@
+export declare function getSortText(typeName: string | null, label?: string): string;
+export declare enum SortTypes {
+    FileCompletion = "FileCompletion",
+    FolderCompletion = "FolderCompletion",
+    LocalComponentCompletion = "LocalComponentCompletion",
+    NewLine = "newLine",
+    PropertyName = "propertyName",
+    NewItem = "newItem",
+    PathMap = "PathMap",
+    MediaTypeMap = "MediaTypeMap",
+    DefinitionRoot = "DefinitionRoot",
+    DefinitionRootOpenapi = "DefinitionRoot_openapi",
+    DefinitionRootInfo = "DefinitionRoot_info",
+    DefinitionRootJsonSchemaDialect = "DefinitionRoot_jsonSchemaDialect",
+    DefinitionRootServers = "DefinitionRoot_servers",
+    DefinitionRootPaths = "DefinitionRoot_paths",
+    DefinitionRootWebhooks = "DefinitionRoot_webhooks",
+    DefinitionRootComponents = "DefinitionRoot_components",
+    DefinitionRootSecurity = "DefinitionRoot_security",
+    DefinitionRootTags = "DefinitionRoot_tags",
+    DefinitionRootExternalDocs = "DefinitionRoot_externalDocs",
+    Info = "Info",
+    InfoTitle = "Info_title",
+    InfoSummary = "Info_summary",
+    InfoDescription = "Info_description",
+    InfoTermsOfService = "Info_termsOfService",
+    InfoContact = "Info_contact",
+    ContactName = "Contact_name",
+    ContactUrl = "Contact_url",
+    ContactEmail = "Contact_email",
+    InfoLicense = "Info_license",
+    LicenseName = "License_name",
+    LicenseIdentifier = "License_identifier",
+    LicenseUrl = "License_url",
+    InfoVersion = "Info_version",
+    jsonSchemaDialect = "jsonSchemaDialect",
+    ServerList = "Server_List",
+    ServerUrl = "Server_url",
+    ServerDescription = "Server_description",
+    ServerVariables = "Server_variables",
+    Default = "Default"
+}
+export declare const sortLabelObject: Record<SortTypes, string>;

package/lib/server/types/completion.d.ts

@@ -0,0 +1,16 @@
+import { NormalizedNodeType } from '@redocly/openapi-core/lib/types';
+import { CompletionItemKind, TextEdit, InsertReplaceEdit } from 'vscode-languageserver/browser';
+declare type ExtendedNormalizedNodeType = NormalizedNodeType & {
+    isExample?: true;
+    enum?: string[];
+    type?: string;
+};
+interface CompletionItemOptions {
+    label: string;
+    kind?: CompletionItemKind;
+    sortText?: string;
+    textEdit?: TextEdit | InsertReplaceEdit;
+    insertText?: string;
+    filterText?: string;
+}
+export type { ExtendedNormalizedNodeType, CompletionItemOptions };

package/lib/server/types/context-core.d.ts

@@ -0,0 +1,42 @@
+import yamlAst from '@redocly/yaml-language-server-parser';
+import type { TextDocument } from 'vscode-languageserver-textdocument';
+import type { NormalizedNodeType } from '@redocly/openapi-core/lib/types';
+export declare enum ContextErrorCodes {
+    FILE_TYPE_NOT_SUPPORTED = 0
+}
+export declare type ContextError = {
+    error: {
+        code: ContextErrorCodes;
+        message: string;
+    };
+};
+export declare type ExistingValues = {
+    [key: string]: {
+        value: string | null;
+        startOffset: number;
+        endOffset: number | null;
+        indent: number;
+        type?: 'scalar' | 'map' | 'sequence';
+        rawValue?: string;
+    };
+};
+export declare type ContextData = {
+    nodePath: (string | number)[];
+    endPath: string | null;
+    type: NormalizedNodeType | null;
+    existingValues: ExistingValues;
+    types: NormalizedNodeType | null;
+};
+declare type OpenApiVersion<T> = {
+    version: T;
+    isDefault: boolean;
+};
+declare type NodePath = (string | number)[];
+declare type NodeWithPath = {
+    node: yamlAst.YAMLNode | null;
+    nodePath: NodePath;
+};
+declare type TextDocumentWithLineOffset = TextDocument & {
+    _lineOffsets: number[];
+};
+export { OpenApiVersion, NodeWithPath, NodePath, TextDocumentWithLineOffset };

package/lib/server/utils.d.ts

@@ -0,0 +1,16 @@
+import { YAMLNode } from '@redocly/yaml-language-server-parser';
+import type { TextDocument } from 'vscode-languageserver-textdocument';
+declare type Func<T> = (textDocument: TextDocument) => T | Promise<T>;
+export declare function debounceDocument<T>(func: Func<T>, wait?: number, immediate?: boolean): Func<Promise<T>>;
+export declare function removeCirculars(object: any): any;
+export declare function isRefField(field: string): boolean;
+export declare function isString<T>(value: T): boolean;
+export declare function isFunction<T>(f: T): boolean;
+export declare function isPromise<T>(value: T): boolean;
+export declare function isYamlMap(node: YAMLNode | null): boolean;
+export declare function isYamlMapping(node: YAMLNode | null): boolean;
+export declare function isYamlSequence(node: YAMLNode | null): boolean;
+export declare function surroundByNodeQuotes(valueToSurround: string, options: Record<string, any> & {
+    singleQuoted?: boolean;
+}): string;
+export {};

package/lib/server/validation/index.d.ts

@@ -0,0 +1,7 @@
+import { NormalizedProblem } from '@redocly/openapi-core';
+import { PublishDiagnosticsParams } from 'vscode-languageserver/browser';
+import { TextDocument } from 'vscode-languageserver-textdocument';
+export declare const validateOpenAPI: (textDocument: TextDocument) => Promise<PublishDiagnosticsParams[]> | Promise<Promise<PublishDiagnosticsParams[]>>;
+export declare function revalidateAllDocuments(): (Promise<PublishDiagnosticsParams[]> | Promise<Promise<PublishDiagnosticsParams[]>>)[];
+export declare function handleUnexpectedError(fileURI: string, error: any, diagnosticsParams?: PublishDiagnosticsParams[]): PublishDiagnosticsParams[];
+export declare function getValidationErrorsForBundle(problems: NormalizedProblem[]): NormalizedProblem[];

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@redocly/openapi-language-server",
+  "version": "0.0.3",
+  "description": "Redocly OpenAPI language server",
+  "module": "lib/index.js",
+  "typings": "lib/index.d.ts",
+  "scripts": {
+    "build": "npm run clean && node esbuild.cjs",
+    "compile": "npm run clean && tsc -p tsconfig.json",
+    "build:types": "tsc --emitDeclarationOnly --declaration --project tsconfig.json",
+    "deploy": "npm publish",
+    "clean": "rm -rf lib",
+    "prettier-base": "prettier \"**/*.{json,js,jsx,ts,tsx,yml,yaml,html,md}\"",
+    "prettier": "npm run prettier-base -- --write",
+    "prettier:check": "npm run prettier-base -- --check",
+    "ts:check": "tsc --noEmit --skipLibCheck",
+    "lint": "eslint . --ext .jsx,.ts,.tsx --cache",
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "postbuild": "npm run build:types"
+  },
+  "author": "Redocly LLC <team@redocly.com>",
+  "license": "SEE LICENSE IN LICENSE",
+  "peerDependencies": {
+    "@redocly/openapi-core": "^1.0.0-beta.108"
+  },
+  "devDependencies": {
+    "@typescript-eslint/eslint-plugin": "^5.33.1",
+    "@typescript-eslint/parser": "^5.33.1",
+    "esbuild": "^0.15.0",
+    "eslint": "^8.21.0",
+    "path-browserify": "^1.0.1",
+    "prettier": "2.7.1",
+    "typescript": "^4.7.4"
+  },
+  "dependencies": {
+    "@redocly/yaml-language-server-parser": "^0.3.0",
+    "vscode-languageserver": "^8.0.2",
+    "vscode-languageserver-textdocument": "^1.0.5",
+    "vscode-uri": "^3.0.2"
+  }
+}