@modern-js/runtime 2.69.4 → 3.0.0-alpha.0

package/dist/esm-node/router/runtime/rsc-router.js

@@ -1,284 +0,0 @@
-import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
-import { ElementsContext, createFromReadableStream } from "@modern-js/render/client";
-import { StaticRouterProvider, createStaticRouter } from "@modern-js/runtime-utils/node/router";
-import { createBrowserRouter, redirect } from "@modern-js/runtime-utils/router";
-import React from "react";
-const safeUse = (promise) => {
-  if (typeof React.use === "function") {
-    return React.use(promise);
-  }
-  return null;
-};
-const createServerPayload = (routerContext, routes) => {
-  return {
-    type: "render",
-    actionData: routerContext.actionData,
-    errors: routerContext.errors,
-    loaderData: routerContext.loaderData,
-    location: routerContext.location,
-    routes: routerContext.matches.map((match, index, matches) => {
-      const element = match.route.element;
-      const parentMatch = index > 0 ? matches[index - 1] : void 0;
-      let processedElement;
-      if (element) {
-        var _routerContext_loaderData, _routerContext_actionData;
-        const ElementComponent = element.type;
-        processedElement = /* @__PURE__ */ React.createElement(ElementComponent, {
-          loaderData: routerContext === null || routerContext === void 0 ? void 0 : (_routerContext_loaderData = routerContext.loaderData) === null || _routerContext_loaderData === void 0 ? void 0 : _routerContext_loaderData[match.route.id],
-          actionData: routerContext === null || routerContext === void 0 ? void 0 : (_routerContext_actionData = routerContext.actionData) === null || _routerContext_actionData === void 0 ? void 0 : _routerContext_actionData[match.route.id],
-          params: match.params,
-          matches: routerContext.matches.map((m) => {
-            var _routerContext_loaderData2;
-            const { route, pathname, params } = m;
-            return {
-              id: route.id,
-              pathname,
-              params,
-              data: routerContext === null || routerContext === void 0 ? void 0 : (_routerContext_loaderData2 = routerContext.loaderData) === null || _routerContext_loaderData2 === void 0 ? void 0 : _routerContext_loaderData2[route.id],
-              handle: route.handle
-            };
-          })
-        });
-      }
-      return {
-        element: processedElement,
-        errorElement: match.route.errorElement,
-        handle: match.route.handle,
-        hasAction: !!match.route.action,
-        hasErrorBoundary: !!match.route.hasErrorBoundary,
-        hasLoader: !!match.route.loader,
-        hasClientLoader: !!match.route.hasClientLoader,
-        id: match.route.id,
-        index: match.route.index,
-        params: match.params,
-        parentId: (parentMatch === null || parentMatch === void 0 ? void 0 : parentMatch.route.id) || match.route.parentId,
-        path: match.route.path,
-        pathname: match.pathname,
-        pathnameBase: match.pathnameBase
-      };
-    })
-  };
-};
-const handleRSCRedirect = (headers, basename, status) => {
-  const newHeaders = new Headers(headers);
-  let redirectUrl = headers.get("Location");
-  if (basename !== "/") {
-    redirectUrl = redirectUrl.replace(basename, "");
-  }
-  newHeaders.set("X-Modernjs-Redirect", redirectUrl);
-  newHeaders.set("X-Modernjs-BaseUrl", basename);
-  newHeaders.delete("Location");
-  return new Response(null, {
-    status,
-    headers: newHeaders
-  });
-};
-const prepareRSCRoutes = async (routes) => {
-  const isLazyComponent = (component) => {
-    return component && typeof component === "object" && component._init !== void 0 && component._payload !== void 0;
-  };
-  const processRoutes = async (routesList) => {
-    await Promise.all(routesList.map(async (route) => {
-      if ("lazyImport" in route && isLazyComponent(route.component)) {
-        route.component = (await route.lazyImport()).default;
-      }
-      if (route.children && Array.isArray(route.children)) {
-        await processRoutes(route.children);
-      }
-    }));
-  };
-  await processRoutes(routes);
-};
-const mergeRoutes = (routes, originalRoutes) => {
-  if (!originalRoutes || !Array.isArray(originalRoutes)) {
-    return routes;
-  }
-  const routesMap = /* @__PURE__ */ new Map();
-  const buildRoutesMap = (routesList) => {
-    routesList.forEach((route) => {
-      if (route.id) {
-        routesMap.set(route.id, route);
-      }
-      if ("children" in route && route.children && Array.isArray(route.children)) {
-        buildRoutesMap(route.children);
-      }
-    });
-  };
-  buildRoutesMap(routes);
-  const mergeRoutesRecursive = (origRoutes) => {
-    return origRoutes.map((origRoute) => {
-      if (origRoute.id && routesMap.has(origRoute.id)) {
-        const matchedRoute = routesMap.get(origRoute.id);
-        const result = {
-          loader: origRoute.hasClientLoader ? origRoute.loader : void 0,
-          ...matchedRoute
-        };
-        if (origRoute.children && Array.isArray(origRoute.children)) {
-          result.children = mergeRoutesRecursive(origRoute.children);
-        }
-        return result;
-      }
-      return origRoute;
-    });
-  };
-  return mergeRoutesRecursive(originalRoutes);
-};
-const findRouteInTree = (routes, routeId) => {
-  for (const route of routes) {
-    if (route.id === routeId) {
-      return route;
-    }
-    if (route.children && Array.isArray(route.children)) {
-      const found = findRouteInTree(route.children, routeId);
-      if (found) {
-        return found;
-      }
-    }
-  }
-  return null;
-};
-const createClientRouterFromPayload = (payload, originalRoutes, basename = "") => {
-  const processedRoutes = payload.routes.reduceRight((previous, route) => {
-    if (previous.length > 0) {
-      return [
-        {
-          ...route,
-          children: previous
-        }
-      ];
-    }
-    return [
-      route
-    ];
-  }, []);
-  const mergedRoutes = mergeRoutes(processedRoutes, originalRoutes);
-  const router = createBrowserRouter(mergedRoutes, {
-    //@ts-ignore
-    hydrationData: payload,
-    basename,
-    dataStrategy: async (context) => {
-      const { request, matches } = context;
-      const results = {};
-      const clientMatches = matches.filter((match) => match.route.hasClientLoader);
-      const fetchPromise = fetch(request.url, {
-        headers: {
-          "x-rsc-tree": "true"
-        }
-      });
-      const clientLoadersPromise = clientMatches.length > 0 ? Promise.all(clientMatches.map(async (clientMatch) => {
-        const foundRoute = findRouteInTree(originalRoutes, clientMatch.route.id);
-        clientMatch.route.loader = foundRoute === null || foundRoute === void 0 ? void 0 : foundRoute.loader;
-        const res2 = await clientMatch.resolve();
-        return {
-          routeId: clientMatch.route.id,
-          result: res2
-        };
-      })) : Promise.resolve([]);
-      const res = await fetchPromise;
-      const redirectLocation = res.headers.get("X-Modernjs-Redirect");
-      if (redirectLocation) {
-        matches.forEach((match) => {
-          const routeId = match.route.id;
-          if (routeId) {
-            results[routeId] = {
-              type: "redirect",
-              result: redirect(redirectLocation)
-            };
-          }
-        });
-        return results;
-      }
-      const [clientLoaderResults] = await Promise.all([
-        clientLoadersPromise
-      ]);
-      clientLoaderResults.forEach(({ routeId, result }) => {
-        results[routeId] = result;
-      });
-      const payload2 = await createFromReadableStream(res.body);
-      if (typeof payload2.type === "undefined" || payload2.type !== "render") {
-        throw new Error("Unexpected payload type");
-      }
-      matches.forEach((match) => {
-        var _payload_loaderData;
-        const routeId = match.route.id;
-        const matchedRoute = payload2.routes.find((route) => route.id === routeId);
-        if (matchedRoute) {
-          router.patchRoutes(matchedRoute.parentId, [
-            matchedRoute
-          ], true);
-        }
-        if ((_payload_loaderData = payload2.loaderData) === null || _payload_loaderData === void 0 ? void 0 : _payload_loaderData[routeId]) {
-          results[routeId] = {
-            type: "data",
-            result: payload2.loaderData[routeId]
-          };
-        }
-      });
-      return results;
-    }
-  });
-  return router;
-};
-const createRSCStaticRouterComponent = (payload, basename) => {
-  const routerContext = {
-    actionData: payload.actionData,
-    actionHeaders: {},
-    activeDeferreds: {},
-    basename: basename || "",
-    errors: payload.errors,
-    loaderData: payload.loaderData,
-    loaderHeaders: {},
-    location: payload.location,
-    statusCode: 200,
-    matches: payload.routes.map((match) => ({
-      params: match.params,
-      pathname: match.pathname,
-      pathnameBase: match.pathnameBase,
-      route: {
-        id: match.id,
-        action: match.hasAction || !!match.clientAction,
-        handle: match.handle,
-        hasErrorBoundary: match.hasErrorBoundary,
-        loader: match.hasLoader || !!match.clientLoader,
-        index: match.index,
-        path: match.path,
-        shouldRevalidate: match.shouldRevalidate
-      }
-    }))
-  };
-  const processedRoutes = payload.routes.reduceRight((previous, route) => {
-    if (previous.length > 0) {
-      return [
-        {
-          ...route,
-          children: previous
-        }
-      ];
-    }
-    return [
-      route
-    ];
-  }, []);
-  const router = createStaticRouter(processedRoutes, routerContext);
-  return /* @__PURE__ */ _jsx(StaticRouterProvider, {
-    context: routerContext,
-    router,
-    hydrate: false
-  });
-};
-const RSCStaticRouter = ({ basename }) => {
-  const payload = safeUse(safeUse(ElementsContext));
-  if (!payload || payload.type !== "render") {
-    return null;
-  }
-  return /* @__PURE__ */ _jsx(_Fragment, {
-    children: createRSCStaticRouterComponent(payload, basename)
-  });
-};
-export {
-  RSCStaticRouter,
-  createClientRouterFromPayload,
-  createServerPayload,
-  handleRSCRedirect,
-  prepareRSCRoutes
-};

