unplugin-vue-components-jsx/dist/volar.cjs

Support JSX for unplugin-vue-components

"use strict";Object.defineProperty(exports, "__esModule", {value: true});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 __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __esm = (fn, res) => function __init() {
  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
};
var __commonJS = (cb, mod) => function __require() {
  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
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 __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);

// node_modules/.pnpm/tsup@8.3.5_jiti@1.21.6_postcss@8.4.49_tsx@4.16.2_typescript@5.7.2_yaml@2.6.1/node_modules/tsup/assets/cjs_shims.js
var init_cjs_shims = __esm({
  "node_modules/.pnpm/tsup@8.3.5_jiti@1.21.6_postcss@8.4.49_tsx@4.16.2_typescript@5.7.2_yaml@2.6.1/node_modules/tsup/assets/cjs_shims.js"() {
    "use strict";
  }
});

// node_modules/.pnpm/muggle-string@0.4.1/node_modules/muggle-string/out/binarySearch.js
var require_binarySearch = __commonJS({
  "node_modules/.pnpm/muggle-string@0.4.1/node_modules/muggle-string/out/binarySearch.js"(exports) {
    "use strict";
    init_cjs_shims();
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.binarySearch = void 0;
    function binarySearch(offsets, start) {
      let low = 0;
      let high = offsets.length - 1;
      while (low <= high) {
        const mid = Math.floor((low + high) / 2);
        const midValue = offsets[mid];
        if (midValue < start) {
          low = mid + 1;
        } else if (midValue > start) {
          high = mid - 1;
        } else {
          low = mid;
          high = mid;
          break;
        }
      }
      return Math.max(Math.min(low, high, offsets.length - 1), 0);
    }
    exports.binarySearch = binarySearch;
  }
});

// node_modules/.pnpm/muggle-string@0.4.1/node_modules/muggle-string/out/track.js
var require_track = __commonJS({
  "node_modules/.pnpm/muggle-string@0.4.1/node_modules/muggle-string/out/track.js"(exports) {
    "use strict";
    init_cjs_shims();
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.getStack = exports.track = exports.resetOffsetStack = exports.offsetStack = exports.setTracking = void 0;
    var tracking = true;
    var stackOffset = 0;
    function setTracking(value) {
      tracking = value;
    }
    exports.setTracking = setTracking;
    function offsetStack() {
      stackOffset++;
    }
    exports.offsetStack = offsetStack;
    function resetOffsetStack() {
      stackOffset--;
    }
    exports.resetOffsetStack = resetOffsetStack;
    function track(segments, stacks = []) {
      return [
        new Proxy(segments, {
          get(target, prop, receiver) {
            if (tracking) {
              if (prop === "push")
                return push;
              if (prop === "pop")
                return pop;
              if (prop === "shift")
                return shift;
              if (prop === "unshift")
                return unshift;
              if (prop === "splice")
                return splice;
              if (prop === "sort")
                return sort;
              if (prop === "reverse")
                return reverse;
            }
            return Reflect.get(target, prop, receiver);
          }
        }),
        stacks
      ];
      function push(...items) {
        stacks.push({ stack: getStack(), length: items.length });
        return segments.push(...items);
      }
      function pop() {
        if (stacks.length) {
          const last = stacks[stacks.length - 1];
          if (last.length > 1) {
            last.length--;
          } else {
            stacks.pop();
          }
        }
        return segments.pop();
      }
      function shift() {
        if (stacks.length) {
          const first = stacks[0];
          if (first.length > 1) {
            first.length--;
          } else {
            stacks.shift();
          }
        }
        return segments.shift();
      }
      function unshift(...items) {
        stacks.unshift({ stack: getStack(), length: items.length });
        return segments.unshift(...items);
      }
      function splice(start, deleteCount, ...items) {
        if (deleteCount === void 0) {
          deleteCount = segments.length - start;
        }
        let _stackStart = 0;
        let operateIndex;
        for (let i2 = 0; i2 < stacks.length; i2++) {
          const stack = stacks[i2];
          const stackStart = _stackStart;
          const stackEnd = stackStart + stack.length;
          _stackStart = stackEnd;
          if (start >= stackStart) {
            operateIndex = i2 + 1;
            const originalLength = stack.length;
            stack.length = start - stackStart;
            stacks.splice(operateIndex, 0, { stack: stack.stack, length: originalLength - stack.length });
            break;
          }
        }
        if (operateIndex === void 0) {
          throw new Error("Invalid splice operation");
        }
        let _deleteCount = deleteCount;
        for (let i2 = operateIndex; i2 < stacks.length; i2++) {
          const stack = stacks[i2];
          while (_deleteCount > 0 && stack.length > 0) {
            stack.length--;
            _deleteCount--;
          }
          if (_deleteCount === 0) {
            break;
          }
        }
        stacks.splice(operateIndex, 0, { stack: getStack(), length: items.length });
        return segments.splice(start, deleteCount, ...items);
      }
      function sort(compareFn) {
        stacks.splice(0, stacks.length, { stack: getStack(), length: segments.length });
        return segments.sort(compareFn);
      }
      function reverse() {
        stacks.splice(0, stacks.length, { stack: getStack(), length: segments.length });
        return segments.reverse();
      }
    }
    exports.track = track;
    function getStack() {
      const stack = new Error().stack;
      let source = stack.split("\n")[3 + stackOffset].trim();
      if (source.endsWith(")")) {
        source = source.slice(source.lastIndexOf("(") + 1, -1);
      } else {
        source = source.slice(source.lastIndexOf(" ") + 1);
      }
      return source;
    }
    exports.getStack = getStack;
  }
});

