feat: init

node_modules/vite-plugin-checker/dist/checkers/vls/diagnostics.d.ts

@@ -0,0 +1,53 @@
+import * as vscode_languageserver from 'vscode-languageserver';
+import { Duplex } from 'node:stream';
+import { VLS } from 'vls';
+import { DiagnosticSeverity, Logger } from 'vscode-languageserver/node.js';
+import { URI } from 'vscode-uri';
+import { NormalizedDiagnostic } from '../../logger.js';
+import { DeepPartial } from '../../types.js';
+import { VlsOptions } from './initParams.js';
+import '@babel/code-frame';
+import 'eslint';
+import 'stylelint';
+import 'typescript';
+import 'vscode-languageclient/node';
+import 'node:worker_threads';
+import 'vite';
+import 'vscode-languageserver/node';
+
+type LogLevel = (typeof logLevels)[number];
+declare const logLevels: readonly ["ERROR", "WARN", "INFO", "HINT"];
+declare const logLevel2Severity: {
+    ERROR: 1;
+    WARN: 2;
+    INFO: 3;
+    HINT: 4;
+};
+interface DiagnosticOptions {
+    watch: boolean;
+    verbose: boolean;
+    config: DeepPartial<VlsOptions> | null;
+    onDispatchDiagnostics?: (normalized: NormalizedDiagnostic[]) => void;
+    onDispatchDiagnosticsSummary?: (errorCount: number, warningCount: number) => void;
+}
+declare function diagnostics(workspace: string | null, logLevel: LogLevel, options?: DiagnosticOptions): Promise<void>;
+declare class NullLogger implements Logger {
+    error(_message: string): void;
+    warn(_message: string): void;
+    info(_message: string): void;
+    log(_message: string): void;
+}
+declare class TestStream extends Duplex {
+    _write(chunk: string, _encoding: string, done: () => void): void;
+    _read(_size: number): void;
+}
+declare function prepareClientConnection(workspaceUri: URI, severity: DiagnosticSeverity, options: DiagnosticOptions): Promise<{
+    clientConnection: vscode_languageserver.ProtocolConnection;
+    serverConnection: vscode_languageserver.Connection;
+    vls: VLS;
+    up: TestStream;
+    down: TestStream;
+    logger: NullLogger;
+}>;
+
+export { type DiagnosticOptions, TestStream, diagnostics, logLevel2Severity, logLevels, prepareClientConnection };

node_modules/vite-plugin-checker/dist/checkers/vls/diagnostics.js

