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

package/dist/esm-node/ssr/serverRender/renderToStream/buildTemplate.after.mjs

@@ -0,0 +1,51 @@
+import "node:module";
+import { sanitizeSSRPayload, serializeJson } from "@modern-js/runtime-utils/node";
+import { attributesToString } from "../utils";
+import { buildTemplate } from "./buildTemplate.share";
+function buildShellAfterTemplate(afterAppTemplate, options) {
+    const callbacks = [
+        injectSSRDataScript
+    ];
+    return buildTemplate(afterAppTemplate, callbacks);
+    function injectSSRDataScript(template) {
+        const ssrDataScript = buildSSRDataScript();
+        return template.replace('<!--<?- SSRDataScript ?>-->', ssrDataScript);
+        function buildSSRDataScript() {
+            const { context: { ssrContext, initialData, __i18nData__ }, renderLevel } = options;
+            const { request, enableUnsafeCtx, nonce, tracker, unsafeHeaders } = ssrContext;
+            const unsafeContext = {
+                headers: request.headers
+            };
+            const SSRData = {
+                data: {
+                    initialData,
+                    i18nData: __i18nData__
+                },
+                context: {
+                    reporter: {
+                        sessionId: tracker.sessionId
+                    },
+                    request: {
+                        params: request.params,
+                        query: request.query,
+                        pathname: request.pathname,
+                        host: request.host,
+                        url: request.url,
+                        ...enableUnsafeCtx ? unsafeContext : {}
+                    }
+                },
+                renderLevel
+            };
+            const attrsStr = attributesToString({
+                nonce
+            });
+            const sanitizedSSRData = sanitizeSSRPayload(SSRData, {
+                unsafeHeaders
+            }).payload;
+            return `
+      <script${attrsStr}>window._SSR_DATA = ${serializeJson(sanitizedSSRData)}</script>
+      `;
+        }
+    }
+}
+export { buildShellAfterTemplate };

package/dist/esm-node/ssr/serverRender/renderToString/entry.mjs

