@bleedingdev/modern-js-runtime 3.2.0-ultramodern.0

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

@@ -0,0 +1,28 @@
+import type { AppNormalizedConfig, AppToolsContext } from '@modern-js/app-tools';
+import type { Entrypoint, NestedRouteForCli, PageRoute, RouteLegacy, SSRMode } from '@modern-js/types';
+export declare const routesForServer: ({ routesForServerLoaderMatches, }: {
+    routesForServerLoaderMatches: (NestedRouteForCli | PageRoute)[];
+}) => string;
+export declare const fileSystemRoutes: ({ metaName, routes, ssrMode, nestedRoutesEntry, entryName, internalDirectory, splitRouteChunks, isRscClientBundle, srcDirectory, internalSrcAlias, }: {
+    metaName: string;
+    routes: RouteLegacy[] | (NestedRouteForCli | PageRoute)[];
+    ssrMode?: SSRMode;
+    nestedRoutesEntry?: string;
+    entryName: string;
+    internalDirectory: string;
+    splitRouteChunks?: boolean;
+    isRscClientBundle?: boolean;
+    srcDirectory?: string;
+    internalSrcAlias?: string;
+}) => Promise<string>;
+export declare function ssrLoaderCombinedModule(entrypoints: Entrypoint[], entrypoint: Entrypoint, config: AppNormalizedConfig, appContext: AppToolsContext): string | null;
+export declare const runtimeGlobalContext: ({ entryName, metaName, srcDirectory, nestedRoutesEntry, internalSrcAlias, globalApp, rscType, basename, }: {
+    entryName: string;
+    metaName: string;
+    srcDirectory: string;
+    nestedRoutesEntry?: string;
+    internalSrcAlias: string;
+    globalApp?: string | false;
+    rscType?: 'server' | 'client' | false;
+    basename?: string;
+}) => Promise<string>;

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

@@ -0,0 +1,12 @@
+export declare const walkDirectory: (dir: string) => string[];
+export declare const isPageComponentFile: (filePath: string) => boolean;
+export declare const replaceWithAlias: (base: string, filePath: string, alias: string) => string;
+export declare const parseModule: ({ source, filename, }: {
+    source: string;
+    filename: string;
+}) => Promise<readonly [imports: readonly import("es-module-lexer").ImportSpecifier[], exports: readonly import("es-module-lexer").ExportSpecifier[], facade: boolean, hasModuleSyntax: boolean]>;
+export declare const hasLoader: (filename: string, source?: string) => Promise<boolean>;
+export declare const hasAction: (filename: string, source?: string) => Promise<boolean>;
+export declare const getServerLoadersFile: (internalDirectory: string, entryName: string) => string;
+export declare const getServerCombinedModuleFile: (internalDirectory: string, entryName: string) => string;
+export declare const getPathWithoutExt: (filename: string) => string;

package/dist/types/router/cli/config-routes/converter.d.ts

@@ -0,0 +1,15 @@
+import type { NestedRouteForCli } from '@modern-js/types';
+/**
+ * Process config-based routes: generate route id, normalize paths and discover related files.
+ * Data structure is unified to NestedRouteForCli, only metadata needs to be enriched.
+ */
+export declare function processConfigRoutes(configRoutes: NestedRouteForCli[], entryName: string, isMainEntry: boolean, configRoutesDir: string, alias?: {
+    name: string;
+    basename: string;
+}): Promise<NestedRouteForCli[]>;
+/**
+ * Remove all `component` fields from a routes tree
+ * @param generatedRoutes - generated routes array
+ * @returns routes with `component` field removed
+ */
+export declare function normalizeRoutes(generatedRoutes: NestedRouteForCli[]): NestedRouteForCli[];

package/dist/types/router/cli/config-routes/parseRouteConfig.d.ts

