@weapp-vite/volar 2.0.0 → 2.0.2

package/dist/index.cjs

@@ -0,0 +1,300 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  default: () => index_default
+});
+module.exports = __toCommonJS(index_exports);
+var import_node_module = require("module");
+var import_node_path = __toESM(require("path"));
+var import_node_process = __toESM(require("process"));
+
+// package.json
+var name = "@weapp-vite/volar";
+
+// src/schema.ts
+var import_schematics = require("@weapp-core/schematics");
+function getSchemaForType(type) {
+  const definition = import_schematics.JSON_SCHEMA_DEFINITIONS.find((d) => d.typeName === type);
+  if (!definition) {
+    return null;
+  }
+  return definition.schema;
+}
+
+// src/index.ts
+var BLOCK_TYPE = "json";
+var JS_LANG = "js";
+var JSONC_LANG = "jsonc";
+var JSON_LANG = "json";
+var JSON5_LANG = "json5";
+var PLUGIN_VERSION = 2.2;
+var TS_LANG = "ts";
+var FULL_CAPABILITIES = {
+  verification: true,
+  completion: true,
+  semantic: true,
+  navigation: true,
+  structure: true,
+  format: true
+};
+var VOID_CAPABILITIES = {
+  verification: false,
+  completion: false,
+  semantic: false,
+  navigation: false,
+  structure: false,
+  format: false
+};
+var require2 = (0, import_node_module.createRequire)(
+  typeof module !== "undefined" && module.filename ? module.filename : import_node_path.default.join(import_node_process.default.cwd(), "weapp-vite-volar.cjs")
+);
+var hasSchematicsTypes = false;
+try {
+  require2.resolve("@weapp-core/schematics");
+  hasSchematicsTypes = true;
+} catch {
+  hasSchematicsTypes = false;
+}
+function normalizeFilename(filename) {
+  if (!filename) {
+    return "";
+  }
+  return filename.replace(/\\/g, "/");
+}
+function inferConfigType(filename) {
+  const normalized = normalizeFilename(filename);
+  if (normalized.endsWith("/app.vue")) {
+    return "App";
+  }
+  if (normalized.includes("/plugin/")) {
+    return "Plugin";
+  }
+  if (normalized.includes("/components/")) {
+    return "Component";
+  }
+  if (normalized.includes("/theme/")) {
+    return "Theme";
+  }
+  if (normalized.includes("/sitemap")) {
+    return "Sitemap";
+  }
+  return "Page";
+}
+function normalizeLang(lang) {
+  if (!lang) {
+    return JSON_LANG;
+  }
+  const lower = lang.toLowerCase();
+  if (lower === "txt") {
+    return JSON_LANG;
+  }
+  return lower;
+}
+function findExportDefaultExpression(code, tsModule, lang) {
+  const scriptKind = lang === TS_LANG ? tsModule.ScriptKind.TS : tsModule.ScriptKind.JS;
+  const sourceFile = tsModule.createSourceFile(
+    `config.${lang}`,
+    code,
+    tsModule.ScriptTarget.Latest,
+    true,
+    scriptKind
+  );
+  for (const statement of sourceFile.statements) {
+    if (tsModule.isExportAssignment(statement)) {
+      const expressionStart = statement.expression.getStart(sourceFile);
+      const expressionEnd = statement.expression.getEnd();
+      const leading = code.slice(0, statement.getStart(sourceFile));
+      const expression = code.slice(expressionStart, expressionEnd);
+      const trailing = code.slice(statement.getEnd());
+      return {
+        expression,
+        expressionStart,
+        expressionEnd,
+        leading,
+        trailing
+      };
+    }
+  }
+  return null;
+}
+function injectSchemaIntoJsonObject(content, schemaId) {
+  const trimmed = content.trim();
+  if (!trimmed.startsWith("{")) {
+    return content;
+  }
+  const leftBraceIndex = content.indexOf("{");
+  if (leftBraceIndex < 0) {
+    return content;
+  }
+  const afterLeft = content.slice(leftBraceIndex + 1);
+  const firstNonSpace = afterLeft.match(/\S/);
+  const nextCharIndex = firstNonSpace ? leftBraceIndex + 1 + firstNonSpace.index : -1;
+  const isEmptyObject = nextCharIndex >= 0 && content[nextCharIndex] === "}";
+  const schemaLine = `  "$schema": "${schemaId}"`;
+  const injected = isEmptyObject ? `{
+${schemaLine}
+}` : `{
+${schemaLine},${content.slice(leftBraceIndex + 1)}`;
+  if (trimmed === content) {
+    return injected;
+  }
+  const leading = content.slice(0, content.indexOf(trimmed));
+  const trailing = content.slice(content.indexOf(trimmed) + trimmed.length);
+  return `${leading}${injected}${trailing}`;
+}
+var plugin = (ctx) => {
+  let tsModule = ctx?.modules?.typescript;
+  if (!tsModule) {
+    try {
+      tsModule = require2("typescript");
+    } catch {
+      tsModule = void 0;
+    }
+  }
+  return {
+    name,
+    version: PLUGIN_VERSION,
+    getEmbeddedCodes(_, sfc) {
+      const names = [];
+      for (let i = 0; i < sfc.customBlocks.length; i++) {
+        const block = sfc.customBlocks[i];
+        if (block.type === BLOCK_TYPE) {
+          const normalizedLang = normalizeLang(block.lang);
+          const isJsLike = normalizedLang === JS_LANG || normalizedLang === TS_LANG;
+          if (isJsLike) {
+            names.push({ id: `${BLOCK_TYPE}_${i}`, lang: TS_LANG });
+            continue;
+          }
+          const embeddedLang = normalizedLang === JSON_LANG || normalizedLang === JSONC_LANG || normalizedLang === JSON5_LANG ? JSONC_LANG : JSON_LANG;
+          names.push({ id: `${BLOCK_TYPE}_${i}`, lang: embeddedLang });
+        }
+      }
+      return names;
+    },
+    resolveEmbeddedCode(fileName, sfc, embeddedCode) {
+      const match = embeddedCode.id.match(new RegExp(`^${BLOCK_TYPE}_(\\d+)$`));
+      if (!match) {
+        return;
+      }
+      const index = Number.parseInt(match[1]);
+      const block = sfc.customBlocks[index];
+      if (!block) {
+        return;
+      }
+      const normalizedLang = normalizeLang(block.lang);
+      const configType = inferConfigType(fileName);
+      if (!hasSchematicsTypes) {
+        embeddedCode.content.push([
+          block.content,
+          block.name,
+          0,
+          FULL_CAPABILITIES
+        ]);
+        return;
+      }
+      const userWantsJs = normalizedLang === JS_LANG || normalizedLang === TS_LANG;
+      if (userWantsJs) {
+        const parsed = tsModule && findExportDefaultExpression(block.content, tsModule, normalizedLang);
+        if (parsed && hasSchematicsTypes) {
+          const typeImport = `import type { ${configType} as __WeappConfig } from '@weapp-core/schematics'
+`;
+          const helper = "const __weapp_defineConfig = <T extends __WeappConfig>(config: T) => config\n\n";
+          embeddedCode.content.push([
+            `${typeImport}${helper}`,
+            void 0,
+            0,
+            VOID_CAPABILITIES
+          ]);
+          if (parsed.leading) {
+            embeddedCode.content.push([
+              parsed.leading,
+              block.name,
+              0,
+              FULL_CAPABILITIES
+            ]);
+          }
+          embeddedCode.content.push([
+            "export default __weapp_defineConfig(",
+            void 0,
+            parsed.expressionStart,
+            VOID_CAPABILITIES
+          ]);
+          embeddedCode.content.push([
+            parsed.expression,
+            block.name,
+            parsed.expressionStart,
+            FULL_CAPABILITIES
+          ]);
+          embeddedCode.content.push([
+            ")",
+            void 0,
+            parsed.expressionEnd,
+            VOID_CAPABILITIES
+          ]);
+          if (parsed.trailing) {
+            embeddedCode.content.push([
+              parsed.trailing,
+              block.name,
+              parsed.expressionEnd,
+              FULL_CAPABILITIES
+            ]);
+          }
+          return;
+        }
+        embeddedCode.content.push([
+          block.content,
+          block.name,
+          0,
+          FULL_CAPABILITIES
+        ]);
+        return;
+      }
+      const schema = getSchemaForType(configType);
+      if (schema && schema.$id && !block.content.includes("$schema")) {
+        embeddedCode.content.push([
+          injectSchemaIntoJsonObject(block.content, schema.$id),
+          block.name,
+          0,
+          FULL_CAPABILITIES
+        ]);
+        return;
+      }
+      embeddedCode.content.push([
+        block.content,
+        block.name,
+        0,
+        FULL_CAPABILITIES
+      ]);
+    }
+  };
+};
+var index_default = plugin;

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+import { VueLanguagePlugin } from '@vue/language-core';
+
+declare const plugin: VueLanguagePlugin;
+
+export = plugin;

package/dist/index.mjs

@@ -1,5 +1,7 @@
 // src/index.ts
 import { createRequire } from "module";
+import path from "path";
+import process from "process";
 
 // package.json
 var name = "@weapp-vite/volar";
@@ -38,7 +40,9 @@ var VOID_CAPABILITIES = {
   structure: false,
   format: false
 };
-var require2 = createRequire(import.meta.url);
+var require2 = createRequire(
+  typeof module !== "undefined" && module.filename ? module.filename : path.join(process.cwd(), "weapp-vite-volar.cjs")
+);
 var hasSchematicsTypes = false;
 try {
   require2.resolve("@weapp-core/schematics");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weapp-vite/volar",
-  "version": "2.0.0",
+  "version": "2.0.2",
   "description": "Volar plugin for weapp-vite - Provides IntelliSense and type checking for WeChat mini-program config blocks",
   "author": "ice breaker <1324318532@qq.com>",
   "license": "MIT",
@@ -26,10 +26,11 @@
   "exports": {
     ".": {
       "types": "./dist/index.d.mts",
-      "import": "./dist/index.mjs"
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
     }
   },
-  "main": "./dist/index.mjs",
+  "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",
   "types": "./dist/index.d.mts",
   "files": [