@@ -0,0 +1,149 @@
+import "node:module";
+import { sanitizeSSRPayload, serializeJson } from "@modern-js/runtime-utils/node";
+import { time } from "@modern-js/runtime-utils/time";
+import react from "react";
+import react_helmet from "react-helmet";
+import { serializeErrors } from "../../../router/runtime/utils.mjs";
+import prefetch from "../../prefetch";
+import helmet from "../helmet";
+import { SSRErrors, SSRTimings } from "../tracker";
+import { RenderLevel } from "../types.mjs";
+import { ROUTER_DATA_JSON_ID, SSR_DATA_JSON_ID, attributesToString } from "../utils";
+import { buildHtml, createReplaceChunkCss, createReplaceChunkJs, createReplaceHtml, createReplaceSSRDataScript } from "./buildHtml";
+import { createLoadableCollector } from "./loadable";
+import { createRender } from "./render";
+import { createStyledCollector } from "./styledComponent";
+const buildTemplateData = (context, data, renderLevel, tracker)=>{
+    const { request, enableUnsafeCtx } = context;
+    const unsafeContext = {
+        headers: request.headers
+    };
+    return {
+        data,
+        context: {
+            request: {
+                params: request.params,
+                query: request.query,
+                pathname: request.pathname,
+                host: request.host,
+                url: request.url,
+                ...enableUnsafeCtx ? unsafeContext : {}
+            },
+            reporter: {
+                sessionId: tracker.sessionId
+            }
+        },
+        renderLevel
+    };
+};
+class Entry {
+    async renderToHtml(context) {
+        const ssrContext = context.ssrContext;
+        if (ssrContext.redirection?.url) return '';
+        const prefetchData = await this.prefetch(context);
+        if (ssrContext.redirection?.url) return '';
+        if (this.result.renderLevel >= RenderLevel.SERVER_PREFETCH) this.result.html = await this.renderToString(context);
+        if (ssrContext.redirection?.url) return '';
+        const { routerContext, routerServerSnapshot } = context;
+        const routerData = routerServerSnapshot?.routerData ? {
+            loaderData: routerServerSnapshot.routerData.loaderData,
+            errors: serializeErrors(routerServerSnapshot.routerData.errors)
+        } : routerContext ? {
+            loaderData: routerContext.loaderData,
+            errors: serializeErrors(routerContext.errors)
+        } : void 0;
+        const templateData = buildTemplateData(ssrContext, prefetchData, this.result.renderLevel, this.tracker);
+        const ssrDataScripts = this.getSSRDataScript(templateData, routerData);
+        const html = buildHtml(this.template, [
+            createReplaceChunkCss(this.result.chunksMap.css),
+            createReplaceChunkJs(this.result.chunksMap.js),
+            createReplaceHtml(this.result.html || ''),
+            createReplaceSSRDataScript(ssrDataScripts),
+            ...this.htmlModifiers
+        ]);
+        const helmetData = react_helmet.renderStatic();
+        return helmetData ? helmet(html, helmetData) : html;
+    }
+    async prefetch(context) {
+        let prefetchData;
+        const end = time();
+        try {
+            prefetchData = await prefetch(this.App, context, this.pluginConfig);
+            this.result.renderLevel = RenderLevel.SERVER_PREFETCH;
+            const prefetchCost = end();
+            this.tracker.trackTiming(SSRTimings.SSR_PREFETCH, prefetchCost);
+        } catch (e) {
+            this.result.renderLevel = RenderLevel.CLIENT_RENDER;
+            this.tracker.trackError(SSRErrors.PREFETCH, e);
+        }
+        return prefetchData || {};
+    }
+    async renderToString(context) {
+        let html = '';
+        const end = time();
+        const { ssrContext } = context;
+        try {
+            const App = react.createElement(this.App, {
+                context: Object.assign(context, {
+                    ssr: true
+                })
+            });
+            html = await createRender(App).addCollector(createStyledCollector(this.result)).addCollector(createLoadableCollector({
+                stats: ssrContext.loadableStats,
+                result: this.result,
+                entryName: this.entryName,
+                config: this.pluginConfig,
+                nonce: this.nonce,
+                template: this.template,
+                routeManifest: this.routeManifest
+            })).finish();
+            const cost = end();
+            this.tracker.trackTiming(SSRTimings.SSR_RENDER_HTML, cost);
+            this.result.renderLevel = RenderLevel.SERVER_RENDER;
+        } catch (e) {
+            this.tracker.trackError(SSRErrors.RENDER_HTML, e);
+        }
+        return html;
+    }
+    getSSRDataScript(templateData, routerData) {
+        const useInlineScript = false !== this.pluginConfig.inlineScript;
+        const sanitizedTemplateData = sanitizeSSRPayload(templateData, {
+            unsafeHeaders: this.pluginConfig.unsafeHeaders
+        }).payload;
+        const ssrData = serializeJson(sanitizedTemplateData);
+        const attrsStr = attributesToString({
+            nonce: this.nonce
+        });
+        let ssrDataScripts = useInlineScript ? `<script${attrsStr}>window._SSR_DATA = ${ssrData}</script>` : `<script type="application/json" id="${SSR_DATA_JSON_ID}">${ssrData}</script>`;
+        if (routerData) {
+            const sanitizedRouterData = sanitizeSSRPayload(routerData, {
+                unsafeHeaders: this.pluginConfig.unsafeHeaders
+            }).payload;
+            const serializedRouterData = serializeJson(sanitizedRouterData);
+            ssrDataScripts += useInlineScript ? `\n<script${attrsStr}>window._ROUTER_DATA = ${serializedRouterData}</script>` : `\n<script type="application/json" id="${ROUTER_DATA_JSON_ID}">${serializedRouterData}</script>`;
+        }
+        return ssrDataScripts;
+    }
+    constructor(options){
+        const { ctx, config } = options;
+        const { entryName, template, nonce } = ctx;
+        this.template = template;
+        this.entryName = entryName;
+        this.App = options.App;
+        this.pluginConfig = config;
+        this.routeManifest = ctx.routeManifest;
+        this.tracker = ctx.tracker;
+        this.metrics = ctx.metrics;
+        this.htmlModifiers = ctx.htmlModifiers;
+        this.nonce = nonce;
+        this.result = {
+            renderLevel: RenderLevel.CLIENT_RENDER,
+            html: '',
+            chunksMap: {
+                js: '',
+                css: ''
+            }
+        };
+    }
+}
+export default Entry;