@@ -0,0 +1,32 @@
+import type { AppToolsContext } from '@modern-js/app-tools';
+import type { Entrypoint, NestedRouteForCli } from '@modern-js/types';
+/**
+ * Type definitions for config-based routing
+ */
+export type RouteConfig = NestedRouteForCli;
+export type RouteFunction = {
+    (component: string, path?: string, children?: RouteConfig[]): RouteConfig;
+    (component: string, children?: RouteConfig[]): RouteConfig;
+};
+export type LayoutFunction = {
+    (component: string, path?: string, children?: RouteConfig[]): RouteConfig;
+    (component: string, children?: RouteConfig[]): RouteConfig;
+};
+export type PageFunction = (component: string, path?: string) => RouteConfig;
+export type WildcardFunction = (component: string, path?: string) => RouteConfig;
+export interface RouteFunctions {
+    route: RouteFunction;
+    layout: LayoutFunction;
+    page: PageFunction;
+    $: WildcardFunction;
+}
+export type DefineRoutesFunction = (routesCallback: (routeFunctions: RouteFunctions, fileRoutes: RouteConfig[]) => RouteConfig[]) => (routeFunctions: RouteFunctions, fileRoutes: RouteConfig[]) => RouteConfig[];
+export interface ConfigRouteFile {
+    entryName: string;
+    filePath: string;
+    routes: NestedRouteForCli[];
+    isMainEntry: boolean;
+}
+export declare function findConfigRoutesFile(entrypoint: Entrypoint, appContext: AppToolsContext): Promise<string | null>;
+export declare function parseConfigRoutesFile(filePath: string, entrypoint: Entrypoint, fileRoutes?: NestedRouteForCli[]): Promise<ConfigRouteFile>;
+export declare function discoverAndParseConfigRoutes(entrypoint: Entrypoint, appContext: AppToolsContext, fileRoutes?: NestedRouteForCli[]): Promise<ConfigRouteFile | null>;

package/dist/types/router/cli/constants.d.ts

@@ -0,0 +1,31 @@
+export declare const NESTED_ROUTES_DIR = "routes";
+export declare const FILE_SYSTEM_ROUTES_FILE_NAME = "routes.js";
+export declare const LOADER_EXPORT_NAME = "loader";
+export declare const ACTION_EXPORT_NAME = "action";
+export declare const TEMP_LOADERS_DIR = "__loaders__";
+export declare const FILE_SYSTEM_ROUTES_INDEX = "index";
+export declare const FILE_SYSTEM_ROUTES_IGNORED_REGEX: RegExp;
+export declare const FILE_SYSTEM_ROUTES_DYNAMIC_REGEXP: RegExp;
+export declare const FILE_SYSTEM_ROUTES_COMPONENTS_DIR = "internal_components";
+export declare const APP_CONFIG_NAME = "config";
+export declare const APP_INIT_EXPORTED = "init";
+export declare const NESTED_ROUTE: {
+    LAYOUT_FILE: string;
+    LAYOUT_CONFIG_FILE: string;
+    LAYOUT_LOADER_FILE: string;
+    LAYOUT_DATA_FILE: string;
+    LAYOUT_CLIENT_LOADER: string;
+    PAGE_FILE: string;
+    PAGE_CONFIG_FILE: string;
+    PAGE_LOADER_FILE: string;
+    PAGE_DATA_FILE: string;
+    PAGE_CLIENT_LOADER: string;
+    SPLATE_FILE: string;
+    SPLATE_CONFIG_FILE: string;
+    SPLATE_LOADER_FILE: string;
+    SPLATE_DATA_FILE: string;
+    SPLATE_CLIENT_DATA: string;
+    LOADING_FILE: string;
+    ERROR_FILE: string;
+    LOADER_FILE: string;
+};

package/dist/types/router/cli/entry.d.ts

@@ -0,0 +1,18 @@
+import type { Entrypoint } from '@modern-js/types';
+export declare const ROUTES_DIR_META_KEY = "__modernRoutesDir";
+export declare const ROUTES_OWNER_META_KEY = "__modernRoutesOwner";
+export declare const BUILT_IN_ROUTES_OWNER = "@modern-js/plugin-router";
+export type EntrypointWithRoutesMeta = Entrypoint & {
+    [ROUTES_DIR_META_KEY]?: string;
+    [ROUTES_OWNER_META_KEY]?: string;
+};
+export declare const getEntrypointRoutesDir: (entrypoint: {
+    [ROUTES_DIR_META_KEY]?: string;
+    nestedRoutesEntry?: string;
+}) => string | null;
+export declare const getEntrypointRoutesOwner: (entrypoint: {
+    [ROUTES_OWNER_META_KEY]?: string;
+}) => string | null;
+export declare const hasNestedRoutes: (dir: string, routesDir?: string) => boolean;
+export declare const isRouteEntry: (dir: string, routesDir?: string) => string | false;
+export declare const modifyEntrypoints: (entrypoints: Entrypoint[], routesDir?: string, routesOwner?: string) => EntrypointWithRoutesMeta[];

package/dist/types/router/cli/handler.d.ts

