@bleedingdev/modern-js-runtime 3.2.0-ultramodern.2 → 3.2.0-ultramodern.22

package/dist/types/document/Scripts.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare function Scripts(): React.JSX.Element;

package/dist/types/document/Style.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+export declare function Style(props: {
+    children?: string;
+    content?: string;
+} & React.DOMAttributes<HTMLStyleElement>): React.JSX.Element;

package/dist/types/document/Title.d.ts

@@ -0,0 +1 @@
+export declare function Title(): import("react").JSX.Element;

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

@@ -0,0 +1,5 @@
+import type { AppTools, CliPlugin } from '@modern-js/app-tools';
+import type { Entrypoint } from '@modern-js/types/cli';
+export declare const getDocumentByEntryName: (entrypoints: Entrypoint[], entryName: string, fallbackDir?: string) => string | undefined;
+export declare const documentPlugin: () => CliPlugin<AppTools>;
+export default documentPlugin;

package/dist/types/document/constants.d.ts

@@ -0,0 +1,25 @@
+export declare const DOC_EXT: string[];
+export declare const DOCUMENT_META_PLACEHOLDER: string;
+export declare const DOCUMENT_TITLE_PLACEHOLDER: string;
+export declare const HTML_SEPARATOR = "<!--<?- html ?>-->";
+export declare const HEAD_PARTICALS_SEPARATOR: string;
+export declare const BODY_PARTICALS_SEPARATOR: string;
+export declare const TOP_PARTICALS_SEPARATOR: string;
+export declare const HTML_SSRDATASCRIPT_SEPARATOR = "<!--<?- SSRDataScript ?>-->";
+export declare const DOCUMENT_SSR_PLACEHOLDER: string;
+export declare const DOCUMENT_CHUNKSMAP_PLACEHOLDER: string;
+export declare const DOCUMENT_SSRDATASCRIPT_PLACEHOLDER: string;
+export declare const DOCUMENT_FILE_NAME = "Document";
+export declare const DOCUMENT_SCRIPTS_PLACEHOLDER: string;
+export declare const DOCUMENT_LINKS_PLACEHOLDER: string;
+export declare const DOCUMENT_SCRIPT_PLACEHOLDER_START: string;
+export declare const DOCUMENT_SCRIPT_PLACEHOLDER_END: string;
+export declare const DOCUMENT_SCRIPT_ATTRIBUTES_START: string;
+export declare const DOCUMENT_SCRIPT_ATTRIBUTES_END: string;
+export declare const DOCUMENT_STYLE_PLACEHOLDER_START: string;
+export declare const DOCUMENT_STYLE_PLACEHOLDER_END: string;
+export declare const DOCUMENT_COMMENT_PLACEHOLDER_START: string;
+export declare const DOCUMENT_COMMENT_PLACEHOLDER_END: string;
+export declare const PLACEHOLDER_REPLACER_MAP: {
+    [x: string]: string;
+};

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

@@ -0,0 +1,12 @@
+export * from './Body';
+export * from './Comment';
+export * from './constants';
+export * from './DocumentContext';
+export * from './DocumentStructureContext';
+export * from './Head';
+export * from './Html';
+export * from './Links';
+export * from './Root';
+export * from './Script';
+export * from './Scripts';
+export * from './Style';

package/dist/types/exports/config-routes.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Type definitions for config-based routing
+ */
+import type { DefineRoutesFunction, LayoutFunction, PageFunction, RouteConfig, RouteFunction, RouteFunctions, WildcardFunction } from '../router/cli/config-routes/parseRouteConfig';
+export type { DefineRoutesFunction, LayoutFunction, PageFunction, RouteConfig, RouteFunction, RouteFunctions, WildcardFunction, };
+/**
+ * defineRoutes - main function to define route configurations
+ */
+export declare function defineRoutes(routesCallback: (routeFunctions: RouteFunctions, fileRoutes: RouteConfig[]) => RouteConfig[]): (routeFunctions: RouteFunctions, fileRoutes: RouteConfig[]) => RouteConfig[];

package/dist/types/exports/head.d.ts

@@ -0,0 +1,4 @@
+import head from 'react-helmet';
+export default head;
+export type { HelmetData, HelmetDatum, HelmetHTMLBodyDatum, HelmetHTMLElementDatum, HelmetProps, HelmetPropsToState, HelmetTags, } from 'react-helmet';
+export { Helmet } from 'react-helmet';

package/dist/types/exports/loadable.d.ts

@@ -0,0 +1,3 @@
+import loadable from '@loadable/component';
+export default loadable;
+export * from '@loadable/component';

package/dist/types/exports/tanstack-router.d.ts

@@ -0,0 +1,5 @@
+export * from '@tanstack/react-router';
+export type { Fetcher, FetcherState, FetcherSubmitOptions, FormProps, SubmitOptions, } from '../router/runtime/tanstack/dataMutation';
+export { Form, RouteActionResponseError, useFetcher, } from '../router/runtime/tanstack/dataMutation';
+export type { LinkProps, NavLinkProps, PrefetchBehavior, } from '../router/runtime/tanstack/prefetchLink';
+export { Link, NavLink } from '../router/runtime/tanstack/prefetchLink';

