@react-router/dev 0.0.0-experimental-312bddb22 → 0.0.0-experimental-2d5e406e4

package/dist/typescript/autotype/language-service.js

@@ -0,0 +1,290 @@
+/**
+ * @react-router/dev v0.0.0-experimental-2d5e406e4
+ *
+ * Copyright (c) Remix Software Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE.md file in the root directory of this source tree.
+ *
+ * @license MIT
+ */
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var path = require('node:path');
+var typegen = require('../typegen.js');
+var ast = require('../ast.js');
+var routes = require('../routes.js');
+
+function _interopNamespace(e) {
+    if (e && e.__esModule) return e;
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n["default"] = e;
+    return Object.freeze(n);
+}
+
+var path__namespace = /*#__PURE__*/_interopNamespace(path);
+
+// Adapted from https://github.com/sveltejs/language-tools/blob/master/packages/typescript-plugin/src/language-service/sveltekit.ts
+const FORCE_UPDATE_VERSION = "FORCE_UPDATE_VERSION";
+// TODO: cache by rootDirectory!
+let CACHED;
+function getAutotypeLanguageService(ctx) {
+  if (CACHED) return CACHED;
+  const host = ctx.languageServiceHost;
+  class AutotypeLanguageServiceHost {
+    routes = {};
+    // TODO: Q: are these needed? do they just "silence" the autotype host?
+    // log() {}
+    // trace() {}
+    // error() {}
+    getCompilationSettings() {
+      return host.getCompilationSettings();
+    }
+    getCurrentDirectory() {
+      return host.getCurrentDirectory();
+    }
+    getDefaultLibFileName(o) {
+      return host.getDefaultLibFileName(o);
+    }
+    getScriptFileNames() {
+      const names = new Set(Object.keys(this.routes));
+      const files = host.getScriptFileNames();
+      for (const file of files) {
+        names.add(file);
+      }
+      return [...names];
+    }
+    getScriptVersion(fileName) {
+      const route = this.routes[fileName];
+      if (!route) return host.getScriptVersion(fileName);
+      return route.version.toString();
+    }
+    getScriptSnapshot(fileName) {
+      const route = this.routes[fileName];
+      if (!route) return host.getScriptSnapshot(fileName);
+      return route.snapshot;
+    }
+    readFile(fileName) {
+      const route = this.routes[fileName];
+      return route ? route.snapshot.getText(0, route.snapshot.getLength()) : host.readFile(fileName);
+    }
+    fileExists(fileName) {
+      return this.routes[fileName] !== undefined || host.fileExists(fileName);
+    }
+    getRouteIfUpToDate(fileName) {
+      const scriptVersion = this.getScriptVersion(fileName);
+      const route = this.routes[fileName];
+      if (!route || scriptVersion !== host.getScriptVersion(fileName) || scriptVersion === FORCE_UPDATE_VERSION) {
+        return undefined;
+      }
+      return route;
+    }
+    upsertRouteFile(fileName) {
+      var _ctx$languageService$;
+      const route = routes.get(ctx, fileName);
+      if (!route) return;
+      const sourceFile = (_ctx$languageService$ = ctx.languageService.getProgram()) === null || _ctx$languageService$ === void 0 ? void 0 : _ctx$languageService$.getSourceFile(fileName);
+      if (!sourceFile) return;
+      const {
+        text: code
+      } = sourceFile;
+      const autotyped = autotypeRoute(ctx, fileName, code);
+      const snapshot = ctx.ts.ScriptSnapshot.fromString(autotyped.code());
+      snapshot.getChangeRange = _ => undefined;
+      this.routes[fileName] = {
+        version: this.routes[fileName] === undefined ? FORCE_UPDATE_VERSION : host.getScriptVersion(fileName),
+        snapshot,
+        autotyped
+      };
+      return this.routes[fileName];
+    }
+    // needed for path auto completions
+    readDirectory = host.readDirectory ? (...args) => {
+      return host.readDirectory(...args);
+    } : undefined;
+  }
+  const autotypeHost = new AutotypeLanguageServiceHost();
+  function getRoute(fileName) {
+    const route = autotypeHost.getRouteIfUpToDate(fileName) ?? autotypeHost.upsertRouteFile(fileName);
+    return route;
+  }
+  const languageService = ctx.ts.createLanguageService(autotypeHost);
+  CACHED = {
+    ...languageService,
+    getRoute
+  };
+  return CACHED;
+}
+function autotypeRoute(ctx, filepath, code) {
+  const sourceFile = ctx.ts.createSourceFile(filepath, code, ctx.ts.ScriptTarget.Latest, true);
+  const route = {
+    file: path__namespace.relative(ctx.config.appDirectory, filepath)
+  };
+  const typesSource = "./" + path__namespace.parse(typegen.getPath(ctx, route)).name;
+  const splices = [...sourceFile.statements.flatMap(stmt => [...annotateDefaultExportFunctionDeclaration(ctx, stmt, typesSource), ...annotateDefaultExportExpression(ctx, stmt, typesSource), ...annotateNamedExportFunctionDeclaration(ctx, stmt, typesSource), ...annotateNamedExportVariableStatement(ctx, stmt, typesSource)])];
+  return new AutotypedRoute(code, splices);
+}
+function annotateDefaultExportFunctionDeclaration(ctx, stmt, typesSource) {
+  var _stmt$name, _stmt$name2;
+  if (!ctx.ts.isFunctionDeclaration(stmt)) return [];
+  if (!ast.exported(ctx.ts, stmt)) return [];
+  const _default = ast.defaulted(ctx.ts, stmt);
+  if (!_default) return [];
+  return annotateFunction(ctx, stmt, {
+    typesSource,
+    name: "default",
+    remapDiagnostics: {
+      start: ((_stmt$name = stmt.name) === null || _stmt$name === void 0 ? void 0 : _stmt$name.getStart()) ?? _default.getStart(),
+      length: ((_stmt$name2 = stmt.name) === null || _stmt$name2 === void 0 ? void 0 : _stmt$name2.getWidth()) ?? _default.getWidth()
+    }
+  });
+}
+function annotateDefaultExportExpression(ctx, stmt, typesSource) {
+  if (!ctx.ts.isExportAssignment(stmt)) return [];
+  if (stmt.isExportEquals) return [];
+  if (!ctx.ts.isArrowFunction(stmt.expression)) return [];
+  const regex = /^export\s+/;
+  const matches = stmt.getText().match(regex);
+  if (!matches) {
+    throw Error(`expected ${regex} at ${stmt.getSourceFile().fileName}:${stmt.getStart()}`);
+  }
+  return annotateFunction(ctx, stmt.expression, {
+    typesSource,
+    name: "default",
+    remapDiagnostics: {
+      start: stmt.getStart() + matches[0].length,
+      length: 7
+    }
+  });
+}
+function annotateNamedExportFunctionDeclaration(ctx, stmt, typesSource) {
+  if (!ctx.ts.isFunctionDeclaration(stmt)) return [];
+  if (!ast.exported(ctx.ts, stmt)) return [];
+  if (ast.defaulted(ctx.ts, stmt)) return [];
+  if (!stmt.name) return [];
+  return annotateFunction(ctx, stmt, {
+    typesSource,
+    name: stmt.name.text,
+    remapDiagnostics: {
+      start: stmt.name.getStart(),
+      length: stmt.name.getWidth()
+    }
+  });
+}
+function annotateNamedExportVariableStatement(ctx, stmt, typesSource) {
+  if (!ctx.ts.isVariableStatement(stmt)) return [];
+  if (!ast.exported(ctx.ts, stmt)) return [];
+  return stmt.declarationList.declarations.flatMap(decl => {
+    if (!ctx.ts.isIdentifier(decl.name)) return [];
+    if (decl.initializer === undefined) return [];
+    if (ctx.ts.isFunctionExpression(decl.initializer) || ctx.ts.isArrowFunction(decl.initializer)) {
+      return annotateFunction(ctx, decl.initializer, {
+        typesSource,
+        name: decl.name.text,
+        remapDiagnostics: {
+          start: decl.name.getStart(),
+          length: decl.name.getWidth()
+        }
+      });
+    }
+    return [];
+  });
+}
+function annotateFunction(ctx, fn, {
+  typesSource,
+  name,
+  remapDiagnostics
+}) {
+  var _fn$body, _Route$exports$name;
+  const param = fn.parameters[0];
+  const returnTypeIndex = ctx.ts.isArrowFunction(fn) ? fn.equalsGreaterThanToken.getStart() : (_fn$body = fn.body) === null || _fn$body === void 0 ? void 0 : _fn$body.getStart();
+  const annotateReturnType = (_Route$exports$name = routes.exports[name]) === null || _Route$exports$name === void 0 ? void 0 : _Route$exports$name.annotateReturnType;
+  name = name === "default" ? "Default" : name;
+  return [param && param.type === undefined ? {
+    index: param.getEnd(),
+    content: `: import("${typesSource}").${name}["args"]`,
+    remapDiagnostics
+  } : null, returnTypeIndex && annotateReturnType && fn.type === undefined ? {
+    index: returnTypeIndex,
+    content: `: import("${typesSource}").${name}["return"]`,
+    remapDiagnostics
+  } : null].filter(x => x !== null);
+}
+class AutotypedRoute {
+  _code = undefined;
+  constructor(code, splices) {
+    this._originalCode = code;
+    this._splices = splices;
+  }
+  code() {
+    if (!this._code) {
+      const chars = Array.from(this._originalCode);
+      // iterate over splices in reverse so that splicing doesn't mess up other indices
+      for (let {
+        index,
+        content
+      } of reverse(this._splices)) {
+        chars.splice(index, 0, content);
+      }
+      this._code = chars.join("");
+    }
+    return this._code;
+  }
+  toSplicedIndex(originalIndex) {
+    let spliceOffset = 0;
+    for (let {
+      index,
+      content
+    } of this._splices) {
+      if (index > originalIndex) break;
+      spliceOffset += content.length;
+    }
+    return originalIndex + spliceOffset;
+  }
+  toOriginalIndex(splicedIndex) {
+    let spliceOffset = 0;
+    for (let {
+      index,
+      content,
+      remapDiagnostics
+    } of this._splices) {
+      // before this splice
+      if (splicedIndex < index + spliceOffset) break;
+      // within this splice
+      if (splicedIndex < index + spliceOffset + content.length) {
+        return {
+          index,
+          remapDiagnostics
+        };
+      }
+      // after this splice
+      spliceOffset += content.length;
+    }
+    return {
+      index: Math.max(0, splicedIndex - spliceOffset)
+    };
+  }
+}
+function* reverse(array) {
+  let i = array.length - 1;
+  while (i >= 0) {
+    yield array[i];
+    i--;
+  }
+}
+
+exports.AutotypedRoute = AutotypedRoute;
+exports.getAutotypeLanguageService = getAutotypeLanguageService;