package/dist/esm-node/ssr/serverRender/types.mjs

@@ -0,0 +1,2 @@
+import "node:module";
+export { RenderLevel } from "./renderToString/type";

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

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

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

@@ -0,0 +1,7 @@
+import type { Entrypoint } from '@modern-js/types';
+import type { RsbuildPlugin } from '@rsbuild/core';
+export declare const builderPluginAlias: ({ entrypoints, internalDirectory, metaName, }: {
+    entrypoints: Entrypoint[];
+    internalDirectory: string;
+    metaName: string;
+}) => RsbuildPlugin;

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

@@ -0,0 +1,3 @@
+import type { AppToolsContext, AppToolsFeatureHooks, AppToolsNormalizedConfig } from '@modern-js/app-tools';
+import type { Entrypoint } from '@modern-js/types';
+export declare const generateCode: (entrypoints: Entrypoint[], appContext: AppToolsContext, config: AppToolsNormalizedConfig, hooks: AppToolsFeatureHooks) => Promise<void>;

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

@@ -0,0 +1,9 @@
+export declare const APP_FILE_NAME = "App";
+export declare const ENTRY_POINT_FILE_NAME = "index.jsx";
+export declare const SERVER_ENTRY_POINT_FILE_NAME = "index.server.jsx";
+export declare const INDEX_FILE_NAME = "index";
+export declare const ENTRY_BOOTSTRAP_FILE_NAME = "bootstrap.jsx";
+export declare const ENTRY_SERVER_BOOTSTRAP_FILE_NAME = "bootstrap.server.jsx";
+export declare const ENTRY_POINT_RUNTIME_REGISTER_FILE_NAME = "runtime-register.js";
+export declare const ENTRY_POINT_RUNTIME_GLOBAL_CONTEXT_FILE_NAME = "runtime-global-context";
+export declare const ENTRY_POINT_REGISTER_FILE_NAME = "register.js";

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

@@ -0,0 +1,2 @@
+export declare const hasApp: (dir: string) => string | false;
+export declare const isRuntimeEntry: (dir: string) => string | false;

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

@@ -0,0 +1,11 @@
+import type { AppTools, CliPlugin } from '@modern-js/app-tools';
+import { documentPlugin } from '../document/cli';
+import { routerPlugin } from '../router/cli';
+import { ssrPlugin } from './ssr';
+export { getEntrypointRoutesDir, handleFileChange, handleGeneratorEntryCode, handleModifyEntrypoints, isRouteEntry, } from '../router/cli';
+export { isRuntimeEntry } from './entry';
+export { documentPlugin, routerPlugin, ssrPlugin };
+export declare const runtimePlugin: (params?: {
+    plugins?: CliPlugin<AppTools>[];
+}) => CliPlugin<AppTools>;
+export default runtimePlugin;

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

@@ -0,0 +1,6 @@
+import type { AppTools, CliPlugin } from '@modern-js/app-tools';
+import type { MergedEnvironmentConfig } from '@rsbuild/core';
+type EnvironmentConfigLike = Partial<Pick<MergedEnvironmentConfig, 'output' | 'source' | 'tools'>>;
+export declare const shouldUseModuleFederationNodeOutput: (config: EnvironmentConfigLike) => boolean;
+export declare const ssrPlugin: () => CliPlugin<AppTools>;
+export default ssrPlugin;

package/dist/types/cli/ssr/loadable-bundler-plugin.d.ts