@@ -0,0 +1,28 @@
+import type { AppNormalizedConfig, AppTools } from '@modern-js/app-tools';
+import type { CLIPluginAPI } from '@modern-js/plugin';
+import type { Entrypoint, NestedRouteForCli, PageRoute } from '@modern-js/types';
+type GeneratedRoutesByEntry = Record<string, (NestedRouteForCli | PageRoute)[]>;
+type RegenerateRoutesFn = (params: {
+    api: CLIPluginAPI<AppTools>;
+    appContext: ReturnType<CLIPluginAPI<AppTools>['getAppContext']>;
+    resolvedConfig: AppNormalizedConfig;
+    entrypoints: Entrypoint[];
+}) => Promise<void>;
+type HandleGeneratorEntryCodeOptions = {
+    entrypointsKey?: string;
+    generateCodeOptions?: {
+        enableTanstackTypes?: boolean;
+    };
+};
+type HandleFileChangeOptions = {
+    includeEntry?: (entrypoint: Entrypoint) => boolean;
+    regenerate?: RegenerateRoutesFn;
+    entrypointsKey?: string;
+};
+type HandleModifyEntrypointsOptions = {
+    routesOwner?: string;
+};
+export declare function handleModifyEntrypoints(entrypoints: Entrypoint[], routesDir?: string, options?: HandleModifyEntrypointsOptions): Promise<import("./entry").EntrypointWithRoutesMeta[]>;
+export declare function handleGeneratorEntryCode(api: CLIPluginAPI<AppTools>, entrypoints: Entrypoint[], options?: HandleGeneratorEntryCodeOptions | string): Promise<GeneratedRoutesByEntry>;
+export declare function handleFileChange(api: CLIPluginAPI<AppTools>, e: any, options?: HandleFileChangeOptions): Promise<void>;
+export {};

package/dist/types/router/cli/index.d.ts

@@ -0,0 +1,5 @@
+import type { AppTools, CliPlugin } from '@modern-js/app-tools';
+export { BUILT_IN_ROUTES_OWNER, getEntrypointRoutesDir, getEntrypointRoutesOwner, isRouteEntry, } from './entry';
+export { handleFileChange, handleGeneratorEntryCode, handleModifyEntrypoints, } from './handler';
+export declare const routerPlugin: () => CliPlugin<AppTools>;
+export default routerPlugin;

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

@@ -0,0 +1 @@
+export * from './runtime';

package/dist/types/router/internal.d.ts

@@ -0,0 +1,2 @@
+export * from './runtime/internal';
+export { routerPlugin as default } from './runtime/internal';

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

@@ -0,0 +1,9 @@
+import React from 'react';
+/**
+ * Server Component that renders CSS link tags
+ * These will be serialized into RSC payload and automatically handled by React on client
+ * React will automatically hoist these link tags to the head
+ */
+export declare function CSSLinks({ cssFiles }: {
+    cssFiles: string[];
+}): React.JSX.Element | null;

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

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare const DefaultNotFound: () => React.JSX.Element;

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

@@ -0,0 +1,2 @@
+declare const _default: () => null;
+export default _default;

package/dist/types/router/runtime/DeferredDataScripts.node.d.ts

@@ -0,0 +1,11 @@
+import type { StaticHandlerContext } from '@modern-js/runtime-utils/router';
+/**
+ * DeferredDataScripts only renders in server side,
+ * it doesn't need to be hydrated in client side.
+ */
+declare const DeferredDataScripts: (props?: {
+    nonce?: string;
+    useJsonScript?: boolean;
+    context: StaticHandlerContext;
+}) => import("react").JSX.Element | null;
+export default DeferredDataScripts;

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

@@ -0,0 +1,27 @@
+import { type LinkProps as RouterLinkProps, type NavLinkProps as RouterNavLinkProps } from '@modern-js/runtime-utils/router';
+import React from 'react';
+/**
+ * Modified from https://github.com/remix-run/remix/blob/9a0601bd704d2f3ee622e0ddacab9b611eb0c5bc/packages/remix-react/components.tsx#L218
+ *
+ * MIT Licensed
+ * Author Michael Jackson
+ * Copyright 2021 Remix Software Inc.
+ * https://github.com/remix-run/remix/blob/2b5e1a72fc628d0408e27cf4d72e537762f1dc5b/LICENSE.md
+ */
+/**
+ * Defines the prefetching behavior of the link:
+ *
+ * - "intent": Fetched when the user focuses or hovers the link
+ * - "render": Fetched when the link is rendered
+ * - "none": Never fetched
+ */
+type PrefetchBehavior = 'intent' | 'render' | 'none';
+export interface LinkProps extends RouterLinkProps {
+    prefetch?: PrefetchBehavior;
+}
+export interface NavLinkProps extends RouterNavLinkProps {
+    prefetch?: PrefetchBehavior;
+}
+declare const Link: React.ForwardRefExoticComponent<LinkProps & React.RefAttributes<HTMLAnchorElement>>;
+declare const NavLink: React.ForwardRefExoticComponent<NavLinkProps & React.RefAttributes<HTMLAnchorElement>>;
+export { Link, NavLink };

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

