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

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/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,33 @@
+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 CreateReadableStreamFromElementOptions = {
+    runtimeContext: TRuntimeContext;
+    config: HandleRequestConfig;
+    ssrConfig: SSRConfig;
+    htmlTemplate: string;
+    entryName: string;
+    rscClientManifest?: RscClientManifest;
+    rscSSRManifest?: RscSSRManifest;
+    rscServerManifest?: RscServerManifest;
+    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,29 @@
+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']): true | {
+    forceCSR?: boolean;
+    mode?: import("@modern-js/types").SSRMode;
+    preload?: boolean | {
+        [x: string]: unknown;
+    };
+    inlineScript?: boolean;
+    disablePrerender?: boolean;
+    unsafeHeaders?: string[];
+    moduleFederationAppSSR?: boolean;
+};
+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;
+}

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