@@ -0,0 +1,31 @@
+/**
+ * The following code is modified based on
+ * https://github.com/gregberge/loadable-components
+ *
+ * MIT Licensed
+ * Author Greg Bergé
+ * Copyright 2019 Greg Bergé
+ * https://github.com/gregberge/loadable-components/blob/main/LICENSE
+ */
+import type { Rspack } from '@modern-js/app-tools';
+interface LoadablePluginOptions {
+    filename: string;
+    path?: string;
+    writeToDisk?: any;
+    outputAsset?: boolean;
+    chunkLoadingGlobal?: string;
+}
+type Compiler = Rspack.Compiler;
+type Compilation = Rspack.Compilation;
+declare class LoadablePlugin {
+    opts: LoadablePluginOptions;
+    compiler: Compiler | null;
+    constructor({ filename, path, writeToDisk, outputAsset, chunkLoadingGlobal, }?: LoadablePluginOptions);
+    apply(compiler: Compiler): void;
+    handleEmit(compilation: Compilation): {
+        source(): string;
+        size(): number;
+    } | null;
+    writeAssetsFile(manifest: string): void;
+}
+export default LoadablePlugin;

package/dist/types/cli/ssr/mode.d.ts

@@ -0,0 +1,15 @@
+import type { AppToolsNormalizedConfig } from '@modern-js/app-tools';
+export type SSRMode = 'string' | 'stream' | false;
+/**
+ * Unified SSR mode resolution function.
+ * Priority:
+ * 1. If SSG is enabled, use SSG configuration (SSG takes precedence over SSR when both are configured)
+ * 2. User's explicit server.ssr/server.ssrByEntries config
+ * 3. Otherwise return false (no SSR)
+ */
+export declare function resolveSSRMode(params: {
+    entry?: string;
+    config: AppToolsNormalizedConfig;
+    appDirectory?: string;
+    nestedRoutesEntry?: string;
+}): SSRMode;

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

@@ -0,0 +1,50 @@
+import type { RuntimePluginConfig } from '@modern-js/app-tools';
+export declare const entryForCSRWithRSC: ({ metaName, entryName, urlPath, mountId, isNestedRouter, }: {
+    metaName: string;
+    entryName: string;
+    urlPath?: string;
+    mountId?: string;
+    isNestedRouter?: string;
+}) => string;
+export declare const index: ({ srcDirectory, internalSrcAlias, metaName, entry, entryName, customEntry, mountId, enableRsc, isNestedRouter, }: {
+    srcDirectory: string;
+    internalSrcAlias: string;
+    metaName: string;
+    entry: string;
+    entryName: string;
+    customEntry?: boolean;
+    mountId?: string;
+    enableRsc?: boolean;
+    isNestedRouter?: boolean;
+}) => string;
+export declare const register: () => string;
+export declare const runtimeRegister: ({ entryName, srcDirectory, internalSrcAlias, metaName, runtimeConfigFile, runtimePlugins, }: {
+    entryName: string;
+    srcDirectory: string;
+    internalSrcAlias: string;
+    metaName: string;
+    runtimeConfigFile: string | false;
+    runtimePlugins: RuntimePluginConfig[];
+}) => string;
+export declare const runtimeGlobalContext: ({ entryName, srcDirectory, internalSrcAlias, metaName, entry, customEntry, basename, }: {
+    entryName: string;
+    srcDirectory: string;
+    internalSrcAlias: string;
+    metaName: string;
+    entry: string;
+    customEntry?: boolean;
+    basename?: string;
+}) => string;
+export declare const runtimeGlobalContextForRSCServer: ({ metaName, }: {
+    metaName: string;
+}) => string;
+export declare const runtimeGlobalContextForRSCClient: ({ metaName, customEntry, }: {
+    metaName: string;
+    customEntry?: boolean;
+}) => string;
+export declare const AppProxyForRSC: ({ srcDirectory, internalSrcAlias, entry, customEntry, }: {
+    srcDirectory: string;
+    internalSrcAlias: string;
+    entry: string;
+    customEntry?: boolean;
+}) => string;

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