@@ -0,0 +1,146 @@
+/**
+ * setup promises for deferred data
+ * original function:
+  function setupDeferredPromise(routeId, key) {
+    _ROUTER_DATA.r  = _ROUTER_DATA.r || {};
+    _ROUTER_DATA.r[routeId] = _ROUTER_DATA.r[routeId] || {};
+    const promise = new Promise(function (resolve, reject) {
+      _ROUTER_DATA.r[routeId][key] = {
+        resolve,
+        reject,
+      };
+    });
+    return promise;
+  };
+ *
+ */
+export declare const setupFnStr = "function s(r,e){_ROUTER_DATA.r=_ROUTER_DATA.r||{},_ROUTER_DATA.r[r]=_ROUTER_DATA.r[r]||{};return new Promise((function(A,R){_ROUTER_DATA.r[r][e]={resolve:A,reject:R}}))};";
+/**
+   * resolve promises for deferred data
+   * original function:
+    function resolveDeferredPromise(routeId, key, data, error) {
+      if (error) {
+        _ROUTER_DATA.r[routeId][key].reject(error);
+      } else {
+        _ROUTER_DATA.r[routeId][key].resolve(data);
+      }
+    };
+   */
+export declare const resolveFnStr = "function r(e,r,o,A){A?_ROUTER_DATA.r[e][r].reject(A):_ROUTER_DATA.r[e][r].resolve(o)};";
+/**
+   * update data for pre resolved promises
+   * original function:
+   * function preResolvedDeferredPromise(data, error) {
+    if(typeof error !== 'undefined'){
+      return Promise.reject(new Error(error.message));
+    }else{
+      return Promise.resolve(data);
+    }
+  }
+   */
+export declare const preResolvedFnStr = "function p(e,r){return void 0!==r?Promise.reject(new Error(r.message)):Promise.resolve(e)};";
+/**
+ * let initialScripts = '...';
+ * initialScripts += Object.entries(activeDeferreds)
+      .map(([routeId, deferredData]) => {
+        const pendingKeys = new Set(deferredData.pendingKeys);
+        const { deferredKeys } = deferredData;
+        const deferredKeyPromiseStr = deferredKeys
+          .map(key => {
+            if (pendingKeys.has(key)) {
+              deferredDataScripts.push(
+                <DeferredDataScript
+                  nonce={props?.nonce}
+                  key={`${routeId} | ${key}`}
+                  data={deferredData.data[key]}
+                  dataKey={key}
+                  routeId={routeId}
+                />,
+              );
+
+              return `${JSON.stringify(key)}: _ROUTER_DATA.s(${JSON.stringify(
+                routeId,
+              )},${JSON.stringify(key)}) `;
+            } else {
+              const trackedPromise = deferredData.data[key] as TrackedPromise;
+              if (typeof trackedPromise._error !== 'undefined') {
+                const error = {
+                  message: trackedPromise._error.message,
+                  stack:
+                    process.env.NODE_ENV !== 'production'
+                      ? trackedPromise._error.stack
+                      : undefined,
+                };
+                return `${JSON.stringify(
+                  key,
+                )}: _ROUTER_DATA.p(${undefined}, ${serializeJson(error)})`;
+              } else {
+                if (typeof trackedPromise._data === 'undefined') {
+                  throw new Error(
+                    `The deferred data for ${key} was not resolved, did you forget to return data from a deferred promise`,
+                  );
+                }
+                return `${JSON.stringify(key)}: _ROUTER_DATA.p(${serializeJson(
+                  trackedPromise._data,
+                )})`;
+              }
+            }
+          })
+          .join(',\n');
+
+        return `Object.assign(_ROUTER_DATA.loaderData[${JSON.stringify(
+          routeId,
+        )}], {${deferredKeyPromiseStr}});`;
+      })
+      .join('\n');
+ */
+/**
+ * Abstracting the above logic to `mergeLoaderData`:
+ *  function mergeLoaderData (routeIdJsonStr, deferredKeyPromiseManifests) {
+      const source = deferredKeyPromiseManifests.reduce(function(o, {key, routerDataFnName, routerDataFnArgs }) {
+        const args = routerDataFnArgs.map(arg => {
+          if (arg === 'undefined' || arg === null) {
+            return undefined;
+          }
+          return JSON.parse(arg);
+        });
+        return {...o, [key]: _ROUTER_DATA[routerDataFnName](...args)};
+      }, {});
+      Object.assign(_ROUTER_DATA.loaderData[routeIdJsonStr], source);
+    };
+ */
+export declare const mergeLoaderDataStr = "function mergeLoaderData(e,n){var r=n.reduce((function(e,{key:n,routerDataFnName:r,routerDataFnArgs:a}){var t=a.map((e=>{if(\"undefined\"!==e&&null!==e)return JSON.parse(e)}));return{...e,[n]:_ROUTER_DATA[r](...t)}}),{});_ROUTER_DATA.loaderData=_ROUTER_DATA.loaderData||{},_ROUTER_DATA.loaderData[e]=_ROUTER_DATA.loaderData[e]||{},Object.assign(_ROUTER_DATA.loaderData[e],r)}";
+/**
+   * This original string is: ${setupFnStr};${resolveFnStr};${preResolvedFnStr};
+   * function mergeData (routeIdJsonStr, deferredKeyPromiseManifests) {
+      const source = deferredKeyPromiseManifests.reduce(function(o, {key, routerDataFnName, routerDataFnArgs }) {
+        return {...o, [key]: _ROUTER_DATA[routerDataFnName](...routerDataFnArgs)}
+      }, {});
+      Object.assign(_ROUTER_DATA.loaderData[routeIdJsonStr], source);
+    };
+   */
+export declare const initRouterDataAttrs = "_ROUTER_DATA.s = function s(r,e){_ROUTER_DATA.r=_ROUTER_DATA.r||{},_ROUTER_DATA.r[r]=_ROUTER_DATA.r[r]||{};return new Promise((function(A,R){_ROUTER_DATA.r[r][e]={resolve:A,reject:R}}))};_ROUTER_DATA.r = function r(e,r,o,A){A?_ROUTER_DATA.r[e][r].reject(A):_ROUTER_DATA.r[e][r].resolve(o)};_ROUTER_DATA.p = function p(e,r){return void 0!==r?Promise.reject(new Error(r.message)):Promise.resolve(e)};function mergeLoaderData(e,n){var r=n.reduce((function(e,{key:n,routerDataFnName:r,routerDataFnArgs:a}){var t=a.map((e=>{if(\"undefined\"!==e&&null!==e)return JSON.parse(e)}));return{...e,[n]:_ROUTER_DATA[r](...t)}}),{});_ROUTER_DATA.loaderData=_ROUTER_DATA.loaderData||{},_ROUTER_DATA.loaderData[e]=_ROUTER_DATA.loaderData[e]||{},Object.assign(_ROUTER_DATA.loaderData[e],r)}";
+/**
+  function runWindowFn() {
+    window[document.currentScript.getAttribute('data-fn-name')](...JSON.parse(document.currentScript.getAttribute('data-fn-args')))
+  }
+  function runRouterDataFn() {
+    _ROUTER_DATA[document.currentScript.getAttribute('data-fn-name')](...JSON.parse(document.currentScript.getAttribute('data-fn-args')))
+  }
+  function initRouterData(id) {
+    const ele = document.getElementById(id);
+    if (ele) {
+      try {
+        _ROUTER_DATA = JSON.parse(ele.textContent);
+      } catch(e) {
+        console.error("parse ".concat(id, " error"), t);
+        _ROUTER_DATA = {};
+      }
+    }
+  }
+  initRouterData();
+  ${initRouterDataAttrs}
+*/
+export declare const modernInline = "function runWindowFn(){window[document.currentScript.getAttribute(\"data-fn-name\")].apply(window,JSON.parse(document.currentScript.getAttribute(\"data-fn-args\")))}function runRouterDataFn(){_ROUTER_DATA[document.currentScript.getAttribute(\"data-fn-name\")].apply(_ROUTER_DATA,JSON.parse(document.currentScript.getAttribute(\"data-fn-args\")))}function initRouterData(e){var r=document.getElementById(e);if(r)try{_ROUTER_DATA=JSON.parse(r.textContent)}catch(r){console.error(\"parse \".concat(e,\" error\"),t),_ROUTER_DATA={}}};initRouterData('__MODERN_ROUTER_DATA__');_ROUTER_DATA.s = function s(r,e){_ROUTER_DATA.r=_ROUTER_DATA.r||{},_ROUTER_DATA.r[r]=_ROUTER_DATA.r[r]||{};return new Promise((function(A,R){_ROUTER_DATA.r[r][e]={resolve:A,reject:R}}))};_ROUTER_DATA.r = function r(e,r,o,A){A?_ROUTER_DATA.r[e][r].reject(A):_ROUTER_DATA.r[e][r].resolve(o)};_ROUTER_DATA.p = function p(e,r){return void 0!==r?Promise.reject(new Error(r.message)):Promise.resolve(e)};function mergeLoaderData(e,n){var r=n.reduce((function(e,{key:n,routerDataFnName:r,routerDataFnArgs:a}){var t=a.map((e=>{if(\"undefined\"!==e&&null!==e)return JSON.parse(e)}));return{...e,[n]:_ROUTER_DATA[r](...t)}}),{});_ROUTER_DATA.loaderData=_ROUTER_DATA.loaderData||{},_ROUTER_DATA.loaderData[e]=_ROUTER_DATA.loaderData[e]||{},Object.assign(_ROUTER_DATA.loaderData[e],r)}";
+export declare const runRouterDataFnStr = "runRouterDataFn();";
+export declare const runWindowFnStr = "runWindowFn();";

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

