@uni-helper/volar-service-uni-pages/dist/index.mjs

Volar plugin for uni-pages route custom block in Vue SFC

import * as json from 'vscode-json-languageservice';
import pagesJsonSchema from '@uni-helper/pages-json-schema/schema.json';
import { getLanguageService } from 'yaml-language-server';

pagesJsonSchema.$ref = "#/definitions/PageMetaDatum";
pagesJsonSchema.definitions.PageMetaDatum.required = [];
const schema = pagesJsonSchema;

function createJsonLs(_context) {
  const jsonLs = json.getLanguageService({});
  jsonLs.configure({
    allowComments: true,
    schemas: [
      {
        fileMatch: ["*.customBlock_route_*.json*"],
        uri: "foo://route-custom-block.schema.json",
        schema
      }
    ]
  });
  return jsonLs;
}

function noop() {
}
function createYamlLs(context) {
  const ls = getLanguageService({
    schemaRequestService: async (uri) => await context.env.fs?.readFile(uri) ?? "",
    telemetry: {
      send: noop,
      sendError: noop,
      sendTrack: noop
    },
    // @ts-expect-error https://github.com/redhat-developer/yaml-language-server/pull/910
    clientCapabilities: context?.env?.clientCapabilities,
    workspaceContext: {
      resolveRelativePath(relativePath, resource) {
        return String(new URL(relativePath, resource));
      }
    }
  });
  ls.configure({
    completion: true,
    customTags: [],
    format: true,
    hover: true,
    isKubernetes: false,
    validate: true,
    yamlVersion: "1.2",
    schemas: [
      {
        fileMatch: ["*.customBlock_route_*.yaml*"],
        uri: "foo://route-custom-block.schema.yaml",
        name: "volar-service-uni-pages",
        description: "Volar plugin for uni-pages route custom block in Vue SFC",
        schema
      }
    ]
  });
  return ls;
}

function isYaml(document) {
  return document.languageId === "yaml";
}

const index = () => (context) => {
  const triggerCharacters = ['"', ":"];
  if (!context)
    return { triggerCharacters };
  const jsonDocuments = /* @__PURE__ */ new WeakMap();
  const jsonLs = createJsonLs();
  const yamlLs = createYamlLs(context);
  return {
    provide: {
      "json/jsonDocument": getJsonDocument,
      "json/languageService": () => jsonLs,
      "yaml/languageService": () => yamlLs
    },
    triggerCharacters,
    provideCodeActions(document, range, context2) {
      if (isYaml(document)) {
        return yamlLs.getCodeAction(document, {
          context: context2,
          range,
          textDocument: document
        });
      }
    },
    provideCodeLenses(document) {
      if (isYaml(document))
        return yamlLs.getCodeLens(document);
    },
    provideCompletionItems(document, position) {
      if (isYaml(document))
        return yamlLs.doComplete(document, position, false);
      return worker(document, async (jsonDocument) => {
        return await jsonLs.doComplete(document, position, jsonDocument);
      });
    },
    resolveCompletionItem(item) {
      return jsonLs.doResolve(item);
    },
    provideDefinition(document, position) {
      if (isYaml(document))
        return yamlLs.doDefinition(document, { position, textDocument: document });
      return worker(document, async (jsonDocument) => {
        return await jsonLs.findDefinition(document, position, jsonDocument);
      });
    },
    provideDiagnostics(document) {
      if (isYaml(document))
        return yamlLs.doValidation(document, false);
      return worker(document, async (jsonDocument) => {
        const documentLanguageSettings = void 0;
        return await jsonLs.doValidation(
          document,
          jsonDocument,
          documentLanguageSettings,
          void 0
          // TODO
        );
      });
    },
    provideHover(document, position) {
      if (isYaml(document))
        return yamlLs.doHover(document, position);
      return worker(document, async (jsonDocument) => {
        return await jsonLs.doHover(document, position, jsonDocument);
      });
    },
    provideDocumentLinks(document) {
      if (isYaml(document))
        return yamlLs.findLinks(document);
      return worker(document, async (jsonDocument) => {
        return await jsonLs.findLinks(document, jsonDocument);
      });
    },
    provideDocumentSymbols(document) {
      if (isYaml(document))
        return yamlLs.findDocumentSymbols2(document, {});
      return worker(document, async (jsonDocument) => {
        return await jsonLs.findDocumentSymbols2(document, jsonDocument);
      });
    },
    provideDocumentColors(document) {
      return worker(document, async (jsonDocument) => {
        return await jsonLs.findDocumentColors(document, jsonDocument);
      });
    },
    provideColorPresentations(document, color, range) {
      return worker(document, async (jsonDocument) => {
        return await jsonLs.getColorPresentations(document, jsonDocument, color, range);
      });
    },
    provideFoldingRanges(document) {
      if (isYaml(document))
        return yamlLs.getFoldingRanges(document, {});
      return worker(document, async () => {
        return await jsonLs.getFoldingRanges(document);
      });
    },
    provideSelectionRanges(document, positions) {
      if (isYaml(document))
        return yamlLs.getSelectionRanges(document, positions);
      return worker(document, async (jsonDocument) => {
        return await jsonLs.getSelectionRanges(document, positions, jsonDocument);
      });
    },
    resolveCodeLens(codeLens) {
      return yamlLs.resolveCodeLens(codeLens);
    },
    provideDocumentFormattingEdits(document, range, options) {
      return worker(document, async () => {
        const options_2 = await context.env.getConfiguration?.("json.format");
        if (!(options_2?.enable ?? true))
          return;
        return jsonLs.format(document, range, {
          ...options_2,
          ...options
        });
      });
    }
  };
  function worker(document, callback) {
    const jsonDocument = getJsonDocument(document);
    if (!jsonDocument)
      return;
    return callback(jsonDocument);
  }
  function getJsonDocument(textDocument) {
    if (textDocument.languageId !== "json" && textDocument.languageId !== "jsonc")
      return;
    const cache = jsonDocuments.get(textDocument);
    if (cache) {
      const [cacheVersion, cacheDoc] = cache;
      if (cacheVersion === textDocument.version)
        return cacheDoc;
    }
    const doc = jsonLs.parseJSONDocument(textDocument);
    jsonDocuments.set(textDocument, [textDocument.version, doc]);
    return doc;
  }
};

export { index as default };