@@ -0,0 +1,20 @@
+type ServerIndexOptinos = GenHandlerCodeOptions & {
+    entryName: string;
+};
+export declare const serverIndex: (options: ServerIndexOptinos) => string;
+export declare const entryForCSRWithRSC: ({ metaName, entryName, }: {
+    metaName: string;
+    entryName: string;
+}) => string;
+type GenHandlerCodeOptions = {
+    customServerEntry?: string | false;
+    srcDirectory: string;
+    internalSrcAlias: string;
+    entry: string;
+    enableRsc?: boolean;
+} & TransformServerEntryOptions;
+type TransformServerEntryOptions = {
+    metaName?: string;
+    mode: 'string' | 'stream';
+};
+export {};

package/dist/types/common.d.ts

@@ -0,0 +1,8 @@
+import type { RuntimePlugin } from './core/plugin';
+export declare const isBrowser: () => boolean;
+export interface RuntimeConfig {
+    plugins?: RuntimePlugin[];
+    [key: string]: any;
+}
+export declare const JSX_SHELL_STREAM_END_MARK = "<!--<?- SHELL_STREAM_END ?>-->";
+export declare const ESCAPED_SHELL_STREAM_END_MARK = "&lt;!--&lt;?- SHELL_STREAM_END ?&gt;--&gt;";

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

@@ -0,0 +1,5 @@
+import type React from 'react';
+import type { Root } from 'react-dom/client';
+import type { TRuntimeContext } from '../context/runtime';
+export declare const isReact18: () => boolean;
+export declare function hydrateRoot(App: React.ReactElement, context: TRuntimeContext, ModernRender: (App: React.ReactElement) => Promise<HTMLElement | Root>, ModernHydrate: (App: React.ReactElement, callback?: () => void) => Promise<HTMLElement | Root>): Promise<HTMLElement | Root>;

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

@@ -0,0 +1,9 @@
+import type React from 'react';
+export type RenderFunc = typeof render;
+export declare function render(App: React.ReactElement<{
+    basename: string;
+}>, id?: HTMLElement | string): Promise<HTMLElement | import("react-dom/client").Root>;
+export declare function renderWithReact18(App: React.ReactElement, rootElement: HTMLElement): Promise<import("react-dom/client").Root>;
+export declare function renderWithReact17(App: React.ReactElement, rootElement: HTMLElement): Promise<HTMLElement>;
+export declare function hydrateWithReact18(App: React.ReactElement, rootElement: HTMLElement): Promise<import("react-dom/client").Root>;
+export declare function hydrateWithReact17(App: React.ReactElement, rootElement: HTMLElement, callback?: () => void): Promise<any>;

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

@@ -0,0 +1,5 @@
+import type React from 'react';
+export declare const WithCallback: React.FC<{
+    callback: () => void;
+    children: React.ReactElement;
+}>;

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

@@ -0,0 +1,4 @@
+import type { TInternalRuntimeContext } from '../context';
+export declare function transformHookRunner(hookRunnerName: string): string;
+export declare function handleSetupResult(setupResult: Record<string, (...args: any) => any>, api: Record<string, any>): void;
+export declare function getHookRunners(runtimeContext: TInternalRuntimeContext): Record<string, any>;

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

@@ -0,0 +1,2 @@
+import type { RuntimePlugin } from '../plugin/types';
+export declare const compatPlugin: () => RuntimePlugin;

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

@@ -0,0 +1,5 @@
+import type { TInternalRuntimeContext } from '../context';
+import type { RuntimePlugin } from '../plugin/types';
+import type { RequestContext } from '../types';
+export declare const makeRequestContext: (context: TInternalRuntimeContext) => RequestContext;
+export declare const requestContextPlugin: () => RuntimePlugin;

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