@@ -0,0 +1,330 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { Duplex } from "node:stream";
+import chokidar from "chokidar";
+import colors from "picocolors";
+import { globSync } from "tinyglobby";
+import { VLS } from "vls";
+import {
+  createConnection,
+  createProtocolConnection,
+  DiagnosticSeverity,
+  DidChangeTextDocumentNotification,
+  DidChangeWatchedFilesNotification,
+  DidOpenTextDocumentNotification,
+  InitializeRequest,
+  StreamMessageReader,
+  StreamMessageWriter
+} from "vscode-languageserver/node.js";
+import { URI } from "vscode-uri";
+import { FileDiagnosticManager } from "../../FileDiagnosticManager.js";
+import {
+  diagnosticToTerminalLog,
+  normalizeLspDiagnostic,
+  normalizePublishDiagnosticParams
+} from "../../logger.js";
+import { getInitParams } from "./initParams.js";
+var DOC_VERSION = /* @__PURE__ */ ((DOC_VERSION2) => {
+  DOC_VERSION2[DOC_VERSION2["init"] = -1] = "init";
+  return DOC_VERSION2;
+})(DOC_VERSION || {});
+const logLevels = ["ERROR", "WARN", "INFO", "HINT"];
+let disposeSuppressConsole;
+let initialVueFilesCount = 0;
+let initialVueFilesTick = 0;
+const fileDiagnosticManager = new FileDiagnosticManager();
+const logLevel2Severity = {
+  ERROR: DiagnosticSeverity.Error,
+  WARN: DiagnosticSeverity.Warning,
+  INFO: DiagnosticSeverity.Information,
+  HINT: DiagnosticSeverity.Hint
+};
+async function diagnostics(workspace, logLevel, options = { watch: false, verbose: false, config: null }) {
+  var _a;
+  if (options.verbose) {
+    console.log("====================================");
+    console.log("Getting Vetur diagnostics");
+  }
+  let workspaceUri;
+  if (workspace) {
+    const absPath = path.resolve(process.cwd(), workspace);
+    console.log(`Loading Vetur in workspace path: ${colors.green(absPath)}`);
+    workspaceUri = URI.file(absPath);
+  } else {
+    console.log(
+      `Loading Vetur in current directory: ${colors.green(process.cwd())}`
+    );
+    workspaceUri = URI.file(process.cwd());
+  }
+  const result = await getDiagnostics(
+    workspaceUri,
+    logLevel2Severity[logLevel],
+    options
+  );
+  if (options.verbose) {
+    console.log("====================================");
+  }
+  if (!options.watch && typeof result === "object" && result !== null) {
+    const { initialErrorCount, initialWarningCount } = result;
+    (_a = options == null ? void 0 : options.onDispatchDiagnosticsSummary) == null ? void 0 : _a.call(
+      options,
+      initialErrorCount,
+      initialWarningCount
+    );
+    process.exit(initialErrorCount > 0 ? 1 : 0);
+  }
+}
+class NullLogger {
+  error(_message) {
+  }
+  warn(_message) {
+  }
+  info(_message) {
+  }
+  log(_message) {
+  }
+}
+class TestStream extends Duplex {
+  _write(chunk, _encoding, done) {
+    this.emit("data", chunk);
+    done();
+  }
+  _read(_size) {
+  }
+}
+function suppressConsole() {
+  let disposed = false;
+  const rawConsoleLog = console.log;
+  console.log = () => {
+  };
+  return () => {
+    if (disposed) return;
+    disposed = true;
+    console.log = rawConsoleLog;
+  };
+}
+async function prepareClientConnection(workspaceUri, severity, options) {
+  const up = new TestStream();
+  const down = new TestStream();
+  const logger = new NullLogger();
+  const clientConnection = createProtocolConnection(
+    new StreamMessageReader(down),
+    new StreamMessageWriter(up),
+    logger
+  );
+  const serverConnection = createConnection(
+    new StreamMessageReader(up),
+    new StreamMessageWriter(down)
+  );
+  serverConnection.sendDiagnostics = async (publishDiagnostics) => {
+    var _a, _b;
+    disposeSuppressConsole == null ? void 0 : disposeSuppressConsole();
+    if (publishDiagnostics.version === -1 /* init */) {
+      return;
+    }
+    const absFilePath = URI.parse(publishDiagnostics.uri).fsPath;
+    publishDiagnostics.diagnostics = filterDiagnostics(
+      publishDiagnostics.diagnostics,
+      severity
+    );
+    const nextDiagnosticInFile = await normalizePublishDiagnosticParams(publishDiagnostics);
+    fileDiagnosticManager.updateByFileId(absFilePath, nextDiagnosticInFile);
+    const normalized = fileDiagnosticManager.getDiagnostics();
+    const errorCount = normalized.filter(
+      (d) => d.level === DiagnosticSeverity.Error
+    ).length;
+    const warningCount = normalized.filter(
+      (d) => d.level === DiagnosticSeverity.Warning
+    ).length;
+    initialVueFilesTick++;
+    if (initialVueFilesTick >= initialVueFilesCount) {
+      (_a = options.onDispatchDiagnostics) == null ? void 0 : _a.call(options, normalized);
+      (_b = options.onDispatchDiagnosticsSummary) == null ? void 0 : _b.call(options, errorCount, warningCount);
+    }
+  };
+  const vls = new VLS(serverConnection);
+  vls.validateTextDocument = async (textDocument, cancellationToken) => {
+    const diagnostics2 = await vls.doValidate(textDocument, cancellationToken);
+    if (diagnostics2) {
+      vls.lspConnection.sendDiagnostics({
+        uri: textDocument.uri,
+        version: textDocument.version,
+        diagnostics: diagnostics2
+      });
+    }
+  };
+  serverConnection.onInitialize(
+    async (params) => {
+      await vls.init(params);
+      if (options.verbose) {
+        console.log("Vetur initialized");
+        console.log("====================================");
+      }
+      return {
+        capabilities: vls.capabilities
+      };
+    }
+  );
+  vls.listen();
+  clientConnection.listen();
+  const initParams = getInitParams(workspaceUri);
+  if (options.config) {
+    mergeDeep(initParams.initializationOptions.config, options.config);
+  }
+  await clientConnection.sendRequest(InitializeRequest.type, initParams);
+  return { clientConnection, serverConnection, vls, up, down, logger };
+}
+function extToGlobs(exts) {
+  return exts.map((e) => `**/*${e}`);
+}
+const watchedDidChangeContent = [".vue"];
+const watchedDidChangeWatchedFiles = [".js", ".ts", ".json"];
+const watchedDidChangeContentGlob = extToGlobs(watchedDidChangeContent);
+async function getDiagnostics(workspaceUri, severity, options) {
+  const { clientConnection } = await prepareClientConnection(
+    workspaceUri,
+    severity,
+    options
+  );
+  const files = globSync([...watchedDidChangeContentGlob], {
+    cwd: workspaceUri.fsPath,
+    ignore: ["node_modules/**"]
+  });
+  if (files.length === 0) {
+    console.log("[VLS checker] No input files");
+    return { initialWarningCount: 0, initialErrorCount: 0 };
+  }
+  if (options.verbose) {
+    console.log("");
+    console.log("Getting diagnostics from: ", files, "\n");
+  }
+  const absFilePaths = files.map((f) => path.resolve(workspaceUri.fsPath, f));
+  disposeSuppressConsole = suppressConsole();
+  initialVueFilesCount = absFilePaths.length;
+  let initialErrorCount = 0;
+  let initialWarningCount = 0;
+  await Promise.all(
+    absFilePaths.map(async (absFilePath) => {
+      const fileText = await fs.promises.readFile(absFilePath, "utf-8");
+      clientConnection.sendNotification(DidOpenTextDocumentNotification.type, {
+        textDocument: {
+          languageId: "vue",
+          uri: URI.file(absFilePath).toString(),
+          version: -1 /* init */,
+          text: fileText
+        }
+      });
+      if (options.watch) return;
+      try {
+        let diagnostics2 = await clientConnection.sendRequest(
+          "$/getDiagnostics",
+          {
+            uri: URI.file(absFilePath).toString(),
+            version: -1 /* init */
+          }
+        );
+        diagnostics2 = filterDiagnostics(diagnostics2, severity);
+        let logChunk = "";
+        if (diagnostics2.length > 0) {
+          logChunk += os.EOL + diagnostics2.map(
+            (d) => diagnosticToTerminalLog(
+              normalizeLspDiagnostic({
+                diagnostic: d,
+                absFilePath,
+                fileText
+              }),
+              "VLS"
+            )
+          ).join(os.EOL);
+          for (const d of diagnostics2) {
+            if (d.severity === DiagnosticSeverity.Error) {
+              initialErrorCount++;
+            }
+            if (d.severity === DiagnosticSeverity.Warning) {
+              initialWarningCount++;
+            }
+          }
+        }
+        console.log(logChunk);
+        return { initialErrorCount, initialWarningCount };
+      } catch (err) {
+        console.error(err.stack);
+        return { initialErrorCount, initialWarningCount };
+      }
+    })
+  );
+  if (!options.watch) {
+    return { initialErrorCount, initialWarningCount };
+  }
+  await Promise.all(
+    absFilePaths.map(async (absFilePath) => {
+      const fileText = await fs.promises.readFile(absFilePath, "utf-8");
+      clientConnection.sendNotification(DidOpenTextDocumentNotification.type, {
+        textDocument: {
+          languageId: "vue",
+          uri: URI.file(absFilePath).toString(),
+          version: -1 /* init */,
+          text: fileText
+        }
+      });
+    })
+  );
+  const watcher = chokidar.watch([], {
+    ignored: (path2) => path2.includes("node_modules")
+  });
+  watcher.add(workspaceUri.fsPath);
+  watcher.on("all", async (event, filePath) => {
+    const extname = path.extname(filePath);
+    if (!filePath.endsWith(".vue")) return;
+    const fileContent = await fs.promises.readFile(filePath, "utf-8");
+    clientConnection.sendNotification(DidChangeTextDocumentNotification.type, {
+      textDocument: {
+        uri: URI.file(filePath).toString(),
+        version: Date.now()
+      },
+      contentChanges: [{ text: fileContent }]
+    });
+    if (watchedDidChangeWatchedFiles.includes(extname)) {
+      clientConnection.sendNotification(
+        DidChangeWatchedFilesNotification.type,
+        {
+          changes: [
+            {
+              uri: URI.file(filePath).toString(),
+              type: event === "add" ? 1 : event === "unlink" ? 3 : 2
+            }
+          ]
+        }
+      );
+    }
+  });
+  return null;
+}
+function isObject(item) {
+  return item && typeof item === "object" && !Array.isArray(item);
+}
+function mergeDeep(target, source) {
+  if (isObject(target) && isObject(source)) {
+    for (const key in source) {
+      if (isObject(source[key])) {
+        if (!target[key]) Object.assign(target, { [key]: {} });
+        mergeDeep(target[key], source[key]);
+      } else {
+        Object.assign(target, { [key]: source[key] });
+      }
+    }
+  }
+  return target;
+}
+function filterDiagnostics(diagnostics2, severity) {
+  return diagnostics2.filter((r) => r.source !== "eslint-plugin-vue").filter((r) => r.severity && r.severity <= severity);
+}
+export {
+  TestStream,
+  diagnostics,
+  logLevel2Severity,
+  logLevels,
+  prepareClientConnection
+};
+//# sourceMappingURL=diagnostics.js.map

