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

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,4 @@
+export declare const getResponseProxy: () => any;
+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,5 @@
+import type { InternalRuntimeContext } from '@modern-js/plugin/runtime';
+import type { RuntimeConfig, RuntimeExtends, RuntimePlugin } from './types';
+export type { RuntimePlugin };
+export declare function registerPlugin(internalPlugins: RuntimePlugin[], runtimeConfig?: RuntimeConfig): InternalRuntimeContext<RuntimeExtends>;
+export declare function mergeConfig(config: Record<string, any>, ...otherConfig: Record<string, any>[]): 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;

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

@@ -0,0 +1,4 @@
+export declare const HTML_PLACEHOLDER = "<!--<?- html ?>-->";
+export declare const SSR_DATA_PLACEHOLDER = "<!--<?- SSRDataScript ?>-->";
+export declare const CHUNK_JS_PLACEHOLDER = "<!--<?- chunksMap.js ?>-->";
+export declare const CHUNK_CSS_PLACEHOLDER = "<!--<?- chunksMap.css ?>-->";

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

@@ -0,0 +1,3 @@
+import type { HelmetData } from 'react-helmet';
+export declare function createReplaceHelemt(helmetData?: HelmetData): (template: string) => string;
+export declare function helmetReplace(content: string, helmetData: HelmetData): string;

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

@@ -0,0 +1,4 @@
+import type { RuntimePlugin } from '../plugin';
+export { NoSSR, NoSSRCache } from './react';
+export declare const ssr: (_config: any) => RuntimePlugin;
+export default ssr;

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

@@ -0,0 +1,2 @@
+export { NoSSRCache } from './no-ssr-cache';
+export { NoSSR } from './nossr';

package/dist/types/core/server/react/no-ssr-cache/index.d.ts

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

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

@@ -0,0 +1,4 @@
+import React, { type ReactElement } from 'react';
+export declare const NoSSR: (props?: React.PropsWithChildren<{
+    fallback?: ReactElement | string;
+}>) => ReactElement | null;

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

@@ -0,0 +1,13 @@
+import type { RequestHandler, RequestHandlerOptions } from '@modern-js/app-tools';
+import React from 'react';
+import { type TInternalRuntimeContext } from '../context';
+export type { RequestHandlerConfig as HandleRequestConfig } from '@modern-js/app-tools';
+export type HandleRequestOptions = Exclude<RequestHandlerOptions, 'staticGenerate'> & {
+    runtimeContext: TInternalRuntimeContext;
+};
+export type HandleRequest = (request: Request, ServerRoot: React.ComponentType, // App, routes,
+options: HandleRequestOptions) => Promise<Response>;
+export type CreateRequestHandler = (handleRequest: HandleRequest, options?: {
+    enableRsc?: boolean;
+}) => Promise<RequestHandler>;
+export declare const createRequestHandler: CreateRequestHandler;

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

@@ -0,0 +1,4 @@
+export { type CreateRequestHandler, createRequestHandler, type HandleRequest, type HandleRequestConfig, type HandleRequestOptions, } from './requestHandler';
+export type { RenderOptions, RenderStreaming, RenderString } from './shared';
+export { renderStreaming } from './stream';
+export { renderString } from './string';

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

@@ -0,0 +1,8 @@
+import type { ServerUserConfig } from '@modern-js/app-tools';
+import type { HandleRequestOptions } from './requestHandler';
+export type RenderOptions = HandleRequestOptions;
+export type SSRConfig = NonNullable<ServerUserConfig['ssr']>;
+export type RenderStreaming = (request: Request, serverRoot: React.ReactElement, optinos: RenderOptions) => Promise<ReadableStream>;
+export type RenderString = (request: Request, serverRoot: React.ReactElement, optinos: RenderOptions) => Promise<string>;
+export type BuildHtmlCb = (template: string) => string | Promise<string>;
+export declare function buildHtml(template: string, callbacks: BuildHtmlCb[]): Promise<string>;

package/dist/types/core/server/stream/afterTemplate.d.ts

@@ -0,0 +1,13 @@
+import { type RenderLevel } from '../../constants';
+import type { TInternalRuntimeContext } from '../../context';
+import type { HandleRequestConfig } from '../requestHandler';
+import { type SSRConfig } from '../shared';
+export type BuildShellAfterTemplateOptions = {
+    runtimeContext: TInternalRuntimeContext;
+    renderLevel: RenderLevel;
+    ssrConfig: SSRConfig;
+    request: Request;
+    entryName: string;
+    config: HandleRequestConfig;
+};
+export declare function buildShellAfterTemplate(afterAppTemplate: string, options: BuildShellAfterTemplateOptions): Promise<string>;

package/dist/types/core/server/stream/beforeTemplate.d.ts