@@ -0,0 +1,6 @@
+import type { RuntimeConfig } from '../common';
+/**
+ * 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 | ((entryName: string) => RuntimeConfig)) => RuntimeConfig | ((entryName: string) => RuntimeConfig);

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

@@ -0,0 +1,6 @@
+export declare enum RenderLevel {
+    CLIENT_RENDER = 0,
+    SERVER_RENDER = 2
+}
+export declare const SSR_DATA_JSON_ID = "__MODERN_SSR_DATA__";
+export declare const ROUTER_DATA_JSON_ID = "__MODERN_ROUTER_DATA__";

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

@@ -0,0 +1,50 @@
+import type { InternalRuntimeContext } from '@modern-js/plugin';
+import type { NestedRoute, PageRoute } from '@modern-js/types';
+import type React from 'react';
+import type { RuntimeExtends } from '../plugin/types';
+import type { ServerPayload } from './serverPayload/index';
+export { getInitialContext, InternalRuntimeContext, RuntimeContext, type TInternalRuntimeContext, type TRuntimeContext, } from './runtime';
+export type { PayloadRoute, ServerPayload } from './serverPayload/index';
+interface GlobalContext {
+    entryName?: string;
+    /**
+     * App.tsx export default component
+     */
+    App?: React.ComponentType;
+    /**
+     * nest router and page router config
+     */
+    routes?: (NestedRoute | PageRoute)[];
+    /**
+     * nest router init function
+     */
+    appInit?: () => Promise<unknown>;
+    /**
+     * page router _app.tsx export layout app
+     */
+    layoutApp?: React.ComponentType;
+    /**
+     * Entry basename for routing
+     */
+    basename?: string;
+    internalRuntimeContext?: InternalRuntimeContext<RuntimeExtends>;
+    /**
+     * RSCRoot
+     */
+    RSCRoot?: React.ComponentType;
+    isRscClient?: boolean;
+    serverPayload?: ServerPayload;
+    enableRsc?: boolean;
+}
+export { getServerPayload, setServerPayload, } from './serverPayload/index';
+export declare function getGlobalIsRscClient(): boolean | undefined;
+export declare function getGlobalEnableRsc(): boolean | undefined;
+export declare function setGlobalContext(context: Omit<GlobalContext, 'internalRuntimeContext'>): void;
+export declare function getCurrentEntryName(): string | undefined;
+export declare function getGlobalRSCRoot(): React.ComponentType<{}> | undefined;
+export declare function setGlobalInternalRuntimeContext(context: InternalRuntimeContext<RuntimeExtends>): void;
+export declare function getGlobalInternalRuntimeContext(): InternalRuntimeContext<Required<import("@modern-js/plugin").RuntimePluginExtends<import("../plugin/types").RuntimeConfig, import("./runtime").TInternalRuntimeContext, {}, {}>>>;
+export declare function getGlobalApp(): React.ComponentType<{}> | undefined;
+export declare function getGlobalRoutes(): undefined | (NestedRoute | PageRoute)[];
+export declare function getGlobalLayoutApp(): React.ComponentType<{}> | undefined;
+export declare function getGlobalBasename(): string | undefined;

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

@@ -0,0 +1,42 @@
+import type { RouteObject, StaticHandlerContext } from '@modern-js/runtime-utils/router';
+import type { InternalRouterRuntimeState, InternalRouterServerSnapshot, RouteManifest, RouterFramework } from '../../router/runtime/types';
+import type { RequestContext, SSRServerContext } from '../types';
+export interface TRuntimeContext {
+    initialData?: Record<string, unknown>;
+    isBrowser: boolean;
+    routes?: RouteObject[];
+    routerFramework?: RouterFramework;
+    requestContext: RequestContext;
+    /**
+     * @deprecated Use `requestContext` instead
+     */
+    context: RequestContext;
+    [key: string]: unknown;
+}
+/**
+ * InternalRuntimeContext used internally and by plugins
+ */
+export interface TInternalRuntimeContext extends TRuntimeContext {
+    routeManifest?: RouteManifest;
+    routerRuntime?: InternalRouterRuntimeState;
+    routerInstance?: unknown;
+    routerHydrationScript?: string;
+    routerMatchedRouteIds?: string[];
+    routerServerSnapshot?: InternalRouterServerSnapshot;
+    routerContext?: StaticHandlerContext;
+    unstable_getBlockNavState?: () => boolean;
+    ssrContext?: SSRServerContext;
+    _internalContext?: any;
+    _internalRouterBaseName?: any;
+}
+export declare const InternalRuntimeContext: import("react").Context<TInternalRuntimeContext>;
+export declare const RuntimeContext: import("react").Context<TRuntimeContext>;
+/**
+ * deprecated, use RuntimeContext instead
+ */
+export declare const ReactRuntimeContext: import("react").Context<TRuntimeContext>;
+export declare const getInitialContext: (isBrowser?: boolean, routeManifest?: RouteManifest) => TInternalRuntimeContext;
+/**
+ * @deprecated use use(RuntimeContext) instead
+ */
+export declare const useRuntimeContext: () => TRuntimeContext;

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