package/dist/esm-node/router/runtime/server.js

@@ -1 +0,0 @@
-export * from "@modern-js/runtime-utils/node/router";

package/dist/esm-node/router/runtime/utils.js

@@ -1,218 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { renderNestedRoute } from "@modern-js/runtime-utils/browser";
-import { UNSAFE_ErrorResponseImpl as ErrorResponseImpl } from "@modern-js/runtime-utils/remix-router";
-import { Route, isRouteErrorResponse } from "@modern-js/runtime-utils/router";
-import React from "react";
-import { DefaultNotFound } from "./DefaultNotFound";
-import DeferredDataScripts from "./DeferredDataScripts";
-function getRouteComponents(routes, { globalApp, ssrMode, props }) {
-  const Layout = ({ Component, ...props2 }) => {
-    const GlobalLayout = globalApp;
-    if (!GlobalLayout) {
-      return /* @__PURE__ */ _jsx(Component, {
-        ...props2
-      });
-    }
-    return /* @__PURE__ */ _jsx(GlobalLayout, {
-      Component,
-      ...props2
-    });
-  };
-  const routeElements = [];
-  for (const route of routes) {
-    if (route.type === "nested") {
-      const routeElement = renderNestedRoute(route, {
-        DeferredDataComponent: ssrMode === "stream" ? DeferredDataScripts : void 0,
-        props
-      });
-      routeElements.push(routeElement);
-    } else {
-      const routeElement = /* @__PURE__ */ _jsx(Route, {
-        path: route.path,
-        element: /* @__PURE__ */ _jsx(Layout, {
-          Component: route.component
-        })
-      }, route.path);
-      routeElements.push(routeElement);
-    }
-  }
-  routeElements.push(/* @__PURE__ */ _jsx(Route, {
-    path: "*",
-    element: /* @__PURE__ */ _jsx(DefaultNotFound, {})
-  }, "*"));
-  return routeElements;
-}
-function getRouteObjects(routes, { globalApp, ssrMode, props }) {
-  const createLayoutElement = (Component) => {
-    const GlobalLayout = globalApp;
-    if (!GlobalLayout) {
-      return Component;
-    }
-    const LayoutWrapper = (props2) => {
-      const LayoutComponent = GlobalLayout;
-      return /* @__PURE__ */ _jsx(LayoutComponent, {
-        Component,
-        ...props2
-      });
-    };
-    return LayoutWrapper;
-  };
-  const routeObjects = [];
-  for (const route of routes) {
-    if (route.type === "nested") {
-      var _route_config;
-      const nestedRouteObject = {
-        path: route.path,
-        id: route.id,
-        loader: route.loader,
-        action: route.action,
-        hasErrorBoundary: route.hasErrorBoundary,
-        shouldRevalidate: route.shouldRevalidate,
-        handle: {
-          ...route.handle,
-          ...typeof route.config === "object" ? (_route_config = route.config) === null || _route_config === void 0 ? void 0 : _route_config.handle : {}
-        },
-        index: route.index,
-        hasClientLoader: !!route.clientData,
-        Component: route.component ? route.component : void 0,
-        errorElement: route.error ? /* @__PURE__ */ _jsx(route.error, {}) : void 0,
-        children: route.children ? route.children.map((child) => getRouteObjects([
-          child
-        ], {
-          globalApp,
-          ssrMode,
-          props
-        })[0]) : void 0
-      };
-      routeObjects.push(nestedRouteObject);
-    } else {
-      if (typeof route.component === "function" || typeof route.component === "object") {
-        const LayoutComponent = createLayoutElement(route.component);
-        const routeObject = {
-          path: route.path,
-          element: /* @__PURE__ */ React.createElement(LayoutComponent)
-        };
-        routeObjects.push(routeObject);
-      }
-    }
-  }
-  routeObjects.push({
-    path: "*",
-    element: /* @__PURE__ */ _jsx(DefaultNotFound, {})
-  });
-  return routeObjects;
-}
-function createRouteObjectsFromConfig({ routesConfig, props, ssrMode }) {
-  if (!routesConfig) {
-    return null;
-  }
-  const { routes, globalApp } = routesConfig;
-  if (!routes) {
-    return null;
-  }
-  return getRouteObjects(routes, {
-    globalApp,
-    ssrMode,
-    props
-  });
-}
-function renderRoutes({ routesConfig, props, ssrMode }) {
-  if (!routesConfig) {
-    return null;
-  }
-  const { routes, globalApp } = routesConfig;
-  if (!routes) {
-    return null;
-  }
-  const routeElements = getRouteComponents(routes, {
-    globalApp,
-    ssrMode,
-    props
-  });
-  return routeElements;
-}
-function getLocation(serverContext) {
-  var _url_replace;
-  const { pathname = "", url = "" } = (serverContext === null || serverContext === void 0 ? void 0 : serverContext.request) || {};
-  const cleanUrl = url === null || url === void 0 ? void 0 : (_url_replace = url.replace("http://", "")) === null || _url_replace === void 0 ? void 0 : _url_replace.replace("https://", "");
-  const index = (cleanUrl || "").indexOf(pathname);
-  if (index === -1) {
-    return pathname;
-  }
-  return cleanUrl.substring(index);
-}
-const urlJoin = (...parts) => {
-  const separator = "/";
-  const replace = new RegExp(`${separator}{1,}`, "g");
-  return standardSlash(parts.join(separator).replace(replace, separator));
-};
-function standardSlash(str) {
-  let addr = str;
-  if (!addr || typeof addr !== "string") {
-    return addr;
-  }
-  if (addr.startsWith(".")) {
-    addr = addr.slice(1);
-  }
-  if (!addr.startsWith("/")) {
-    addr = `/${addr}`;
-  }
-  if (addr.endsWith("/") && addr !== "/") {
-    addr = addr.slice(0, addr.length - 1);
-  }
-  return addr;
-}
-function serializeErrors(errors) {
-  if (!errors) {
-    return null;
-  }
-  const entries = Object.entries(errors);
-  const serialized = {};
-  for (const [key, val] of entries) {
-    if (isRouteErrorResponse(val)) {
-      serialized[key] = {
-        ...val,
-        __type: "RouteErrorResponse"
-      };
-    } else if (val instanceof Error) {
-      serialized[key] = {
-        message: val.message,
-        stack: val.stack,
-        __type: "Error"
-      };
-    } else {
-      serialized[key] = val;
-    }
-  }
-  return serialized;
-}
-function deserializeErrors(errors) {
-  if (!errors) {
-    return null;
-  }
-  const entries = Object.entries(errors);
-  const serialized = {};
-  for (const [key, val] of entries) {
-    if (val && val.__type === "RouteErrorResponse") {
-      serialized[key] = new ErrorResponseImpl(val.status, val.statusText, val.data, val.internal === true);
-    } else if (val && val.__type === "Error") {
-      const error = new Error(val.message);
-      error.stack = val.stack;
-      serialized[key] = error;
-    } else {
-      serialized[key] = val;
-    }
-  }
-  return serialized;
-}
-export {
-  createRouteObjectsFromConfig,
-  deserializeErrors,
-  getLocation,
-  getRouteComponents,
-  getRouteObjects,
-  renderRoutes,
-  serializeErrors,
-  standardSlash,
-  urlJoin
-};