package/dist/typescript/context.d.ts

@@ -0,0 +1,15 @@
+import type ts from "typescript/lib/tsserverlibrary";
+import type { RouteManifest } from "../config/routes";
+export type Context = {
+    config: {
+        rootDirectory: string;
+        appDirectory: string;
+    };
+    routes: RouteManifest;
+    languageService: ts.LanguageService;
+    languageServiceHost: ts.LanguageServiceHost;
+    ts: typeof ts;
+    logger?: {
+        info: (message: string) => void;
+    };
+};

package/dist/typescript/decorate.d.ts

@@ -0,0 +1,2 @@
+import type { Context } from "./context";
+export declare function decorateLanguageService(ctx: Context): void;

package/dist/typescript/decorate.js

@@ -0,0 +1,233 @@
+/**
+ * @react-router/dev v0.0.0-experimental-2d5e406e4
+ *
+ * Copyright (c) Remix Software Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE.md file in the root directory of this source tree.
+ *
+ * @license MIT
+ */
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var api_completions = require('./autotype/api.completions.js');
+var api_definitions = require('./autotype/api.definitions.js');
+var api_diagnostics = require('./autotype/api.diagnostics.js');
+var api_hover = require('./autotype/api.hover.js');
+var api_inlayHints = require('./autotype/api.inlay-hints.js');
+var ast = require('./ast.js');
+var routes = require('./routes.js');
+
+function decorateLanguageService(ctx) {
+  const ls = ctx.languageService;
+  // completions
+  // --------------------------------------------------------------------------
+  const {
+    getCompletionsAtPosition
+  } = ls;
+  ls.getCompletionsAtPosition = (fileName, position, ...rest) => {
+    var _ctx$languageService$;
+    if (!routes.get(ctx, fileName)) {
+      return getCompletionsAtPosition(fileName, position, ...rest);
+    }
+    const completions = api_completions.getCompletionsAtPosition(ctx)(fileName, position, ...rest);
+    const sourceFile = (_ctx$languageService$ = ctx.languageService.getProgram()) === null || _ctx$languageService$ === void 0 ? void 0 : _ctx$languageService$.getSourceFile(fileName);
+    if (!sourceFile) return completions;
+    const node = ast.findNodeAtPosition(sourceFile, position);
+    if (!node) return completions;
+    const isTopLevel = ctx.ts.isSourceFile(node.parent) || ctx.ts.isStatement(node.parent) && ctx.ts.isSourceFile(node.parent.parent);
+    if (!isTopLevel) return completions;
+    const {
+      line
+    } = sourceFile.getLineAndCharacterOfPosition(position);
+    const lineStart = sourceFile.getPositionOfLineAndCharacter(line, 0);
+    const normalizedLine = sourceFile.text.slice(lineStart, position).trim().replace(/\s+g/, " ");
+    const exports = ast.getExportNames(ctx.ts, sourceFile);
+    const routeExportCompletions = Object.keys(routes.exports).map(key => {
+      if (exports.has(key)) return null;
+      const insertText = key === "default" ? `export default function Component() {}` : `export function ${key}() {}`;
+      if (!fzf(normalizedLine, insertText)) return null;
+      const completion = {
+        name: key,
+        insertText,
+        kind: ctx.ts.ScriptElementKind.functionElement,
+        kindModifiers: ctx.ts.ScriptElementKindModifier.exportedModifier,
+        sortText: "0",
+        labelDetails: {
+          description: "React Router Export"
+        },
+        data: {
+          exportName: key,
+          // TS needs this
+          __reactRouter: key
+        }
+      };
+      return {
+        ...completion,
+        replacementSpan: {
+          start: lineStart,
+          length: position - lineStart
+        }
+      };
+    }).filter(x => x !== null);
+    if (!completions) {
+      return routeExportCompletions.length > 0 ? {
+        isGlobalCompletion: false,
+        isMemberCompletion: false,
+        isNewIdentifierLocation: false,
+        isIncomplete: true,
+        entries: routeExportCompletions
+      } : undefined;
+    }
+    return routeExportCompletions.length > 0 ? {
+      ...completions,
+      entries: [...routeExportCompletions, ...completions.entries]
+    } : completions;
+  };
+  const {
+    getCompletionEntryDetails
+  } = ls;
+  ls.getCompletionEntryDetails = (...args) => {
+    const data = args[6];
+    if (data.__reactRouter) {
+      var _Route$exports$key;
+      const key = data.__reactRouter;
+      return {
+        name: key,
+        kind: ctx.ts.ScriptElementKind.functionElement,
+        kindModifiers: ctx.ts.ScriptElementKindModifier.exportedModifier,
+        documentation: ((_Route$exports$key = routes.exports[key]) === null || _Route$exports$key === void 0 ? void 0 : _Route$exports$key.documentation) ?? [],
+        displayParts: []
+      };
+    }
+    return routes.get(ctx, args[0]) ? api_completions.getCompletionEntryDetails(ctx)(...args) : getCompletionEntryDetails(...args);
+  };
+  const {
+    getSignatureHelpItems
+  } = ls;
+  ls.getSignatureHelpItems = (...args) => routes.get(ctx, args[0]) ? api_completions.getSignatureHelpItems(ctx)(...args) : getSignatureHelpItems(...args);
+  // definitions
+  // --------------------------------------------------------------------------
+  const {
+    getDefinitionAndBoundSpan
+  } = ls;
+  ls.getDefinitionAndBoundSpan = (...args) => routes.get(ctx, args[0]) ? api_definitions.getDefinitionAndBoundSpan(ctx)(...args) : getDefinitionAndBoundSpan(...args);
+  const {
+    getTypeDefinitionAtPosition
+  } = ls;
+  ls.getTypeDefinitionAtPosition = (...args) => routes.get(ctx, args[0]) ? api_definitions.getTypeDefinitionAtPosition(ctx)(...args) : getTypeDefinitionAtPosition(...args);
+  // diagnostics
+  // --------------------------------------------------------------------------
+  const {
+    getSyntacticDiagnostics
+  } = ls;
+  ls.getSyntacticDiagnostics = (...args) => routes.get(ctx, args[0]) ? api_diagnostics.getSyntacticDiagnostics(ctx)(...args) : getSyntacticDiagnostics(...args);
+  const {
+    getSemanticDiagnostics
+  } = ls;
+  ls.getSemanticDiagnostics = fileName => {
+    var _ls$getProgram;
+    if (!routes.get(ctx, fileName)) return getSemanticDiagnostics(fileName);
+    const diagnostics = api_diagnostics.getSemanticDiagnostics(ctx)(fileName);
+    const sourceFile = (_ls$getProgram = ls.getProgram()) === null || _ls$getProgram === void 0 ? void 0 : _ls$getProgram.getSourceFile(fileName);
+    if (!sourceFile) return diagnostics;
+    const exportStarDiagnostics = sourceFile.statements
+    // eslint-disable-next-line array-callback-return
+    .map(stmt => {
+      if (!ctx.ts.isExportDeclaration(stmt)) return undefined;
+      if (stmt.exportClause === undefined ||
+      // export * as stuff from "..."
+      ctx.ts.isNamespaceExportDeclaration(stmt) // export * as stuff from "..."
+      ) {
+        const diagnostic = {
+          file: sourceFile,
+          category: ctx.ts.DiagnosticCategory.Warning,
+          start: stmt.getStart(),
+          length: stmt.getWidth(),
+          messageText: "React Router cannot typecheck route exports from `*` exports",
+          code: 100
+        };
+        return diagnostic;
+      }
+    }).filter(x => x !== undefined);
+    const hmrNamedFunctionsDiagnostics = sourceFile.statements
+    // eslint-disable-next-line array-callback-return
+    .map(stmt => {
+      if (ctx.ts.isFunctionDeclaration(stmt)) {
+        // export default function ...
+        if (!ast.exported(ctx.ts, stmt)) return undefined;
+        if (!ast.defaulted(ctx.ts, stmt)) return undefined;
+        if (!stmt.name) {
+          return {
+            file: sourceFile,
+            category: ctx.ts.DiagnosticCategory.Warning,
+            start: stmt.getStart(),
+            length: stmt.getWidth(),
+            messageText: "For HMR to work, React Router default export must be named\n\nhttps://remix.run/docs/en/main/discussion/hot-module-replacement#named-function-components",
+            code: 101
+          };
+        }
+      }
+      if (ctx.ts.isExportAssignment(stmt)) {
+        if (stmt.isExportEquals) return undefined;
+        // export default expr
+        return {
+          file: sourceFile,
+          category: ctx.ts.DiagnosticCategory.Warning,
+          start: stmt.getStart(),
+          length: stmt.getWidth(),
+          messageText: "For HMR to work, React Router default export must be named\n\nhttps://remix.run/docs/en/main/discussion/hot-module-replacement#named-function-components",
+          code: 101
+        };
+      }
+    }).filter(x => x !== undefined);
+    return [...hmrNamedFunctionsDiagnostics, ...exportStarDiagnostics, ...diagnostics];
+  };
+  const {
+    getSuggestionDiagnostics
+  } = ls;
+  ls.getSuggestionDiagnostics = (...args) => routes.get(ctx, args[0]) ? api_diagnostics.getSuggestionDiagnostics(ctx)(...args) : getSuggestionDiagnostics(...args);
+  // diagnostics
+  // --------------------------------------------------------------------------
+  const {
+    getQuickInfoAtPosition
+  } = ls;
+  ls.getQuickInfoAtPosition = (fileName, position) => {
+    var _ctx$languageService$2, _Route$exports$export;
+    const route = routes.get(ctx, fileName);
+    if (!route) return getQuickInfoAtPosition(fileName, position);
+    const quickinfo = routes.get(ctx, fileName) ? api_hover.getQuickInfoAtPosition(ctx)(fileName, position) : getQuickInfoAtPosition(fileName, position);
+    if (!quickinfo) return;
+    const sourceFile = (_ctx$languageService$2 = ctx.languageService.getProgram()) === null || _ctx$languageService$2 === void 0 ? void 0 : _ctx$languageService$2.getSourceFile(fileName);
+    const node = sourceFile && ast.findNodeAtPosition(sourceFile, position);
+    const exportName = node && ast.getRouteExportName(ctx, node);
+    const routeExportDocs = exportName ? (_Route$exports$export = routes.exports[exportName]) === null || _Route$exports$export === void 0 ? void 0 : _Route$exports$export.documentation : undefined;
+    const documentation = [...(quickinfo.documentation ?? []), ...(routeExportDocs ?? [])];
+    return {
+      ...quickinfo,
+      documentation: documentation.length > 0 ? documentation : undefined
+    };
+  };
+  // inlay hints
+  // --------------------------------------------------------------------------
+  const {
+    provideInlayHints
+  } = ls;
+  ls.provideInlayHints = (...args) => routes.get(ctx, args[0]) ? api_inlayHints.provideInlayHints(ctx)(...args) : provideInlayHints(...args);
+}
+function fzf(pattern, target) {
+  let patternIndex = 0;
+  let targetIndex = 0;
+  while (patternIndex < pattern.length && targetIndex < target.length) {
+    var _pattern$patternIndex, _target$targetIndex;
+    if (((_pattern$patternIndex = pattern[patternIndex]) === null || _pattern$patternIndex === void 0 ? void 0 : _pattern$patternIndex.toLowerCase()) === ((_target$targetIndex = target[targetIndex]) === null || _target$targetIndex === void 0 ? void 0 : _target$targetIndex.toLowerCase())) {
+      patternIndex += 1;
+    }
+    targetIndex += 1;
+  }
+  return patternIndex === pattern.length;
+}
+
+exports.decorateLanguageService = decorateLanguageService;