@@ -0,0 +1,9 @@
+import type { TInternalRuntimeContext } from '../../context';
+import type { HandleRequestConfig } from '../requestHandler';
+export interface BuildShellBeforeTemplateOptions {
+    runtimeContext: TInternalRuntimeContext;
+    entryName: string;
+    config: HandleRequestConfig;
+    styledComponentsStyleTags?: string;
+}
+export declare function buildShellBeforeTemplate(beforeAppTemplate: string, options: BuildShellBeforeTemplateOptions): Promise<string>;

package/dist/types/core/server/stream/beforeTemplate.worker.d.ts

@@ -0,0 +1,9 @@
+import type { TInternalRuntimeContext } from '../../context';
+import type { HandleRequestConfig } from '../requestHandler';
+export interface BuildShellBeforeTemplateOptions {
+    runtimeContext: TInternalRuntimeContext;
+    entryName: string;
+    config: HandleRequestConfig;
+    styledComponentsStyleTags?: string;
+}
+export declare function buildShellBeforeTemplate(beforeAppTemplate: string, options: BuildShellBeforeTemplateOptions): Promise<string>;

package/dist/types/core/server/stream/createReadableStream.d.ts

@@ -0,0 +1,2 @@
+import { type CreateReadableStreamFromElement } from './shared';
+export declare const createReadableStreamFromElement: CreateReadableStreamFromElement;

package/dist/types/core/server/stream/createReadableStream.worker.d.ts

@@ -0,0 +1,2 @@
+import { type CreateReadableStreamFromElement } from './shared';
+export declare const createReadableStreamFromElement: CreateReadableStreamFromElement;

package/dist/types/core/server/stream/deferredScript.d.ts

@@ -0,0 +1,15 @@
+import type { DeferredData } from '@modern-js/runtime-utils/browser';
+export type DeferredDataLike = Pick<DeferredData, 'data' | 'pendingKeys'> & {
+    data?: Record<string, unknown>;
+    pendingKeys?: string[];
+};
+export declare function escapeAttr(value: string): string;
+export declare function isRecord(v: unknown): v is Record<string, unknown>;
+export declare function isDeferredDataLike(v: unknown): v is DeferredDataLike;
+export declare function isPromiseLike(value: unknown): value is Promise<unknown>;
+export declare function toErrorInfo(error: unknown): {
+    message: string;
+    stack?: string;
+};
+export declare function buildDeferredDataScript(nonce: string | undefined, args: unknown[]): string;
+export declare function enqueueFromEntries(entries: Array<[string, unknown]>, nonce: string | undefined, emit: (script: string) => void): void;

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

@@ -0,0 +1 @@
+export declare const renderStreaming: import("../shared").RenderStreaming;

package/dist/types/core/server/stream/shared.d.ts

@@ -0,0 +1,40 @@
+import type { OnError } from '@modern-js/app-tools';
+import type { ClientManifest as RscClientManifest, ServerManifest as RscServerManifest, SSRManifest as RscSSRManifest } from '@modern-js/types/server';
+import type React from 'react';
+import type { TRuntimeContext } from '../../context';
+import type { HandleRequestConfig } from '../requestHandler';
+import type { RenderStreaming, SSRConfig } from '../shared';
+export type RscManifest = {
+    clientManifest?: RscClientManifest;
+    serverConsumerModuleMap?: unknown;
+    serverManifest?: RscServerManifest;
+    entryCssFiles?: Record<string, string[]>;
+};
+export type CreateReadableStreamFromElementOptions = {
+    runtimeContext: TRuntimeContext;
+    config: HandleRequestConfig;
+    ssrConfig: SSRConfig;
+    htmlTemplate: string;
+    entryName: string;
+    rscClientManifest?: RscClientManifest;
+    rscSSRManifest?: RscSSRManifest;
+    rscServerManifest?: RscServerManifest;
+    rscManifest?: RscManifest;
+    rscRoot?: React.ReactElement;
+    onShellReady?: () => void;
+    onShellError?: (error: unknown) => void;
+    onAllReady?: () => void;
+    onError: OnError;
+};
+export type CreateReadableStreamFromElement = (request: Request, rootElement: React.ReactElement, options: CreateReadableStreamFromElementOptions) => Promise<ReadableStream<Uint8Array>>;
+export declare enum ShellChunkStatus {
+    START = 0,
+    FINISH = 1
+}
+export declare function resolveStreamingMode(request: Request, forceStreamToString: boolean): {
+    onReady: 'onAllReady' | 'onShellReady';
+    waitForAllReady: boolean;
+};
+export declare function encodeForWebStream(thing: unknown): unknown;
+export declare function getReadableStreamFromString(content: string): ReadableStream;
+export declare function createRenderStreaming(createReadableStreamPromise: Promise<CreateReadableStreamFromElement>): RenderStreaming;