@@ -0,0 +1,18 @@
+import type { RouteObject } from '@modern-js/runtime-utils/router';
+import type { TRuntimeContext } from '../../core/context/runtime';
+import type { RouterLifecycleContext } from './lifecycle';
+declare const modifyRoutes: import("@modern-js/plugin").SyncHook<(routes: RouteObject[]) => RouteObject[]>;
+declare const onBeforeCreateRoutes: import("@modern-js/plugin").SyncHook<(context: TRuntimeContext) => void>;
+declare const onBeforeCreateRouter: import("@modern-js/plugin").SyncHook<(context: RouterLifecycleContext) => void>;
+declare const onAfterCreateRouter: import("@modern-js/plugin").SyncHook<(context: RouterLifecycleContext) => void>;
+declare const onBeforeHydrateRouter: import("@modern-js/plugin").SyncHook<(context: RouterLifecycleContext) => void>;
+declare const onAfterHydrateRouter: import("@modern-js/plugin").SyncHook<(context: RouterLifecycleContext) => void>;
+export { modifyRoutes, onAfterCreateRouter, onAfterHydrateRouter, onBeforeCreateRouter, onBeforeCreateRoutes, onBeforeHydrateRouter, };
+export type RouterExtendsHooks = {
+    modifyRoutes: typeof modifyRoutes;
+    onBeforeCreateRoutes: typeof onBeforeCreateRoutes;
+    onBeforeCreateRouter: typeof onBeforeCreateRouter;
+    onAfterCreateRouter: typeof onAfterCreateRouter;
+    onBeforeHydrateRouter: typeof onBeforeHydrateRouter;
+    onAfterHydrateRouter: typeof onAfterHydrateRouter;
+};

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