node_modules/vite-plugin-checker/dist/checkers/vls/initParams.d.ts

@@ -0,0 +1,72 @@
+import { InitializeParams } from 'vscode-languageserver/node';
+import { URI } from 'vscode-uri';
+
+type VlsOptions = ReturnType<typeof getDefaultVLSConfig>;
+declare function getInitParams(workspaceUri: URI): InitializeParams;
+declare function getDefaultVLSConfig(): {
+    vetur: {
+        ignoreProjectWarning: boolean;
+        useWorkspaceDependencies: boolean;
+        validation: {
+            template: boolean;
+            templateProps: boolean;
+            interpolation: boolean;
+            style: boolean;
+            script: boolean;
+        };
+        completion: {
+            autoImport: boolean;
+            tagCasing: string;
+            scaffoldSnippetSources: {
+                workspace: string;
+                user: string;
+                vetur: string;
+            };
+        };
+        grammar: {
+            customBlocks: {};
+        };
+        format: {
+            enable: boolean;
+            options: {
+                tabSize: number;
+                useTabs: boolean;
+            };
+            defaultFormatter: {};
+            defaultFormatterOptions: {};
+            scriptInitialIndent: boolean;
+            styleInitialIndent: boolean;
+        };
+        languageFeatures: {
+            codeActions: boolean;
+            updateImportOnFileMove: boolean;
+            semanticTokens: boolean;
+        };
+        trace: {
+            server: string;
+        };
+        dev: {
+            vlsPath: string;
+            vlsPort: number;
+            logLevel: string;
+        };
+        experimental: {
+            templateInterpolationService: boolean;
+        };
+    };
+    css: {};
+    html: {
+        suggest: {};
+    };
+    javascript: {
+        format: {};
+    };
+    typescript: {
+        tsdk: null;
+        format: {};
+    };
+    emmet: {};
+    stylusSupremacy: {};
+};
+
+export { type VlsOptions, getDefaultVLSConfig, getInitParams };