package/dist/esm-node/router/runtime/withRouter.js

@@ -1,18 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { useLocation, useNavigate, useParams } from "@modern-js/runtime-utils/router";
-const withRouter = (Component) => {
-  return (props) => {
-    const location = useLocation();
-    const params = useParams();
-    const navigate = useNavigate();
-    return /* @__PURE__ */ _jsx(Component, {
-      ...props,
-      location,
-      params,
-      navigate
-    });
-  };
-};
-export {
-  withRouter
-};

package/dist/esm-node/rsc/client.js

@@ -1,7 +0,0 @@
-export * from "@modern-js/render/client";
-const isRedirectResponse = (res) => {
-  return res.headers.get("X-Modernjs-Redirect") != null;
-};
-export {
-  isRedirectResponse
-};

package/dist/esm-node/rsc/server.js

@@ -1,36 +0,0 @@
-export * from "@modern-js/render/rsc";
-async function processRSCStream(rscStream, controller, encoder) {
-  try {
-    const reader = rscStream.getReader();
-    const decoder = new TextDecoder("utf-8", {
-      fatal: true
-    });
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done)
-        break;
-      try {
-        const chunk = JSON.stringify(decoder.decode(value, {
-          stream: true
-        }));
-        const scriptTag = `<script>(self.__FLIGHT_DATA||=[]).push(${chunk})</script>`;
-        controller.enqueue(encoder.encode(scriptTag));
-      } catch (err) {
-        const base64 = JSON.stringify(btoa(String.fromCodePoint(...value)));
-        const scriptTag = `<script>(self.__FLIGHT_DATA||=[]).push(Uint8Array.from(atob(${base64}), m => m.codePointAt(0)))</script>`;
-        controller.enqueue(encoder.encode(scriptTag));
-      }
-    }
-    const remaining = decoder.decode();
-    if (remaining.length) {
-      const scriptTag = `<script>(self.__FLIGHT_DATA||=[]).push(${JSON.stringify(remaining)})</script>`;
-      controller.enqueue(encoder.encode(scriptTag));
-    }
-    controller.close();
-  } catch (error) {
-    controller.error(error);
-  }
-}
-export {
-  processRSCStream
-};

