@mgamil/mapx 0.2.4

package/dist/parsers/common-methods.d.ts

@@ -0,0 +1,3 @@
+declare const COMMON_FRAMEWORK_METHODS: Set<string>;
+
+export { COMMON_FRAMEWORK_METHODS };

package/dist/parsers/common-methods.js

@@ -0,0 +1,33 @@
+const COMMON_FRAMEWORK_METHODS = /* @__PURE__ */ new Set([
+  // Laravel / PHP
+  "save",
+  "delete",
+  "find",
+  "findOrFail",
+  "create",
+  "update",
+  "get",
+  "all",
+  "toArray",
+  "toJson",
+  "rules",
+  "handle",
+  "boot",
+  "register",
+  // JavaScript / Node
+  "on",
+  "off",
+  "emit",
+  "once",
+  "then",
+  "catch",
+  "finally",
+  "toString",
+  "valueOf",
+  "call",
+  "apply",
+  "bind"
+]);
+export {
+  COMMON_FRAMEWORK_METHODS
+};

package/dist/parsers/fallback-parser.d.ts

@@ -0,0 +1,10 @@
+import { LanguageParser } from './parser-interface.js';
+import { ParseResult } from '../types.js';
+
+declare class FallbackParser implements LanguageParser {
+    readonly languageName = "fallback";
+    get supportedExtensions(): string[];
+    parse(filePath: string, source: string): Promise<ParseResult>;
+}
+
+export { FallbackParser };

package/dist/parsers/fallback-parser.js

@@ -0,0 +1,18 @@
+class FallbackParser {
+  languageName = "fallback";
+  get supportedExtensions() {
+    return [];
+  }
+  async parse(filePath, source) {
+    const lines = source.split("\n");
+    const ext = "." + filePath.split(".").pop()?.toLowerCase();
+    return {
+      symbols: [],
+      references: [],
+      errors: []
+    };
+  }
+}
+export {
+  FallbackParser
+};

package/dist/parsers/generic-wasm-parser.d.ts

@@ -0,0 +1,23 @@
+import { LanguageParser } from './parser-interface.js';
+import { ParseResult, SymbolKind, ExtractedReference } from '../types.js';
+import { LanguageDefinition } from '../languages/registry.js';
+
+declare class GenericWasmParser implements LanguageParser {
+    readonly languageName: string;
+    readonly supportedExtensions: string[];
+    protected langDef: LanguageDefinition;
+    protected language: any;
+    protected symbolsQuery: string | null;
+    protected referencesQuery: string | null;
+    protected loadingPromise: Promise<void> | null;
+    constructor(langDef: LanguageDefinition);
+    protected ensureLoaded(): Promise<void>;
+    parse(filePath: string, source: string, options?: any): Promise<ParseResult>;
+    protected isContainerKind(kind: SymbolKind): boolean;
+    protected isMemberKind(kind: SymbolKind): boolean;
+    protected extractSignature(source: string, node: any, name: string, kind: string, startLine: number): string;
+    protected cleanTarget(name: string, refType: string): string;
+    protected mapRefType(refType: string): ExtractedReference['referenceType'];
+}
+
+export { GenericWasmParser };

package/dist/parsers/generic-wasm-parser.js