node_modules/vite-plugin-checker/dist/checkers/vls/initParams.js

@@ -0,0 +1,95 @@
+function getInitParams(workspaceUri) {
+  const defaultVLSConfig = getDefaultVLSConfig();
+  defaultVLSConfig.vetur.validation = {
+    template: true,
+    style: true,
+    script: true,
+    interpolation: true,
+    templateProps: true
+  };
+  defaultVLSConfig.vetur.experimental = {
+    templateInterpolationService: true
+  };
+  const init = {
+    rootPath: workspaceUri.fsPath,
+    rootUri: workspaceUri.toString(),
+    processId: process.pid,
+    capabilities: {},
+    initializationOptions: {
+      config: defaultVLSConfig
+    }
+  };
+  return init;
+}
+function getDefaultVLSConfig() {
+  return {
+    vetur: {
+      ignoreProjectWarning: false,
+      useWorkspaceDependencies: false,
+      validation: {
+        template: true,
+        templateProps: true,
+        interpolation: true,
+        style: true,
+        script: true
+      },
+      completion: {
+        autoImport: false,
+        tagCasing: "initial",
+        scaffoldSnippetSources: {
+          workspace: "\u{1F4BC}",
+          user: "\u{1F5D2}\uFE0F",
+          vetur: "\u270C"
+        }
+      },
+      grammar: {
+        customBlocks: {}
+      },
+      format: {
+        enable: true,
+        options: {
+          tabSize: 2,
+          useTabs: false
+        },
+        defaultFormatter: {},
+        defaultFormatterOptions: {},
+        scriptInitialIndent: false,
+        styleInitialIndent: false
+      },
+      languageFeatures: {
+        codeActions: true,
+        updateImportOnFileMove: true,
+        semanticTokens: true
+      },
+      trace: {
+        server: "off"
+      },
+      dev: {
+        vlsPath: "",
+        vlsPort: -1,
+        logLevel: "INFO"
+      },
+      experimental: {
+        templateInterpolationService: false
+      }
+    },
+    css: {},
+    html: {
+      suggest: {}
+    },
+    javascript: {
+      format: {}
+    },
+    typescript: {
+      tsdk: null,
+      format: {}
+    },
+    emmet: {},
+    stylusSupremacy: {}
+  };
+}
+export {
+  getDefaultVLSConfig,
+  getInitParams
+};
+//# sourceMappingURL=initParams.js.map