// node_modules/.pnpm/muggle-string@0.4.1/node_modules/muggle-string/out/types.js
var require_types = __commonJS({
  "node_modules/.pnpm/muggle-string@0.4.1/node_modules/muggle-string/out/types.js"(exports) {
    "use strict";
    init_cjs_shims();
    Object.defineProperty(exports, "__esModule", { value: true });
  }
});

// node_modules/.pnpm/muggle-string@0.4.1/node_modules/muggle-string/out/index.js
var require_out = __commonJS({
  "node_modules/.pnpm/muggle-string@0.4.1/node_modules/muggle-string/out/index.js"(exports) {
    "use strict";
    init_cjs_shims();
    var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m2, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m2, k);
      if (!desc || ("get" in desc ? !m2.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m2[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    } : function(o, m2, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m2[k];
    });
    var __exportStar = exports && exports.__exportStar || function(m2, exports2) {
      for (var p in m2) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m2, p);
    };
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.replaceRange = exports.replaceSourceRange = exports.replaceAll = exports.replace = exports.create = exports.toString = exports.getLength = void 0;
    var binarySearch_1 = require_binarySearch();
    var track_1 = require_track();
    __exportStar(require_types(), exports);
    __exportStar(require_track(), exports);
    function getLength(segments) {
      let length = 0;
      for (const segment of segments) {
        length += typeof segment == "string" ? segment.length : segment[0].length;
      }
      return length;
    }
    exports.getLength = getLength;
    function toString(segments) {
      return segments.map((s) => typeof s === "string" ? s : s[0]).join("");
    }
    exports.toString = toString;
    function create(source) {
      return [[source, void 0, 0]];
    }
    exports.create = create;
    function replace(segments, pattern, ...replacers) {
      const str = toString(segments);
      const match = str.match(pattern);
      if (match && match.index !== void 0) {
        const startOffset = match.index;
        const endOffset = startOffset + match[0].length;
        (0, track_1.offsetStack)();
        replaceRange(segments, startOffset, endOffset, ...replacers.map((replacer) => typeof replacer === "function" ? replacer(match[0]) : replacer));
        (0, track_1.resetOffsetStack)();
      }
    }
    exports.replace = replace;
    function replaceAll(segments, pattern, ...replacers) {
      const str = toString(segments);
      const allMatch = str.matchAll(pattern);
      let length = str.length;
      let lengthDiff = 0;
      for (const match of allMatch) {
        if (match.index !== void 0) {
          const startOffset = match.index + lengthDiff;
          const endOffset = startOffset + match[0].length;
          (0, track_1.offsetStack)();
          replaceRange(segments, startOffset, endOffset, ...replacers.map((replacer) => typeof replacer === "function" ? replacer(match[0]) : replacer));
          (0, track_1.resetOffsetStack)();
          const newLength = getLength(segments);
          lengthDiff += newLength - length;
          length = newLength;
        }
      }
    }
    exports.replaceAll = replaceAll;
    function replaceSourceRange(segments, source, startOffset, endOffset, ...newSegments) {
      for (const segment of segments) {
        if (typeof segment === "string") {
          continue;
        }
        if (segment[1] === source) {
          const segmentStart = segment[2];
          const segmentEnd = segment[2] + segment[0].length;
          if (segmentStart <= startOffset && segmentEnd >= endOffset) {
            const inserts = [];
            if (startOffset > segmentStart) {
              inserts.push(trimSegmentEnd(segment, startOffset - segmentStart));
            }
            for (const newSegment of newSegments) {
              inserts.push(newSegment);
            }
            if (endOffset < segmentEnd) {
              inserts.push(trimSegmentStart(segment, endOffset - segmentEnd));
            }
            combineStrings(inserts);
            (0, track_1.offsetStack)();
            segments.splice(segments.indexOf(segment), 1, ...inserts);
            (0, track_1.resetOffsetStack)();
            return true;
          }
        }
      }
      return false;
    }
    exports.replaceSourceRange = replaceSourceRange;
    function replaceRange(segments, startOffset, endOffset, ...newSegments) {
      const offsets = toOffsets(segments);
      const startIndex = (0, binarySearch_1.binarySearch)(offsets, startOffset);
      const endIndex = (0, binarySearch_1.binarySearch)(offsets, endOffset);
      const startSegment = segments[startIndex];
      const endSegment = segments[endIndex];
      const startSegmentStart = offsets[startIndex];
      const endSegmentStart = offsets[endIndex];
      const endSegmentEnd = offsets[endIndex] + (typeof endSegment === "string" ? endSegment.length : endSegment[0].length);
      const inserts = [];
      if (startOffset > startSegmentStart) {
        inserts.push(trimSegmentEnd(startSegment, startOffset - startSegmentStart));
      }
      for (const newSegment of newSegments) {
        inserts.push(newSegment);
      }
      if (endOffset < endSegmentEnd) {
        inserts.push(trimSegmentStart(endSegment, endOffset - endSegmentStart));
      }
      combineStrings(inserts);
      (0, track_1.offsetStack)();
      segments.splice(startIndex, endIndex - startIndex + 1, ...inserts);
      (0, track_1.resetOffsetStack)();
    }
    exports.replaceRange = replaceRange;
    function combineStrings(segments) {
      for (let i2 = segments.length - 1; i2 >= 1; i2--) {
        if (typeof segments[i2] === "string" && typeof segments[i2 - 1] === "string") {
          segments[i2 - 1] = segments[i2 - 1] + segments[i2];
          (0, track_1.offsetStack)();
          segments.splice(i2, 1);
          (0, track_1.resetOffsetStack)();
        }
      }
    }
    function trimSegmentEnd(segment, trimEnd) {
      if (typeof segment === "string") {
        return segment.slice(0, trimEnd);
      }
      return [
        segment[0].slice(0, trimEnd),
        ...segment.slice(1)
      ];
    }
    function trimSegmentStart(segment, trimStart) {
      if (typeof segment === "string") {
        return segment.slice(trimStart);
      }
      if (trimStart < 0) {
        trimStart += segment[0].length;
      }
      return [
        segment[0].slice(trimStart),
        segment[1],
        segment[2] + trimStart,
        ...segment.slice(3)
      ];
    }
    function toOffsets(segments) {
      const offsets = [];
      let offset = 0;
      for (const segment of segments) {
        offsets.push(offset);
        offset += typeof segment == "string" ? segment.length : segment[0].length;
      }
      return offsets;
    }
  }
});

