@modern-js/runtime 2.40.0 → 2.42.0

package/dist/esm-node/ssr/serverRender/tracker.js

@@ -14,49 +14,52 @@ var SSRErrors;
   SSRErrors2[SSRErrors2["RENDER_SHELL"] = 4] = "RENDER_SHELL";
 })(SSRErrors || (SSRErrors = {}));
 const errors = {
-  [SSRErrors.PRERENDER]: {
-    reporter: "SSR Error - App Prerender",
+  [0]: {
+    reporter: "App Prerender",
     logger: "App Prerender",
     metrics: "app.prerender.error"
   },
-  [SSRErrors.USE_LOADER]: {
-    reporter: "SSR Error - App run useLoader",
+  [1]: {
+    reporter: "App run useLoader",
     logger: "App run useLoader",
     metrics: "app.useloader.error"
   },
-  [SSRErrors.RENDER_HTML]: {
-    reporter: "SSR Error - App Render To HTML",
+  [2]: {
+    reporter: "App Render To HTML",
     logger: "App Render To HTML",
     metrics: "app.render.html.error"
   },
-  [SSRErrors.RENDER_STREAM]: {
-    reporter: "SSR Error - App Render To Streaming",
+  [3]: {
+    reporter: "App Render To Streaming",
     logger: "An error occurs during streaming SSR",
     metrics: "app.render.streaming.error"
   },
-  [SSRErrors.RENDER_SHELL]: {
+  [4]: {
     metrics: "app.render.streaming.shell.error"
   }
 };
 const timings = {
-  [SSRTimings.PRERENDER]: {
+  [0]: {
     reporter: "ssr-prerender",
     serverTiming: "ssr-prerender",
     metrics: "app.prerender.cost",
     logger: "App Prerender cost = %d ms"
   },
-  [SSRTimings.RENDER_HTML]: {
+  [1]: {
     reporter: "ssr-render-html",
     serverTiming: "ssr-render-html",
     metrics: "app.render.html.cost",
     logger: "App Render To HTML cost = %d ms"
   },
-  [SSRTimings.RENDER_SHELL]: {
-    reporter: "ssr-render-shell"
+  [2]: {
+    reporter: "ssr-render-shell",
+    metrics: "app.render.shell.cost",
+    logger: "App Render To Shell cost = %d ms"
   },
-  [SSRTimings.USE_LOADER]: {
+  [3]: {
     reporter: "use-loader",
     serverTiming: "use-loader",
+    metrics: "app.useloader.cost",
     logger: "App run useLoader cost = %d ms"
   }
 };
@@ -67,7 +70,7 @@ function createSSRTracker({ reporter, serverTiming, metrics, logger }) {
     },
     trackError(key, e) {
       const { reporter: reporterContent, metrics: metricsContent, logger: loggerContent } = errors[key];
-      reporterContent && reporter.reportError(reporterContent, e);
+      reporterContent && reporter.reportError(`SSR Error - ${reporterContent}`, e);
       metricsContent && metrics.emitCounter(metricsContent, 1);
       loggerContent && logger.error(loggerContent, e);
     },

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

@@ -1,3 +1,3 @@
 import type { CliPlugin, AppTools } from '@modern-js/app-tools';
 export declare const runtimePlugin: () => CliPlugin<AppTools>;
-export default runtimePlugin;
+export default runtimePlugin;

package/dist/types/common.d.ts

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

package/dist/types/config.d.ts

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

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

@@ -1,4 +1,4 @@
 import type React from 'react';
 import { AppConfig } from '../common';
 export declare const getConfig: (Component: React.ComponentType<any>) => AppConfig | undefined;
-export declare const defineConfig: (Component: React.ComponentType<any>, config: AppConfig) => React.ComponentType<any>;
+export declare const defineConfig: (Component: React.ComponentType<any>, config: AppConfig) => React.ComponentType<any>;

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

@@ -4,19 +4,16 @@ import type { hydrateRoot, createRoot } from 'react-dom/client';
 import { RuntimeContext, TRuntimeContext } from '../runtimeContext';
 import { Plugin } from './plugin';
 export type CreateAppOptions = {
-  plugins: Plugin[];
-  props?: any;
+    plugins: Plugin[];
+    props?: any;
 };
-export declare const createApp: ({
-  plugins,
-  props: globalProps
-}: CreateAppOptions) => (App?: React.ComponentType<any>) => React.ComponentType<any>;
+export declare const createApp: ({ plugins, props: globalProps, }: CreateAppOptions) => (App?: React.ComponentType<any>) => React.ComponentType<any>;
 type BootStrap<T = unknown> = (App: React.ComponentType, id: string | HTMLElement | RuntimeContext, root?: any, ReactDOM?: {
-  render?: Renderer;
-  hydrate?: Renderer;
-  createRoot?: typeof createRoot;
-  hydrateRoot?: typeof hydrateRoot;
+    render?: Renderer;
+    hydrate?: Renderer;
+    createRoot?: typeof createRoot;
+    hydrateRoot?: typeof hydrateRoot;
 }) => Promise<T>;
 export declare const bootstrap: BootStrap;
 export declare const useRuntimeContext: () => TRuntimeContext;
-export {};
+export {};

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

@@ -6,4 +6,4 @@ export type { TRuntimeContext, RuntimeContext } from '../runtimeContext';
 export { RuntimeReactContext, ServerRouterContext } from '../runtimeContext';
 export * from './loader';
 export type { SSRData, SSRContainer } from './types';
-export * from '@modern-js/plugin';
+export * from '@modern-js/plugin';

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

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

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

@@ -1,56 +1,56 @@
 import { LoaderOptions } from './useLoader';
 export declare enum LoaderStatus {
-  idle = 0,
-  loading = 1,
-  fulfilled = 2,
-  rejected = 3,
+    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> | undefined, 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>;
+    _error?: any;
+};
+declare const createLoader: (id: string, initialData: Partial<LoaderResult> | undefined, 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;
+    /**
+     * 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;
+    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 {};
+export {};

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

@@ -1,36 +1,36 @@
 type LoaderFn<P = any, T = any> = (context: any, params: P) => Promise<T>;
 export interface LoaderOptions<Params = any, TData = any, TError extends Error = any> {
-  /**
-   * Revoke when loader excuted successfully.
-   */
-  onSuccess?: (data: TData) => void;
-  /**
-   * Revoke when loader ended with error
-   */
-  onError?: (error: TError) => void;
-  /**
-   * initialData to display once loader is ready.
-   */
-  initialData?: TData;
-  /**
-   * whether skip loader
-   * if true, the loader will not exec.
-   */
-  skip?: boolean;
-  /**
-   * User params, it will pass to loader's second parameter.
-   */
-  params?: Params;
-  /**
-   * whether loader can exec on build phase.
-   */
-  static?: boolean;
+    /**
+     * Revoke when loader excuted successfully.
+     */
+    onSuccess?: (data: TData) => void;
+    /**
+     * Revoke when loader ended with error
+     */
+    onError?: (error: TError) => void;
+    /**
+     * initialData to display once loader is ready.
+     */
+    initialData?: TData;
+    /**
+     * whether skip loader
+     * if true, the loader will not exec.
+     */
+    skip?: boolean;
+    /**
+     * User params, it will pass to loader's second parameter.
+     */
+    params?: Params;
+    /**
+     * whether loader can exec on build phase.
+     */
+    static?: boolean;
 }
 declare const useLoader: <TData = any, Params = any, E = any>(loaderFn: LoaderFn<Params, TData>, options?: LoaderOptions<Params, any, any>) => {
-  reload: (params?: Params | undefined) => Promise<any> | undefined;
-  loading: boolean;
-  reloading: boolean;
-  data: TData;
-  error: E;
+    reload: (params?: Params | undefined) => Promise<any> | undefined;
+    loading: boolean;
+    reloading: boolean;
+    data: TData;
+    error: E;
 };
-export default useLoader;
+export default useLoader;