package/dist/types/index.d.ts

@@ -0,0 +1,10 @@
+import type { RouterConfig } from './router/internal';
+export type { RuntimeConfig } from './common';
+export { isBrowser } from './common';
+export type { RuntimePlugin } from './core';
+export { defineRuntimeConfig, RuntimeContext, useRuntimeContext, } from './core';
+export { getMonitors } from './core/context/monitors';
+export { getRequest } from './core/context/request';
+export { redirect, setHeaders, setStatus } from './core/context/response';
+export type { TRuntimeContext } from './core/context/runtime';
+export type { RouterConfig };

package/dist/types/internal.d.ts

@@ -0,0 +1,2 @@
+export { InternalRuntimeContext, type TInternalRuntimeContext, } from './core/context/runtime';
+export type { SSRServerContext } from './core/types';

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

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

package/dist/types/router/cli/code/getClientRoutes/getRoutes.d.ts

@@ -0,0 +1,8 @@
+import type { Entrypoint, NestedRouteForCli, PageRoute } from '@modern-js/types';
+export declare const getClientRoutes: ({ entrypoint, srcDirectory, srcAlias, internalDirectory, internalDirAlias, }: {
+    entrypoint: Entrypoint;
+    srcDirectory: string;
+    srcAlias: string;
+    internalDirectory: string;
+    internalDirAlias: string;
+}) => (NestedRouteForCli | PageRoute)[];

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

@@ -0,0 +1 @@
+export { getClientRoutes } from './getRoutes';

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

@@ -0,0 +1,4 @@
+declare const debug: (...args: unknown[]) => void;
+export { debug };
+export declare const getRouteWeight: (route: string) => number;
+export declare const shouldSkip: (file: string) => boolean;

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

@@ -0,0 +1,12 @@
+import type { AppNormalizedConfig, AppTools, AppToolsContext } from '@modern-js/app-tools';
+import type { CLIPluginAPI } from '@modern-js/plugin';
+import type { Entrypoint, NestedRouteForCli, PageRoute } from '@modern-js/types';
+/**
+ * Generate routing information for a single entry point (can be reused by the routes inspect feature)
+ */
+export declare function generateRoutesForEntry(entrypoint: Entrypoint, appContext: AppToolsContext): Promise<NestedRouteForCli[]>;
+export declare const generateCode: (appContext: AppToolsContext, config: AppNormalizedConfig, entrypoints: Entrypoint[], api: CLIPluginAPI<AppTools>, options?: {
+    enableTanstackTypes?: boolean;
+}) => Promise<Record<string, (NestedRouteForCli | PageRoute)[]>>;
+export declare function generatorRegisterCode(internalDirectory: string, entryName: string, code: string): void;
+export declare function generatorServerRegisterCode(internalDirectory: string, entryName: string, code: string): void;

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

@@ -0,0 +1,22 @@
+import type { AppTools } from '@modern-js/app-tools';
+import type { CLIPluginAPI } from '@modern-js/plugin';
+export interface RouteInspectInfo {
+    path?: string;
+    component: string;
+    data?: string;
+    clientData?: string;
+    error?: string;
+    loading?: string;
+    config?: string;
+    params?: string[];
+    children?: RouteInspectInfo[];
+}
+export interface RoutesInspectReport {
+    routes: RouteInspectInfo[];
+}
+export interface MultiEntryRoutesInspectReport {
+    [entryName: string]: {
+        routes: RouteInspectInfo[];
+    };
+}
+export declare function generateRoutesInspectReport(api: CLIPluginAPI<AppTools>): Promise<void>;

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

@@ -0,0 +1 @@
+export declare function makeLegalIdentifier(str: string): string;

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

@@ -0,0 +1,13 @@
+import type { NestedRouteForCli } from '@modern-js/types';
+export declare const getRouteId: (componentPath: string, routesDir: string, entryName: string, isMainEntry: boolean) => string;
+export declare const optimizeRoute: (routeTree: NestedRouteForCli) => NestedRouteForCli[];
+export declare const walk: (options: {
+    dirname: string;
+    rootDir: string;
+    alias?: {
+        name: string;
+        basename: string;
+    };
+    entryName: string;
+    isMainEntry: boolean;
+}) => Promise<NestedRouteForCli | NestedRouteForCli[] | null>;

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

@@ -0,0 +1,10 @@
+import type { AppToolsContext } from '@modern-js/app-tools';
+import type { NestedRouteForCli, PageRoute } from '@modern-js/types';
+export declare function isTanstackRouterFrameworkEnabled(appContext: AppToolsContext): Promise<boolean>;
+export declare function generateTanstackRouterTypesSourceForEntry(opts: {
+    appContext: AppToolsContext;
+    entryName: string;
+    routes: (NestedRouteForCli | PageRoute)[];
+}): Promise<{
+    routerGenTs: string;
+}>;

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) => any;
+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) => any;
+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 };