@@ -0,0 +1,7 @@
+import { useRouteLoaderData as useRouteData } from '@modern-js/runtime-utils/router';
+export * from '@modern-js/runtime-utils/router';
+export type { LinkProps, NavLinkProps } from './PrefetchLink';
+export { Link, NavLink } from './PrefetchLink';
+export declare const useRouteLoaderData: typeof useRouteData;
+export type { LoaderFunction, LoaderFunctionArgs } from './types';
+export * from './withRouter';

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

@@ -0,0 +1,11 @@
+import type { RuntimePlugin } from '../../core';
+import type { RouterExtendsHooks } from './hooks';
+import type { RouterConfig, SingleRouteConfig } from './types';
+export declare const routerPlugin: (userConfig?: Partial<RouterConfig>) => RuntimePlugin<{
+    extendHooks: RouterExtendsHooks;
+}>;
+export default routerPlugin;
+export type { RouterExtendsHooks } from './hooks';
+export { modifyRoutes } from './plugin';
+export { renderRoutes } from './utils';
+export type { RouterConfig, SingleRouteConfig };

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

@@ -0,0 +1,25 @@
+import type { RouteObject } from '@modern-js/runtime-utils/router';
+import type { TInternalRuntimeContext } from '../../core/context/runtime';
+import type { InternalRouterRuntimeState, InternalRouterServerSnapshot, RouterFramework, RouterRouteMatchSnapshot, RouterServerPrepareResult } from './types';
+export type RouterLifecyclePhase = 'ssr-prepare' | 'client-create' | 'hydrate';
+export type RouterLifecycleContext = {
+    framework: RouterFramework;
+    phase: RouterLifecyclePhase;
+    routes: RouteObject[];
+    runtimeContext: TInternalRuntimeContext;
+    basename?: string;
+    hydrationData?: unknown;
+    router?: unknown;
+    matches?: RouterRouteMatchSnapshot[];
+    cleanup?: () => void | Promise<void>;
+    serverSnapshot?: InternalRouterServerSnapshot;
+};
+type RouterSnapshotLike = Partial<InternalRouterServerSnapshot>;
+export declare function createRouterServerSnapshot(state: RouterSnapshotLike): InternalRouterServerSnapshot;
+export declare function createRouterRuntimeState(state: InternalRouterRuntimeState): InternalRouterRuntimeState;
+export declare function applyRouterRuntimeState(runtimeContext: TInternalRuntimeContext, state: InternalRouterRuntimeState): TInternalRuntimeContext;
+export declare function applyRouterServerPrepareResult(runtimeContext: TInternalRuntimeContext, result: RouterServerPrepareResult): TInternalRuntimeContext;
+export declare function getRouterHydrationScripts(runtimeContext: TInternalRuntimeContext): string[];
+export declare function getRouterMatchedRouteIds(runtimeContext: TInternalRuntimeContext): string[] | undefined;
+export declare function cleanupRouterRuntimeState(runtimeContext: TInternalRuntimeContext): Promise<void>;
+export {};

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