package/dist/types/core/server/stream/template.d.ts

@@ -0,0 +1,9 @@
+import { type BuildShellAfterTemplateOptions } from './afterTemplate';
+import { type BuildShellBeforeTemplateOptions } from './beforeTemplate';
+export type InjectTemplate = {
+    shellBefore: string;
+    shellAfter: string;
+};
+type GetTemplatesOptions = BuildShellAfterTemplateOptions & BuildShellBeforeTemplateOptions;
+export declare const getTemplates: (htmlTemplate: string, options: GetTemplatesOptions) => Promise<InjectTemplate>;
+export {};

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

@@ -0,0 +1,2 @@
+import { type RenderString } from '../shared';
+export declare const renderString: RenderString;

package/dist/types/core/server/string/loadable.d.ts

@@ -0,0 +1,36 @@
+import type { ReactElement } from 'react';
+import type { ChunkSet, Collector } from './types';
+declare module '@loadable/server' {
+    interface ChunkExtractor {
+        chunks: string[];
+        getChunkAssets: (chunks: string[]) => Chunk[];
+    }
+}
+export interface LoadableCollectorOptions {
+    nonce?: string;
+    stats?: Record<string, any>;
+    routeManifest?: Record<string, any>;
+    template: string;
+    entryName: string;
+    chunkSet: ChunkSet;
+    config: LoadableCollectorConfig;
+}
+export interface LoadableCollectorConfig {
+    scriptLoading?: 'defer' | 'blocking' | 'module' | 'async';
+    inlineStyles?: boolean | RegExp;
+    inlineScripts?: boolean | RegExp;
+    crossorigin?: boolean | 'anonymous' | 'use-credentials';
+    enableAsyncEntry?: boolean;
+}
+export declare class LoadableCollector implements Collector {
+    private options;
+    private extractor?;
+    constructor(options: LoadableCollectorOptions);
+    private get existsAssets();
+    collect(comopnent: ReactElement): ReactElement;
+    effect(): Promise<void>;
+    private emitLoadableScripts;
+    private emitScriptAssets;
+    private emitStyleAssets;
+    private generateAttributes;
+}

package/dist/types/core/server/string/ssrData.d.ts

@@ -0,0 +1,20 @@
+import type { StaticHandlerContext } from '@modern-js/runtime-utils/router';
+import type { TInternalRuntimeContext } from '../../context';
+import type { SSRServerContext } from '../../types';
+import type { SSRConfig } from '../shared';
+import type { ChunkSet, Collector } from './types';
+export interface SSRDataCreatorOptions {
+    runtimeContext: TInternalRuntimeContext;
+    request: Request;
+    chunkSet: ChunkSet;
+    ssrContext: SSRServerContext;
+    ssrConfig?: SSRConfig;
+    routerContext?: StaticHandlerContext;
+    nonce?: string;
+    useJsonScript?: boolean;
+}
+export declare class SSRDataCollector implements Collector {
+    #private;
+    constructor(options: SSRDataCreatorOptions);
+    effect(): void;
+}

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

@@ -0,0 +1,12 @@
+import type { ReactElement } from 'react';
+import type { RenderLevel } from '../../constants';
+export interface Collector {
+    collect?: (comopnent: ReactElement) => ReactElement;
+    effect: () => void | Promise<void>;
+}
+export type ChunkSet = {
+    renderLevel: RenderLevel;
+    ssrScripts: string;
+    jsChunk: string;
+    cssChunk: string;
+};

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

@@ -0,0 +1,17 @@
+import type { OnError, OnTiming } from '@modern-js/app-tools';
+export declare enum SSRTimings {
+    PRERENDER = "ssr-prerender",
+    RENDER_HTML = "ssr-render-html",
+    RENDER_SHELL = "ssr-render-shell"
+}
+export declare enum SSRErrors {
+    PRERENDER = "App Prerender",
+    RENDER_HTML = "App Render To HTML",
+    RENDER_STREAM = "An error occurs during streaming SSR",
+    RENDER_SHELL = "An error occurs during streaming render shell",
+    LOADER_ERROR = "App error occurs during data loader"
+}
+export type Tracer = {
+    onError: OnError;
+    onTiming: OnTiming;
+};

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