package/dist/types/cli/ssr/babel-plugin-ssr-loader-id.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/types/config.d.ts

@@ -1,6 +0,0 @@
-import type { RouterConfig } from './router/internal';
-export interface RuntimeUserConfig {
-    runtime?: {
-        router?: boolean | RouterConfig;
-    };
-}

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

@@ -1,24 +0,0 @@
-import type { RuntimePlugin } from '@modern-js/plugin-v2';
-import React from 'react';
-import type { Renderer } from 'react-dom';
-import type { createRoot, hydrateRoot } from 'react-dom/client';
-import { type RuntimeContext, type TRuntimeContext } from './context/runtime';
-import { type Plugin } from './plugin';
-import type { RuntimeExtends } from './plugin/types';
-export type CreateAppOptions = {
-    plugins: (Plugin | RuntimePlugin<RuntimeExtends>)[];
-    /**
-     * In the test cases, we need to execute multiple createApp instances simultaneously, and they must not share the runtime.
-     */
-    props?: any;
-};
-export declare const createApp: ({ plugins, props: globalProps, }: CreateAppOptions) => (App?: React.ComponentType<any>) => (props: any) => React.JSX.Element;
-type BootStrap<T = unknown> = (App: React.ComponentType, id: string | HTMLElement | RuntimeContext, root?: any, ReactDOM?: {
-    render?: Renderer;
-    hydrate?: Renderer;
-    createRoot?: typeof createRoot;
-    hydrateRoot?: typeof hydrateRoot;
-}) => Promise<T>;
-export declare const bootstrap: BootStrap;
-export declare const useRuntimeContext: () => TRuntimeContext;
-export {};

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