@@ -0,0 +1,4 @@
+import type { PayloadRoute, ServerPayload } from './index.server';
+export type { PayloadRoute, ServerPayload };
+export declare const getServerPayload: () => ServerPayload | undefined;
+export declare const setServerPayload: (payload: ServerPayload) => void;

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

@@ -0,0 +1,31 @@
+import type { RouterState, ShouldRevalidateFunction } from '@modern-js/runtime-utils/router';
+export type PayloadRoute = {
+    clientAction?: (...args: unknown[]) => unknown;
+    clientLoader?: (...args: unknown[]) => unknown;
+    element?: React.ReactNode;
+    errorElement?: React.ReactNode;
+    handle?: unknown;
+    hasAction: boolean;
+    hasErrorBoundary: boolean;
+    hasLoader: boolean;
+    hasClientLoader?: boolean;
+    id: string;
+    index?: boolean;
+    params: Record<string, string>;
+    parentId?: string;
+    path?: string;
+    pathname: string;
+    pathnameBase: string;
+    shouldRevalidate?: ShouldRevalidateFunction;
+};
+export type ServerPayload = {
+    type: 'render';
+    actionData: RouterState['actionData'];
+    errors: RouterState['errors'];
+    loaderData: RouterState['loaderData'];
+    location: RouterState['location'];
+    routes: PayloadRoute[];
+    originalRoutes?: PayloadRoute[];
+};
+export declare const getServerPayload: () => ServerPayload | undefined;
+export declare const setServerPayload: (payload: ServerPayload) => void;

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

@@ -0,0 +1,5 @@
+export { defineRuntimeConfig } from './config';
+export type { TRuntimeContext } from './context/runtime';
+export { RuntimeContext, useRuntimeContext, } from './context/runtime';
+export type { RuntimePlugin } from './plugin';
+export type { SSRContainer, SSRData } from './types';

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

@@ -0,0 +1,4 @@
+import type { RuntimeConfig, RuntimePlugin } from './types';
+export type { RuntimePlugin };
+export declare function registerPlugin(internalPlugins: RuntimePlugin[], runtimeConfig?: RuntimeConfig): any;
+export declare function mergeConfig(config: Record<string, any>, ...otherConfig: Record<string, any>[]): Record<string, any>;

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

@@ -0,0 +1,10 @@
+import type { RuntimePlugin as BaseRuntimePlugin, RuntimePluginExtends } from '@modern-js/plugin';
+import type { Hooks } from '@modern-js/plugin/runtime';
+import type { RuntimeConfig as BaseRuntimeConfig } from '../../common';
+import type { TInternalRuntimeContext } from '../context/runtime';
+export type RuntimeHooks = Hooks<RuntimeConfig, TInternalRuntimeContext>;
+export type RuntimeExtends = Required<RuntimePluginExtends<RuntimeConfig, TInternalRuntimeContext, {}, {}>>;
+export type RuntimePlugin<Extends extends RuntimePluginExtends = {}> = BaseRuntimePlugin<RuntimeExtends & Extends>;
+export interface RuntimeConfig extends BaseRuntimeConfig {
+    plugins?: RuntimePlugin[];
+}

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

@@ -0,0 +1,2 @@
+import type React from 'react';
+export declare function createRoot(UserApp?: React.ComponentType | null): React.ComponentType<any>;

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

@@ -0,0 +1,3 @@
+import type React from 'react';
+import { type TRuntimeContext } from '../context';
+export declare function wrapRuntimeContextProvider(App: React.ReactElement, contextValue: TRuntimeContext): React.JSX.Element;