@@ -0,0 +1,19 @@
+import type { ServerUserConfig } from '@modern-js/app-tools';
+import { type StaticHandlerContext } from '@modern-js/runtime-utils/router';
+import type { SSRConfig } from './shared';
+export declare function attributesToString(attributes: Record<string, any>): string;
+/**
+ * @param source
+ * @param searchValue
+ * @param replaceValue
+ * @returns
+ */
+export declare function safeReplace(source: string, searchValue: string | RegExp, replaceValue: string): string;
+export declare function checkIsNode(): boolean;
+/**
+ * forked from https://github.com/remix-run/remix/blob/main/packages/remix-server-runtime/errors.ts
+ * license at https://github.com/remix-run/remix/blob/main/LICENSE.md
+ */
+export declare function serializeErrors(errors: StaticHandlerContext['errors']): StaticHandlerContext['errors'];
+export declare function getSSRConfigByEntry(entryName: string, ssr?: ServerUserConfig['ssr'], ssrByEntries?: ServerUserConfig['ssrByEntries']): any;
+export declare function getSSRMode(ssrConfig?: SSRConfig): 'string' | 'stream' | false;

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

@@ -0,0 +1,49 @@
+import type { OnError, OnTiming } from '@modern-js/app-tools';
+import type { BaseSSRServerContext } from '@modern-js/types';
+import type { RenderLevel } from './constants';
+declare global {
+    interface Window {
+        _SSR_DATA?: SSRContainer;
+        _ROUTER_DATA?: RouterSSRData;
+    }
+}
+export interface SSRData {
+    initialData?: Record<string, unknown>;
+    i18nData?: Record<string, unknown>;
+    [props: string]: any;
+}
+export interface RouteData {
+    [routeId: string]: any;
+}
+export interface RouterSSRData {
+    loaderData: RouteData;
+    errors: RouteData | null;
+}
+export type SSRMode = 'string' | 'stream';
+export interface SSRContainer {
+    renderLevel: RenderLevel;
+    mode: SSRMode;
+    data?: SSRData;
+    context?: {
+        request: BaseSSRServerContext['request'];
+        reporter?: {
+            sessionId?: string;
+        };
+    };
+}
+type BuildHtmlCb = (tempalte: string) => string;
+export type SSRServerContext = Pick<BaseSSRServerContext, 'baseUrl' | 'response' | 'nonce' | 'mode' | 'loaderContext' | 'reporter' | 'routeManifest'> & {
+    request: BaseSSRServerContext['request'] & {
+        raw: Request;
+    };
+    htmlModifiers: BuildHtmlCb[];
+    loaderFailureMode?: 'clientRender' | 'errorBoundary';
+    onError: OnError;
+    onTiming: OnTiming;
+    useJsonScript?: boolean;
+};
+export type RequestContext = {
+    request: BaseSSRServerContext['request'];
+    response: BaseSSRServerContext['response'];
+};
+export {};

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

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare function Body(props: React.DOMAttributes<HTMLBodyElement>): React.JSX.Element;

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

@@ -0,0 +1,5 @@
+import React from 'react';
+export declare function Comment(props: {
+    comment?: string;
+    children?: string;
+}): React.JSX.Element;

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

@@ -0,0 +1,13 @@
+import React, { type JSX } from 'react';
+type DocumentProps = {
+    [x: string]: any;
+    config?: any;
+    templateParams: {
+        [y: string]: any;
+        mountId?: string;
+    };
+    processEnv?: Record<string, string | undefined>;
+    children?: JSX.Element;
+};
+export declare const DocumentContext: React.Context<DocumentProps>;
+export {};

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

@@ -0,0 +1,12 @@
+import React, { type ReactNode } from 'react';
+type DocumentStructureContextProps = {
+    hasSetHead?: boolean;
+    hasSetScripts?: boolean;
+    hasSetLinks?: boolean;
+    hasSetBody?: boolean;
+    hasSetRoot?: boolean;
+    hasSetTitle?: boolean;
+    docChild?: ReactNode;
+};
+export declare const DocumentStructureContext: React.Context<DocumentStructureContextProps>;
+export {};

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

@@ -0,0 +1,5 @@
+import React from 'react';
+export declare function Head(props: {
+    children?: any;
+}): React.JSX.Element;
+export declare function DefaultHead(): React.JSX.Element;

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

@@ -0,0 +1,4 @@
+import React from 'react';
+export declare function Html(props: {
+    children: any[];
+} & React.HtmlHTMLAttributes<HTMLHtmlElement>): React.JSX.Element;

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

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

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

@@ -0,0 +1,7 @@
+import React from 'react';
+export declare function Root(props: {
+    rootId?: string;
+} & React.DOMAttributes<HTMLDivElement>): React.JSX.Element;
+export declare function DefaultRoot(props: {
+    children?: any;
+}): React.JSX.Element;

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

@@ -0,0 +1,4 @@
+export declare function Script(props: DocumentScriptProps): import("react").JSX.Element;
+export interface DocumentScriptProps extends Omit<React.ScriptHTMLAttributes<HTMLScriptElement>, 'content'> {
+    content?: () => void;
+}