// src/volar.ts
init_cjs_shims();

// node_modules/.pnpm/ts-macro@0.1.9_rollup@4.27.4_typescript@5.7.2/node_modules/ts-macro/dist/index.mjs
init_cjs_shims();
var import_muggle_string = __toESM(require_out(), 1);
var import_muggle_string2 = __toESM(require_out(), 1);
var A = __toESM(require_out(), 1);
var y = Object.defineProperty;
var h = Object.getOwnPropertyDescriptor;
var O = Object.getOwnPropertyNames;
var P = Object.prototype.hasOwnProperty;
var x = (o, t) => {
  for (var e in t) y(o, e, { get: t[e], enumerable: true });
};
var f = (o, t, e, n) => {
  if (t && typeof t == "object" || typeof t == "function") for (let s of O(t)) !P.call(o, s) && s !== e && y(o, s, { get: () => t[s], enumerable: !(n = h(t, s)) || n.enumerable });
  return o;
};
var i = (o, t, e) => (f(o, t, "default"), e && f(e, t, "default"));
var a = {};
x(a, { TsmVirtualCode: () => m, allCodeFeatures: () => c, createPlugin: () => S, defineConfig: () => b, replaceRange: () => C });
var c = { completion: true, format: true, navigation: true, semantic: true, structure: true, verification: true };
var m = class {
  constructor(t, e, n = "tsx", s = []) {
    __publicField(this, "id");
    __publicField(this, "mappings");
    __publicField(this, "embeddedCodes", []);
    __publicField(this, "codes", []);
    __publicField(this, "snapshot");
    __publicField(this, "source");
    var _a;
    this.filePath = t;
    this.ast = e;
    this.languageId = n;
    this.plugins = s;
    this.id = `root_${this.languageId}`, this.codes.push(`/* placeholder */
`, [`
`, void 0, 0, c], [e.text, void 0, 0, c]);
    for (let u of this.plugins) try {
      (_a = u.resolveVirtualCode) == null ? void 0 : _a.call(u, this);
    } catch (g) {
      console.error(`[${u.name}]:`, g);
    }
    this.mappings = T(this.codes);
    let p = (0, import_muggle_string.toString)(this.codes);
    this.snapshot = { getLength: () => p.length, getText: (u, g) => p.slice(u, g), getChangeRange() {
    } };
  }
};
function T(o) {
  let t = 0, e = [];
  for (let n of o) typeof n == "string" ? t += n.length : (e.push({ sourceOffsets: [n[2]], generatedOffsets: [t], lengths: [n[0].length], data: n[3] }), t += n[0].length);
  return e;
}
function b(o) {
  return o;
}
function S(o) {
  return (t) => (t == null ? void 0 : t.modules) ? [o({ ts: t.modules.typescript, ...t })].flatMap((e) => {
    var _a, _b, _c;
    return e.resolveVirtualCode && ((_a = e.resolveEmbeddedCode) != null ? _a : e.resolveEmbeddedCode = (n, s, p) => {
      var _a2;
      for (let u of ["script", "scriptSetup"]) {
        let g = (_a2 = s[u]) == null ? void 0 : _a2.ast;
        g && e.resolveVirtualCode({ ast: g, source: u, filePath: n, id: p.id, codes: p.content, languageId: p.lang, embeddedCodes: p.embeddedCodes, linkedCodeMappings: p.linkedCodeMappings });
      }
    }), (_b = e.order) != null ? _b : e.order = e.enforce === "pre" ? -1 : e.enforce === "post" ? 1 : 0, (_c = e.version) != null ? _c : e.version = 2.1, e;
  }) : (e) => o(e, t);
}
var r = {};
x(r, { replaceRange: () => C });
i(r, A);
function C(o, t, e, ...n) {
  return (0, import_muggle_string2.replaceSourceRange)(o, void 0, t, e, ...n);
}
i(a, r);