@@ -0,0 +1,9 @@
+import { type RuntimePlugin } from '../../core';
+import { type RouterExtendsHooks } from './hooks';
+import type { RouterConfig, Routes } from './types';
+export declare let finalRouteConfig: RouterConfig['routesConfig'];
+export declare let beforeCreateRouter: boolean;
+export declare function modifyRoutes(modifyFunction: (routes: Routes) => Routes): void;
+export declare const routerPlugin: (userConfig?: Partial<RouterConfig>) => RuntimePlugin<{
+    extendHooks: RouterExtendsHooks;
+}>;

package/dist/types/router/runtime/plugin.node.d.ts

@@ -0,0 +1,7 @@
+import type { RuntimePlugin } from '../../core';
+import { type RouterExtendsHooks } from './hooks';
+import type { RouterConfig } from './types';
+export declare const routerPlugin: (userConfig?: Partial<RouterConfig>) => RuntimePlugin<{
+    extendHooks: RouterExtendsHooks;
+}>;
+export declare const modifyRoutes: () => void;

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

@@ -0,0 +1,5 @@
+import type { ShouldRevalidateFunction } from '@modern-js/runtime-utils/router';
+import type Module from 'module';
+export declare const createShouldRevalidate: (routeId: string) => ShouldRevalidateFunction;
+export declare const handleRouteModule: (routeModule: Module, routeId: string) => Module;
+export declare const handleRouteModuleError: (error: Error) => null;

package/dist/types/router/runtime/rsc-router.d.ts

@@ -0,0 +1,20 @@
+import { type RouteObject, type StaticHandlerContext } from '@modern-js/runtime-utils/router';
+import React from 'react';
+import type { ServerPayload } from '../../core/context';
+import type { RouteManifest } from './types';
+declare global {
+    interface Window {
+        _MODERNJS_ROUTE_MANIFEST?: RouteManifest;
+        __webpack_public_path__?: string;
+    }
+}
+export declare const createServerPayload: (routerContext: StaticHandlerContext, routes: RouteObject[]) => ServerPayload;
+export declare const handleRSCRedirect: (headers: Headers, basename: string, status: number) => Response;
+export declare const prepareRSCRoutes: (routes: RouteObject[]) => Promise<void>;
+export declare const createClientRouterFromPayload: (payload: ServerPayload, originalRoutes: RouteObject[], basename?: string) => import("react-router").DataRouter;
+interface RSCStaticRouterProps {
+    basename?: string;
+    useJsonScript?: boolean;
+}
+export declare const RSCStaticRouter: React.FC<RSCStaticRouterProps>;
+export {};

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

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

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

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

package/dist/types/router/runtime/tanstack/basepathRewrite.d.ts

@@ -0,0 +1,8 @@
+export declare function createModernBasepathRewrite(basepath: string, caseSensitive?: boolean): {
+    input: ({ url }: {
+        url: URL;
+    }) => URL;
+    output: ({ url }: {
+        url: URL;
+    }) => URL;
+} | undefined;

package/dist/types/router/runtime/tanstack/dataMutation.d.ts

@@ -0,0 +1,29 @@
+import type React from 'react';
+type SubmitTarget = HTMLFormElement | FormData | URLSearchParams | Record<string, string | number | boolean | null | undefined>;
+export type SubmitOptions = {
+    action?: string;
+    method?: string;
+    encType?: string;
+};
+export type FetcherState = 'idle' | 'submitting' | 'loading';
+export declare class RouteActionResponseError<TData = unknown> extends Error {
+    readonly response: Response;
+    readonly data: TData;
+    constructor(response: Response, data: TData);
+}
+export type FormProps = Omit<React.FormHTMLAttributes<HTMLFormElement>, 'onSubmit' | 'action'> & {
+    action?: string;
+    onSubmit?: React.FormEventHandler<HTMLFormElement>;
+    reloadDocument?: boolean;
+};
+export declare function Form({ action, method, encType, reloadDocument, onSubmit, ...rest }: FormProps): React.JSX.Element;
+export type FetcherSubmitOptions = SubmitOptions;
+export type Fetcher = {
+    state: FetcherState;
+    data: unknown;
+    error: unknown;
+    Form: React.ComponentType<FormProps>;
+    submit: (target: SubmitTarget, options?: FetcherSubmitOptions) => Promise<void>;
+};
+export declare function useFetcher(): Fetcher;
+export {};