node_modules/vite-plugin-checker/dist/checkers/vls/initParams.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/checkers/vls/initParams.ts"],"sourcesContent":["import type { InitializeParams } from 'vscode-languageserver/node'\nimport type { URI } from 'vscode-uri'\n\nexport type VlsOptions = ReturnType<typeof getDefaultVLSConfig>\n\nexport function getInitParams(workspaceUri: URI): InitializeParams {\n  const defaultVLSConfig = getDefaultVLSConfig()\n\n  defaultVLSConfig.vetur.validation = {\n    template: true,\n    style: true,\n    script: true,\n    interpolation: true,\n    templateProps: true,\n  }\n  defaultVLSConfig.vetur.experimental = {\n    templateInterpolationService: true,\n  }\n\n  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions\n  const init: InitializeParams = {\n    rootPath: workspaceUri.fsPath,\n    rootUri: workspaceUri.toString(),\n    processId: process.pid,\n    capabilities: {},\n    initializationOptions: {\n      config: defaultVLSConfig,\n    },\n  } as InitializeParams\n\n  return init\n}\n\nexport function getDefaultVLSConfig() {\n  return {\n    vetur: {\n      ignoreProjectWarning: false,\n      useWorkspaceDependencies: false,\n      validation: {\n        template: true,\n        templateProps: true,\n        interpolation: true,\n        style: true,\n        script: true,\n      },\n      completion: {\n        autoImport: false,\n        tagCasing: 'initial',\n        scaffoldSnippetSources: {\n          workspace: '💼',\n          user: '🗒️',\n          vetur: '✌',\n        },\n      },\n      grammar: {\n        customBlocks: {},\n      },\n      format: {\n        enable: true,\n        options: {\n          tabSize: 2,\n          useTabs: false,\n        },\n        defaultFormatter: {},\n        defaultFormatterOptions: {},\n        scriptInitialIndent: false,\n        styleInitialIndent: false,\n      },\n      languageFeatures: {\n        codeActions: true,\n        updateImportOnFileMove: true,\n        semanticTokens: true,\n      },\n      trace: {\n        server: 'off',\n      },\n      dev: {\n        vlsPath: '',\n        vlsPort: -1,\n        logLevel: 'INFO',\n      },\n      experimental: {\n        templateInterpolationService: false,\n      },\n    },\n    css: {},\n    html: {\n      suggest: {},\n    },\n    javascript: {\n      format: {},\n    },\n    typescript: {\n      tsdk: null,\n      format: {},\n    },\n    emmet: {},\n    stylusSupremacy: {},\n  }\n}\n"],"mappings":"AAKO,SAAS,cAAc,cAAqC;AACjE,QAAM,mBAAmB,oBAAoB;AAE7C,mBAAiB,MAAM,aAAa;AAAA,IAClC,UAAU;AAAA,IACV,OAAO;AAAA,IACP,QAAQ;AAAA,IACR,eAAe;AAAA,IACf,eAAe;AAAA,EACjB;AACA,mBAAiB,MAAM,eAAe;AAAA,IACpC,8BAA8B;AAAA,EAChC;AAGA,QAAM,OAAyB;AAAA,IAC7B,UAAU,aAAa;AAAA,IACvB,SAAS,aAAa,SAAS;AAAA,IAC/B,WAAW,QAAQ;AAAA,IACnB,cAAc,CAAC;AAAA,IACf,uBAAuB;AAAA,MACrB,QAAQ;AAAA,IACV;AAAA,EACF;AAEA,SAAO;AACT;AAEO,SAAS,sBAAsB;AACpC,SAAO;AAAA,IACL,OAAO;AAAA,MACL,sBAAsB;AAAA,MACtB,0BAA0B;AAAA,MAC1B,YAAY;AAAA,QACV,UAAU;AAAA,QACV,eAAe;AAAA,QACf,eAAe;AAAA,QACf,OAAO;AAAA,QACP,QAAQ;AAAA,MACV;AAAA,MACA,YAAY;AAAA,QACV,YAAY;AAAA,QACZ,WAAW;AAAA,QACX,wBAAwB;AAAA,UACtB,WAAW;AAAA,UACX,MAAM;AAAA,UACN,OAAO;AAAA,QACT;AAAA,MACF;AAAA,MACA,SAAS;AAAA,QACP,cAAc,CAAC;AAAA,MACjB;AAAA,MACA,QAAQ;AAAA,QACN,QAAQ;AAAA,QACR,SAAS;AAAA,UACP,SAAS;AAAA,UACT,SAAS;AAAA,QACX;AAAA,QACA,kBAAkB,CAAC;AAAA,QACnB,yBAAyB,CAAC;AAAA,QAC1B,qBAAqB;AAAA,QACrB,oBAAoB;AAAA,MACtB;AAAA,MACA,kBAAkB;AAAA,QAChB,aAAa;AAAA,QACb,wBAAwB;AAAA,QACxB,gBAAgB;AAAA,MAClB;AAAA,MACA,OAAO;AAAA,QACL,QAAQ;AAAA,MACV;AAAA,MACA,KAAK;AAAA,QACH,SAAS;AAAA,QACT,SAAS;AAAA,QACT,UAAU;AAAA,MACZ;AAAA,MACA,cAAc;AAAA,QACZ,8BAA8B;AAAA,MAChC;AAAA,IACF;AAAA,IACA,KAAK,CAAC;AAAA,IACN,MAAM;AAAA,MACJ,SAAS,CAAC;AAAA,IACZ;AAAA,IACA,YAAY;AAAA,MACV,QAAQ,CAAC;AAAA,IACX;AAAA,IACA,YAAY;AAAA,MACV,MAAM;AAAA,MACN,QAAQ,CAAC;AAAA,IACX;AAAA,IACA,OAAO,CAAC;AAAA,IACR,iBAAiB,CAAC;AAAA,EACpB;AACF;","names":[]}

