@modern-js/runtime 2.65.1 → 2.65.3

package/dist/esm-node/core/server/string/index.js

@@ -1,6 +1,4 @@
-import { run } from "@modern-js/runtime-utils/node";
 import { time } from "@modern-js/runtime-utils/time";
-import { parseHeaders } from "@modern-js/runtime-utils/universal/request";
 import ReactDomServer from "react-dom/server";
 import ReactHelmet from "react-helmet";
 import { RenderLevel } from "../../constants";
@@ -15,59 +13,56 @@ import { prefetch } from "./prefetch";
 import { SSRDataCollector } from "./ssrData";
 import { StyledCollector } from "./styledComponent";
 const renderString = async (request, serverRoot, options) => {
-  const headersData = parseHeaders(request);
-  return run(headersData, async () => {
-    var _runtimeContext_ssrContext;
-    const { resource, runtimeContext, config, onError, onTiming } = options;
-    const tracer = {
-      onError,
-      onTiming
-    };
-    const routerContext = runtimeContext.routerContext;
-    const { htmlTemplate, entryName, loadableStats, routeManifest } = resource;
-    const ssrConfig = getSSRConfigByEntry(entryName, config.ssr, config.ssrByEntries);
-    const chunkSet = {
-      renderLevel: RenderLevel.CLIENT_RENDER,
-      ssrScripts: "",
-      jsChunk: "",
-      cssChunk: ""
-    };
-    let prefetchData = {};
-    try {
-      prefetchData = await prefetch(serverRoot, request, options, ssrConfig, tracer);
-      chunkSet.renderLevel = RenderLevel.SERVER_PREFETCH;
-    } catch (e) {
-      chunkSet.renderLevel = RenderLevel.CLIENT_RENDER;
-      tracer.onError(e, SSRErrors.PRERENDER);
-    }
-    const collectors = [
-      new StyledCollector(chunkSet),
-      new LoadableCollector({
-        stats: loadableStats,
-        nonce: config.nonce,
-        routeManifest,
-        template: htmlTemplate,
-        entryName,
-        chunkSet,
-        config
-      }),
-      new SSRDataCollector({
-        request,
-        prefetchData,
-        ssrConfig,
-        ssrContext: runtimeContext.ssrContext,
-        chunkSet,
-        routerContext,
-        nonce: config.nonce,
-        useJsonScript: config.useJsonScript
-      })
-    ];
-    const rootElement = wrapRuntimeContextProvider(serverRoot, Object.assign(runtimeContext, {
-      ssr: true
-    }));
-    const html = await generateHtml(rootElement, htmlTemplate, chunkSet, collectors, ((_runtimeContext_ssrContext = runtimeContext.ssrContext) === null || _runtimeContext_ssrContext === void 0 ? void 0 : _runtimeContext_ssrContext.htmlModifiers) || [], tracer);
-    return html;
-  });
+  var _runtimeContext_ssrContext;
+  const { resource, runtimeContext, config, onError, onTiming } = options;
+  const tracer = {
+    onError,
+    onTiming
+  };
+  const routerContext = runtimeContext.routerContext;
+  const { htmlTemplate, entryName, loadableStats, routeManifest } = resource;
+  const ssrConfig = getSSRConfigByEntry(entryName, config.ssr, config.ssrByEntries);
+  const chunkSet = {
+    renderLevel: RenderLevel.CLIENT_RENDER,
+    ssrScripts: "",
+    jsChunk: "",
+    cssChunk: ""
+  };
+  let prefetchData = {};
+  try {
+    prefetchData = await prefetch(serverRoot, request, options, ssrConfig, tracer);
+    chunkSet.renderLevel = RenderLevel.SERVER_PREFETCH;
+  } catch (e) {
+    chunkSet.renderLevel = RenderLevel.CLIENT_RENDER;
+    tracer.onError(e, SSRErrors.PRERENDER);
+  }
+  const collectors = [
+    new StyledCollector(chunkSet),
+    new LoadableCollector({
+      stats: loadableStats,
+      nonce: config.nonce,
+      routeManifest,
+      template: htmlTemplate,
+      entryName,
+      chunkSet,
+      config
+    }),
+    new SSRDataCollector({
+      request,
+      prefetchData,
+      ssrConfig,
+      ssrContext: runtimeContext.ssrContext,
+      chunkSet,
+      routerContext,
+      nonce: config.nonce,
+      useJsonScript: config.useJsonScript
+    })
+  ];
+  const rootElement = wrapRuntimeContextProvider(serverRoot, Object.assign(runtimeContext, {
+    ssr: true
+  }));
+  const html = await generateHtml(rootElement, htmlTemplate, chunkSet, collectors, ((_runtimeContext_ssrContext = runtimeContext.ssrContext) === null || _runtimeContext_ssrContext === void 0 ? void 0 : _runtimeContext_ssrContext.htmlModifiers) || [], tracer);
+  return html;
 };
 async function generateHtml(App, htmlTemplate, chunkSet, collectors, htmlModifiers, { onError, onTiming }) {
   let html = "";

package/dist/esm-node/core/server/string/prefetch.js

@@ -1,73 +1,68 @@
 import { ChunkExtractor } from "@loadable/server";
-import { run } from "@modern-js/runtime-utils/node";
 import { time } from "@modern-js/runtime-utils/time";
-import { parseHeaders } from "@modern-js/runtime-utils/universal/request";
 import { renderToStaticMarkup } from "react-dom/server";
 import { wrapRuntimeContextProvider } from "../../react/wrapper";
 import { SSRErrors, SSRTimings } from "../tracer";
 const prefetch = async (App, request, options, ssrConfig, { onError, onTiming }) => {
-  const headersData = parseHeaders(request);
+  var _context_store;
   const { runtimeContext: context, resource } = options;
   const { entryName, loadableStats } = resource;
-  return run(headersData, async () => {
-    var _context_store;
-    if (typeof ssrConfig === "boolean" || !ssrConfig.disablePrerender) {
-      try {
-        const end = time();
-        if (loadableStats) {
-          const extractor = new ChunkExtractor({
-            stats: loadableStats,
-            entrypoints: [
-              entryName
-            ].filter(Boolean)
-          });
-          renderToStaticMarkup(extractor.collectChunks(wrapRuntimeContextProvider(App, Object.assign(context, {
-            ssr: false
-          }))));
-        } else {
-          renderToStaticMarkup(wrapRuntimeContextProvider(App, Object.assign(context, {
-            ssr: false
-          })));
-        }
-        const cost = end();
-        onTiming(SSRTimings.PRERENDER, cost);
-      } catch (e) {
-        const error = e;
-        onError(error, SSRErrors.PRERENDER);
-        throw e;
-      }
-    }
-    if (!context.loaderManager.hasPendingLoaders()) {
-      return {
-        initialData: context.initialData,
-        i18nData: context.__i18nData__
-      };
-    }
-    let loadersData = {};
+  if (typeof ssrConfig === "boolean" || !ssrConfig.disablePrerender) {
     try {
       const end = time();
-      loadersData = await context.loaderManager.awaitPendingLoaders();
+      if (loadableStats) {
+        const extractor = new ChunkExtractor({
+          stats: loadableStats,
+          entrypoints: [
+            entryName
+          ].filter(Boolean)
+        });
+        renderToStaticMarkup(extractor.collectChunks(wrapRuntimeContextProvider(App, Object.assign(context, {
+          ssr: false
+        }))));
+      } else {
+        renderToStaticMarkup(wrapRuntimeContextProvider(App, Object.assign(context, {
+          ssr: false
+        })));
+      }
       const cost = end();
-      onTiming(SSRTimings.USE_LOADER, cost);
+      onTiming(SSRTimings.PRERENDER, cost);
     } catch (e) {
-      onError(e, SSRErrors.USE_LOADER);
+      const error = e;
+      onError(error, SSRErrors.PRERENDER);
       throw e;
     }
-    Object.keys(loadersData).forEach((id) => {
-      const data = loadersData[id];
-      if (data._error) {
-        onError(data._error, SSRErrors.USE_LOADER);
-        delete data._error;
-      }
-    });
+  }
+  if (!context.loaderManager.hasPendingLoaders()) {
     return {
-      loadersData,
       initialData: context.initialData,
-      i18nData: context.__i18nData__,
-      // todo: move to plugin state
-      storeState: context === null || context === void 0 ? void 0 : (_context_store = context.store) === null || _context_store === void 0 ? void 0 : _context_store.getState()
+      i18nData: context.__i18nData__
     };
+  }
+  let loadersData = {};
+  try {
+    const end = time();
+    loadersData = await context.loaderManager.awaitPendingLoaders();
+    const cost = end();
+    onTiming(SSRTimings.USE_LOADER, cost);
+  } catch (e) {
+    onError(e, SSRErrors.USE_LOADER);
+    throw e;
+  }
+  Object.keys(loadersData).forEach((id) => {
+    const data = loadersData[id];
+    if (data._error) {
+      onError(data._error, SSRErrors.USE_LOADER);
+      delete data._error;
+    }
   });
+  return {
+    loadersData,
+    initialData: context.initialData,
+    i18nData: context.__i18nData__,
+    // todo: move to plugin state
+    storeState: context === null || context === void 0 ? void 0 : (_context_store = context.store) === null || _context_store === void 0 ? void 0 : _context_store.getState()
+  };
 };
 export {
   prefetch

package/dist/esm-node/index.js

@@ -1,4 +1,7 @@
 import { isBrowser } from "./common";
+import { getMonitors } from "./core/context/monitors";
+import { getRequest } from "./core/context/request";
+import { setHeaders, setStatus, redirect } from "./core/context/response";
 import { createApp, useLoader, bootstrap, RuntimeReactContext, defineConfig, defineRuntimeConfig, useRuntimeContext } from "./core";
 export {
   RuntimeReactContext,
@@ -6,7 +9,12 @@ export {
   createApp,
   defineConfig,
   defineRuntimeConfig,
+  getMonitors,
+  getRequest,
   isBrowser,
+  redirect,
+  setHeaders,
+  setStatus,
   useLoader,
   useRuntimeContext
 };

package/dist/esm-node/react-server.js

@@ -0,0 +1,10 @@
+import { getRequest } from "./core/context/request";
+import { getMonitors } from "./core/context/monitors";
+import { setHeaders, setStatus, redirect } from "./core/context/response";
+export {
+  getMonitors,
+  getRequest,
+  redirect,
+  setHeaders,
+  setStatus
+};

package/dist/esm-node/router/cli/code/templates.js

@@ -362,7 +362,7 @@ function ssrLoaderCombinedModule(entrypoints, entrypoint, config, appContext) {
   }
   return null;
 }
-const runtimeGlobalContext = async ({ metaName, srcDirectory, nestedRoutesEntry, internalSrcAlias, globalApp }) => {
+const runtimeGlobalContext = async ({ entryName, metaName, srcDirectory, nestedRoutesEntry, internalSrcAlias, globalApp }) => {
   const imports = [
     `import { setGlobalContext } from '@${metaName}/runtime/context';`
   ];
@@ -408,7 +408,9 @@ const runtimeGlobalContext = async ({ metaName, srcDirectory, nestedRoutesEntry,
 
 import { routes } from './routes';
 
+const entryName = '${entryName}';
 setGlobalContext({
+  entryName,
   layoutApp,
   routes,
   appInit,

package/dist/esm-node/router/cli/handler.js

@@ -19,6 +19,7 @@ async function handleGeneratorEntryCode(api, entrypoints) {
     if (entrypoint.nestedRoutesEntry || entrypoint.pageRoutesEntry) {
       var _entrypoint_fileSystemRoutes;
       generatorRegisterCode(internalDirectory, entrypoint.entryName, await templates.runtimeGlobalContext({
+        entryName: entrypoint.entryName,
         metaName: appContext.metaName,
         srcDirectory: appContext.srcDirectory,
         nestedRoutesEntry: entrypoint.nestedRoutesEntry,

package/dist/esm-node/router/runtime/plugin.node.js

@@ -57,8 +57,7 @@ const routerPlugin = (userConfig = {}) => {
           ssrMode,
           props: {
             nonce
-          },
-          reporter
+          }
         }));
         routes = hooks.modifyRoutes.call(routes);
         const { query } = createStaticHandler(routes, {

package/dist/esm-node/router/runtime/utils.js

@@ -4,7 +4,7 @@ import { UNSAFE_ErrorResponseImpl as ErrorResponseImpl } from "@modern-js/runtim
 import { Route, isRouteErrorResponse } from "@modern-js/runtime-utils/router";
 import { DefaultNotFound } from "./DefaultNotFound";
 import DeferredDataScripts from "./DeferredDataScripts";
-function getRouteComponents(routes, { globalApp, ssrMode, props, reporter }) {
+function getRouteComponents(routes, { globalApp, ssrMode, props }) {
   const Layout = ({ Component, ...props2 }) => {
     const GlobalLayout = globalApp;
     if (!GlobalLayout) {
@@ -22,8 +22,7 @@ function getRouteComponents(routes, { globalApp, ssrMode, props, reporter }) {
     if (route.type === "nested") {
       const routeElement = renderNestedRoute(route, {
         DeferredDataComponent: ssrMode === "stream" ? DeferredDataScripts : void 0,
-        props,
-        reporter
+        props
       });
       routeElements.push(routeElement);
     } else {
@@ -42,7 +41,7 @@ function getRouteComponents(routes, { globalApp, ssrMode, props, reporter }) {
   }, "*"));
   return routeElements;
 }
-function renderRoutes({ routesConfig, props, ssrMode, reporter }) {
+function renderRoutes({ routesConfig, props, ssrMode }) {
   if (!routesConfig) {
     return null;
   }
@@ -53,8 +52,7 @@ function renderRoutes({ routesConfig, props, ssrMode, reporter }) {
   const routeElements = getRouteComponents(routes, {
     globalApp,
     ssrMode,
-    props,
-    reporter
+    props
   });
   return routeElements;
 }

package/dist/types/cache/index.d.ts

@@ -0,0 +1 @@
+export * from '@modern-js/runtime-utils/cache';

package/dist/types/cli/template.d.ts

@@ -25,7 +25,8 @@ export declare const runtimeRegister: ({ entryName, srcDirectory, internalSrcAli
     runtimeConfigFile: string | false;
     runtimePlugins: RuntimePluginConfig[];
 }) => string;
-export declare const runtimeGlobalContext: ({ srcDirectory, internalSrcAlias, metaName, entry, customEntry, }: {
+export declare const runtimeGlobalContext: ({ entryName, srcDirectory, internalSrcAlias, metaName, entry, customEntry, }: {
+    entryName: string;
     srcDirectory: string;
     internalSrcAlias: string;
     metaName: string;

package/dist/types/core/compat/requestContext.d.ts

@@ -0,0 +1,27 @@
+/// <reference types="node" />
+/// <reference types="node/http" />
+/// <reference types="types" />
+import type { RuntimeContext } from '../context';
+import type { RuntimePluginFuture } from '../plugin/types';
+export declare const makeRequestContext: (context: RuntimeContext) => import("../types").ServerContext | import("../types").ClientContext | {
+    isBrowser: boolean;
+    request: {
+        [propsName: string]: any;
+        params: Record<string, string>;
+        pathname: string;
+        query: Record<string, string>;
+        headers: import("http").IncomingHttpHeaders;
+        host: string;
+        url: string;
+        referer?: string | undefined;
+        userAgent?: string | undefined;
+        cookie?: string | undefined;
+        cookieMap?: Record<string, string> | undefined;
+    } & {
+        baseUrl: string;
+        raw: Request;
+    };
+    response: import("@modern-js/types").BaseResponseLike;
+    logger: import("@modern-js/types").Logger;
+};
+export declare const requestContextPlugin: () => RuntimePluginFuture;

package/dist/types/core/compatible.d.ts

@@ -2,7 +2,7 @@ import type { RuntimePlugin } from '@modern-js/plugin-v2';
 import React from 'react';
 import type { Renderer } from 'react-dom';
 import type { createRoot, hydrateRoot } from 'react-dom/client';
-import { type RuntimeContext } from './context/runtime';
+import { type RuntimeContext, type TRuntimeContext } from './context/runtime';
 import { type Plugin } from './plugin';
 import type { RuntimeExtends } from './plugin/types';
 export type CreateAppOptions = {
@@ -20,5 +20,5 @@ type BootStrap<T = unknown> = (App: React.ComponentType, id: string | HTMLElemen
     hydrateRoot?: typeof hydrateRoot;
 }) => Promise<T>;
 export declare const bootstrap: BootStrap;
-export declare const useRuntimeContext: () => RuntimeContext;
+export declare const useRuntimeContext: () => TRuntimeContext;
 export {};

package/dist/types/core/config.d.ts

@@ -10,4 +10,4 @@ export declare const defineConfig: (Component: React.ComponentType<any>, config:
  * This function helps you to autocomplete configuration types.
  * It accepts a direct config object, or a function that returns a config.
  */
-export declare const defineRuntimeConfig: (config: RuntimeConfig) => RuntimeConfig;
+export declare const defineRuntimeConfig: (config: RuntimeConfig | ((entryName: string) => RuntimeConfig)) => RuntimeConfig | ((entryName: string) => RuntimeConfig);

package/dist/types/core/context/index.d.ts

@@ -5,6 +5,7 @@ import type { AppConfig } from '../../common';
 import type { RuntimeExtends } from '../plugin/types';
 export { type RuntimeContext, RuntimeReactContext, getInitialContext, } from './runtime';
 interface GlobalContext {
+    entryName?: string;
     /**
      * App.tsx export default component
      */
@@ -34,6 +35,7 @@ interface GlobalContext {
 export declare function setGlobalContext(context: Omit<GlobalContext, 'appConfig' | 'internalRuntimeContext'> & {
     appConfig?: () => AppConfig;
 }): void;
+export declare function getCurrentEntryName(): string | undefined;
 export declare function getGlobalRSCRoot(): import("react").ComponentType<{}> | undefined;
 export declare function setGlobalInternalRuntimeContext(context: InternalRuntimeContext<RuntimeExtends>): void;
 export declare function getGlobalInternalRuntimeContext(): InternalRuntimeContext<Required<import("@modern-js/plugin-v2").RuntimePluginExtends<import("../plugin/types").RuntimeConfig, import("./runtime").RuntimeContext, {}, {}>>>;

package/dist/types/core/context/monitors/default.d.ts

@@ -0,0 +1,2 @@
+import type { Monitors } from '@modern-js/types';
+export declare const defaultMonitors: Omit<Monitors, 'push'>;

package/dist/types/core/context/monitors/index.d.ts

@@ -0,0 +1 @@
+export declare const getMonitors: () => Omit<import("@modern-js/types").Monitors, "push">;

package/dist/types/core/context/monitors/index.server.d.ts

@@ -0,0 +1,2 @@
+import type { Monitors } from '@modern-js/types';
+export declare const getMonitors: () => Omit<Monitors, 'push'>;

package/dist/types/core/context/request/index.d.ts

@@ -0,0 +1 @@
+export declare const getRequest: () => Request;

package/dist/types/core/context/request/index.server.d.ts

@@ -0,0 +1 @@
+export declare const getRequest: () => Request;

package/dist/types/core/context/response/index.d.ts

@@ -0,0 +1,4 @@
+export declare const getResponseProxy: () => null;
+export declare const setHeaders: (headers: Record<string, string>) => void;
+export declare const setStatus: (status: number) => void;
+export declare const redirect: (url: string, init?: number | ResponseInit) => void;

package/dist/types/core/context/response/index.server.d.ts

@@ -0,0 +1,7 @@
+export declare const getResponseProxy: () => {
+    headers: Record<string, string>;
+    status: number;
+} | undefined;
+export declare const setHeaders: (headers: Record<string, string>) => void;
+export declare const setStatus: (status: number) => void;
+export declare const redirect: (url: string, init?: number | ResponseInit) => void;

package/dist/types/core/context/runtime.d.ts

@@ -12,6 +12,7 @@ interface BaseRuntimeContext {
     store?: Store;
     routeManifest: RouteManifest;
     routerContext?: StaticHandlerContext;
+    context?: TSSRContext;
     /**
      * private
      */

package/dist/types/core/types.d.ts

@@ -27,14 +27,7 @@ export interface SSRContainer {
     mode: SSRMode;
     data?: SSRData;
     context?: {
-        request: {
-            params: Record<string, any>;
-            query: Record<string, string>;
-            pathname: string;
-            host: string;
-            url: string;
-            headers?: Record<string, string | undefined>;
-        };
+        request: BaseSSRServerContext['request'];
         reporter?: {
             sessionId?: string;
         };
@@ -44,9 +37,6 @@ type BuildHtmlCb = (tempalte: string) => string;
 export type SSRServerContext = Pick<BaseSSRServerContext, 'redirection' | 'response' | 'nonce' | 'mode' | 'loaderContext' | 'reporter' | 'logger' | 'metrics' | 'routeManifest'> & {
     request: BaseSSRServerContext['request'] & {
         baseUrl: string;
-        userAgent: string;
-        cookie: string;
-        cookieMap: Record<string, string>;
         raw: Request;
     };
     htmlModifiers: BuildHtmlCb[];
@@ -56,18 +46,15 @@ export type SSRServerContext = Pick<BaseSSRServerContext, 'redirection' | 'respo
     useJsonScript?: boolean;
 };
 interface TSSRBaseContext {
-    request: BaseSSRServerContext['request'] & {
-        userAgent: string;
-        cookie: string;
-    };
+    request: BaseSSRServerContext['request'];
     [propName: string]: any;
 }
-interface ServerContext extends TSSRBaseContext {
+export interface ServerContext extends TSSRBaseContext {
     isBrowser: false;
     response: BaseSSRServerContext['response'];
     logger: BaseSSRServerContext['logger'];
 }
-interface ClientContext extends TSSRBaseContext {
+export interface ClientContext extends TSSRBaseContext {
     isBrowser: true;
 }
 export declare type TSSRContext = ServerContext | ClientContext;

package/dist/types/index.d.ts

@@ -5,5 +5,8 @@ export type { AppConfig, RuntimeConfig } from './common';
 export { isBrowser } from './common';
 export type { RuntimeContext } from './core/context/runtime';
 export type { RuntimeUserConfig } from './config';
+export { getMonitors } from './core/context/monitors';
+export { getRequest } from './core/context/request';
+export { setHeaders, setStatus, redirect } from './core/context/response';
 export { createApp, useLoader, bootstrap, RuntimeReactContext, defineConfig, defineRuntimeConfig, useRuntimeContext, } from './core';
 export type { StateConfig, RouterConfig };

package/dist/types/react-server.d.ts

@@ -0,0 +1,3 @@
+export { getRequest } from './core/context/request';
+export { getMonitors } from './core/context/monitors';
+export { setHeaders, setStatus, redirect } from './core/context/response';

package/dist/types/router/cli/code/templates.d.ts

@@ -13,7 +13,8 @@ export declare const fileSystemRoutes: ({ metaName, routes, ssrMode, nestedRoute
     splitRouteChunks?: boolean | undefined;
 }) => Promise<string>;
 export declare function ssrLoaderCombinedModule(entrypoints: Entrypoint[], entrypoint: Entrypoint, config: AppNormalizedConfig<'shared'>, appContext: AppToolsContext<'shared'>): string | null;
-export declare const runtimeGlobalContext: ({ metaName, srcDirectory, nestedRoutesEntry, internalSrcAlias, globalApp, }: {
+export declare const runtimeGlobalContext: ({ entryName, metaName, srcDirectory, nestedRoutesEntry, internalSrcAlias, globalApp, }: {
+    entryName: string;
     metaName: string;
     srcDirectory: string;
     nestedRoutesEntry?: string | undefined;

package/dist/types/router/runtime/utils.d.ts

@@ -1,18 +1,16 @@
 import { type Router, type StaticHandlerContext } from '@modern-js/runtime-utils/remix-router';
-import type { NestedRoute, PageRoute, Reporter, SSRMode } from '@modern-js/types';
+import type { NestedRoute, PageRoute, SSRMode } from '@modern-js/types';
 import type React from 'react';
 import type { RouterConfig } from './types';
-export declare function getRouteComponents(routes: (NestedRoute | PageRoute)[], { globalApp, ssrMode, props, reporter, }: {
+export declare function getRouteComponents(routes: (NestedRoute | PageRoute)[], { globalApp, ssrMode, props, }: {
     globalApp?: React.ComponentType<any>;
     ssrMode?: SSRMode;
     props?: Record<string, any>;
-    reporter?: Reporter;
 }): React.ReactElement<any, string | React.JSXElementConstructor<any>>[];
-export declare function renderRoutes({ routesConfig, props, ssrMode, reporter, }: {
+export declare function renderRoutes({ routesConfig, props, ssrMode, }: {
     routesConfig: RouterConfig['routesConfig'];
     props?: Record<string, any>;
     ssrMode?: SSRMode;
-    reporter?: Reporter;
 }): React.ReactElement<any, string | React.JSXElementConstructor<any>>[] | null;
 export declare function getLocation(serverContext: any): string;
 export declare const urlJoin: (...parts: string[]) => string;