@@ -0,0 +1,168 @@
+import { loadLanguage, loadQueryFile, parseWithQueries } from "./wasm-parser.js";
+import { COMMON_FRAMEWORK_METHODS } from "./common-methods.js";
+class GenericWasmParser {
+  languageName;
+  supportedExtensions;
+  langDef;
+  language = null;
+  symbolsQuery = null;
+  referencesQuery = null;
+  loadingPromise = null;
+  constructor(langDef) {
+    this.langDef = langDef;
+    this.languageName = langDef.name;
+    this.supportedExtensions = langDef.extensions;
+  }
+  ensureLoaded() {
+    if (!this.loadingPromise) {
+      this.loadingPromise = (async () => {
+        this.language = await loadLanguage(this.langDef);
+        this.symbolsQuery = await loadQueryFile(this.langDef.queries.symbols);
+        this.referencesQuery = await loadQueryFile(this.langDef.queries.references);
+      })();
+    }
+    return this.loadingPromise;
+  }
+  async parse(filePath, source, options) {
+    await this.ensureLoaded();
+    const errors = [];
+    const symbols = [];
+    const references = [];
+    try {
+      const { symbols: symCaptures, references: refCaptures, nameByNodeId, scopeByNodeId } = await parseWithQueries(
+        source,
+        this.language,
+        this.symbolsQuery,
+        this.referencesQuery
+      );
+      let currentScope = null;
+      for (const [captureName, captures] of symCaptures) {
+        if (captureName.startsWith("symbol.kind_")) {
+          const baseKind = captureName.replace("symbol.kind_", "");
+          for (const capture of captures) {
+            let kind = baseKind;
+            const name = nameByNodeId.get(capture.node.id) || capture.node.text;
+            const startLine = capture.node.startPosition.row + 1;
+            const endLine = capture.node.endPosition.row + 1;
+            if (this.isContainerKind(kind)) {
+              currentScope = name;
+            }
+            let extractedScope = null;
+            if (kind === "function") {
+              let curr = capture.node.parent;
+              while (curr) {
+                if (curr.type === "class_definition" || curr.type === "class_declaration" || curr.type === "struct_specifier" || curr.type === "impl_item" || curr.type === "interface_declaration") {
+                  kind = "method";
+                  if (curr.type === "impl_item") {
+                    const typeChild = curr.childForFieldName ? curr.childForFieldName("type") : null;
+                    if (typeChild) {
+                      extractedScope = typeChild.text;
+                    }
+                  }
+                  break;
+                }
+                curr = curr.parent;
+              }
+            }
+            const signature = this.extractSignature(source, capture.node, name, kind, startLine);
+            const explicitScope = scopeByNodeId.get(capture.node.id) || extractedScope;
+            const resolvedScope = explicitScope || (this.isMemberKind(kind) ? currentScope : null);
+            if (options?.ignoredSymbols?.has(name)) {
+              continue;
+            }
+            symbols.push({
+              name,
+              kind,
+              scope: resolvedScope,
+              signature,
+              startLine,
+              endLine,
+              metadata: {}
+            });
+          }
+        }
+      }
+      for (const [captureName, captures] of refCaptures) {
+        if (captureName.startsWith("ref.target_")) {
+          const refType = captureName.replace("ref.target_", "");
+          for (const capture of captures) {
+            const targetText = capture.node.text;
+            if (!targetText || typeof targetText !== "string") continue;
+            const targetName = this.cleanTarget(targetText, refType);
+            if (!targetName || typeof targetName !== "string") continue;
+            const startLine = capture.node.startPosition.row + 1;
+            const referenceType = this.mapRefType(refType);
+            let verifiability = "verified";
+            if (referenceType === "call" && COMMON_FRAMEWORK_METHODS.has(targetName)) {
+              verifiability = "inferred";
+            }
+            if (options?.ignoredSymbols?.has(targetName)) {
+              continue;
+            }
+            references.push({
+              sourceSymbol: null,
+              targetName,
+              referenceType,
+              startLine,
+              verifiability
+            });
+          }
+        }
+      }
+    } catch (e) {
+      errors.push({ message: e.message, line: 0 });
+    }
+    return { symbols, references, errors };
+  }
+  isContainerKind(kind) {
+    return kind === "class" || kind === "interface" || kind === "trait" || kind === "enum" || kind === "struct" || kind === "module";
+  }
+  isMemberKind(kind) {
+    return kind === "method" || kind === "property" || kind === "constant" || kind === "field";
+  }
+  extractSignature(source, node, name, kind, startLine) {
+    const lines = source.split("\n");
+    const lineIdx = startLine - 1;
+    if (lineIdx >= lines.length) return name;
+    const line = lines[lineIdx].trim();
+    if (kind === "function") {
+      const match = line.match(/(?:export\s+)?(?:async\s+)?function\s+\w+[^{]*/);
+      if (match) return match[0].trim();
+    }
+    if (kind === "method") {
+      const match = line.match(/(?:abstract\s+)?(?:private|protected|public)?\s*(?:async\s+)?(?:get\s+|set\s+)?\w+\s*\([^)]*\)(\s*:\s*[^{;]+)?/);
+      if (match) return match[0].trim();
+    }
+    if (kind === "class") {
+      const match = line.match(/(?:export\s+)?(?:abstract\s+)?class\s+\w+[^{]*/);
+      if (match) return match[0].trim();
+    }
+    if (kind === "interface") {
+      const match = line.match(/(?:export\s+)?interface\s+\w+[^{]*/);
+      if (match) return match[0].trim();
+    }
+    if (kind === "enum") {
+      const match = line.match(/(?:export\s+)?enum\s+\w+/);
+      if (match) return match[0].trim();
+    }
+    return name;
+  }
+  cleanTarget(name, refType) {
+    if (refType === "import" || refType === "require") return name.replace(/^['"]|['"]$/g, "");
+    return name;
+  }
+  mapRefType(refType) {
+    const map = {
+      import: "import",
+      require: "require",
+      extends: "extends",
+      implements: "implements",
+      call: "call",
+      instantiation: "instantiation"
+    };
+    return map[refType] || "call";
+  }
+}
+export {
+  GenericWasmParser
+};

package/dist/parsers/ignored-symbols.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Framework-specific symbol ignore lists.
+ *
+ * Each key is a framework name (matching FrameworkDetector.name) or a language
+ * name (matching LanguageDefinition.name). When a framework or language is
+ * active for the project being scanned, parsers can look up the corresponding
+ * set and skip those symbols/references to keep the code graph clean.
+ *
+ * To add support for a new framework or language:
+ *   1. Add a new entry to IGNORED_SYMBOLS_BY_FRAMEWORK below.
+ *   2. The key should match the detector's `name` field or the language name.
+ *   3. The scanner will automatically pick it up — no parser changes needed.
+ */
+/**
+ * Build a merged ignore set from a list of active framework/language names.
+ *
+ * This is called once per scan pass and the result is forwarded through
+ * parse options so each parser invocation does not need to re-compute it.
+ */
+declare function buildIgnoredSymbols(activeFrameworks: string[]): Set<string>;
+/**
+ * Get the registry so callers can inspect or extend it at runtime.
+ */
+declare function getIgnoredSymbolsRegistry(): Record<string, Set<string>>;
+
+export { buildIgnoredSymbols, getIgnoredSymbolsRegistry };

package/dist/parsers/ignored-symbols.js

@@ -0,0 +1,77 @@
+const IGNORED_SYMBOLS_BY_FRAMEWORK = {
+  // Vue ecosystem — detected via VueRouterDetector (name: 'vue-router')
+  "vue-router": /* @__PURE__ */ new Set([
+    // Vue Core & Composition API
+    "ref",
+    "computed",
+    "reactive",
+    "watch",
+    "watchEffect",
+    "defineComponent",
+    "setup",
+    "onMounted",
+    "onUnmounted",
+    "onBeforeMount",
+    "onBeforeUnmount",
+    "onUpdated",
+    "onBeforeUpdate",
+    "provide",
+    "inject",
+    "nextTick",
+    "defineProps",
+    "defineEmits",
+    "defineExpose",
+    "defineModel",
+    "defineOptions",
+    "withDefaults",
+    "toRef",
+    "toRefs",
+    "unref",
+    "isRef",
+    "isReactive",
+    "isProxy",
+    "shallowRef",
+    "shallowReactive",
+    "readonly",
+    "markRaw",
+    // Vue Router
+    "useRoute",
+    "useRouter",
+    "createRouter",
+    "createWebHistory",
+    // Pinia
+    "useStore",
+    "defineStore",
+    "storeToRefs",
+    // Vue I18n
+    "useI18n",
+    "t",
+    "te",
+    "tm",
+    "rt",
+    "d",
+    "n",
+    // Nuxt / VueUse
+    "useHead",
+    "useMeta",
+    "useFetch",
+    "useAsyncData"
+  ])
+};
+function buildIgnoredSymbols(activeFrameworks) {
+  const merged = /* @__PURE__ */ new Set();
+  for (const name of activeFrameworks) {
+    const symbols = IGNORED_SYMBOLS_BY_FRAMEWORK[name];
+    if (symbols) {
+      for (const s of symbols) merged.add(s);
+    }
+  }
+  return merged;
+}
+function getIgnoredSymbolsRegistry() {
+  return IGNORED_SYMBOLS_BY_FRAMEWORK;
+}
+export {
+  buildIgnoredSymbols,
+  getIgnoredSymbolsRegistry
+};

package/dist/parsers/index.d.ts

@@ -0,0 +1,9 @@
+export { LanguageParser } from './parser-interface.js';
+export { clearParserCache, getParserForFile } from './parser-registry.js';
+export { PhpParser } from './languages/php.js';
+export { JavaScriptParser } from './languages/javascript.js';
+export { TypeScriptParser } from './languages/typescript.js';
+export { COMMON_FRAMEWORK_METHODS } from './common-methods.js';
+import '../types.js';
+import '../languages/registry.js';
+import './generic-wasm-parser.js';

package/dist/parsers/index.js

@@ -0,0 +1,13 @@
+import { getParserForFile, clearParserCache } from "./parser-registry.js";
+import { PhpParser } from "./languages/php.js";
+import { JavaScriptParser } from "./languages/javascript.js";
+import { TypeScriptParser } from "./languages/typescript.js";
+import { COMMON_FRAMEWORK_METHODS } from "./common-methods.js";
+export {
+  COMMON_FRAMEWORK_METHODS,
+  JavaScriptParser,
+  PhpParser,
+  TypeScriptParser,
+  clearParserCache,
+  getParserForFile
+};

package/dist/parsers/languages/javascript.d.ts

@@ -0,0 +1,11 @@
+import { GenericWasmParser } from '../generic-wasm-parser.js';
+import { LanguageDefinition } from '../../languages/registry.js';
+import '../parser-interface.js';
+import '../../types.js';
+
+declare class JavaScriptParser extends GenericWasmParser {
+    constructor(langDef: LanguageDefinition);
+    protected extractSignature(source: string, node: any, name: string, kind: string, startLine: number): string;
+}
+
+export { JavaScriptParser };

package/dist/parsers/languages/javascript.js

@@ -0,0 +1,28 @@
+import { GenericWasmParser } from "../generic-wasm-parser.js";
+class JavaScriptParser extends GenericWasmParser {
+  constructor(langDef) {
+    super(langDef);
+  }
+  extractSignature(source, node, name, kind, startLine) {
+    const lines = source.split("\n");
+    const lineIdx = startLine - 1;
+    if (lineIdx >= lines.length) return name;
+    const line = lines[lineIdx].trim();
+    if (kind === "function") {
+      const match = line.match(/(function\s+\w+|const\s+\w+\s*=\s*(?:async\s+)?\([^)]*\)\s*=>)/);
+      if (match) return match[0];
+    }
+    if (kind === "method") {
+      const match = line.match(/(?:async\s+)?(?:get\s+|set\s+)?\w+\s*\([^)]*\)/);
+      if (match) return match[0];
+    }
+    if (kind === "class") {
+      const match = line.match(/class\s+\w+(\s+extends\s+\w+)?(\s+implements\s+\w+)?/);
+      if (match) return match[0];
+    }
+    return name;
+  }
+}
+export {
+  JavaScriptParser
+};

package/dist/parsers/languages/php.d.ts

@@ -0,0 +1,15 @@
+import { ParseResult, ExtractedReference } from '../../types.js';
+import { LanguageDefinition } from '../../languages/registry.js';
+import { GenericWasmParser } from '../generic-wasm-parser.js';
+import '../parser-interface.js';
+
+declare const LARAVEL_FACADE_MAP: Record<string, string>;
+declare class PhpParser extends GenericWasmParser {
+    constructor(langDef: LanguageDefinition);
+    parse(filePath: string, source: string, options?: any): Promise<ParseResult>;
+    protected extractSignature(source: string, node: any, name: string, kind: string, startLine: number): string;
+    private cleanTargetName;
+    protected mapRefType(refType: string): ExtractedReference['referenceType'];
+}
+
+export { LARAVEL_FACADE_MAP, PhpParser };