node_modules/vite-plugin-checker/dist/checkers/vls/main.d.ts

@@ -0,0 +1,19 @@
+import { Checker } from '../../Checker.js';
+import { CreateDiagnostic } from '../../types.js';
+import 'vite';
+import '../../worker.js';
+import 'node:worker_threads';
+import 'eslint';
+import 'stylelint';
+import './initParams.js';
+import 'vscode-languageserver/node';
+import 'vscode-uri';
+
+declare let createServeAndBuild: any;
+declare const createDiagnostic: CreateDiagnostic<'vls'>;
+declare class VlsChecker extends Checker<'vls'> {
+    constructor();
+    init(): void;
+}
+
+export { VlsChecker, createDiagnostic, createServeAndBuild };

node_modules/vite-plugin-checker/dist/checkers/vls/main.js

@@ -0,0 +1,103 @@
+import { fileURLToPath } from "node:url";
+import { parentPort } from "node:worker_threads";
+import { Checker } from "../../Checker.js";
+import {
+  composeCheckerSummary,
+  consoleLog,
+  diagnosticToConsoleLevel,
+  diagnosticToRuntimeError,
+  diagnosticToTerminalLog,
+  toClientPayload
+} from "../../logger.js";
+import { ACTION_TYPES } from "../../types.js";
+import { diagnostics } from "./diagnostics.js";
+const __filename = fileURLToPath(import.meta.url);
+let createServeAndBuild;
+const createDiagnostic = (pluginConfig) => {
+  let overlay = true;
+  let terminal = true;
+  let command;
+  return {
+    config: ({ enableOverlay, enableTerminal, env }) => {
+      overlay = enableOverlay;
+      terminal = enableTerminal;
+      command = env.command;
+    },
+    async configureServer({ root }) {
+      const workDir = root;
+      const onDispatchDiagnosticsSummary = (errorCount, warningCount) => {
+        if (!terminal) return;
+        consoleLog(
+          composeCheckerSummary("VLS", errorCount, warningCount),
+          errorCount ? "error" : warningCount ? "warn" : "info"
+        );
+      };
+      const onDispatchDiagnostics = (normalized) => {
+        var _a;
+        if (overlay && command === "serve") {
+          (_a = parentPort) == null ? void 0 : _a.postMessage({
+            type: ACTION_TYPES.overlayError,
+            payload: toClientPayload(
+              "vls",
+              diagnosticToRuntimeError(normalized)
+            )
+          });
+        }
+        if (terminal) {
+          for (const d of normalized) {
+            consoleLog(
+              diagnosticToTerminalLog(d, "VLS"),
+              diagnosticToConsoleLevel(d)
+            );
+          }
+        }
+      };
+      const vlsConfig = pluginConfig == null ? void 0 : pluginConfig.vls;
+      await diagnostics(workDir, "WARN", {
+        onDispatchDiagnostics,
+        onDispatchDiagnosticsSummary,
+        watch: true,
+        verbose: false,
+        config: typeof vlsConfig === "object" ? vlsConfig : null
+      });
+    }
+  };
+};
+class VlsChecker extends Checker {
+  constructor() {
+    super({
+      name: "vls",
+      absFilePath: __filename,
+      build: {
+        buildBin: (config) => {
+          if (typeof config.vls === "object") {
+            return [
+              "vti",
+              [
+                "diagnostics",
+                // Escape quotes so that the system shell doesn't strip them out:
+                `"${JSON.stringify(config.vls).replace(/[\\"]/g, "\\$&")}"`
+              ]
+            ];
+          }
+          return ["vti", ["diagnostics"]];
+        }
+      },
+      createDiagnostic
+    });
+  }
+  init() {
+    const _createServeAndBuild = super.initMainThread();
+    createServeAndBuild = _createServeAndBuild;
+    super.initWorkerThread();
+  }
+}
+const vlsChecker = new VlsChecker();
+vlsChecker.prepare();
+vlsChecker.init();
+export {
+  VlsChecker,
+  createDiagnostic,
+  createServeAndBuild
+};
+//# sourceMappingURL=main.js.map

