@bleedingdev/modern-js-runtime 3.2.0-ultramodern.120 → 3.2.0-ultramodern.121

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

@@ -1,152 +0,0 @@
-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 { HelmetProvider } from "react-helmet-async";
-import { getHelmetData, helmetReplace } from "../../../core/server/helmet.mjs";
-import { serializeErrors } from "../../../router/runtime/utils.mjs";
-import prefetch from "../../prefetch";
-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 = getHelmetData(context);
-        return helmetData ? helmetReplace(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 helmetContext = context._helmetContext ??= {};
-            const App = react.createElement(HelmetProvider, {
-                context: helmetContext
-            }, 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

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

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

@@ -1,10 +0,0 @@
-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/runtime/tanstack/basepathRewrite.d.ts

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

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

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

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

@@ -1,2 +0,0 @@
-import { type ReactElement } from 'react';
-export declare function wrapTanstackSsrHydrationBoundary(routerContent: ReactElement, shouldWrap: boolean): import("react").JSX.Element;

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

@@ -1,2 +0,0 @@
-export declare const Outlet: import("react").MemoExoticComponent<() => import("react").JSX.Element>;
-export declare function withModernRouteMatchContext(component: unknown, _routeId: string): unknown;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,5 +0,0 @@
-import type React from 'react';
-import { type AnyRenderableServerComponent } from './symbols';
-export declare function RscNodeRenderer({ data, }: {
-    data: AnyRenderableServerComponent;
-}): React.JSX.Element;

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

@@ -1,11 +0,0 @@
-import type React from 'react';
-export type SlotImplementations = Record<string, unknown>;
-export declare function useSlotContext(): {
-    implementations: SlotImplementations;
-    strict: boolean;
-} | null;
-export declare function SlotProvider({ children, implementations, strict, }: {
-    children?: React.ReactNode;
-    implementations: SlotImplementations;
-    strict?: boolean;
-}): React.JSX.Element;

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

@@ -1,11 +0,0 @@
-import { CompositeComponent } from './CompositeComponent';
-import type { AnyCompositeComponent, RscSlotUsageEvent } from './symbols';
-export type { AnyCompositeComponent, AnyRenderableServerComponent, CompositeComponentProps, } from './symbols';
-export { CompositeComponent };
-type SerializedRsc = {
-    kind: 'renderable' | 'composite';
-    stream: ReadableStream<Uint8Array>;
-    slotUsagesStream?: ReadableStream<RscSlotUsageEvent>;
-};
-export declare function getTanstackRscSerializationAdapters(): import("@tanstack/router-core").SerializationAdapter<AnyCompositeComponent<Record<string, unknown>, import("react").ReactNode>, SerializedRsc, never>[];
-export declare const rscSerializationAdapter: typeof getTanstackRscSerializationAdapters;

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

@@ -1,7 +0,0 @@
-import { type RscSlotUsageEvent, type ServerComponentStream } from './symbols';
-export declare function createRscProxy(getTree: () => unknown, options?: {
-    renderable?: boolean;
-    slotUsages?: RscSlotUsageEvent[];
-    slotUsagesStream?: ReadableStream<RscSlotUsageEvent>;
-    stream?: ServerComponentStream;
-}): any;

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

@@ -1,2 +0,0 @@
-export { CompositeComponent, getTanstackRscSerializationAdapters, rscSerializationAdapter, } from './client';
-export type { AnyCompositeComponent, AnyRenderableServerComponent, CompositeComponentProps, } from './symbols';

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

@@ -1,14 +0,0 @@
-import { RawStream } from '@tanstack/router-core';
-import React from 'react';
-import { type AnyCompositeComponent, type AnyRenderableServerComponent, type RscSlotUsageEvent } from './symbols';
-export { CompositeComponent } from './CompositeComponent';
-export type { AnyCompositeComponent, AnyRenderableServerComponent, CompositeComponentProps, } from './symbols';
-export declare function renderServerComponent<TNode extends React.ReactNode>(node: TNode): Promise<TNode & AnyRenderableServerComponent<TNode>>;
-export declare function createCompositeComponent<TProps extends object = Record<string, unknown>, TReturn = React.ReactNode>(component: (props: TProps) => React.ReactNode | Promise<React.ReactNode>): Promise<AnyCompositeComponent<TProps, TReturn>>;
-type SerializedRsc = {
-    kind: 'renderable' | 'composite';
-    stream: RawStream;
-    slotUsagesStream?: ReadableStream<RscSlotUsageEvent>;
-};
-export declare function getTanstackRscSerializationAdapters(): import("@tanstack/router-core").SerializationAdapter<AnyCompositeComponent<Record<string, unknown>, React.ReactNode> | AnyRenderableServerComponent<React.ReactNode>, SerializedRsc, never>[];
-export declare const rscSerializationAdapter: typeof getTanstackRscSerializationAdapters;

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

@@ -1,2 +0,0 @@
-import type { SerializableSlotArg } from './symbols';
-export declare function sanitizeSlotArgs(args: unknown[]): SerializableSlotArg[];

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

@@ -1,46 +0,0 @@
-import type React from 'react';
-export interface ServerComponentStream {
-    createReplayStream: () => ReadableStream<Uint8Array>;
-}
-export declare const SERVER_COMPONENT_STREAM: unique symbol;
-export declare const RENDERABLE_RSC: unique symbol;
-export declare const RSC_PROXY_GET_TREE: unique symbol;
-export declare const RSC_PROXY_PATH: unique symbol;
-export declare const RSC_SLOT_USAGES_STREAM: unique symbol;
-export declare const RSC_SLOT_USAGES: unique symbol;
-export type SerializableSlotArg = string | number | boolean | bigint | null | undefined | SerializableSlotArg[] | {
-    [key: string]: SerializableSlotArg;
-};
-export type RscSlotUsageEvent = {
-    slot: string;
-    args?: SerializableSlotArg[];
-};
-export interface AnyRenderableServerComponent<TNode = React.ReactNode> {
-    [SERVER_COMPONENT_STREAM]: ServerComponentStream;
-    [RENDERABLE_RSC]: true;
-    [RSC_PROXY_GET_TREE]?: () => unknown;
-    [RSC_PROXY_PATH]?: string[];
-    [RSC_SLOT_USAGES_STREAM]?: ReadableStream<RscSlotUsageEvent>;
-    '~types'?: {
-        node: TNode;
-    };
-}
-export interface AnyCompositeComponent<TProps extends object = Record<string, unknown>, TReturn = React.ReactNode> {
-    [SERVER_COMPONENT_STREAM]?: ServerComponentStream;
-    [RSC_PROXY_GET_TREE]?: () => unknown;
-    [RSC_PROXY_PATH]?: string[];
-    [RSC_SLOT_USAGES]?: RscSlotUsageEvent[];
-    [RSC_SLOT_USAGES_STREAM]?: ReadableStream<RscSlotUsageEvent>;
-    '~types'?: {
-        props: TProps;
-        return: TReturn;
-    };
-}
-type InferCompositeProps<TComp extends AnyCompositeComponent> = TComp extends AnyCompositeComponent<infer TProps, unknown> ? TProps : Record<string, unknown>;
-export type CompositeComponentProps<TComp extends AnyCompositeComponent> = {
-    src: TComp;
-    strict?: boolean;
-} & InferCompositeProps<TComp>;
-export declare function isServerComponent(value: unknown): value is AnyCompositeComponent | AnyRenderableServerComponent;
-export declare function isRenderableServerComponent(value: unknown): boolean;
-export {};