@bobe-js/lang-core 0.0.1

package/dist/bobe-language-core.esm.js

@@ -0,0 +1,940 @@
+import { NodeType, Tokenizer, Compiler } from 'bobe/compiler';
+import { TypeFlags, SymbolFlags } from 'typescript';
+
+const G = {};
+function log(...args) {
+  G.log?.info?.(args.join(" "));
+}
+const Virtual_File_Suffix = "__bobe_virtual_file__";
+const Virtual_File_Exp = /__bobe_virtual_file__/;
+
+class LRUCache {
+  constructor(maxSize) {
+    this.cache = /* @__PURE__ */ new Map();
+    // 新增 has 方法，检查某个键是否在缓存中
+    this.has = this.cache.has.bind(this.cache);
+    this.delete = this.cache.delete.bind(this.cache);
+    this.maxSize = maxSize;
+  }
+  get(key) {
+    if (!this.cache.has(key)) {
+      return void 0;
+    }
+    const value = this.cache.get(key);
+    this.cache.delete(key);
+    this.cache.set(key, value);
+    return value;
+  }
+  set(key, value) {
+    if (this.cache.has(key)) {
+      this.cache.delete(key);
+      this.cache.set(key, value);
+    } else {
+      if (this.cache.size >= this.maxSize) {
+        this.cache.delete(this.cache.keys().next().value);
+      }
+      this.cache.set(key, value);
+    }
+  }
+}
+const cache = new LRUCache(1e3);
+function memo(fn) {
+  const wrap = (v) => {
+    const res = fn(v);
+    cache.set(v, res);
+    return res;
+  };
+  return wrap;
+}
+function createMemo() {
+  const cache2 = new LRUCache(1e3);
+  return function memo2(fn) {
+    const wrap = (v) => {
+      const res = fn(v);
+      cache2.set(v, res);
+      return res;
+    };
+    return wrap;
+  };
+}
+function uniqBy(arr, keyFn) {
+  const seen = /* @__PURE__ */ new Set();
+  return arr.filter((item) => {
+    const key = keyFn(item);
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+function getVirtualName(fileName) {
+  const dotI = fileName.lastIndexOf(".");
+  const rawName = fileName.slice(0, dotI);
+  const suffix = fileName.slice(dotI);
+  return rawName + Virtual_File_Suffix + suffix;
+}
+function getRealName(virtualFileName) {
+  return virtualFileName.replace(Virtual_File_Exp, "");
+}
+function isVirtualFile(fileName) {
+  return fileName.match(Virtual_File_Exp);
+}
+function isOverlap(start1, end1, start2, end2) {
+  return start1 < end2 && start2 < end1;
+}
+function inInsBrace(content, targetIndex) {
+  let stack = [];
+  for (let i = 0; i < content.length; i++) {
+    if (i === targetIndex) {
+      return stack.length > 0 && stack[stack.length - 1] === "block";
+    }
+    const char = content[i];
+    const nextChar = content[i + 1];
+    if (char === "$" && nextChar === "{") {
+      stack.push("expression");
+      i++;
+      continue;
+    }
+    if (char === "{") {
+      stack.push("block");
+      continue;
+    }
+    if (char === "}") {
+      stack.pop();
+      continue;
+    }
+  }
+  return false;
+}
+function isBobeIdentifier(node, tss) {
+  return tss.isIdentifier(node.tag) && node.tag.text === "bobe";
+}
+function isBobeTemplate(node, tss) {
+  return tss.isTaggedTemplateExpression(node) && isBobeIdentifier(node, tss);
+}
+function sfHasBobeTemplate(sf, tss) {
+  let hasBobe = false;
+  function visit(node) {
+    if (hasBobe) {
+      return;
+    }
+    if (isBobeTemplate(node, tss)) {
+      hasBobe = true;
+    } else {
+      tss.forEachChild(node, visit);
+    }
+  }
+  visit(sf);
+  return hasBobe;
+}
+const strHasBobeTemplate = (str) => str.match(/bobe(?:\\s*(<)([^`]*)(>))?`/);
+function findPrecedingClassNode(targetNode, sourceFile, tss) {
+  let result, alreadyCrossTargetNode = false;
+  function visit(node) {
+    if (node.pos >= targetNode.pos || alreadyCrossTargetNode || result) {
+      return alreadyCrossTargetNode = true;
+    }
+    if (isClass(node, tss) && node.name && contains(node, targetNode)) {
+      result = node;
+    }
+    tss.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  return result;
+}
+function findPrecedingBobeTemplate(targetNode, classNode, tss) {
+  let result;
+  function visit(node) {
+    if (node.pos >= targetNode.pos) return;
+    if (isBobeTemplate(node, tss)) {
+      result = node;
+    }
+    tss.forEachChild(node, visit);
+  }
+  visit(classNode);
+  return result;
+}
+function getClassMembersInClass(classNode, tss) {
+  const names = [];
+  for (const member of classNode.members) {
+    if (isClassProp(member, tss)) {
+      names.push(member);
+    }
+  }
+  return names;
+}
+function getClassMemberNames(className, rangeNode, tss) {
+  const names = [];
+  function visit(node) {
+    if (isClass(node, tss) && node.name?.text === className) {
+      for (const member of node.members) {
+        if (isClassProp(member, tss)) {
+          names.push(member);
+        }
+      }
+      return;
+    }
+    tss.forEachChild(node, visit);
+  }
+  visit(rangeNode);
+  return names;
+}
+function calcAbsSourceMap(cursorOffset, templates, isVirtualCursor = false) {
+  const compareKey = isVirtualCursor ? "codeOffset" : "originOffset";
+  const startKey = isVirtualCursor ? "virtualStart" : "templateStart";
+  for (let i = templates.length; i--; ) {
+    const template = templates[i];
+    if (template[startKey] < cursorOffset) {
+      for (const map of template.sourceMap) {
+        if (cursorOffset >= map[compareKey] && cursorOffset <= map[compareKey] + map.length) {
+          const { codeOffset: virtualStart, originOffset: originStart, length } = map;
+          const dt = cursorOffset - map[compareKey];
+          return {
+            virtualStart,
+            originStart,
+            virtualOffset: virtualStart + dt,
+            originOffset: originStart + dt,
+            length
+          };
+        }
+      }
+    }
+  }
+}
+function inWitchVirtualPart(absCursorOffset, templates) {
+  for (const template of templates) {
+    const range = template.headTemplate?.findRange(absCursorOffset);
+    if (range) {
+      return { template, part: "headTemplate", range };
+    } else {
+      for (const area of template?.headAreas || []) {
+        const found = area.findRange(absCursorOffset);
+        if (found) {
+          return { template, part: "headClass", range: found };
+        }
+      }
+    }
+  }
+  return { template: void 0, part: void 0, range: void 0 };
+}
+function calcHeadSourceMap(absCursorOffset, templates) {
+  let virtualStart;
+  let originStart, length;
+  for (const tmpl of templates) {
+    if (!inVirtualHead(tmpl.headMap, { start: absCursorOffset }, tmpl)) continue;
+    const cursorOffset = absCursorOffset - tmpl.iifeStartInVirtual;
+    for (const entry of tmpl.headMap) {
+      if (cursorOffset >= entry.codeOffset && cursorOffset <= entry.codeOffset + entry.length) {
+        virtualStart = tmpl.iifeStartInVirtual + entry.codeOffset;
+        originStart = entry.originOffset;
+        const dt = cursorOffset - entry.codeOffset;
+        length = entry.length;
+        return {
+          virtualStart,
+          originStart,
+          virtualOffset: virtualStart + dt,
+          originOffset: originStart + dt,
+          length
+        };
+      }
+    }
+  }
+}
+function fixTextSpan(textSpan, code, map) {
+  const originalCode = code.slice(map.originStart, map.originStart + map.length);
+  if (textSpan.length < map.length && !originalCode.match(domPropertyExp)) {
+    const { start, length } = textSpan;
+    const targetStart = map.originOffset - (map.virtualOffset - start);
+    return { start: targetStart, length };
+  }
+  return { start: map.originStart, length: map.length };
+}
+function getPosTemplateCtx(info, tss, fileName, position) {
+  const sf = info.languageService.getProgram()?.getSourceFile(fileName);
+  if (!sf) return null;
+  const node = findNodeAtPosition(tss, sf, position);
+  if (!node) return null;
+  const templateNode = getValidBobeTemplateNode(tss, node);
+  if (!templateNode || position <= templateNode.pos) return null;
+  const baseOffset = templateNode.getStart() + 1;
+  const ctx = makeContext(templateNode, sf, fileName, baseOffset);
+  const relPos = getRelativePosition(info, baseOffset, fileName, position);
+  return { ctx, relPos };
+}
+function getSourceFileAndNode(info, tss, fileName, position) {
+  const sf = info.languageService.getProgram()?.getSourceFile(fileName);
+  if (!sf) return null;
+  const node = findNodeAtPosition(tss, sf, position);
+  if (!node) return null;
+  return { sf, node };
+}
+function getValidBobeTemplateNode(tss, node) {
+  switch (node.kind) {
+    case tss.SyntaxKind.TaggedTemplateExpression: {
+      const t = node;
+      return isBobeIdentifier(t, tss) ? t.template : void 0;
+    }
+    case tss.SyntaxKind.NoSubstitutionTemplateLiteral: {
+      const p = node.parent;
+      return p && isBobeTemplate(p, tss) ? node : void 0;
+    }
+    case tss.SyntaxKind.TemplateHead:
+      return node.parent?.parent ? getValidBobeTemplateNode(tss, node.parent.parent) : void 0;
+    case tss.SyntaxKind.TemplateMiddle:
+    case tss.SyntaxKind.TemplateTail:
+      return node.parent?.parent?.parent ? getValidBobeTemplateNode(tss, node.parent.parent.parent) : void 0;
+    default:
+      return void 0;
+  }
+}
+function getRelativePosition(info, baseOffset, fileName, position) {
+  const scriptInfo = info.project.getScriptInfo(fileName);
+  if (!scriptInfo) return { line: 0, column: 0, offset: position - baseOffset };
+  const baseLoc = scriptInfo.positionToLineOffset(baseOffset);
+  const cursorLoc = scriptInfo.positionToLineOffset(position);
+  const bl = baseLoc.line - 1, bc = baseLoc.offset - 1;
+  const cl = cursorLoc.line - 1, cc = cursorLoc.offset - 1;
+  return { line: cl - bl, column: cl === bl ? cc - bc : cc, offset: position - baseOffset };
+}
+function makeContext(templateNode, sf, fileName, baseOffset) {
+  return { node: templateNode, fileName, text: templateNode.getText().slice(1, -1), sf, baseOffset };
+}
+function findNodeAtPosition(tss, sf, position) {
+  function find(node) {
+    if (position >= node.getStart() && position < node.getEnd()) {
+      return tss.forEachChild(node, find) || node;
+    }
+    return void 0;
+  }
+  return find(sf);
+}
+function findTemplateTypePos(templates, pos) {
+  for (const tmpl of templates) {
+    const { typeMap } = tmpl;
+    if (!typeMap) continue;
+    const { originOffset, codeOffset, length } = typeMap;
+    if (originOffset <= pos && pos < originOffset + length) {
+      const dt = pos - originOffset;
+      return {
+        virtualStart: codeOffset,
+        originStart: originOffset,
+        virtualOffset: codeOffset + dt,
+        originOffset: originOffset + dt,
+        length
+      };
+    }
+  }
+}
+const domPropertyExp = /^[a-zA-Z][\w-]*$/;
+const AND = `__BOBE_AND_${Date.now().toString(36)}__`;
+function isClassProp(node, tss) {
+  return tss.isPropertyDeclaration(node) || tss.isMethodDeclaration(node) && tss.isIdentifier(node.name);
+}
+function isClass(node, tss) {
+  return tss.isClassDeclaration(node) || tss.isClassExpression(node);
+}
+function* getSharedItems(arr1, arr2, isEqual, isBigger) {
+  const it1 = arr1[Symbol.iterator]();
+  const it2 = arr2[Symbol.iterator]();
+  let res1 = it1.next();
+  let res2 = it2.next();
+  while (!res1.done && !res2.done) {
+    const v1 = res1.value;
+    const v2 = res2.value;
+    if (isEqual(v1, v2)) {
+      yield [v1, v2];
+      res1 = it1.next();
+      res2 = it2.next();
+    } else if (isBigger(v1, v2)) {
+      res2 = it2.next();
+    } else {
+      res1 = it1.next();
+    }
+  }
+}
+const inVirtualPart = (sf, textSpan) => textSpan.start > sf.getFullWidth();
+const inVirtualHead = (headMap, textSpan, tmpl) => tmpl.iifeStartInVirtual + headMap.range[0] <= textSpan.start && textSpan.start < tmpl.iifeStartInVirtual + headMap.range[1];
+const contains = (parent, child) => (
+  // parent.pos 是包含注释和空白的起始位置
+  // parent.getStart() 是代码实际开始的位置
+  child.getStart() >= parent.getStart() && child.getEnd() <= parent.getEnd()
+);
+const processHandlers = (fns, node) => {
+  for (const handler of fns) {
+    const shouldSkip = handler(node);
+    if (shouldSkip != null) {
+      return shouldSkip;
+    }
+  }
+  return 0;
+};
+class Range {
+  constructor(start, end) {
+    this.start = start;
+    this.end = end;
+  }
+  contains(pos) {
+    return this.start <= pos && pos < this.end;
+  }
+}
+class Area {
+  constructor() {
+    this.ranges = [];
+  }
+  get start() {
+    return this.ranges[0]?.start || -1;
+  }
+  get end() {
+    return this.ranges[this.ranges.length - 1]?.end || -1;
+  }
+  findRange(pos) {
+    if (!Range.prototype.contains.call(this, pos)) {
+      return;
+    }
+    for (const range of this.ranges) {
+      if (range.contains(pos)) {
+        return range;
+      }
+    }
+  }
+  addRange(start, end) {
+    this.ranges.push(new Range(start, end));
+  }
+}
+
+class Dent {
+  constructor(base) {
+    this.base = base;
+    this.stack = [base];
+  }
+  get v() {
+    const length = this.stack[this.stack.length - 1];
+    return new Array(length).fill(" ").join("");
+  }
+  indent() {
+    const length = this.stack[this.stack.length - 1];
+    this.stack.push(length + 2);
+  }
+  dedent() {
+    this.stack.pop();
+  }
+}
+const BRACE_REG = /(^\$\{)|(^\{)|(\}$)/g;
+const BOBE_PREFIX = "$Bobe" + Date.now().toString(36);
+const BOBE_DOM_PROP_TRANSFER = `type ${BOBE_PREFIX}ToMap<K extends string, T> = {
+  [P in K]?: T;
+};
+type ${BOBE_PREFIX}BooleanProps = ${BOBE_PREFIX}ToMap<
+  'disabled' | 'checked' | 'selected' | 'readonly' | 'required' | 
+  'multiple' | 'hidden' | 'autofocus' | 'novalidate' | 'ismap' | 
+  'open' | 'reversed' | 'indeterminate', 
+  boolean|string|undefined|null
+>;
+type ${BOBE_PREFIX}NumericProps = ${BOBE_PREFIX}ToMap<
+  'style'|'value' | 'placeholder' | 'title' | 'alt' | 'width' | 'height' | 'columnCount' | 'tabIndex' | 'maxLength' | 
+  'minLength' | 'size' | 'rows' | 'cols' | 'span' | 'start' | 
+  'valueAsNumber' | 'max' | 'min' | 'step', 
+  string|number|undefined|null
+>;
+type ${BOBE_PREFIX}NativeProperties = ${BOBE_PREFIX}BooleanProps & ${BOBE_PREFIX}NumericProps;
+type ${BOBE_PREFIX}CreateTextOrComponent = {
+  <T>(a: {defineProps?: T} & Record<any, any>): T;
+  <T extends new (...args: any[]) =>any>(input: T): InstanceType<T>;
+  (input: any): Text;
+};
+let ${BOBE_PREFIX}_h!:<K extends keyof HTMLElementTagNameMap>(
+  tag: K, 
+  options?: ElementCreationOptions
+) => Omit<HTMLElementTagNameMap[K], keyof ${BOBE_PREFIX}NativeProperties |'textContent' > & { text: string|number|undefined|null } & ${BOBE_PREFIX}NativeProperties & Record<string, any>;
+let ${BOBE_PREFIX}_t!: ${BOBE_PREFIX}CreateTextOrComponent;
+`;
+class Bobe2ts {
+  constructor(c, template, templateStart, virtualStart, templateCode) {
+    this.c = c;
+    this.template = template;
+    this.templateStart = templateStart;
+    this.virtualStart = virtualStart;
+    this.templateCode = templateCode;
+    this.res = {
+      output: "",
+      input: "",
+      sourceMap: []
+    };
+    this.dent = new Dent(2);
+    this.lines = [];
+    this.output = ``;
+    this.createSetPropsExp = (props, name) => {
+      const nameDot = `${name}.`;
+      props.forEach((_prop) => {
+        const prop = _prop;
+        const loc = prop.key.loc;
+        let { source: key } = loc;
+        this.map(this.off(prop.key), this.output.length + nameDot.length, key.length);
+        let replaceCount = 0;
+        key = key.replace(/\-(\w)/g, (_, match) => {
+          const res = match.toUpperCase();
+          replaceCount++;
+          return res;
+        });
+        key = key + new Array(replaceCount).fill(" ").join("");
+        const assignLeft = `${nameDot}${key}=`;
+        this.output += assignLeft;
+        if (!prop.value) {
+          this.output += "null;";
+          return;
+        }
+        if (prop.inlineName) {
+          this.output += `${prop.inlineName} as any;`;
+          return;
+        }
+        let { source: value } = prop.value.loc;
+        if (prop.value.type === NodeType.DynamicValue) {
+          value = value.replace(BRACE_REG, " ");
+        }
+        this.map(this.off(prop.value), this.output.length, value.length);
+        this.output += value + ";";
+      });
+    };
+    this.idg = c.idg || new IdGenerator();
+    this.program = c.program;
+    const tokenizer = this.tokenizer = new Tokenizer(() => void 0, false);
+    tokenizer.setCode(templateCode);
+    this.compiler = new Compiler(tokenizer, {
+      parsePropertyInlineFragment: {
+        enter: (node) => {
+          const prop = node.parent;
+          const component = prop.parent;
+          const { varName: cmpInsName, templateSpan } = component.componentName;
+          const key = prop.key.key;
+          const inlineName = this.idg.name;
+          this.idg.i++;
+          prop.inlineName = inlineName;
+          this.output += `let ${inlineName}=(`;
+          const rightBrace = `}: NonNullable<NonNullable<(typeof ${cmpInsName})['${key}']>['defineProps']>) => {
+`;
+          if (templateSpan && this.program) {
+            const area = new Area();
+            this.output += "{";
+            const checker = this.program.getTypeChecker();
+            const gotType = checker.getTypeAtLocation(templateSpan.expression);
+            const exec = new PropertyExtractor(checker, key, templateSpan.expression);
+            const names = exec.extractPropertyNames(gotType);
+            for (const name of names) {
+              const start = this.output.length;
+              this.output += `${name}:${name},`;
+              area.addRange(this.virtualStart + start, this.virtualStart + this.output.length);
+            }
+            this.output += rightBrace;
+            this.template.headAreas.push(area);
+          } else {
+            this.c.undoneDocPoint.push(this.output.length);
+            this.output += `{${rightBrace}`;
+          }
+        },
+        leave: () => {
+          this.output += `};
+`;
+        }
+      },
+      parseElementNode: {
+        propsAdded: (node) => {
+          const _node = node;
+          const tagName = _node.tagName;
+          const varName = this.idg.name;
+          this.output += `${this.dent.v}let ${varName}=${BOBE_PREFIX}_h('`;
+          this.map(this.off(_node), this.output.length, tagName.length);
+          this.output += `${tagName}');`;
+          this.createSetPropsExp(_node.props, varName);
+          this.output += `
+`;
+          this.idg.i++;
+        }
+      },
+      parseName: {
+        leave: (node) => {
+          const varName = this.idg.name;
+          this.idg.i++;
+          const name = node;
+          name.varName = varName;
+          const source = name.loc.source;
+          const sourceName = source.replace(BRACE_REG, (match) => {
+            if (match.length === 1) return " ";
+            return "  ";
+          });
+          this.output += `${this.dent.v}let ${varName}=${BOBE_PREFIX}_t(`;
+          const map = this.map(this.off(name), this.output.length, source.length);
+          this.output += `${sourceName});
+`;
+          if (name.type !== NodeType.StaticValue) {
+            return;
+          }
+          let ins;
+          while ((ins = this.nextInsExp()) != null) {
+            const insStart = ins.getFullStart();
+            if (insStart > map.originOffset) {
+              if (insStart < map.originOffset + map.length) {
+                name.templateSpan = ins;
+              }
+              break;
+            }
+          }
+        }
+      },
+      parseComponentNode: {
+        propsAdded: (node) => {
+          const _node = node;
+          const name = _node.componentName;
+          this.createSetPropsExp(_node.props, name.varName);
+          this.output += `
+`;
+        }
+      },
+      parseConditionalNode: {
+        propsAdded: (node) => {
+          const _node = node;
+          const cond = _node.condition;
+          const condVal = cond.loc.source;
+          const ifHeadS = `${this.dent.v}if(`;
+          this.output += ifHeadS;
+          this.map(this.off(cond), this.output.length, condVal.length);
+          this.output += condVal + `){
+`;
+          this.dent.indent();
+        },
+        leave: (node) => {
+          this.dent.dedent();
+          this.output += `${this.dent.v}}
+`;
+        }
+      },
+      parseLoopNode: {
+        propsAdded: (node) => {
+          const _node = node;
+          this.output += `${this.dent.v}`;
+          const { collection: arr, item, index, key } = _node;
+          this.map(this.off(arr), this.output.length, arr.loc.source.length);
+          this.output += arr.loc.source + ".forEach((";
+          this.map(this.off(item), this.output.length, item.loc.source.length);
+          this.output += item.loc.source;
+          if (index) {
+            this.output += ",";
+            this.map(this.off(index), this.output.length, index.loc.source.length);
+            this.output += index.loc.source;
+          }
+          this.output += `)=>{`;
+          if (key) {
+            this.output += `let ${this.idg.k}=`;
+            this.map(this.off(key), this.output.length, key.loc.source.length);
+            this.output += key.loc.source + ";";
+          }
+          this.output += "\n";
+          this.dent.indent();
+        },
+        leave: (node) => {
+          this.dent.dedent();
+          this.output += `${this.dent.v}});
+`;
+        }
+      }
+    });
+  }
+  map(templateOffset, codeOffset, length) {
+    const item = {
+      originOffset: this.templateStart + templateOffset,
+      codeOffset: this.virtualStart + codeOffset,
+      length
+    };
+    this.res.sourceMap.push(item);
+    return item;
+  }
+  nextInsExp() {
+    const nextData = this.c.tempStaticIns?.next();
+    return nextData?.value;
+  }
+  off(n) {
+    return n.loc.start.offset - 1;
+  }
+  process() {
+    this.compiler.parseProgram();
+    return {
+      output: this.output,
+      input: this.templateCode,
+      sourceMap: this.res.sourceMap,
+      errors: this.compiler.errors
+    };
+  }
+}
+class IdGenerator {
+  constructor() {
+    this.id = Date.now().toString(36);
+    this.i = 0;
+  }
+  get name() {
+    return `${BOBE_PREFIX}_var_${this.id}_${this.i}`;
+  }
+  get h() {
+    return `h_${this.id}`;
+  }
+  get t() {
+    return `t_${this.id}`;
+  }
+  get k() {
+    return `${BOBE_PREFIX}_for_key_${this.id}`;
+  }
+}
+class PropertyExtractor {
+  constructor(checker, key, locationNode) {
+    this.checker = checker;
+    this.key = key;
+    this.locationNode = locationNode;
+  }
+  /**
+   * 主入口：两步提取属性名
+   * 1. 解析 midType（通过 key 从原始类型中获取）
+   * 2. 从 midType 中提取属性名列表
+   * 中间任何一步不符合正向逻辑时返回空数组
+   */
+  extractPropertyNames(type) {
+    if (!type || type.intrinsicName === "error") {
+      return [];
+    }
+    const midType = this.resolveMidType(type);
+    if (!midType) return [];
+    const midTStr = this.checker.typeToString(midType);
+    log("midType:", midTStr);
+    return this.extractNamesFromMidType(midType);
+  }
+  /**
+   * Step 1: 获取传入类型对应实例属性的 key 的类型 (midType)
+   * 1.1 classType 是类 → 获取实例类型 → 获取 instance.key 的类型
+   * 1.2 classType 是 { defineProps?: T } → 获取 defineProps.key 的类型
+   */
+  resolveMidType(type) {
+    if (this.isClassType(type)) {
+      const symbol = type.getSymbol() || type.aliasSymbol;
+      if (!symbol) return null;
+      const instanceType = this.checker.getDeclaredTypeOfSymbol(symbol);
+      if (!(instanceType.flags & TypeFlags.Object)) return null;
+      const targetProp = instanceType.getProperty(this.key);
+      if (!targetProp) return null;
+      return this.checker.getTypeOfSymbolAtLocation(targetProp, this.locationNode);
+    }
+    if (this.isObjectType(type)) {
+      const defineProps = type.getProperty("defineProps");
+      if (defineProps) {
+        const definePropsType = this.checker.getTypeOfSymbolAtLocation(defineProps, this.locationNode);
+        const targetProp = definePropsType.getProperty(this.key);
+        if (!targetProp) return null;
+        return this.checker.getTypeOfSymbolAtLocation(targetProp, this.locationNode);
+      }
+    }
+    return null;
+  }
+  /**
+   * Step 2: 处理 midType，提取属性名列表
+   * 2.1 midType 是 class → 获取其实例的所有属性名
+   * 2.2 midType 是 { defineProps?: T } → 获取 defineProps 的所有属性名
+   */
+  extractNamesFromMidType(midType) {
+    if (midType.flags & TypeFlags.UnionOrIntersection) {
+      const types = midType.types;
+      if (types) {
+        for (const t of types) {
+          const names = this.extractNamesFromMidType(t);
+          if (names.length > 0) return names;
+        }
+      }
+      return [];
+    }
+    if (this.isClassType(midType)) {
+      const symbol = midType.getSymbol() || midType.aliasSymbol;
+      if (!symbol) return [];
+      const instanceType = this.checker.getDeclaredTypeOfSymbol(symbol);
+      if (!(instanceType.flags & TypeFlags.Object)) return [];
+      return this.getStandardProperties(instanceType);
+    }
+    if (this.isObjectType(midType)) {
+      const defineProps = midType.getProperty("defineProps");
+      if (defineProps) {
+        const definePropsType = this.checker.getTypeOfSymbolAtLocation(defineProps, this.locationNode);
+        return this.extractNamesFromMidType(definePropsType);
+      }
+      return this.getStandardProperties(midType);
+    }
+    return [];
+  }
+  /**
+   * 判断是否为 Class（构造函数静态类型）
+   */
+  isClassType(type) {
+    const symbol = type.getSymbol() || type.aliasSymbol;
+    if (!symbol) return false;
+    return !!(symbol.flags & (SymbolFlags.Class | SymbolFlags.Function));
+  }
+  /**
+   * 判断是否为普通对象类型 (Object)
+   */
+  isObjectType(type) {
+    return !!(type.flags & TypeFlags.Object);
+  }
+  /**
+   * 获取类型的所有属性名（排除 prototype 等元属性）
+   */
+  getStandardProperties(type) {
+    try {
+      const props = this.checker.getPropertiesOfType(type);
+      return props.map((p) => p.name).filter((name) => name !== "prototype");
+    } catch {
+      return [];
+    }
+  }
+}
+
+function findBobeTemplatesInClass(classNode, tss, sourceFile, program) {
+  const preInfos = [];
+  const checker = program?.getTypeChecker();
+  function visit(node) {
+    if (isBobeTemplate(node, tss)) {
+      const template = node.template;
+      const typeArg = node.typeArguments?.[0];
+      let props = void 0, parent = node.parent, uiName = void 0, typeExp = void 0;
+      for (let i = 0; i < 5 && parent; i++) {
+        const parentIsAssign = tss.isPropertyDeclaration(parent);
+        if (parentIsAssign) {
+          uiName = parent.name.getText();
+          break;
+        }
+      }
+      if (typeArg && checker && uiName) {
+        typeExp = typeArg.getText();
+        const typeNode = checker.getTypeAtLocation(typeArg);
+        const propNodes = checker.getPropertiesOfType(typeNode);
+        props = propNodes.map((prop) => prop.name);
+      }
+      const raw = tss.isNoSubstitutionTemplateLiteral(template) ? template.rawText ?? template.text : template.getText().slice(1, -1);
+      const templateStart = template.getStart() + 1;
+      preInfos.push({
+        raw,
+        uiName,
+        typeExp,
+        props,
+        className: classNode.name?.text || "",
+        sf: sourceFile,
+        templateStart
+      });
+    } else {
+      tss.forEachChild(node, visit);
+    }
+  }
+  visit(classNode);
+  return preInfos;
+}
+let c = {};
+function buildVirtualDocument(sourceFile, tss, program) {
+  const source = sourceFile.text;
+  const virtualCode = source + "\nexport {};\n" + BOBE_DOM_PROP_TRANSFER;
+  const baseVOffset = virtualCode.length;
+  c = { tss, program, baseVOffset, virtualCode, templates: [], undoneDocPoint: [] };
+  function walk(node) {
+    const skip = processHandlers([beginClass, beginTemplate], node);
+    if (!skip) tss.forEachChild(node, walk);
+    processHandlers([endClass, endTemplate], node);
+  }
+  walk(sourceFile);
+  log("\u865A\u62DF\u6587\u4EF6\n", c.virtualCode);
+  const result = { code: c.virtualCode, templates: c.templates, sf: sourceFile };
+  c = {};
+  return result;
+}
+function beginClass(node) {
+  if (!isClass(node, c.tss)) return;
+  c.currentClass = node;
+  return 0;
+}
+function endClass(node) {
+  if (!isClass(node, c.tss)) return;
+  c.currentClass = void 0;
+  if (c.builtHeadAreas) {
+    c.builtHeadAreas = void 0;
+    c.idg = void 0;
+    c.virtualCode += `}
+`;
+  }
+  return;
+}
+function beginTemplate(node) {
+  if (!c.tss.isTaggedTemplateExpression(node)) return;
+  if (!isBobeIdentifier(node, c.tss)) return 1;
+  const template = { headAreas: [] };
+  if (c.currentClass && !c.builtHeadAreas) {
+    c.idg = new IdGenerator();
+    const { currentClass } = c;
+    const className = currentClass.name.getText();
+    const area = new Area();
+    c.virtualCode += `{
+const {`;
+    const members = getClassMembersInClass(currentClass, c.tss);
+    for (const member of members) {
+      const nameText = member.name.getText();
+      const itemStart = c.virtualCode.length;
+      c.virtualCode += `${nameText}:${nameText},`;
+      const itemEnd = c.virtualCode.length;
+      area.addRange(itemStart, itemEnd);
+    }
+    c.virtualCode += `} = {} as any as ${className};
+`;
+    c.builtHeadAreas = template.headAreas = [area];
+  }
+  c.virtualCode += "{\n";
+  if (node.typeArguments) {
+    const typeArg = node.typeArguments[0];
+    const checker = c.program?.getTypeChecker();
+    if (checker) {
+      const typeNode = checker.getTypeAtLocation(typeArg);
+      const typeExp = typeArg.getText();
+      const originOffset = typeArg.getFullStart();
+      const propNodes = checker.getPropertiesOfType(typeNode);
+      const area = new Area();
+      c.virtualCode += `const {`;
+      for (const { name } of propNodes) {
+        const itemStart = c.virtualCode.length;
+        c.virtualCode += `${name}:${name},`;
+        const itemEnd = c.virtualCode.length;
+        area.addRange(itemStart, itemEnd);
+      }
+      c.virtualCode += `} = {} as any as `;
+      const codeOffset = c.virtualCode.length;
+      c.virtualCode += typeExp;
+      template.headTemplate = area;
+      template.typeMap = {
+        originOffset,
+        codeOffset,
+        length: typeExp.length
+      };
+      c.virtualCode += `;
+`;
+    }
+  }
+  if (!c.tss.isNoSubstitutionTemplateLiteral(node.template)) {
+    const insArr = Array.from(node.template.templateSpans);
+    c.tempStaticIns = insArr[Symbol.iterator]();
+  }
+  const templateStart = node.template.getFullStart() + 1;
+  const virtualStart = c.virtualCode.length;
+  const raw = node.template.getText().slice(1, -1);
+  const { output, sourceMap, errors } = new Bobe2ts(c, template, templateStart, virtualStart, raw).process();
+  c.virtualCode += output + `}
+`;
+  template.sourceMap = sourceMap;
+  template.errors = errors;
+  template.templateStart = templateStart;
+  template.virtualStart = virtualStart;
+  c.templates.push(template);
+  return 1;
+}
+function endTemplate(node) {
+  if (!isBobeTemplate(node, c.tss)) return;
+  return;
+}
+
+export { AND, Area, BOBE_DOM_PROP_TRANSFER, BOBE_PREFIX, Bobe2ts, G, IdGenerator, LRUCache, PropertyExtractor, Range, Virtual_File_Exp, Virtual_File_Suffix, buildVirtualDocument, calcAbsSourceMap, calcHeadSourceMap, contains, createMemo, domPropertyExp, findBobeTemplatesInClass, findNodeAtPosition, findPrecedingBobeTemplate, findPrecedingClassNode, findTemplateTypePos, fixTextSpan, getClassMemberNames, getClassMembersInClass, getPosTemplateCtx, getRealName, getRelativePosition, getSharedItems, getSourceFileAndNode, getValidBobeTemplateNode, getVirtualName, inInsBrace, inVirtualHead, inVirtualPart, inWitchVirtualPart, isBobeIdentifier, isBobeTemplate, isClass, isClassProp, isOverlap, isVirtualFile, log, makeContext, memo, processHandlers, sfHasBobeTemplate, strHasBobeTemplate, uniqBy };
+//# sourceMappingURL=bobe-language-core.esm.js.map