node_modules/vite-plugin-checker/dist/checkers/vls/main.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/checkers/vls/main.ts"],"sourcesContent":["import { fileURLToPath } from 'node:url'\nimport { parentPort } from 'node:worker_threads'\nimport type { ConfigEnv } from 'vite'\nimport { Checker } from '../../Checker.js'\nimport {\n  composeCheckerSummary,\n  consoleLog,\n  diagnosticToConsoleLevel,\n  diagnosticToRuntimeError,\n  diagnosticToTerminalLog,\n  toClientPayload,\n} from '../../logger.js'\nimport type { CreateDiagnostic } from '../../types.js'\nimport { ACTION_TYPES } from '../../types.js'\nimport { type DiagnosticOptions, diagnostics } from './diagnostics.js'\n\nconst __filename = fileURLToPath(import.meta.url)\n\nlet createServeAndBuild: any\n\nexport const createDiagnostic: CreateDiagnostic<'vls'> = (pluginConfig) => {\n  let overlay = true\n  let terminal = true\n  let command: ConfigEnv['command']\n\n  return {\n    config: ({ enableOverlay, enableTerminal, env }) => {\n      overlay = enableOverlay\n      terminal = enableTerminal\n      command = env.command\n    },\n    async configureServer({ root }) {\n      const workDir: string = root\n\n      const onDispatchDiagnosticsSummary: DiagnosticOptions['onDispatchDiagnosticsSummary'] =\n        (errorCount, warningCount) => {\n          if (!terminal) return\n\n          consoleLog(\n            composeCheckerSummary('VLS', errorCount, warningCount),\n            errorCount ? 'error' : warningCount ? 'warn' : 'info',\n          )\n        }\n\n      const onDispatchDiagnostics: DiagnosticOptions['onDispatchDiagnostics'] =\n        (normalized) => {\n          if (overlay && command === 'serve') {\n            parentPort?.postMessage({\n              type: ACTION_TYPES.overlayError,\n              payload: toClientPayload(\n                'vls',\n                diagnosticToRuntimeError(normalized),\n              ),\n            })\n          }\n\n          if (terminal) {\n            for (const d of normalized) {\n              consoleLog(\n                diagnosticToTerminalLog(d, 'VLS'),\n                diagnosticToConsoleLevel(d),\n              )\n            }\n          }\n        }\n\n      const vlsConfig = pluginConfig?.vls\n      await diagnostics(workDir, 'WARN', {\n        onDispatchDiagnostics,\n        onDispatchDiagnosticsSummary,\n        watch: true,\n        verbose: false,\n        config: typeof vlsConfig === 'object' ? vlsConfig : null,\n      })\n    },\n  }\n}\n\nexport class VlsChecker extends Checker<'vls'> {\n  public constructor() {\n    super({\n      name: 'vls',\n      absFilePath: __filename,\n      build: {\n        buildBin: (config) => {\n          if (typeof config.vls === 'object') {\n            return [\n              'vti',\n              [\n                'diagnostics',\n                // Escape quotes so that the system shell doesn't strip them out:\n                `\"${JSON.stringify(config.vls).replace(/[\\\\\"]/g, '\\\\$&')}\"`,\n              ],\n            ]\n          }\n\n          return ['vti', ['diagnostics']]\n        },\n      },\n      createDiagnostic,\n    })\n  }\n\n  public init() {\n    const _createServeAndBuild = super.initMainThread()\n    createServeAndBuild = _createServeAndBuild\n    super.initWorkerThread()\n  }\n}\n\nexport { createServeAndBuild }\nconst vlsChecker = new VlsChecker()\nvlsChecker.prepare()\nvlsChecker.init()\n"],"mappings":"AAAA,SAAS,qBAAqB;AAC9B,SAAS,kBAAkB;AAE3B,SAAS,eAAe;AACxB;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAEP,SAAS,oBAAoB;AAC7B,SAAiC,mBAAmB;AAEpD,MAAM,aAAa,cAAc,YAAY,GAAG;AAEhD,IAAI;AAEG,MAAM,mBAA4C,CAAC,iBAAiB;AACzE,MAAI,UAAU;AACd,MAAI,WAAW;AACf,MAAI;AAEJ,SAAO;AAAA,IACL,QAAQ,CAAC,EAAE,eAAe,gBAAgB,IAAI,MAAM;AAClD,gBAAU;AACV,iBAAW;AACX,gBAAU,IAAI;AAAA,IAChB;AAAA,IACA,MAAM,gBAAgB,EAAE,KAAK,GAAG;AAC9B,YAAM,UAAkB;AAExB,YAAM,+BACJ,CAAC,YAAY,iBAAiB;AAC5B,YAAI,CAAC,SAAU;AAEf;AAAA,UACE,sBAAsB,OAAO,YAAY,YAAY;AAAA,UACrD,aAAa,UAAU,eAAe,SAAS;AAAA,QACjD;AAAA,MACF;AAEF,YAAM,wBACJ,CAAC,eAAe;AA7CxB;AA8CU,YAAI,WAAW,YAAY,SAAS;AAClC,kDAAY,YAAY;AAAA,YACtB,MAAM,aAAa;AAAA,YACnB,SAAS;AAAA,cACP;AAAA,cACA,yBAAyB,UAAU;AAAA,YACrC;AAAA,UACF;AAAA,QACF;AAEA,YAAI,UAAU;AACZ,qBAAW,KAAK,YAAY;AAC1B;AAAA,cACE,wBAAwB,GAAG,KAAK;AAAA,cAChC,yBAAyB,CAAC;AAAA,YAC5B;AAAA,UACF;AAAA,QACF;AAAA,MACF;AAEF,YAAM,YAAY,6CAAc;AAChC,YAAM,YAAY,SAAS,QAAQ;AAAA,QACjC;AAAA,QACA;AAAA,QACA,OAAO;AAAA,QACP,SAAS;AAAA,QACT,QAAQ,OAAO,cAAc,WAAW,YAAY;AAAA,MACtD,CAAC;AAAA,IACH;AAAA,EACF;AACF;AAEO,MAAM,mBAAmB,QAAe;AAAA,EACtC,cAAc;AACnB,UAAM;AAAA,MACJ,MAAM;AAAA,MACN,aAAa;AAAA,MACb,OAAO;AAAA,QACL,UAAU,CAAC,WAAW;AACpB,cAAI,OAAO,OAAO,QAAQ,UAAU;AAClC,mBAAO;AAAA,cACL;AAAA,cACA;AAAA,gBACE;AAAA;AAAA,gBAEA,IAAI,KAAK,UAAU,OAAO,GAAG,EAAE,QAAQ,UAAU,MAAM,CAAC;AAAA,cAC1D;AAAA,YACF;AAAA,UACF;AAEA,iBAAO,CAAC,OAAO,CAAC,aAAa,CAAC;AAAA,QAChC;AAAA,MACF;AAAA,MACA;AAAA,IACF,CAAC;AAAA,EACH;AAAA,EAEO,OAAO;AACZ,UAAM,uBAAuB,MAAM,eAAe;AAClD,0BAAsB;AACtB,UAAM,iBAAiB;AAAA,EACzB;AACF;AAGA,MAAM,aAAa,IAAI,WAAW;AAClC,WAAW,QAAQ;AACnB,WAAW,KAAK;","names":[]}

node_modules/vite-plugin-checker/dist/checkers/vls/typings.d.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

node_modules/vite-plugin-checker/dist/checkers/vls/typings.d.js

@@ -0,0 +1 @@
+//# sourceMappingURL=typings.d.js.map

node_modules/vite-plugin-checker/dist/checkers/vls/typings.d.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}