@fynixorg/ui 1.0.21 → 1.0.22

package/dist/typescript-fynix-plugin/index.js

@@ -0,0 +1,1044 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import * as ts from "typescript/lib/tsserverlibrary";
+import fs from "fs";
+import path from "path";
+import {
+  transformToTsx,
+  getLineAndCharacterOfPosition,
+  getPositionOfLineAndCharacter,
+  mapTransformedToOriginal,
+  mapOriginalToTransformed
+} from "../../core/parser/fnx-parser";
+function init(modules) {
+  const tsx = modules.typescript;
+  function create(info) {
+    const config = info.config || {};
+    const log = config.debug ? info.project.projectService.logger : { info() {
+    }, msg() {
+    } };
+    log.info?.("[Fynix TS Engine] Loaded with full TypeScript support");
+    const fnxCache = /* @__PURE__ */ new Map();
+    function transformFnx(source) {
+      return transformToTsx(source, {
+        debug: config.debug,
+        logger: /* @__PURE__ */ __name((message) => log.info?.(message), "logger")
+      });
+    }
+    __name(transformFnx, "transformFnx");
+    function mapTransformedToOriginalWithCache(position, cache) {
+      return mapTransformedToOriginal(
+        position,
+        cache.code,
+        cache.originalContent,
+        cache.lineMap,
+        cache.sourceMap
+      );
+    }
+    __name(mapTransformedToOriginalWithCache, "mapTransformedToOriginalWithCache");
+    function mapOriginalToTransformedWithCache(position, cache) {
+      return mapOriginalToTransformed(
+        position,
+        cache.code,
+        cache.originalContent,
+        cache.lineMap,
+        cache.sourceMap
+      );
+    }
+    __name(mapOriginalToTransformedWithCache, "mapOriginalToTransformedWithCache");
+    const host = info.languageServiceHost;
+    const oldGetScriptSnapshot = host.getScriptSnapshot.bind(host);
+    const oldGetScriptKind = host.getScriptKind?.bind(host);
+    const oldGetScriptVersion = host.getScriptVersion.bind(host);
+    const oldResolveModuleNames = host.resolveModuleNames?.bind(host);
+    if (oldResolveModuleNames) {
+      host.resolveModuleNames = (moduleNames, containingFile, reusedNames, redirectedReference, options) => {
+        const resolved = oldResolveModuleNames(
+          moduleNames,
+          containingFile,
+          reusedNames,
+          redirectedReference,
+          options
+        );
+        return resolved.map((resolvedModule, index) => {
+          const moduleName = moduleNames[index];
+          if (config.debug) {
+            log.info?.(
+              `[Fynix Plugin] Processing module: ${moduleName}, resolved: ${!!resolvedModule}`
+            );
+          }
+          if (!resolvedModule && moduleName.endsWith(".fnx")) {
+            let fnxFilePath;
+            if (path.isAbsolute(moduleName)) {
+              fnxFilePath = moduleName;
+            } else {
+              const containingDir = path.dirname(containingFile);
+              fnxFilePath = path.resolve(containingDir, moduleName);
+            }
+            if (config.debug) {
+              log.info?.(
+                `[Fynix Plugin] Trying to resolve .fnx file: ${fnxFilePath}`
+              );
+            }
+            if (fs.existsSync(fnxFilePath)) {
+              if (config.debug) {
+                log.info?.(`[Fynix Plugin] Found .fnx file: ${fnxFilePath}`);
+              }
+              return {
+                resolvedFileName: fnxFilePath,
+                extension: tsx.Extension.Tsx,
+                isExternalLibraryImport: false
+              };
+            }
+            const resolvedFnx = tsx.resolveModuleName(
+              moduleName,
+              containingFile,
+              options,
+              host
+            );
+            if (resolvedFnx.resolvedModule) {
+              if (config.debug) {
+                log.info?.(
+                  `[Fynix Plugin] Resolved with TS: ${resolvedFnx.resolvedModule.resolvedFileName}`
+                );
+              }
+              return {
+                ...resolvedFnx.resolvedModule,
+                extension: tsx.Extension.Tsx
+              };
+            }
+          }
+          if (!resolvedModule && !moduleName.endsWith(".fnx")) {
+            const isRelativeOrLocal = moduleName.startsWith(".") || !moduleName.startsWith("@") && !moduleName.includes("/") && !moduleName.includes("://");
+            if (isRelativeOrLocal) {
+              const fnxPath = moduleName + ".fnx";
+              let fnxFilePath;
+              if (path.isAbsolute(fnxPath)) {
+                fnxFilePath = fnxPath;
+              } else {
+                const containingDir = path.dirname(containingFile);
+                fnxFilePath = path.resolve(containingDir, fnxPath);
+              }
+              if (config.debug) {
+                log.info?.(
+                  `[Fynix Plugin] Trying to resolve with .fnx extension: ${fnxFilePath}`
+                );
+              }
+              if (fs.existsSync(fnxFilePath)) {
+                if (config.debug) {
+                  log.info?.(
+                    `[Fynix Plugin] Found file with .fnx extension: ${fnxFilePath}`
+                  );
+                }
+                return {
+                  resolvedFileName: fnxFilePath,
+                  extension: tsx.Extension.Tsx,
+                  isExternalLibraryImport: false
+                };
+              }
+              const resolvedFnx = tsx.resolveModuleName(
+                fnxPath,
+                containingFile,
+                options,
+                host
+              );
+              if (resolvedFnx.resolvedModule) {
+                if (config.debug) {
+                  log.info?.(
+                    `[Fynix Plugin] Resolved .fnx with TS: ${resolvedFnx.resolvedModule.resolvedFileName}`
+                  );
+                }
+                return {
+                  ...resolvedFnx.resolvedModule,
+                  extension: tsx.Extension.Tsx
+                };
+              }
+            }
+          }
+          if (resolvedModule?.resolvedFileName?.endsWith(".fnx")) {
+            if (config.debug) {
+              log.info?.(
+                `[Fynix Plugin] Marking .fnx file as TSX: ${resolvedModule.resolvedFileName}`
+              );
+            }
+            return {
+              ...resolvedModule,
+              extension: tsx.Extension.Tsx
+            };
+          }
+          return resolvedModule;
+        });
+      };
+    } else {
+      host.resolveModuleNames = (moduleNames, containingFile, reusedNames, redirectedReference, options) => {
+        return moduleNames.map((moduleName) => {
+          if (moduleName.endsWith(".fnx")) {
+            let fnxFilePath;
+            if (path.isAbsolute(moduleName)) {
+              fnxFilePath = moduleName;
+            } else {
+              const containingDir = path.dirname(containingFile);
+              fnxFilePath = path.resolve(containingDir, moduleName);
+            }
+            if (fs.existsSync(fnxFilePath)) {
+              return {
+                resolvedFileName: fnxFilePath,
+                extension: tsx.Extension.Tsx,
+                isExternalLibraryImport: false
+              };
+            }
+          }
+          const isRelativeOrLocal = moduleName.startsWith(".") || !moduleName.startsWith("@") && !moduleName.includes("/") && !moduleName.includes("://");
+          if (isRelativeOrLocal && !moduleName.endsWith(".fnx")) {
+            const fnxPath = moduleName + ".fnx";
+            let fnxFilePath;
+            if (path.isAbsolute(fnxPath)) {
+              fnxFilePath = fnxPath;
+            } else {
+              const containingDir = path.dirname(containingFile);
+              fnxFilePath = path.resolve(containingDir, fnxPath);
+            }
+            if (fs.existsSync(fnxFilePath)) {
+              return {
+                resolvedFileName: fnxFilePath,
+                extension: tsx.Extension.Tsx,
+                isExternalLibraryImport: false
+              };
+            }
+          }
+          const resolved = tsx.resolveModuleName(
+            moduleName,
+            containingFile,
+            options,
+            host
+          );
+          return resolved.resolvedModule;
+        });
+      };
+    }
+    host.getScriptKind = (fileName) => {
+      if (fileName.endsWith(".fnx")) return tsx.ScriptKind.TSX;
+      return oldGetScriptKind?.(fileName) ?? tsx.ScriptKind.Unknown;
+    };
+    const oldFileExists = host.fileExists?.bind(host);
+    if (oldFileExists) {
+      host.fileExists = (fileName) => {
+        if (oldFileExists(fileName)) {
+          return true;
+        }
+        if (fileName.endsWith(".fnx")) {
+          try {
+            return fs.existsSync(fileName);
+          } catch {
+            return false;
+          }
+        }
+        return false;
+      };
+    }
+    const oldReadFile = host.readFile?.bind(host);
+    if (oldReadFile) {
+      host.readFile = (fileName) => {
+        const content = oldReadFile(fileName);
+        if (content !== void 0) {
+          return content;
+        }
+        if (fileName.endsWith(".fnx")) {
+          try {
+            return fs.readFileSync(fileName, "utf8");
+          } catch {
+            return void 0;
+          }
+        }
+        return void 0;
+      };
+    }
+    host.getScriptSnapshot = (fileName) => {
+      if (!fileName.endsWith(".fnx")) return oldGetScriptSnapshot(fileName);
+      const version = oldGetScriptVersion(fileName);
+      const cached = fnxCache.get(fileName);
+      if (cached && cached.version === version) {
+        return tsx.ScriptSnapshot.fromString(cached.code);
+      }
+      const snap = oldGetScriptSnapshot(fileName);
+      if (!snap) return snap;
+      try {
+        const content = snap.getText(0, snap.getLength());
+        const parsed = transformFnx(content);
+        fnxCache.set(fileName, {
+          code: parsed.code,
+          lineMap: parsed.lineMap,
+          sourceMap: parsed.sourceMap,
+          version,
+          originalContent: content
+        });
+        log.info?.(
+          `[Fynix] Transformed ${fileName} (${content.length} \u2192 ${parsed.code.length} bytes)`
+        );
+        return tsx.ScriptSnapshot.fromString(parsed.code);
+      } catch (error) {
+        log.info?.(`[Fynix] Transform error in ${fileName}: ${error}`);
+        return snap;
+      }
+    };
+    function remapDiagnostics(diags, fileName) {
+      if (!fileName.endsWith(".fnx")) {
+        return diags;
+      }
+      const cache = fnxCache.get(fileName);
+      if (!cache) {
+        return diags;
+      }
+      const remapped = [];
+      for (const d of diags) {
+        if (!d.file || d.start === void 0) {
+          remapped.push(d);
+          continue;
+        }
+        const { line: transformedLine } = getLineAndCharacterOfPosition(
+          cache.code,
+          d.start
+        );
+        const originalLine = cache.lineMap[transformedLine];
+        if (originalLine < 0) {
+          const messageText = typeof d.messageText === "string" ? d.messageText : d.messageText.messageText;
+          const isModuleResolutionError = messageText.includes("Cannot find module") || messageText.includes("Module not found") || d.code === 2307;
+          if (!isModuleResolutionError) {
+            if (config.debug) {
+              log.info?.(
+                `[Fynix] Skipping diagnostic on injected line ${transformedLine}: ${messageText}`
+              );
+            }
+            continue;
+          }
+          let mappedLine = 0;
+          let mappedChar = 0;
+          const lines = cache.originalContent.split("\n");
+          for (let i = 0; i < lines.length; i++) {
+            if (lines[i].includes("@fynixorg/ui")) {
+              mappedLine = i;
+              mappedChar = lines[i].indexOf("@fynixorg/ui");
+              break;
+            }
+          }
+          if (mappedLine === 0 && mappedChar === 0) {
+            const logicMatch = cache.originalContent.match(
+              /<logic\s+setup\s*=\s*["']?(ts|js)["']?\s*>/i
+            );
+            if (logicMatch) {
+              const before = cache.originalContent.slice(
+                0,
+                logicMatch.index + logicMatch[0].length
+              );
+              mappedLine = before.split("\n").length - 1;
+              mappedChar = 0;
+            }
+          }
+          const mappedStart = getPositionOfLineAndCharacter(
+            cache.originalContent,
+            mappedLine,
+            mappedChar
+          );
+          const remappedDiag2 = {
+            ...d,
+            file: {
+              ...d.file,
+              fileName,
+              text: cache.originalContent,
+              getLineAndCharacterOfPosition: /* @__PURE__ */ __name((pos) => getLineAndCharacterOfPosition(cache.originalContent, pos), "getLineAndCharacterOfPosition"),
+              getPositionOfLineAndCharacter: /* @__PURE__ */ __name((line, character) => getPositionOfLineAndCharacter(
+                cache.originalContent,
+                line,
+                character
+              ), "getPositionOfLineAndCharacter")
+            },
+            start: mappedStart,
+            length: "@fynixorg/ui".length
+          };
+          remapped.push(remappedDiag2);
+          continue;
+        }
+        const originalStart = mapTransformedToOriginalWithCache(d.start, cache);
+        let originalLength = d.length || 1;
+        if (d.length) {
+          const transformedEnd = d.start + d.length;
+          const originalEnd = mapTransformedToOriginalWithCache(
+            transformedEnd,
+            cache
+          );
+          originalLength = Math.max(1, originalEnd - originalStart);
+        }
+        const originalSnapshot = tsx.ScriptSnapshot.fromString(
+          cache.originalContent
+        );
+        const remappedDiag = {
+          ...d,
+          file: {
+            ...d.file,
+            fileName,
+            text: cache.originalContent,
+            getLineAndCharacterOfPosition: /* @__PURE__ */ __name((pos) => getLineAndCharacterOfPosition(cache.originalContent, pos), "getLineAndCharacterOfPosition"),
+            getPositionOfLineAndCharacter: /* @__PURE__ */ __name((line, character) => getPositionOfLineAndCharacter(
+              cache.originalContent,
+              line,
+              character
+            ), "getPositionOfLineAndCharacter")
+          },
+          start: originalStart,
+          length: originalLength
+        };
+        log.info?.(
+          `[Fynix] Remapped diagnostic: ${typeof d.messageText === "string" ? d.messageText : d.messageText.messageText} at original pos ${originalStart} (line ${originalLine})`
+        );
+        remapped.push(remappedDiag);
+      }
+      return remapped;
+    }
+    __name(remapDiagnostics, "remapDiagnostics");
+    function remapDiagnosticsWithLocation(diags, fileName) {
+      if (!fileName.endsWith(".fnx")) {
+        return diags;
+      }
+      const cache = fnxCache.get(fileName);
+      if (!cache) {
+        return diags;
+      }
+      const remapped = [];
+      for (const d of diags) {
+        const { line: transformedLine } = getLineAndCharacterOfPosition(
+          cache.code,
+          d.start
+        );
+        const originalLine = cache.lineMap[transformedLine];
+        if (originalLine < 0) {
+          let nearestLineIndex = transformedLine;
+          let nearestOriginalLine = -1;
+          for (let i = transformedLine; i < cache.lineMap.length; i++) {
+            if (cache.lineMap[i] >= 0) {
+              nearestLineIndex = i;
+              nearestOriginalLine = cache.lineMap[i];
+              break;
+            }
+          }
+          if (nearestOriginalLine < 0) {
+            for (let i = transformedLine - 1; i >= 0; i--) {
+              if (cache.lineMap[i] >= 0) {
+                nearestLineIndex = i;
+                nearestOriginalLine = cache.lineMap[i];
+                break;
+              }
+            }
+          }
+          if (nearestOriginalLine < 0) {
+            log.info?.(
+              `[Fynix] No valid line mapping found for diagnostic: ${typeof d.messageText === "string" ? d.messageText : d.messageText.messageText}`
+            );
+            continue;
+          }
+          const nearestOriginalPos = getPositionOfLineAndCharacter(
+            cache.originalContent,
+            nearestOriginalLine,
+            0
+          );
+          const remappedDiag2 = {
+            ...d,
+            file: {
+              ...d.file,
+              fileName,
+              text: cache.originalContent,
+              getLineAndCharacterOfPosition: /* @__PURE__ */ __name((pos) => getLineAndCharacterOfPosition(cache.originalContent, pos), "getLineAndCharacterOfPosition"),
+              getPositionOfLineAndCharacter: /* @__PURE__ */ __name((line, character) => getPositionOfLineAndCharacter(
+                cache.originalContent,
+                line,
+                character
+              ), "getPositionOfLineAndCharacter")
+            },
+            start: nearestOriginalPos,
+            length: d.length || 1
+          };
+          log.info?.(
+            `[Fynix] Remapped injected line diagnostic to nearest line ${nearestOriginalLine}: ${typeof d.messageText === "string" ? d.messageText : d.messageText.messageText}`
+          );
+          remapped.push(remappedDiag2);
+          continue;
+        }
+        const originalStart = mapTransformedToOriginalWithCache(d.start, cache);
+        let originalLength = d.length || 1;
+        if (d.length) {
+          const transformedEnd = d.start + d.length;
+          const originalEnd = mapTransformedToOriginalWithCache(
+            transformedEnd,
+            cache
+          );
+          originalLength = Math.max(1, originalEnd - originalStart);
+        }
+        const remappedDiag = {
+          ...d,
+          file: {
+            ...d.file,
+            fileName,
+            text: cache.originalContent,
+            getLineAndCharacterOfPosition: /* @__PURE__ */ __name((pos) => getLineAndCharacterOfPosition(cache.originalContent, pos), "getLineAndCharacterOfPosition"),
+            getPositionOfLineAndCharacter: /* @__PURE__ */ __name((line, character) => getPositionOfLineAndCharacter(
+              cache.originalContent,
+              line,
+              character
+            ), "getPositionOfLineAndCharacter")
+          },
+          start: originalStart,
+          length: originalLength
+        };
+        log.info?.(
+          `[Fynix] Remapped diagnostic: ${typeof d.messageText === "string" ? d.messageText : d.messageText.messageText} at original pos ${originalStart} (line ${originalLine})`
+        );
+        remapped.push(remappedDiag);
+      }
+      return remapped;
+    }
+    __name(remapDiagnosticsWithLocation, "remapDiagnosticsWithLocation");
+    const proxy = /* @__PURE__ */ Object.create(null);
+    for (const k of Object.keys(
+      info.languageService
+    )) {
+      proxy[k] = (...args) => info.languageService[k].apply(info.languageService, args);
+    }
+    proxy.getSemanticDiagnostics = (fileName) => {
+      const diags = info.languageService.getSemanticDiagnostics(fileName);
+      return remapDiagnostics(diags, fileName);
+    };
+    proxy.getSyntacticDiagnostics = (fileName) => {
+      const diags = info.languageService.getSyntacticDiagnostics(fileName);
+      return remapDiagnosticsWithLocation(diags, fileName);
+    };
+    proxy.getSuggestionDiagnostics = (fileName) => {
+      const diags = info.languageService.getSuggestionDiagnostics(fileName);
+      return remapDiagnosticsWithLocation(diags, fileName);
+    };
+    proxy.getCompletionsAtPosition = (fileName, position, opts) => {
+      let mappedPosition = position;
+      if (fileName.endsWith(".fnx")) {
+        const cache = fnxCache.get(fileName);
+        if (cache) {
+          mappedPosition = mapOriginalToTransformedWithCache(position, cache);
+        }
+      }
+      const prior = info.languageService.getCompletionsAtPosition(
+        fileName,
+        mappedPosition,
+        opts
+      );
+      if (!fileName.endsWith(".fnx")) return prior;
+      const fynixCompletions = [
+        // Fynix hooks
+        {
+          name: "nixState",
+          kind: tsx.ScriptElementKind.functionElement,
+          sortText: "0_nixState",
+          labelDetails: { description: "Fynix reactive state" }
+        },
+        {
+          name: "nixStore",
+          kind: tsx.ScriptElementKind.functionElement,
+          sortText: "0_nixStore",
+          labelDetails: { description: "Fynix global store" }
+        },
+        {
+          name: "nixAsync",
+          kind: tsx.ScriptElementKind.functionElement,
+          sortText: "0_nixAsync",
+          labelDetails: { description: "Fynix async state" }
+        },
+        {
+          name: "nixEffect",
+          kind: tsx.ScriptElementKind.functionElement,
+          sortText: "0_nixEffect",
+          labelDetails: { description: "Fynix side effect" }
+        },
+        {
+          name: "nixComputed",
+          kind: tsx.ScriptElementKind.functionElement,
+          sortText: "0_nixComputed",
+          labelDetails: { description: "Fynix computed value" }
+        },
+        {
+          name: "nixForm",
+          kind: tsx.ScriptElementKind.functionElement,
+          sortText: "0_nixForm",
+          labelDetails: { description: "Fynix form handler" }
+        },
+        {
+          name: "nixRef",
+          kind: tsx.ScriptElementKind.functionElement,
+          sortText: "0_nixRef",
+          labelDetails: { description: "Fynix DOM reference" }
+        },
+        {
+          name: "nixCallback",
+          kind: tsx.ScriptElementKind.functionElement,
+          sortText: "0_nixCallback",
+          labelDetails: { description: "Fynix memoized callback" }
+        },
+        {
+          name: "nixMemo",
+          kind: tsx.ScriptElementKind.functionElement,
+          sortText: "0_nixMemo",
+          labelDetails: { description: "Fynix memoized value" }
+        },
+        {
+          name: "nixDebounce",
+          kind: tsx.ScriptElementKind.functionElement,
+          sortText: "0_nixDebounce",
+          labelDetails: { description: "Fynix debounced callback" }
+        },
+        {
+          name: "nixLocalStorage",
+          kind: tsx.ScriptElementKind.functionElement,
+          sortText: "0_nixLocalStorage",
+          labelDetails: { description: "Fynix localStorage state" }
+        },
+        // Fynix reactive event handlers (r-* attributes)
+        {
+          name: "r-click",
+          kind: tsx.ScriptElementKind.jsxAttribute,
+          sortText: "1_r-click",
+          labelDetails: { description: "Reactive click handler" },
+          insertText: "r-click={($event) => {}}"
+        },
+        {
+          name: "r-dblclick",
+          kind: tsx.ScriptElementKind.jsxAttribute,
+          sortText: "1_r-dblclick",
+          labelDetails: { description: "Reactive double-click handler" },
+          insertText: "r-dblclick={($event) => {}}"
+        },
+        {
+          name: "r-submit",
+          kind: tsx.ScriptElementKind.jsxAttribute,
+          sortText: "1_r-submit",
+          labelDetails: { description: "Reactive form submit handler" },
+          insertText: "r-submit={($event) => { $event.preventDefault(); }}"
+        },
+        {
+          name: "r-input",
+          kind: tsx.ScriptElementKind.jsxAttribute,
+          sortText: "1_r-input",
+          labelDetails: { description: "Reactive input handler" },
+          insertText: "r-input={($event) => {}}"
+        },
+        {
+          name: "r-change",
+          kind: tsx.ScriptElementKind.jsxAttribute,
+          sortText: "1_r-change",
+          labelDetails: { description: "Reactive change handler" },
+          insertText: "r-change={($event) => {}}"
+        },
+        {
+          name: "r-focus",
+          kind: tsx.ScriptElementKind.jsxAttribute,
+          sortText: "1_r-focus",
+          labelDetails: { description: "Reactive focus handler" },
+          insertText: "r-focus={($event) => {}}"
+        },
+        {
+          name: "r-blur",
+          kind: tsx.ScriptElementKind.jsxAttribute,
+          sortText: "1_r-blur",
+          labelDetails: { description: "Reactive blur handler" },
+          insertText: "r-blur={($event) => {}}"
+        },
+        {
+          name: "r-keydown",
+          kind: tsx.ScriptElementKind.jsxAttribute,
+          sortText: "1_r-keydown",
+          labelDetails: { description: "Reactive keydown handler" },
+          insertText: "r-keydown={($event) => {}}"
+        },
+        {
+          name: "r-keyup",
+          kind: tsx.ScriptElementKind.jsxAttribute,
+          sortText: "1_r-keyup",
+          labelDetails: { description: "Reactive keyup handler" },
+          insertText: "r-keyup={($event) => {}}"
+        },
+        {
+          name: "r-keypress",
+          kind: tsx.ScriptElementKind.jsxAttribute,
+          sortText: "1_r-keypress",
+          labelDetails: { description: "Reactive keypress handler" },
+          insertText: "r-keypress={($event) => {}}"
+        },
+        {
+          name: "r-mouseenter",
+          kind: tsx.ScriptElementKind.jsxAttribute,
+          sortText: "1_r-mouseenter",
+          labelDetails: { description: "Reactive mouseenter handler" },
+          insertText: "r-mouseenter={($event) => {}}"
+        },
+        {
+          name: "r-mouseleave",
+          kind: tsx.ScriptElementKind.jsxAttribute,
+          sortText: "1_r-mouseleave",
+          labelDetails: { description: "Reactive mouseleave handler" },
+          insertText: "r-mouseleave={($event) => {}}"
+        },
+        {
+          name: "r-mouseover",
+          kind: tsx.ScriptElementKind.jsxAttribute,
+          sortText: "1_r-mouseover",
+          labelDetails: { description: "Reactive mouseover handler" },
+          insertText: "r-mouseover={($event) => {}}"
+        },
+        {
+          name: "r-mouseout",
+          kind: tsx.ScriptElementKind.jsxAttribute,
+          sortText: "1_r-mouseout",
+          labelDetails: { description: "Reactive mouseout handler" },
+          insertText: "r-mouseout={($event) => {}}"
+        },
+        {
+          name: "r-mousemove",
+          kind: tsx.ScriptElementKind.jsxAttribute,
+          sortText: "1_r-mousemove",
+          labelDetails: { description: "Reactive mousemove handler" },
+          insertText: "r-mousemove={($event) => {}}"
+        },
+        {
+          name: "r-mousedown",
+          kind: tsx.ScriptElementKind.jsxAttribute,
+          sortText: "1_r-mousedown",
+          labelDetails: { description: "Reactive mousedown handler" },
+          insertText: "r-mousedown={($event) => {}}"
+        },
+        {
+          name: "r-mouseup",
+          kind: tsx.ScriptElementKind.jsxAttribute,
+          sortText: "1_r-mouseup",
+          labelDetails: { description: "Reactive mouseup handler" },
+          insertText: "r-mouseup={($event) => {}}"
+        },
+        {
+          name: "r-scroll",
+          kind: tsx.ScriptElementKind.jsxAttribute,
+          sortText: "1_r-scroll",
+          labelDetails: { description: "Reactive scroll handler" },
+          insertText: "r-scroll={($event) => {}}"
+        },
+        {
+          name: "r-wheel",
+          kind: tsx.ScriptElementKind.jsxAttribute,
+          sortText: "1_r-wheel",
+          labelDetails: { description: "Reactive wheel handler" },
+          insertText: "r-wheel={($event) => {}}"
+        },
+        {
+          name: "r-touchstart",
+          kind: tsx.ScriptElementKind.jsxAttribute,
+          sortText: "1_r-touchstart",
+          labelDetails: { description: "Reactive touchstart handler" },
+          insertText: "r-touchstart={($event) => {}}"
+        },
+        {
+          name: "r-touchend",
+          kind: tsx.ScriptElementKind.jsxAttribute,
+          sortText: "1_r-touchend",
+          labelDetails: { description: "Reactive touchend handler" },
+          insertText: "r-touchend={($event) => {}}"
+        },
+        {
+          name: "r-touchmove",
+          kind: tsx.ScriptElementKind.jsxAttribute,
+          sortText: "1_r-touchmove",
+          labelDetails: { description: "Reactive touchmove handler" },
+          insertText: "r-touchmove={($event) => {}}"
+        },
+        {
+          name: "r-drag",
+          kind: tsx.ScriptElementKind.jsxAttribute,
+          sortText: "1_r-drag",
+          labelDetails: { description: "Reactive drag handler" },
+          insertText: "r-drag={($event) => {}}"
+        },
+        {
+          name: "r-dragstart",
+          kind: tsx.ScriptElementKind.jsxAttribute,
+          sortText: "1_r-dragstart",
+          labelDetails: { description: "Reactive dragstart handler" },
+          insertText: "r-dragstart={($event) => {}}"
+        },
+        {
+          name: "r-dragend",
+          kind: tsx.ScriptElementKind.jsxAttribute,
+          sortText: "1_r-dragend",
+          labelDetails: { description: "Reactive dragend handler" },
+          insertText: "r-dragend={($event) => {}}"
+        },
+        {
+          name: "r-dragover",
+          kind: tsx.ScriptElementKind.jsxAttribute,
+          sortText: "1_r-dragover",
+          labelDetails: { description: "Reactive dragover handler" },
+          insertText: "r-dragover={($event) => {}}"
+        },
+        {
+          name: "r-drop",
+          kind: tsx.ScriptElementKind.jsxAttribute,
+          sortText: "1_r-drop",
+          labelDetails: { description: "Reactive drop handler" },
+          insertText: "r-drop={($event) => {}}"
+        },
+        {
+          name: "r-load",
+          kind: tsx.ScriptElementKind.jsxAttribute,
+          sortText: "1_r-load",
+          labelDetails: { description: "Reactive load handler" },
+          insertText: "r-load={($event) => {}}"
+        },
+        {
+          name: "r-error",
+          kind: tsx.ScriptElementKind.jsxAttribute,
+          sortText: "1_r-error",
+          labelDetails: { description: "Reactive error handler" },
+          insertText: "r-error={($event) => {}}"
+        }
+      ];
+      if (!prior) {
+        return {
+          isGlobalCompletion: false,
+          isMemberCompletion: false,
+          isNewIdentifierLocation: false,
+          entries: fynixCompletions
+        };
+      }
+      return {
+        ...prior,
+        entries: [...fynixCompletions, ...prior.entries]
+      };
+    };
+    const FYNIX_HOVER_INFO = {
+      nixState: {
+        kind: tsx.ScriptElementKind.functionElement,
+        kindModifiers: "declare",
+        displayParts: [
+          {
+            text: "function nixState<T>(initialValue: T): NixState<T>",
+            kind: "text"
+          }
+        ],
+        documentation: [
+          {
+            text: "Creates a reactive state primitive. The value can be accessed via .value and will trigger re-renders when updated.",
+            kind: "text"
+          }
+        ]
+      },
+      nixStore: {
+        kind: tsx.ScriptElementKind.functionElement,
+        kindModifiers: "declare",
+        displayParts: [
+          {
+            text: "function nixStore<T>(initialValue: T): NixStore<T>",
+            kind: "text"
+          }
+        ],
+        documentation: [
+          {
+            text: "Creates a global reactive store that persists across component instances.",
+            kind: "text"
+          }
+        ]
+      },
+      nixAsync: {
+        kind: tsx.ScriptElementKind.functionElement,
+        kindModifiers: "declare",
+        displayParts: [
+          {
+            text: "function nixAsync<T>(asyncFn: () => Promise<T>): NixAsync<T>",
+            kind: "text"
+          }
+        ],
+        documentation: [
+          {
+            text: "Handles async operations with loading, error, and data states.",
+            kind: "text"
+          }
+        ]
+      },
+      nixEffect: {
+        kind: tsx.ScriptElementKind.functionElement,
+        kindModifiers: "declare",
+        displayParts: [
+          {
+            text: "function nixEffect(fn: () => void | (() => void), deps?: any[]): void",
+            kind: "text"
+          }
+        ],
+        documentation: [
+          {
+            text: "Runs side effects when dependencies change. Returns cleanup function.",
+            kind: "text"
+          }
+        ]
+      },
+      nixComputed: {
+        kind: tsx.ScriptElementKind.functionElement,
+        kindModifiers: "declare",
+        displayParts: [
+          {
+            text: "function nixComputed<T>(fn: () => T, deps: any[]): NixComputed<T>",
+            kind: "text"
+          }
+        ],
+        documentation: [
+          {
+            text: "Creates a computed value that automatically updates when dependencies change.",
+            kind: "text"
+          }
+        ]
+      },
+      nixForm: {
+        kind: tsx.ScriptElementKind.functionElement,
+        kindModifiers: "declare",
+        displayParts: [
+          {
+            text: "function nixForm<T>(config: NixFormConfig<T>): NixForm<T>",
+            kind: "text"
+          }
+        ],
+        documentation: [
+          {
+            text: "Creates a form handler with validation and state management.",
+            kind: "text"
+          }
+        ]
+      }
+    };
+    proxy.getQuickInfoAtPosition = (fileName, position) => {
+      let mappedPosition = position;
+      if (fileName.endsWith(".fnx")) {
+        const cache = fnxCache.get(fileName);
+        if (cache) {
+          mappedPosition = mapOriginalToTransformedWithCache(position, cache);
+        }
+      }
+      const program = info.languageService.getProgram();
+      const sf = program?.getSourceFile(fileName);
+      if (!sf || !fileName.endsWith(".fnx")) {
+        return info.languageService.getQuickInfoAtPosition(
+          fileName,
+          mappedPosition
+        );
+      }
+      const node = findNode(sf, mappedPosition);
+      if (!node) {
+        return info.languageService.getQuickInfoAtPosition(
+          fileName,
+          mappedPosition
+        );
+      }
+      const text = node.getText(sf);
+      if (text in FYNIX_HOVER_INFO) {
+        return {
+          ...FYNIX_HOVER_INFO[text],
+          textSpan: { start: node.getStart(), length: node.getWidth() }
+        };
+      }
+      return info.languageService.getQuickInfoAtPosition(
+        fileName,
+        mappedPosition
+      );
+    };
+    proxy.getDefinitionAtPosition = (fileName, position) => {
+      let mappedPosition = position;
+      if (fileName.endsWith(".fnx")) {
+        const cache2 = fnxCache.get(fileName);
+        if (cache2) {
+          mappedPosition = mapOriginalToTransformedWithCache(position, cache2);
+        }
+      }
+      const defs = info.languageService.getDefinitionAtPosition(
+        fileName,
+        mappedPosition
+      );
+      if (!defs || !fileName.endsWith(".fnx")) return defs;
+      const cache = fnxCache.get(fileName);
+      if (!cache) return defs;
+      return defs.map((def) => {
+        if (def.fileName === fileName) {
+          const originalStart = mapTransformedToOriginalWithCache(
+            def.textSpan.start,
+            cache
+          );
+          return {
+            ...def,
+            textSpan: {
+              start: originalStart,
+              length: def.textSpan.length
+            }
+          };
+        }
+        return def;
+      });
+    };
+    proxy.getReferencesAtPosition = (fileName, position) => {
+      let mappedPosition = position;
+      if (fileName.endsWith(".fnx")) {
+        const cache2 = fnxCache.get(fileName);
+        if (cache2) {
+          mappedPosition = mapOriginalToTransformedWithCache(position, cache2);
+        }
+      }
+      const refs = info.languageService.getReferencesAtPosition(
+        fileName,
+        mappedPosition
+      );
+      if (!refs || !fileName.endsWith(".fnx")) return refs;
+      const cache = fnxCache.get(fileName);
+      if (!cache) return refs;
+      return refs.map((ref) => {
+        if (ref.fileName === fileName) {
+          const originalStart = mapTransformedToOriginalWithCache(
+            ref.textSpan.start,
+            cache
+          );
+          return {
+            ...ref,
+            textSpan: {
+              start: originalStart,
+              length: ref.textSpan.length
+            }
+          };
+        }
+        return ref;
+      });
+    };
+    proxy.getRenameInfo = (fileName, position) => {
+      let mappedPosition = position;
+      if (fileName.endsWith(".fnx")) {
+        const cache = fnxCache.get(fileName);
+        if (cache) {
+          mappedPosition = mapOriginalToTransformedWithCache(position, cache);
+        }
+      }
+      return info.languageService.getRenameInfo(fileName, mappedPosition);
+    };
+    return proxy;
+  }
+  __name(create, "create");
+  return { create };
+}
+__name(init, "init");
+function findNode(sf, pos) {
+  function walk(node) {
+    if (pos >= node.getStart() && pos < node.getEnd()) {
+      return ts.forEachChild(node, walk) || node;
+    }
+    return void 0;
+  }
+  __name(walk, "walk");
+  return walk(sf);
+}
+__name(findNode, "findNode");
+export {
+  init as default
+};
+//# sourceMappingURL=index.js.map