@@ -1 +0,0 @@
-export { default as useLoader } from './useLoader';

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

@@ -1,56 +0,0 @@
-import type { LoaderOptions } from './useLoader';
-export declare enum LoaderStatus {
-    idle = 0,
-    loading = 1,
-    fulfilled = 2,
-    rejected = 3
-}
-export type LoaderResult = {
-    loading: boolean;
-    reloading: boolean;
-    data: any;
-    error: any;
-    _error?: any;
-};
-declare const createLoader: (id: string, initialData?: Partial<LoaderResult>, loaderFn?: () => Promise<any>, skip?: boolean) => {
-    readonly result: {
-        loading: boolean;
-        reloading: boolean;
-        data: any;
-        error: any;
-        _error: any;
-    };
-    readonly promise: Promise<any> | null;
-    onChange: (handler: (status: LoaderStatus, result: LoaderResult) => void) => () => void;
-    load: () => Promise<any>;
-};
-type ManagerOption = {
-    /**
-     * whether current manage only exec static loader
-     */
-    skipStatic?: boolean;
-    skipNonStatic?: boolean;
-};
-/**
- * Create loaders manager. It's returned instance will add to context
- * @param initialDataMap used to initialing loader data
- */
-export declare const createLoaderManager: (initialDataMap: Record<string, LoaderResult>, managerOptions?: ManagerOption) => {
-    hasPendingLoaders: () => boolean;
-    awaitPendingLoaders: () => Promise<Record<string, LoaderResult>>;
-    add: (loaderFn: () => Promise<any>, loaderOptions: LoaderOptions) => any;
-    get: (id: string) => {
-        readonly result: {
-            loading: boolean;
-            reloading: boolean;
-            data: any;
-            error: any;
-            _error: any;
-        };
-        readonly promise: Promise<any> | null;
-        onChange: (handler: (status: LoaderStatus, result: LoaderResult) => void) => () => void;
-        load: () => Promise<any>;
-    } | undefined;
-};
-export type Loader = ReturnType<typeof createLoader>;
-export {};