package/dist/typescript/plugin.d.ts

@@ -0,0 +1,6 @@
+import type ts from "typescript/lib/tsserverlibrary";
+export default function init(modules: {
+    typescript: typeof ts;
+}): {
+    create: (info: ts.server.PluginCreateInfo) => ts.LanguageService;
+};

package/dist/typescript/plugin.js

@@ -0,0 +1,67 @@
+/**
+ * @react-router/dev v0.0.0-experimental-2d5e406e4
+ *
+ * Copyright (c) Remix Software Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE.md file in the root directory of this source tree.
+ *
+ * @license MIT
+ */
+'use strict';
+
+var Path = require('pathe');
+var typegen = require('./typegen.js');
+var decorate = require('./decorate.js');
+
+function _interopNamespace(e) {
+    if (e && e.__esModule) return e;
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n["default"] = e;
+    return Object.freeze(n);
+}
+
+var Path__namespace = /*#__PURE__*/_interopNamespace(Path);
+
+// For compatibility with the TS language service plugin API, this entrypoint:
+function init(modules) {
+  function create(info) {
+    const {
+      logger
+    } = info.project.projectService;
+    logger.info("[react-router] setup");
+    const rootDirectory = Path__namespace.normalize(info.project.getCurrentDirectory());
+    const config = {
+      rootDirectory,
+      appDirectory: Path__namespace.join(rootDirectory, "app")
+    };
+    const ctx = {
+      config,
+      routes: {},
+      // will be updated by `Typegen.watch`
+      languageService: info.languageService,
+      languageServiceHost: info.languageServiceHost,
+      ts: modules.typescript,
+      logger
+    };
+    typegen.watch(ctx);
+    decorate.decorateLanguageService(ctx);
+    return info.languageService;
+  }
+  return {
+    create
+  };
+}
+
+module.exports = init;

package/dist/typescript/routes.d.ts

@@ -0,0 +1,10 @@
+import type ts from "typescript/lib/tsserverlibrary";
+import type { Context } from "./context";
+import type { RouteManifestEntry } from "../config/routes";
+export declare function get(ctx: Context, fileName: string): RouteManifestEntry | undefined;
+type RouteExportInfo = {
+    annotateReturnType: boolean;
+    documentation: ts.SymbolDisplayPart[];
+};
+export declare const exports: Record<string, RouteExportInfo>;
+export {};