gemi 0.56.0 → 0.58.0

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

@@ -0,0 +1,1206 @@
+// ide/typescript-plugin/ast.ts
+function unwrapExpression(ts, node) {
+  let current = node;
+  for (;; ) {
+    if (ts.isParenthesizedExpression(current))
+      current = current.expression;
+    else if (ts.isAsExpression(current))
+      current = current.expression;
+    else if (ts.isSatisfiesExpression(current))
+      current = current.expression;
+    else if (ts.isNonNullExpression(current))
+      current = current.expression;
+    else if (ts.isTypeAssertionExpression(current))
+      current = current.expression;
+    else
+      return current;
+  }
+}
+function unwrapBuilderChain(ts, node) {
+  const chainable = new Set(["middleware", "alwaysRun"]);
+  let current = unwrapExpression(ts, node);
+  while (ts.isCallExpression(current) && ts.isPropertyAccessExpression(current.expression) && chainable.has(current.expression.name.text)) {
+    current = unwrapExpression(ts, current.expression.expression);
+  }
+  return current;
+}
+function getThisCall(ts, node) {
+  if (!ts.isCallExpression(node))
+    return;
+  const callee = node.expression;
+  if (!ts.isPropertyAccessExpression(callee))
+    return;
+  if (callee.expression.kind !== ts.SyntaxKind.ThisKeyword)
+    return;
+  return { method: callee.name.text, args: node.arguments, node };
+}
+function getStringValue(ts, checker, node) {
+  if (!node)
+    return;
+  const expression = unwrapExpression(ts, node);
+  if (ts.isStringLiteralLike(expression))
+    return expression.text;
+  const type = checker.getTypeAtLocation(expression);
+  if (type.isStringLiteral())
+    return type.value;
+  return;
+}
+function getPropertyKeyText(ts, checker, name) {
+  if (ts.isStringLiteralLike(name))
+    return name.text;
+  if (ts.isIdentifier(name))
+    return name.text;
+  if (ts.isNumericLiteral(name))
+    return name.text;
+  if (ts.isComputedPropertyName(name))
+    return getStringValue(ts, checker, name.expression);
+  return;
+}
+function resolveClassDeclaration(ts, checker, node) {
+  if (ts.isClassExpression(node))
+    return node;
+  let symbol = checker.getSymbolAtLocation(node);
+  if (!symbol)
+    return;
+  if (symbol.flags & ts.SymbolFlags.Alias)
+    symbol = checker.getAliasedSymbol(symbol);
+  const declaration = symbol.valueDeclaration ?? symbol.declarations?.[0];
+  return declaration && ts.isClassLike(declaration) ? declaration : undefined;
+}
+function getRoutesObjectLiteral(ts, classDeclaration) {
+  for (const member of classDeclaration.members) {
+    if (!ts.isPropertyDeclaration(member))
+      continue;
+    if (!member.name || !ts.isIdentifier(member.name) || member.name.text !== "routes")
+      continue;
+    if (!member.initializer)
+      continue;
+    const initializer = unwrapExpression(ts, member.initializer);
+    if (ts.isObjectLiteralExpression(initializer))
+      return initializer;
+  }
+  return;
+}
+function spanOf(node) {
+  const start = node.getStart(node.getSourceFile());
+  return { start, length: node.getEnd() - start };
+}
+function nameNodeOf(ts, declaration) {
+  const named = declaration;
+  return named.name && !ts.isComputedPropertyName(named.name) ? named.name : declaration;
+}
+function targetFromDeclaration(ts, declaration, name, containerName, kind) {
+  return {
+    fileName: declaration.getSourceFile().fileName,
+    span: spanOf(nameNodeOf(ts, declaration)),
+    contextSpan: spanOf(declaration),
+    name,
+    containerName,
+    kind
+  };
+}
+function displayNameOfClass(ts, checker, expression) {
+  const declaration = resolveClassDeclaration(ts, checker, expression);
+  if (declaration?.name)
+    return declaration.name.text;
+  return expression.getText();
+}
+
+// ide/typescript-plugin/callSite.ts
+var HTTP_VERBS = new Set(["GET", "POST", "PUT", "PATCH", "DELETE"]);
+var VIEW_ATTRIBUTES = new Set(["href", "to"]);
+var ACTION_ATTRIBUTES = new Set(["action"]);
+function findRouteQuery(ts, checker, sourceFile, position) {
+  const node = findStringLiteral(ts, sourceFile, position);
+  if (!node)
+    return;
+  if (!isRouteReferencePosition(ts, node))
+    return;
+  return {
+    node,
+    path: node.text,
+    allowedPaths: allowedPathsAt(ts, checker, node),
+    ...contextHints(ts, checker, node)
+  };
+}
+function findStringLiteral(ts, sourceFile, position) {
+  let found;
+  const visit = (node) => {
+    if (position < node.getFullStart() || position > node.getEnd())
+      return;
+    if (ts.isStringLiteralLike(node)) {
+      const start = node.getStart(sourceFile);
+      if (position > start && position < node.getEnd())
+        found = node;
+    }
+    ts.forEachChild(node, visit);
+  };
+  ts.forEachChild(sourceFile, visit);
+  return found;
+}
+function isRouteReferencePosition(ts, node) {
+  const parent = node.parent;
+  if (!parent)
+    return false;
+  if (ts.isImportDeclaration(parent) || ts.isExportDeclaration(parent))
+    return false;
+  if (ts.isImportTypeNode(parent) || ts.isExternalModuleReference(parent))
+    return false;
+  if (ts.isImportSpecifier(parent) || ts.isExportSpecifier(parent))
+    return false;
+  if ((ts.isPropertyAssignment(parent) || ts.isPropertySignature(parent) || ts.isMethodDeclaration(parent) || ts.isPropertyDeclaration(parent) || ts.isEnumMember(parent)) && parent.name === node) {
+    return false;
+  }
+  if (ts.isLiteralTypeNode(parent))
+    return false;
+  if (ts.isElementAccessExpression(parent) && parent.argumentExpression === node)
+    return false;
+  return true;
+}
+function allowedPathsAt(ts, checker, node) {
+  const site = argumentSite(ts, node);
+  if (!site)
+    return;
+  const declaration = checker.getResolvedSignature(site.call)?.getDeclaration();
+  if (!declaration || !ts.isFunctionLike(declaration))
+    return;
+  const parameter = declaration.parameters[site.index];
+  if (!parameter || parameter.dotDotDotToken)
+    return;
+  let type = checker.getTypeAtLocation(parameter);
+  if (site.property !== undefined) {
+    const symbol = type.getProperty(site.property);
+    if (!symbol)
+      return;
+    type = checker.getTypeOfSymbolAtLocation(symbol, parameter);
+  }
+  const constraint = checker.getBaseConstraintOfType(type) ?? type;
+  return stringLiteralSet(constraint);
+}
+function argumentSite(ts, node) {
+  const parent = node.parent;
+  if (!parent)
+    return;
+  if (ts.isCallExpression(parent) || ts.isNewExpression(parent)) {
+    const index2 = [...parent.arguments ?? []].indexOf(node);
+    return index2 < 0 ? undefined : { call: parent, index: index2 };
+  }
+  if (!ts.isPropertyAssignment(parent) || parent.initializer !== node)
+    return;
+  const property = ts.isIdentifier(parent.name) || ts.isStringLiteralLike(parent.name) ? parent.name.text : undefined;
+  if (property === undefined)
+    return;
+  const object = parent.parent;
+  if (!ts.isObjectLiteralExpression(object))
+    return;
+  const call = object.parent;
+  if (!call || !ts.isCallExpression(call) && !ts.isNewExpression(call))
+    return;
+  const index = [...call.arguments ?? []].indexOf(object);
+  return index < 0 ? undefined : { call, index, property };
+}
+function stringLiteralSet(type) {
+  const members = type.isUnion() ? type.types : [type];
+  const paths = new Set;
+  for (const member of members) {
+    if (!member.isStringLiteral())
+      return;
+    paths.add(member.value);
+  }
+  return paths.size > 0 ? paths : undefined;
+}
+function contextHints(ts, checker, node) {
+  const attribute = enclosingJsxAttribute(ts, node);
+  if (attribute) {
+    const name = ts.isIdentifier(attribute.name) ? attribute.name.text : attribute.name.getText();
+    if (VIEW_ATTRIBUTES.has(name))
+      return { prefer: "view" };
+    if (ACTION_ATTRIBUTES.has(name)) {
+      return { prefer: "api", verb: siblingMethodVerb(ts, checker, attribute) ?? "POST" };
+    }
+    return {};
+  }
+  const call = node.parent;
+  if (call && ts.isCallExpression(call)) {
+    const index = call.arguments.indexOf(node);
+    const previous = index > 0 ? call.arguments[index - 1] : undefined;
+    const value = getStringValue(ts, checker, previous)?.toUpperCase();
+    if (value && HTTP_VERBS.has(value))
+      return { verb: value, prefer: "api" };
+  }
+  return {};
+}
+function enclosingJsxAttribute(ts, node) {
+  const parent = node.parent;
+  if (!parent)
+    return;
+  if (ts.isJsxAttribute(parent))
+    return parent;
+  if (ts.isJsxExpression(parent) && parent.parent && ts.isJsxAttribute(parent.parent)) {
+    return parent.parent;
+  }
+  return;
+}
+function siblingMethodVerb(ts, checker, attribute) {
+  const attributes = attribute.parent;
+  if (!attributes || !ts.isJsxAttributes(attributes))
+    return;
+  for (const sibling of attributes.properties) {
+    if (!ts.isJsxAttribute(sibling))
+      continue;
+    const name = ts.isIdentifier(sibling.name) ? sibling.name.text : sibling.name.getText();
+    if (name !== "method" || !sibling.initializer)
+      continue;
+    const initializer = ts.isJsxExpression(sibling.initializer) ? sibling.initializer.expression : sibling.initializer;
+    const value = getStringValue(ts, checker, initializer)?.toUpperCase();
+    if (value && HTTP_VERBS.has(value))
+      return value;
+  }
+  return;
+}
+
+// ide/typescript-plugin/lookup.ts
+var VERB_ORDER = ["GET", "POST", "PUT", "PATCH", "DELETE"];
+var indexes = new WeakMap;
+function indexOf(table) {
+  const cached = indexes.get(table);
+  if (cached)
+    return cached;
+  const knownPaths = new Set;
+  const pathsByVerb = new Map;
+  for (const entries of table.api.values()) {
+    for (const entry of entries) {
+      let paths = pathsByVerb.get(entry.verb);
+      if (!paths)
+        pathsByVerb.set(entry.verb, paths = new Set);
+      paths.add(entry.path);
+      knownPaths.add(entry.path);
+    }
+  }
+  const viewPaths = new Set;
+  for (const entries of table.views.values()) {
+    for (const entry of entries) {
+      viewPaths.add(entry.path);
+      knownPaths.add(entry.path);
+    }
+  }
+  const index = { pathsByVerb, viewPaths, knownPaths };
+  indexes.set(table, index);
+  return index;
+}
+function lookupRoute(table, query) {
+  let candidates = [
+    ...(table.api.get(query.path) ?? []).map((entry) => ({ kind: "api", entry })),
+    ...(table.views.get(query.path) ?? []).map((entry) => ({ kind: "view", entry }))
+  ];
+  if (candidates.length === 0)
+    return [];
+  if (query.prefer) {
+    candidates = narrow(candidates, (candidate) => candidate.kind === query.prefer);
+  }
+  if (query.verb) {
+    candidates = narrow(candidates, (candidate) => candidate.kind === "api" && candidate.entry.verb === query.verb);
+  }
+  if (query.allowedPaths) {
+    const { pathsByVerb, viewPaths, knownPaths } = indexOf(table);
+    const allowed = intersect(query.allowedPaths, knownPaths);
+    if (allowed.size > 0) {
+      candidates = narrow(candidates, (candidate) => candidate.kind === "api" ? isSubset(allowed, pathsByVerb.get(candidate.entry.verb)) : isSubset(allowed, viewPaths));
+    }
+  }
+  candidates.sort(compareCandidates);
+  return candidates.map((candidate) => ({ candidate, targets: candidate.entry.targets }));
+}
+function narrow(candidates, predicate) {
+  const kept = candidates.filter(predicate);
+  return kept.length > 0 ? kept : candidates;
+}
+function isSubset(subset, superset) {
+  if (!superset)
+    return false;
+  for (const value of subset) {
+    if (!superset.has(value))
+      return false;
+  }
+  return true;
+}
+function intersect(subset, universe) {
+  const kept = new Set;
+  for (const value of subset) {
+    if (universe.has(value))
+      kept.add(value);
+  }
+  return kept;
+}
+function compareCandidates(a, b) {
+  if (a.kind !== b.kind)
+    return a.kind === "api" ? -1 : 1;
+  if (a.kind === "api" && b.kind === "api") {
+    return VERB_ORDER.indexOf(a.entry.verb) - VERB_ORDER.indexOf(b.entry.verb);
+  }
+  const rank = (kind) => kind === "view" ? 0 : 1;
+  return rank(a.entry.kind) - rank(b.entry.kind);
+}
+function describeCandidate(candidate) {
+  return candidate.kind === "api" ? `${candidate.entry.verb} ${candidate.entry.path}` : `${candidate.entry.kind} ${candidate.entry.path}`;
+}
+function describeTarget(target) {
+  switch (target.kind) {
+    case "controller-method":
+      return `${target.containerName}.${target.name}()`;
+    case "inline-handler":
+      return "inline handler";
+    case "view-component":
+      return `${target.name} component`;
+    case "route-entry":
+      return `${target.containerName} routes entry`;
+  }
+}
+
+// ide/typescript-plugin/entryPoints.ts
+var RPC_INTERFACES = {
+  api: { interfaceName: "RPC" },
+  view: { interfaceName: "ViewRPC" }
+};
+var CONFIG_HELPER = "defineRouteConfig";
+var CONFIG_MODULE = "gemi/services";
+var CLIENT_MODULE = "gemi/client";
+var FALLBACK_API_ROUTER = "app/http/routes/api";
+var FALLBACK_VIEW_ROUTER = "app/http/routes/view";
+function findRootRouters(ts, program, projectRoot) {
+  const checker = program.getTypeChecker();
+  const result = { api: [], view: [], dependencies: [], diagnostics: [] };
+  const seen = new Set;
+  for (const kind of ["api", "view"]) {
+    const { interfaceName } = RPC_INTERFACES[kind];
+    for (const declaration of findInterfaceDeclarations(ts, checker, program, interfaceName)) {
+      result.dependencies.push(declaration.getSourceFile().fileName);
+      for (const mount of readMounts(ts, checker, declaration)) {
+        const fileName = mount.declaration.getSourceFile().fileName;
+        const key = `${kind}\x00${mount.prefix}\x00${fileName}\x00${mount.declaration.pos}`;
+        if (seen.has(key))
+          continue;
+        seen.add(key);
+        result[kind].push(mount);
+        result.dependencies.push(fileName);
+      }
+    }
+  }
+  const hasAppMount = (kind) => result[kind].some((mount) => isApplicationFile(mount.declaration.getSourceFile().fileName, projectRoot));
+  if (hasAppMount("api") || hasAppMount("view"))
+    return result;
+  result.diagnostics.push("the RPC / ViewRPC augmentation names none of this project's routers — falling back " + "to the app's route config. Check that gemi/client is imported and that " + `${projectRoot}/${FALLBACK_API_ROUTER}.ts typechecks, so route types and route jumps agree.`);
+  const config = findRouteConfigCall(ts, program);
+  if (config) {
+    result.dependencies.push(config.getSourceFile().fileName);
+    const object = unwrapExpression(ts, config.arguments[0] ?? config);
+    if (ts.isObjectLiteralExpression(object)) {
+      for (const kind of ["api", "view"]) {
+        const declaration = readRootRouter(ts, checker, object, kind);
+        if (!declaration)
+          continue;
+        result[kind].push({ declaration, prefix: "" });
+        result.dependencies.push(declaration.getSourceFile().fileName);
+      }
+    }
+  }
+  if (!hasAppMount("api")) {
+    const declaration = findConventionalRouter(ts, program, projectRoot, FALLBACK_API_ROUTER);
+    if (declaration) {
+      result.api.push({ declaration, prefix: "" });
+      result.dependencies.push(declaration.getSourceFile().fileName);
+    }
+  }
+  if (!hasAppMount("view")) {
+    const declaration = findConventionalRouter(ts, program, projectRoot, FALLBACK_VIEW_ROUTER);
+    if (declaration) {
+      result.view.push({ declaration, prefix: "" });
+      result.dependencies.push(declaration.getSourceFile().fileName);
+    }
+  }
+  if (!hasAppMount("api") && !hasAppMount("view")) {
+    result.diagnostics.push(`no application routers found: no ${CONFIG_HELPER}() call and nothing at ${projectRoot}/${FALLBACK_API_ROUTER}`);
+  }
+  return result;
+}
+function isApplicationFile(fileName, projectRoot) {
+  return fileName.startsWith(`${projectRoot}/`) && !fileName.includes("/node_modules/");
+}
+function findInterfaceDeclarations(ts, checker, program, name) {
+  const fromModule = findClientModuleSymbol(ts, checker, program);
+  if (fromModule) {
+    const exported = checker.getExportsOfModule(fromModule).find((symbol) => symbol.name === name);
+    const resolved = exported && exported.flags & ts.SymbolFlags.Alias ? checker.getAliasedSymbol(exported) : exported;
+    const declarations = resolved?.declarations?.filter((declaration) => ts.isInterfaceDeclaration(declaration));
+    if (declarations && declarations.length > 0)
+      return declarations;
+  }
+  for (const sourceFile of program.getSourceFiles()) {
+    if (sourceFile.fileName.includes("/node_modules/"))
+      continue;
+    const local = findInterfaceIn(ts, sourceFile, name);
+    if (!local)
+      continue;
+    const symbol = checker.getSymbolAtLocation(local.name);
+    const declarations = symbol?.declarations?.filter((declaration) => ts.isInterfaceDeclaration(declaration));
+    return declarations && declarations.length > 0 ? declarations : [local];
+  }
+  return [];
+}
+function findClientModuleSymbol(ts, checker, program) {
+  for (const sourceFile of program.getSourceFiles()) {
+    if (sourceFile.fileName.includes("/node_modules/"))
+      continue;
+    for (const statement of sourceFile.statements) {
+      const reference = clientModuleReference(ts, statement);
+      if (!reference)
+        continue;
+      const symbol = checker.getSymbolAtLocation(reference);
+      if (symbol)
+        return symbol;
+    }
+  }
+  return;
+}
+function clientModuleReference(ts, statement) {
+  if (ts.isImportDeclaration(statement) || ts.isExportDeclaration(statement)) {
+    const specifier = statement.moduleSpecifier;
+    if (specifier && ts.isStringLiteralLike(specifier) && specifier.text === CLIENT_MODULE) {
+      return specifier;
+    }
+    return;
+  }
+  if (ts.isModuleDeclaration(statement) && ts.isStringLiteralLike(statement.name) && statement.name.text === CLIENT_MODULE) {
+    return statement.name;
+  }
+  return;
+}
+function findInterfaceIn(ts, sourceFile, name) {
+  let found;
+  const visit = (node) => {
+    if (found)
+      return;
+    if (ts.isInterfaceDeclaration(node) && node.name.text === name) {
+      found = node;
+      return;
+    }
+    if (ts.isSourceFile(node) || ts.isModuleDeclaration(node) || ts.isModuleBlock(node)) {
+      ts.forEachChild(node, visit);
+    }
+  };
+  visit(sourceFile);
+  return found;
+}
+function readMounts(ts, checker, declaration) {
+  const mounts = [];
+  for (const clause of declaration.heritageClauses ?? []) {
+    for (const type of clause.types) {
+      let router;
+      let prefix = "";
+      for (const argument of type.typeArguments ?? []) {
+        if (!router) {
+          const resolved = resolveClassFromTypeNode(ts, checker, argument);
+          if (resolved) {
+            router = resolved;
+            continue;
+          }
+        }
+        if (!prefix)
+          prefix = readPrefix(ts, checker, argument);
+      }
+      if (router)
+        mounts.push({ declaration: router, prefix });
+    }
+  }
+  return mounts;
+}
+function resolveClassFromTypeNode(ts, checker, node) {
+  if (!ts.isTypeReferenceNode(node))
+    return;
+  const name = ts.isQualifiedName(node.typeName) ? node.typeName.right : node.typeName;
+  return resolveClassDeclaration(ts, checker, name);
+}
+function readPrefix(ts, checker, node) {
+  if (!node)
+    return "";
+  if (ts.isLiteralTypeNode(node) && ts.isStringLiteral(node.literal))
+    return node.literal.text;
+  const type = checker.getTypeFromTypeNode(node);
+  return type.isStringLiteral() ? type.value : "";
+}
+function findRouteConfigCall(ts, program) {
+  for (const sourceFile of program.getSourceFiles()) {
+    if (sourceFile.isDeclarationFile)
+      continue;
+    if (sourceFile.fileName.includes("/node_modules/"))
+      continue;
+    const localName = importedNameOf(ts, sourceFile);
+    if (!localName)
+      continue;
+    let found;
+    const visit = (node) => {
+      if (found)
+        return;
+      if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === localName) {
+        found = node;
+        return;
+      }
+      ts.forEachChild(node, visit);
+    };
+    ts.forEachChild(sourceFile, visit);
+    if (found)
+      return found;
+  }
+  return;
+}
+function importedNameOf(ts, sourceFile) {
+  for (const statement of sourceFile.statements) {
+    if (!ts.isImportDeclaration(statement))
+      continue;
+    const specifier = statement.moduleSpecifier;
+    if (!ts.isStringLiteralLike(specifier) || specifier.text !== CONFIG_MODULE)
+      continue;
+    const bindings = statement.importClause?.namedBindings;
+    if (!bindings || !ts.isNamedImports(bindings))
+      continue;
+    for (const element of bindings.elements) {
+      const imported = element.propertyName?.text ?? element.name.text;
+      if (imported === CONFIG_HELPER)
+        return element.name.text;
+    }
+  }
+  return;
+}
+function readRootRouter(ts, checker, config, section) {
+  const sectionValue = getPropertyValue(ts, config, section);
+  if (!sectionValue || !ts.isObjectLiteralExpression(sectionValue))
+    return;
+  const rootRouter = getPropertyValue(ts, sectionValue, "rootRouter");
+  return rootRouter ? resolveClassDeclaration(ts, checker, rootRouter) : undefined;
+}
+function getPropertyValue(ts, object, name) {
+  for (const property of object.properties) {
+    if (ts.isPropertyAssignment(property)) {
+      const key = property.name;
+      const text = ts.isIdentifier(key) || ts.isStringLiteralLike(key) ? key.text : undefined;
+      if (text === name)
+        return unwrapExpression(ts, property.initializer);
+    } else if (ts.isShorthandPropertyAssignment(property) && property.name.text === name) {
+      return property.name;
+    }
+  }
+  return;
+}
+function findConventionalRouter(ts, program, projectRoot, relativePath) {
+  const checker = program.getTypeChecker();
+  for (const extension of [".ts", ".tsx"]) {
+    const sourceFile = program.getSourceFile(`${projectRoot}/${relativePath}${extension}`);
+    if (!sourceFile)
+      continue;
+    const moduleSymbol = checker.getSymbolAtLocation(sourceFile);
+    if (!moduleSymbol)
+      continue;
+    for (const exported of checker.getExportsOfModule(moduleSymbol)) {
+      if (exported.name !== "default")
+        continue;
+      const resolved = exported.flags & ts.SymbolFlags.Alias ? checker.getAliasedSymbol(exported) : exported;
+      const declaration = resolved.valueDeclaration ?? resolved.declarations?.[0];
+      if (declaration && ts.isClassLike(declaration))
+        return declaration;
+    }
+  }
+  return;
+}
+
+// ide/typescript-plugin/routePath.ts
+function removeDoubleSlash(input) {
+  const at = input.indexOf("//");
+  if (at === -1)
+    return input;
+  return removeDoubleSlash(`${input.slice(0, at)}/${input.slice(at + 2)}`);
+}
+function removeGroupPrefix(input) {
+  const open = input.indexOf("(");
+  if (open === -1)
+    return input;
+  const close = input.indexOf(")", open + 1);
+  if (close === -1)
+    return input;
+  return removeDoubleSlash(`${input.slice(0, open)}${input.slice(close + 1)}`);
+}
+function parsePrefixAndKey(prefix, key) {
+  const joined = `${prefix}${key}`;
+  if (joined === "//")
+    return "/";
+  const doubleSlash = joined.indexOf("//");
+  if (doubleSlash !== -1) {
+    return `${removeGroupPrefix(joined.slice(0, doubleSlash))}/${removeGroupPrefix(joined.slice(doubleSlash + 2))}`;
+  }
+  if (joined.endsWith("/")) {
+    const first = joined.indexOf("/");
+    if (first !== -1 && first < joined.length - 1) {
+      return `${removeGroupPrefix(joined.slice(0, first))}/${removeGroupPrefix(joined.slice(first + 1, -1))}`;
+    }
+  }
+  return removeGroupPrefix(joined);
+}
+function removeTrailingId(input) {
+  const at = input.indexOf("/:");
+  if (at === -1)
+    return input;
+  const head = input.slice(0, at);
+  const tail = input.slice(at + 2);
+  if (tail.includes("/:"))
+    return `${head}/:${removeTrailingId(tail)}`;
+  if (head.startsWith("/:"))
+    return "X";
+  return head;
+}
+function joinHandlerMapKey(prefix, key) {
+  return `${prefix}${key === "/" ? "" : key}`;
+}
+
+// ide/typescript-plugin/routeTable.ts
+var VERBS = {
+  get: "GET",
+  post: "POST",
+  put: "PUT",
+  patch: "PATCH",
+  delete: "DELETE"
+};
+var RESOURCE_ROUTES = [
+  { method: "list", verb: "GET", scope: "collection" },
+  { method: "store", verb: "POST", scope: "collection" },
+  { method: "show", verb: "GET", scope: "member" },
+  { method: "update", verb: "PUT", scope: "member" },
+  { method: "delete", verb: "DELETE", scope: "member" }
+];
+var VIEW_EXTENSIONS = [".tsx", ".jsx", ".ts", ".js"];
+function buildRouteTable(ts, program, options) {
+  return new RouteTableBuilder(ts, program, options).build();
+}
+
+class RouteTableBuilder {
+  ts;
+  program;
+  options;
+  checker;
+  api = new Map;
+  views = new Map;
+  dependencies = new Set;
+  diagnostics = [];
+  constructor(ts, program, options) {
+    this.ts = ts;
+    this.program = program;
+    this.options = options;
+    this.checker = program.getTypeChecker();
+  }
+  build() {
+    const roots = findRootRouters(this.ts, this.program, this.options.projectRoot);
+    for (const dependency of roots.dependencies)
+      this.dependencies.add(dependency);
+    this.diagnostics.push(...roots.diagnostics);
+    for (const mount of roots.api)
+      this.walkApiRouter(mount.declaration, mount.prefix, []);
+    for (const mount of roots.view)
+      this.walkViewRouter(mount.declaration, mount.prefix, []);
+    return {
+      api: this.api,
+      views: this.views,
+      dependencies: [...this.dependencies],
+      diagnostics: this.diagnostics
+    };
+  }
+  walkApiRouter(classDeclaration, prefix, stack) {
+    const ts = this.ts;
+    const routes = getRoutesObjectLiteral(ts, classDeclaration);
+    if (!routes)
+      return;
+    this.dependencies.add(classDeclaration.getSourceFile().fileName);
+    for (const property of routes.properties) {
+      if (!ts.isPropertyAssignment(property)) {
+        this.noteUnreadableEntry(property, prefix, classDeclaration);
+        continue;
+      }
+      const key = getPropertyKeyText(ts, this.checker, property.name);
+      if (key === undefined)
+        continue;
+      const value = unwrapExpression(ts, property.initializer);
+      const nested = resolveClassDeclaration(ts, this.checker, value);
+      if (nested && getRoutesObjectLiteral(ts, nested)) {
+        if (stack.includes(nested)) {
+          this.diagnostics.push(`router cycle at ${parsePrefixAndKey(prefix, key)}; stopped descending`);
+          continue;
+        }
+        this.walkApiRouter(nested, parsePrefixAndKey(prefix, key), [...stack, nested]);
+        continue;
+      }
+      if (ts.isObjectLiteralExpression(value)) {
+        const path = joinHandlerMapKey(prefix, key);
+        for (const inner of value.properties) {
+          if (!ts.isPropertyAssignment(inner))
+            continue;
+          this.addApiRoute(path, unwrapExpression(ts, inner.initializer), inner, classDeclaration);
+        }
+        continue;
+      }
+      this.addApiRoute(parsePrefixAndKey(prefix, key), value, property, classDeclaration);
+    }
+  }
+  addApiRoute(path, value, entryNode, router) {
+    const call = getThisCall(this.ts, unwrapBuilderChain(this.ts, value));
+    if (!call)
+      return;
+    const fallback = this.routeEntryTarget(entryNode, router);
+    if (call.method === "resource") {
+      const controller = call.args[0];
+      const collection = removeTrailingId(path);
+      for (const { method, verb: verb2, scope } of RESOURCE_ROUTES) {
+        const target = controller ? this.controllerMethodTarget(controller, method) : undefined;
+        this.pushApi({
+          path: scope === "collection" ? collection : path,
+          verb: verb2,
+          inRpc: true,
+          targets: [target ?? fallback]
+        });
+      }
+      return;
+    }
+    const verb = VERBS[call.method];
+    if (verb) {
+      this.pushApi({ path, verb, inRpc: true, targets: this.handlerTargets(call.args, fallback) });
+      return;
+    }
+    if (call.method === "file" || call.method === "stream") {
+      this.pushApi({
+        path,
+        verb: "GET",
+        inRpc: false,
+        targets: this.handlerTargets(call.args, fallback)
+      });
+      return;
+    }
+    if (call.method === "proxy") {
+      this.pushApi({ path, verb: "GET", inRpc: false, targets: [fallback] });
+    }
+  }
+  pushApi(entry) {
+    const existing = this.api.get(entry.path);
+    if (existing)
+      existing.push(entry);
+    else
+      this.api.set(entry.path, [entry]);
+  }
+  walkViewRouter(classDeclaration, prefix, stack) {
+    const routes = getRoutesObjectLiteral(this.ts, classDeclaration);
+    if (!routes)
+      return;
+    this.dependencies.add(classDeclaration.getSourceFile().fileName);
+    this.walkViewRoutes(routes, prefix, stack, classDeclaration);
+  }
+  walkViewRoutes(routes, prefix, stack, router) {
+    const ts = this.ts;
+    for (const property of routes.properties) {
+      if (!ts.isPropertyAssignment(property)) {
+        this.noteUnreadableEntry(property, prefix, router);
+        continue;
+      }
+      const key = getPropertyKeyText(ts, this.checker, property.name);
+      if (key === undefined)
+        continue;
+      const value = unwrapExpression(ts, property.initializer);
+      const path = parsePrefixAndKey(prefix, key);
+      const nested = resolveClassDeclaration(ts, this.checker, value);
+      if (nested && getRoutesObjectLiteral(ts, nested)) {
+        if (stack.includes(nested)) {
+          this.diagnostics.push(`view router cycle at ${path}; stopped descending`);
+          continue;
+        }
+        this.walkViewRouter(nested, path, [...stack, nested]);
+        continue;
+      }
+      const call = getThisCall(ts, unwrapBuilderChain(ts, value));
+      if (!call)
+        continue;
+      const fallback = this.routeEntryTarget(property, router);
+      switch (call.method) {
+        case "view":
+          this.pushView({
+            path,
+            kind: "view",
+            inRpc: true,
+            targets: this.viewTargets(call.args[0], call.args[1], fallback)
+          });
+          break;
+        case "redirect":
+          this.pushView({
+            path,
+            kind: "view",
+            inRpc: true,
+            targets: this.viewTargets(undefined, call.args[0], fallback)
+          });
+          break;
+        case "file":
+          this.pushView({
+            path,
+            kind: "view",
+            inRpc: false,
+            targets: this.viewTargets(undefined, call.args[0], fallback)
+          });
+          break;
+        case "layout": {
+          const second = call.args[1] ? unwrapExpression(ts, call.args[1]) : undefined;
+          const third = call.args[2] ? unwrapExpression(ts, call.args[2]) : undefined;
+          const children = third && ts.isObjectLiteralExpression(third) ? third : second && ts.isObjectLiteralExpression(second) ? second : undefined;
+          const handler = children === second ? undefined : second;
+          this.pushView({
+            path,
+            kind: "layout",
+            inRpc: true,
+            targets: this.viewTargets(call.args[0], handler, fallback)
+          });
+          if (children)
+            this.walkViewRoutes(children, path, stack, router);
+          break;
+        }
+      }
+    }
+  }
+  pushView(entry) {
+    const existing = this.views.get(entry.path);
+    if (existing)
+      existing.push(entry);
+    else
+      this.views.set(entry.path, [entry]);
+  }
+  viewTargets(viewPath, handler, fallback) {
+    const targets = [];
+    const component = viewPath ? this.viewComponentTarget(viewPath) : undefined;
+    if (component)
+      targets.push(component);
+    if (handler)
+      targets.push(...this.handlerTargets([handler], fallback, { silent: true }));
+    return targets.length > 0 ? targets : [fallback];
+  }
+  viewComponentTarget(viewPath) {
+    const ts = this.ts;
+    const relative = getStringValue(ts, this.checker, viewPath);
+    if (!relative)
+      return;
+    for (const extension of VIEW_EXTENSIONS) {
+      const fileName = `${this.options.viewsDir}/${relative}${extension}`;
+      const sourceFile = this.program.getSourceFile(fileName);
+      if (sourceFile) {
+        this.dependencies.add(fileName);
+        const exported = this.defaultExportDeclaration(sourceFile);
+        if (exported) {
+          return targetFromDeclaration(ts, exported, relative, "view", "view-component");
+        }
+        return {
+          fileName,
+          span: { start: 0, length: 0 },
+          name: relative,
+          containerName: "view",
+          kind: "view-component"
+        };
+      }
+      if (this.options.fileExists(fileName)) {
+        return {
+          fileName,
+          span: { start: 0, length: 0 },
+          name: relative,
+          containerName: "view",
+          kind: "view-component"
+        };
+      }
+    }
+    return;
+  }
+  defaultExportDeclaration(sourceFile) {
+    const moduleSymbol = this.checker.getSymbolAtLocation(sourceFile);
+    if (!moduleSymbol)
+      return;
+    for (const exported of this.checker.getExportsOfModule(moduleSymbol)) {
+      if (exported.name !== "default")
+        continue;
+      const resolved = exported.flags & this.ts.SymbolFlags.Alias ? this.checker.getAliasedSymbol(exported) : exported;
+      const declaration = resolved.valueDeclaration ?? resolved.declarations?.[0];
+      if (declaration)
+        return declaration;
+    }
+    return;
+  }
+  handlerTargets(args, fallback, options = {}) {
+    const ts = this.ts;
+    const first = args[0] ? unwrapExpression(ts, args[0]) : undefined;
+    if (!first)
+      return options.silent ? [] : [fallback];
+    if (ts.isArrayLiteralExpression(first)) {
+      const [controller, method] = first.elements;
+      const name = getStringValue(ts, this.checker, method);
+      const target = controller && name ? this.controllerMethodTarget(controller, name) : undefined;
+      return [target ?? fallback];
+    }
+    if (ts.isFunctionExpression(first) || ts.isArrowFunction(first)) {
+      return [
+        {
+          fileName: first.getSourceFile().fileName,
+          span: spanOf(first),
+          contextSpan: spanOf(first),
+          name: "handler",
+          containerName: "",
+          kind: "inline-handler"
+        }
+      ];
+    }
+    const methodName = getStringValue(ts, this.checker, args[1]);
+    if (methodName) {
+      const target = this.controllerMethodTarget(first, methodName);
+      if (target)
+        return [target];
+    }
+    return options.silent ? [] : [fallback];
+  }
+  controllerMethodTarget(controller, methodName) {
+    const type = this.checker.getTypeAtLocation(controller);
+    const instance = type.getConstructSignatures()[0]?.getReturnType();
+    const property = instance?.getProperty(methodName);
+    const declaration = property?.declarations?.[0];
+    if (!declaration)
+      return;
+    this.dependencies.add(declaration.getSourceFile().fileName);
+    return targetFromDeclaration(this.ts, declaration, methodName, displayNameOfClass(this.ts, this.checker, controller), "controller-method");
+  }
+  noteUnreadableEntry(property, prefix, router) {
+    const ts = this.ts;
+    const what = ts.isSpreadAssignment(property) ? `the spread \`...${property.expression.getText()}\`` : ts.isShorthandPropertyAssignment(property) ? `the shorthand entry \`${property.name.text}\`` : "an entry";
+    this.diagnostics.push(`${router.name?.text ?? "router"} mounted at ${prefix || "/"}: ${what} in \`routes\` ` + `cannot be read statically — the routes it holds are typed but not jumpable`);
+  }
+  routeEntryTarget(property, router) {
+    return {
+      fileName: property.getSourceFile().fileName,
+      span: spanOf(property.name),
+      contextSpan: spanOf(property),
+      name: getPropertyKeyText(this.ts, this.checker, property.name) ?? "route",
+      containerName: router.name?.text ?? "router",
+      kind: "route-entry"
+    };
+  }
+}
+
+// ide/typescript-plugin/plugin.ts
+function decorateLanguageService(host) {
+  const { ts, languageService } = host;
+  const routes = createRouteTableCache(host);
+  const forwarded = Object.create(null);
+  const source = languageService;
+  for (const key of Object.keys(source)) {
+    const member = source[key];
+    if (typeof member !== "function")
+      continue;
+    forwarded[key] = (...args) => member.apply(languageService, args);
+  }
+  const proxy = forwarded;
+  proxy.getDefinitionAndBoundSpan = (fileName, position) => {
+    const matched = match(fileName, position);
+    if (!matched)
+      return languageService.getDefinitionAndBoundSpan(fileName, position);
+    const definitions = toDefinitions(ts, matched.matches);
+    if (definitions.length === 0) {
+      return languageService.getDefinitionAndBoundSpan(fileName, position);
+    }
+    return { textSpan: matched.textSpan, definitions };
+  };
+  proxy.getDefinitionAtPosition = (fileName, position) => {
+    const matched = match(fileName, position);
+    if (!matched)
+      return languageService.getDefinitionAtPosition(fileName, position);
+    const definitions = toDefinitions(ts, matched.matches);
+    return definitions.length > 0 ? definitions : languageService.getDefinitionAtPosition(fileName, position);
+  };
+  proxy.getQuickInfoAtPosition = (fileName, position) => {
+    const original = languageService.getQuickInfoAtPosition(fileName, position);
+    const matched = match(fileName, position);
+    if (!matched)
+      return original;
+    const { heading, documentation } = describeMatches(host, matched.matches);
+    if (original) {
+      return {
+        ...original,
+        documentation: [...original.documentation ?? [], ...documentation]
+      };
+    }
+    return {
+      kind: ts.ScriptElementKind.string,
+      kindModifiers: "",
+      textSpan: matched.textSpan,
+      displayParts: heading,
+      documentation
+    };
+  };
+  return proxy;
+  function match(fileName, position) {
+    try {
+      const program = languageService.getProgram();
+      const sourceFile = program?.getSourceFile(fileName);
+      if (!program || !sourceFile)
+        return;
+      const query = findRouteQuery(ts, program.getTypeChecker(), sourceFile, position);
+      if (!query)
+        return;
+      const matches = lookupRoute(routes.get(program), query);
+      if (matches.length === 0)
+        return;
+      const start = query.node.getStart(sourceFile) + 1;
+      return { matches, textSpan: { start, length: query.node.text.length } };
+    } catch (error) {
+      host.log(`route lookup failed at ${fileName}:${position} — ${describeError(error)}`);
+      return;
+    }
+  }
+}
+function describeError(error) {
+  return error instanceof Error ? `${error.message}
+${error.stack ?? ""}` : String(error);
+}
+function toDefinitions(ts, matches) {
+  const definitions = [];
+  const seen = new Set;
+  for (const { candidate, targets } of matches) {
+    for (const target of targets) {
+      const key = `${target.fileName}:${target.span.start}`;
+      if (seen.has(key))
+        continue;
+      seen.add(key);
+      definitions.push({
+        fileName: target.fileName,
+        textSpan: toTextSpan(target.span),
+        contextSpan: target.contextSpan ? toTextSpan(target.contextSpan) : undefined,
+        kind: scriptElementKind(ts, target.kind),
+        name: target.name,
+        containerName: target.containerName || describeCandidate(candidate),
+        containerKind: ts.ScriptElementKind.unknown
+      });
+    }
+  }
+  return definitions;
+}
+function describeMatches(host, matches) {
+  const lines = [];
+  for (const { candidate, targets } of matches) {
+    lines.push(describeCandidate(candidate));
+    for (const target of targets) {
+      lines.push(`  → ${describeTarget(target)} · ${location(host, target)}`);
+    }
+  }
+  return {
+    heading: [
+      {
+        text: matches.map(({ candidate }) => describeCandidate(candidate)).join(", "),
+        kind: "text"
+      }
+    ],
+    documentation: [{ text: lines.join(`
+`), kind: "text" }]
+  };
+}
+function location(host, target) {
+  const relative = target.fileName.startsWith(`${host.projectRoot}/`) ? target.fileName.slice(host.projectRoot.length + 1) : target.fileName;
+  const sourceFile = host.languageService.getProgram()?.getSourceFile(target.fileName);
+  if (!sourceFile)
+    return relative;
+  const { line } = sourceFile.getLineAndCharacterOfPosition(target.span.start);
+  return `${relative}:${line + 1}`;
+}
+function toTextSpan(span) {
+  return { start: span.start, length: span.length };
+}
+function scriptElementKind(ts, kind) {
+  switch (kind) {
+    case "controller-method":
+      return ts.ScriptElementKind.memberFunctionElement;
+    case "inline-handler":
+      return ts.ScriptElementKind.functionElement;
+    case "view-component":
+      return ts.ScriptElementKind.functionElement;
+    case "route-entry":
+      return ts.ScriptElementKind.memberVariableElement;
+  }
+}
+function createRouteTableCache(host) {
+  let cached;
+  return {
+    get(program) {
+      const fileCount = program.getSourceFiles().length;
+      if (cached && cached.fileCount === fileCount && isUnchanged(cached.versions)) {
+        return cached.table;
+      }
+      const started = Date.now();
+      const table = buildRouteTable(host.ts, program, {
+        projectRoot: host.projectRoot,
+        viewsDir: host.viewsDir,
+        fileExists: host.fileExists
+      });
+      const versions = new Map;
+      for (const fileName of table.dependencies) {
+        versions.set(fileName, host.getScriptVersion(fileName));
+      }
+      cached = { table, versions, fileCount };
+      host.log(`built route table in ${Date.now() - started}ms: ${table.api.size} api paths, ` + `${table.views.size} view paths, from ${table.dependencies.length} files`);
+      for (const diagnostic of table.diagnostics)
+        host.log(diagnostic);
+      return table;
+    }
+  };
+  function isUnchanged(versions) {
+    for (const [fileName, version] of versions) {
+      if (host.getScriptVersion(fileName) !== version)
+        return false;
+    }
+    return true;
+  }
+}
+
+// ide/typescript-plugin/index.ts
+function init(modules) {
+  const tsModule = modules.typescript;
+  return {
+    create(info) {
+      const log = (message) => info.project.projectService.logger.info(`[gemi] ${message}`);
+      try {
+        const config = info.config ?? {};
+        if (config.enable === false) {
+          log("disabled by config");
+          return info.languageService;
+        }
+        const projectRoot = trimTrailingSlash(config.projectRoot ? absolute(config.projectRoot, info.project.getCurrentDirectory()) : info.project.getCurrentDirectory());
+        const viewsDir = trimTrailingSlash(config.viewsDir ? absolute(config.viewsDir, projectRoot) : `${projectRoot}/app/views`);
+        log(`activated for ${projectRoot} (views: ${viewsDir})`);
+        return decorateLanguageService({
+          ts: tsModule,
+          languageService: info.languageService,
+          projectRoot,
+          viewsDir,
+          fileExists: (fileName) => info.serverHost.fileExists(fileName),
+          getScriptVersion: (fileName) => info.project.getScriptVersion(fileName),
+          log
+        });
+      } catch (error) {
+        log(`failed to activate, falling back to the plain language service — ${describeError(error)}`);
+        return info.languageService;
+      }
+    }
+  };
+}
+function absolute(path, base) {
+  const normalized = path.replace(/\\/g, "/");
+  if (normalized.startsWith("/") || /^[a-zA-Z]:\//.test(normalized))
+    return normalized;
+  return `${trimTrailingSlash(base)}/${normalized.replace(/^\.\//, "")}`;
+}
+function trimTrailingSlash(path) {
+  return path.length > 1 && path.endsWith("/") ? path.slice(0, -1) : path;
+}
+module.exports = init;
+
+//# debugId=3EB5BA7A2D4DD49664756E2164756E21