package/dist/types/router/runtime/tanstack/plugin.d.ts

@@ -0,0 +1,6 @@
+import type { RuntimePlugin } from '../../../core';
+import { type RouterExtendsHooks } from '../hooks';
+import type { RouterConfig } from '../types';
+export declare const tanstackRouterPlugin: (userConfig?: Partial<RouterConfig>) => RuntimePlugin<{
+    extendHooks: RouterExtendsHooks;
+}>;

package/dist/types/router/runtime/tanstack/plugin.node.d.ts

@@ -0,0 +1,6 @@
+import type { RuntimePlugin } from '../../../core';
+import type { RouterExtendsHooks } from '../hooks';
+import type { RouterConfig } from '../types';
+export declare const tanstackRouterPlugin: (userConfig?: Partial<RouterConfig>) => RuntimePlugin<{
+    extendHooks: RouterExtendsHooks;
+}>;

package/dist/types/router/runtime/tanstack/prefetchLink.d.ts

@@ -0,0 +1,11 @@
+import { type AnyRouter, type LinkComponentProps, type RegisteredRouter } from '@tanstack/react-router';
+import type { ReactElement } from 'react';
+export type PrefetchBehavior = 'intent' | 'render' | 'viewport' | 'none';
+export type LinkProps<TRouter extends AnyRouter = RegisteredRouter, TFrom extends string = string, TTo extends string | undefined = '.', TMaskFrom extends string = TFrom, TMaskTo extends string = '.'> = LinkComponentProps<'a', TRouter, TFrom, TTo, TMaskFrom, TMaskTo> & {
+    prefetch?: PrefetchBehavior;
+};
+export type NavLinkProps<TRouter extends AnyRouter = RegisteredRouter, TFrom extends string = string, TTo extends string | undefined = '.', TMaskFrom extends string = TFrom, TMaskTo extends string = '.'> = LinkProps<TRouter, TFrom, TTo, TMaskFrom, TMaskTo>;
+type LinkComponent = <TRouter extends AnyRouter = RegisteredRouter, const TFrom extends string = string, const TTo extends string | undefined = undefined, const TMaskFrom extends string = TFrom, const TMaskTo extends string = ''>(props: LinkProps<TRouter, TFrom, TTo, TMaskFrom, TMaskTo>) => ReactElement;
+export declare const Link: LinkComponent;
+export declare const NavLink: LinkComponent;
+export {};

package/dist/types/router/runtime/tanstack/routeTree.d.ts

@@ -0,0 +1,8 @@
+import type { RouteObject } from '@modern-js/runtime-utils/router';
+import type { NestedRoute, PageRoute } from '@modern-js/types';
+import type { AnyRouter, RootRoute as TanstackRootRoute } from '@tanstack/react-router';
+type ModernTanstackRootRoute = TanstackRootRoute;
+export declare function createRouteTreeFromModernRoutes(routes: Array<NestedRoute | PageRoute>): ModernTanstackRootRoute;
+export declare function createRouteTreeFromRouteObjects(routes: RouteObject[]): ModernTanstackRootRoute;
+export declare function getModernRouteIdsFromMatches(router: AnyRouter): string[];
+export {};

package/dist/types/router/runtime/tanstack/rsc/ClientSlot.d.ts

@@ -0,0 +1,5 @@
+import type React from 'react';
+export declare function ClientSlot({ args, slot }: {
+    args: unknown[];
+    slot: string;
+}): React.JSX.Element | null;

package/dist/types/router/runtime/tanstack/rsc/CompositeComponent.d.ts

@@ -0,0 +1,3 @@
+import type React from 'react';
+import { type AnyCompositeComponent, type CompositeComponentProps } from './symbols';
+export declare function CompositeComponent<TComp extends AnyCompositeComponent>(props: CompositeComponentProps<TComp>): React.JSX.Element;

package/dist/types/router/runtime/tanstack/rsc/ReplayableStream.d.ts

@@ -0,0 +1,24 @@
+export interface ReplayableStreamOptions {
+    signal?: AbortSignal;
+}
+export declare const REPLAYABLE_STREAM_MARKER: unique symbol;
+export declare class ReplayableStream<T = Uint8Array> {
+    private source;
+    private options;
+    readonly [REPLAYABLE_STREAM_MARKER] = true;
+    private chunks;
+    private done;
+    private error;
+    private waiter;
+    private released;
+    private reader;
+    private abortListener;
+    constructor(source: ReadableStream<T>, options?: ReplayableStreamOptions);
+    private start;
+    private detachAbortListener;
+    private notify;
+    private wait;
+    release(): void;
+    isReleased(): boolean;
+    createReplayStream(): ReadableStream<T>;
+}