// src/volar.ts
var plugin = S(({ ts }, options) => {
  const currentDirectory = ts.sys.getCurrentDirectory();
  const dts = typeof (options == null ? void 0 : options.dts) === "string" ? options.dts : `${ts.sys.getCurrentDirectory()}/components.d.ts`;
  function getComponents() {
    const configContent = ts.sys.readFile(dts);
    if (!configContent)
      return;
    const ast = ts.createSourceFile(dts, configContent, 99);
    const result = {};
    function collect(node, name) {
      if (ts.isIndexedAccessTypeNode(node) && ts.isImportTypeNode(node.objectType)) {
        const { indexType, objectType } = node;
        result[name] = `import { ${getText(indexType, ast, ts).slice(1, -1)} as ${name} } from ${getText(objectType.argument, ast, ts)}`;
      }
    }
    ts.forEachChild(ast, (node) => {
      if (ts.isModuleDeclaration(node) && node.body && ts.isModuleBlock(node.body)) {
        node.body.statements.forEach((statement) => {
          if (getText(node.name, ast, ts) === "global") {
            if (ts.isVariableStatement(statement)) {
              ts.forEachChild(statement.declarationList, (declaration) => {
                if (ts.isVariableDeclaration(declaration) && declaration.initializer && ts.isAsExpression(declaration.initializer)) {
                  collect(declaration.initializer.type, getText(declaration.name, ast, ts));
                }
              });
            }
          } else if (ts.isInterfaceDeclaration(statement) && getText(statement.name, ast, ts) === "GlobalComponents") {
            statement.members.forEach((member) => {
              if (ts.isPropertySignature(member) && member.type) {
                collect(member.type, getText(member.name, ast, ts));
              }
            });
          }
        });
      }
    });
    return result;
  }
  let watched = false;
  let components;
  return {
    name: "ts-macro-components-jsx",
    resolveVirtualCode({ codes, ast }) {
      var _a, _b;
      if (!watched) {
        components = getComponents();
        (_b = (_a = ts.sys).watchFile) == null ? void 0 : _b.call(_a, dts, () => {
          components = getComponents();
        });
        watched = true;
      }
      if (!components)
        return;
      const nodes = [];
      const imports = [];
      function walk(node) {
        if (ts.isImportDeclaration(node) && node.importClause && ts.isImportClause(node.importClause)) {
          if (node.importClause.name) {
            imports.push(getText(node.importClause.name, ast, ts));
          } else if (node.importClause.namedBindings && ts.isNamedImportBindings(node.importClause.namedBindings)) {
            if (ts.isNamespaceImport(node.importClause.namedBindings)) {
              imports.push(getText(node.importClause.namedBindings.name, ast, ts));
            } else {
              node.importClause.namedBindings.elements.forEach((element) => {
                imports.push(getText(element.name, ast, ts));
              });
            }
          }
        }
        if (ts.isJsxOpeningElement(node) || ts.isJsxSelfClosingElement(node)) {
          const name = node.tagName.getText(ast);
          if ((components == null ? void 0 : components[name]) && !imports.includes(name)) {
            nodes.push(components[name].replace("./", `${currentDirectory}/`));
          }
        }
        ts.forEachChild(node, walk);
      }
      ts.forEachChild(ast, walk);
      if (nodes.length)
        codes.splice(1, 0, nodes.join(";\n"));
    }
  };
});
var volar_default = plugin;
function getStart(node, ast, ts) {
  return ts.getTokenPosOfNode(node, ast);
}
function getText(node, ast, ts) {
  return ast.text.slice(getStart(node, ast, ts), node.end);
}


exports.default = volar_default;