@modern-js/runtime 1.4.4 → 1.16.0

package/dist/js/treeshaking/ssr/react/withCallback/index.js

@@ -0,0 +1,16 @@
+// See https://github.com/reactwg/react-18/discussions/5#discussioncomment-2276079
+import { useRef, useLayoutEffect } from 'react';
+export var WithCallback = function WithCallback(_ref) {
+  var callback = _ref.callback,
+      children = _ref.children;
+  var once = useRef(false);
+  useLayoutEffect(function () {
+    if (once.current) {
+      return;
+    }
+
+    once.current = true;
+    callback();
+  }, [callback]);
+  return children;
+};

package/dist/js/treeshaking/ssr/serverRender/helmet.js

@@ -2,8 +2,8 @@
 var RE_HTML_ATTR = /<html[^>]*>/;
 var RE_BODY_ATTR = /<body[^>]*>/;
 var RE_LAST_IN_HEAD = /<\/head>/;
-var RE_TITLE = /<title[^>]*>([\s\S\n\r]*?)<\/title>/g;
-var TEST_TITLE_CONTENT = /(?<=<title[^>]*>)([\s\S\n\r]*?)([.|\S])([\s\S\n\r]*?)(?=<\/title>)/g; // 通过 react-helmet 修改模板
+var RE_TITLE = /<title[^>]*>([\s\S\n\r]*?)<\/title>/;
+var TEST_TITLE_CONTENT = /(?<=<title[^>]*>)([\s\S\n\r]*?)([.|\S])([\s\S\n\r]*?)(?=<\/title>)/; // 通过 react-helmet 修改模板
 
 export default function helmet(content, helmetData) {
   var result = content;

package/dist/js/treeshaking/ssr/serverRender/index.js

@@ -1,7 +1,7 @@
 import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
 import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
-import { RuntimeContext } from '@modern-js/runtime-core';
 import { run } from '@modern-js/utils/ssr';
+import { RuntimeContext } from "../../core";
 import { PreRender } from "../react/prerender";
 import SSREntry from "./entry";
 import { time } from "./measure";

package/dist/js/treeshaking/ssr/serverRender/styledComponent.js

@@ -1,4 +1,4 @@
-import { ServerStyleSheet } from '@modern-js/runtime-core/styled';
+import { ServerStyleSheet } from 'styled-components';
 export var toHtml = function toHtml(jsx, renderer, next) {
   var sheet = new ServerStyleSheet();
   var html = next(sheet.collectStyles(jsx));

package/dist/js/treeshaking/ssr/utils.js

@@ -22,20 +22,25 @@ var getQuery = function getQuery() {
         key = _item$split2[0],
         value = _item$split2[1];
 
-    res[key] = value;
+    if (key) {
+      res[key] = value;
+    }
+
     return res;
   }, {});
 };
 
 export var formatClient = function formatClient(request) {
+  var _request$headers, _request$headers2;
+
   return {
     params: request.params || {},
     host: request.host || location.host,
     pathname: request.pathname || location.pathname,
     headers: request.headers || {},
     cookieMap: request.cookieMap || {},
-    cookie: request.headers.cookie || document.cookie,
-    userAgent: request.headers['user-agent'] || navigator.userAgent,
+    cookie: ((_request$headers = request.headers) === null || _request$headers === void 0 ? void 0 : _request$headers.cookie) || document.cookie,
+    userAgent: ((_request$headers2 = request.headers) === null || _request$headers2 === void 0 ? void 0 : _request$headers2['user-agent']) || navigator.userAgent,
     referer: request.referer || document.referrer,
     query: request.query || getQuery(),
     url: location.href

package/dist/js/treeshaking/state/runtime/plugin.js

@@ -1,9 +1,9 @@
 import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
 import { useContext } from 'react';
-import { RuntimeReactContext } from '@modern-js/runtime-core';
 import { createStore } from '@modern-js-reduck/store';
 import { Provider } from '@modern-js-reduck/react';
 import hoistNonReactStatics from 'hoist-non-react-statics';
+import { RuntimeReactContext } from "../../core";
 import { isBrowser } from "../../common";
 import { jsx as _jsx } from "react/jsx-runtime";
 

package/dist/types/core/app-config.d.ts

@@ -0,0 +1,6 @@
+import type React from 'react';
+export interface AppConfig {
+  [key: string]: any;
+}
+export declare const getConfig: (Component: React.ComponentType<any>) => AppConfig | undefined;
+export declare const defineConfig: (Component: React.ComponentType<any>, config: AppConfig) => React.ComponentType<any>;

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

@@ -0,0 +1,17 @@
+import React from 'react';
+import { Plugin } from './plugin';
+import { TRuntimeContext } from './runtime-context';
+export declare type CreateAppOptions = {
+  plugins: Plugin[];
+};
+export declare const createApp: ({
+  plugins
+}: CreateAppOptions) => (App?: React.ComponentType<any>) => React.ComponentType<any>;
+interface HydrateFunc {
+  (container: Element | Document, initialChildren: React.ReactNode): void;
+  (initialChildren: React.ReactNode, container: Element | Document, callback?: () => void): void;
+}
+declare type BootStrap<T = unknown> = (App: React.ComponentType, id?: string | Record<string, any> | HTMLElement, root?: any, render?: (children: React.ReactNode, rootElement?: HTMLElement) => void, hydrate?: HydrateFunc) => Promise<T>;
+export declare const bootstrap: BootStrap;
+export declare const useRuntimeContext: () => TRuntimeContext;
+export {};

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

@@ -0,0 +1,9 @@
+export { createPlugin, createRuntime, runtime, registerInit, registerPrefetch } from './plugin';
+export type { Plugin } from './plugin';
+export { defineConfig, getConfig } from './app-config';
+export type { AppConfig } from './app-config';
+export * from './compatible';
+export type { TRuntimeContext, RuntimeContext } from './runtime-context';
+export { RuntimeReactContext } from './runtime-context';
+export * from './loader';
+export * from '@modern-js/plugin';

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

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

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

@@ -0,0 +1,57 @@
+import { LoaderOptions } from './useLoader';
+export declare enum LoaderStatus {
+  idle = 0,
+  loading = 1,
+  fulfilled = 2,
+  rejected = 3,
+}
+export declare 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>;
+};
+declare 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 declare type Loader = ReturnType<typeof createLoader>;
+export {};

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

@@ -0,0 +1,54 @@
+import { LoaderResult } from './loaderManager';
+export interface SSRData {
+  loadersData: Record<string, LoaderResult | undefined>;
+  initialData?: Record<string, unknown>;
+}
+export interface SSRContainer {
+  data?: SSRData;
+}
+declare global {
+  interface Window {
+    _SSR_DATA?: SSRContainer;
+  }
+}
+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;
+}
+declare type LoaderFn<P = any, T = any> = (context: any, params: P) => Promise<T>;
+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;
+};
+export default useLoader;

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

@@ -0,0 +1,215 @@
+import type React from 'react';
+import { Setup, ToThreads, CommonAPI, PluginOptions } from '@modern-js/plugin';
+import type { RuntimeContext, TRuntimeContext } from './runtime-context';
+export interface AppProps {}
+declare const runtimeHooks: {
+  hoc: import("@modern-js/plugin").Pipeline<{
+    App: React.ComponentType<any>;
+  }, React.ComponentType<any>>;
+  provide: import("@modern-js/plugin").Pipeline<{
+    element: JSX.Element;
+    readonly props: AppProps;
+    readonly context: RuntimeContext;
+  }, JSX.Element>;
+  client: import("@modern-js/plugin").AsyncPipeline<{
+    App: React.ComponentType<any>;
+    readonly context?: RuntimeContext | undefined;
+    ModernRender: (App: React.ReactNode) => void;
+    ModernHydrate: (App: React.ReactNode, callback?: () => void) => void;
+  }, void>;
+  server: import("@modern-js/plugin").AsyncPipeline<{
+    App: React.ComponentType<any>;
+    readonly context?: RuntimeContext | undefined;
+  }, string>;
+  init: import("@modern-js/plugin").AsyncPipeline<{
+    context: RuntimeContext;
+  }, unknown>;
+  pickContext: import("@modern-js/plugin").Pipeline<{
+    context: RuntimeContext;
+    pickedContext: TRuntimeContext;
+  }, TRuntimeContext>;
+};
+/** All hooks of runtime plugin. */
+
+export declare type RuntimeHooks = typeof runtimeHooks;
+/** All hook callbacks of runtime plugin. */
+
+export declare type RuntimeHookCallbacks = ToThreads<RuntimeHooks>;
+/** All apis for runtime plugin. */
+
+export declare type PluginAPI = CommonAPI<RuntimeHooks>;
+/** Plugin options of a runtime plugin. */
+
+export declare type Plugin = PluginOptions<RuntimeHooks, Setup<RuntimeHooks>>;
+export declare const createRuntime: () => import("@modern-js/plugin").Manager<{
+  hoc: import("@modern-js/plugin").Pipeline<{
+    App: React.ComponentType<any>;
+  }, React.ComponentType<any>>;
+  provide: import("@modern-js/plugin").Pipeline<{
+    element: JSX.Element;
+    readonly props: AppProps;
+    readonly context: RuntimeContext;
+  }, JSX.Element>;
+  client: import("@modern-js/plugin").AsyncPipeline<{
+    App: React.ComponentType<any>;
+    readonly context?: RuntimeContext | undefined;
+    ModernRender: (App: React.ReactNode) => void;
+    ModernHydrate: (App: React.ReactNode, callback?: () => void) => void;
+  }, void>;
+  server: import("@modern-js/plugin").AsyncPipeline<{
+    App: React.ComponentType<any>;
+    readonly context?: RuntimeContext | undefined;
+  }, string>;
+  init: import("@modern-js/plugin").AsyncPipeline<{
+    context: RuntimeContext;
+  }, unknown>;
+  pickContext: import("@modern-js/plugin").Pipeline<{
+    context: RuntimeContext;
+    pickedContext: TRuntimeContext;
+  }, TRuntimeContext>;
+}, Record<string, never>>;
+/**
+ * register init hook. It would be revoked both ssr and csr.
+ */
+
+declare const registerInit: (App: React.ComponentType, _init: (context: RuntimeContext) => any | Promise<any>) => void;
+/**
+ * register prefetch hook. It would be revoked both ssr and csr.
+ * But if ssr success, It wont exec in csr again.
+ * If ssr prefetch failed, It will fallback to exec in csr.
+ */
+
+declare const registerPrefetch: (App: React.ComponentType, prefetch: (context: RuntimeContext) => Promise<any>) => void;
+export declare const runtime: import("@modern-js/plugin").Manager<{
+  hoc: import("@modern-js/plugin").Pipeline<{
+    App: React.ComponentType<any>;
+  }, React.ComponentType<any>>;
+  provide: import("@modern-js/plugin").Pipeline<{
+    element: JSX.Element;
+    readonly props: AppProps;
+    readonly context: RuntimeContext;
+  }, JSX.Element>;
+  client: import("@modern-js/plugin").AsyncPipeline<{
+    App: React.ComponentType<any>;
+    readonly context?: RuntimeContext | undefined;
+    ModernRender: (App: React.ReactNode) => void;
+    ModernHydrate: (App: React.ReactNode, callback?: () => void) => void;
+  }, void>;
+  server: import("@modern-js/plugin").AsyncPipeline<{
+    App: React.ComponentType<any>;
+    readonly context?: RuntimeContext | undefined;
+  }, string>;
+  init: import("@modern-js/plugin").AsyncPipeline<{
+    context: RuntimeContext;
+  }, unknown>;
+  pickContext: import("@modern-js/plugin").Pipeline<{
+    context: RuntimeContext;
+    pickedContext: TRuntimeContext;
+  }, TRuntimeContext>;
+}, Record<string, never>>;
+export declare const createPlugin: (setup?: Setup<{
+  hoc: import("@modern-js/plugin").Pipeline<{
+    App: React.ComponentType<any>;
+  }, React.ComponentType<any>>;
+  provide: import("@modern-js/plugin").Pipeline<{
+    element: JSX.Element;
+    readonly props: AppProps;
+    readonly context: RuntimeContext;
+  }, JSX.Element>;
+  client: import("@modern-js/plugin").AsyncPipeline<{
+    App: React.ComponentType<any>;
+    readonly context?: RuntimeContext | undefined;
+    ModernRender: (App: React.ReactNode) => void;
+    ModernHydrate: (App: React.ReactNode, callback?: () => void) => void;
+  }, void>;
+  server: import("@modern-js/plugin").AsyncPipeline<{
+    App: React.ComponentType<any>;
+    readonly context?: RuntimeContext | undefined;
+  }, string>;
+  init: import("@modern-js/plugin").AsyncPipeline<{
+    context: RuntimeContext;
+  }, unknown>;
+  pickContext: import("@modern-js/plugin").Pipeline<{
+    context: RuntimeContext;
+    pickedContext: TRuntimeContext;
+  }, TRuntimeContext>;
+}, Record<string, never>> | undefined, options?: PluginOptions<{
+  hoc: import("@modern-js/plugin").Pipeline<{
+    App: React.ComponentType<any>;
+  }, React.ComponentType<any>>;
+  provide: import("@modern-js/plugin").Pipeline<{
+    element: JSX.Element;
+    readonly props: AppProps;
+    readonly context: RuntimeContext;
+  }, JSX.Element>;
+  client: import("@modern-js/plugin").AsyncPipeline<{
+    App: React.ComponentType<any>;
+    readonly context?: RuntimeContext | undefined;
+    ModernRender: (App: React.ReactNode) => void;
+    ModernHydrate: (App: React.ReactNode, callback?: () => void) => void;
+  }, void>;
+  server: import("@modern-js/plugin").AsyncPipeline<{
+    App: React.ComponentType<any>;
+    readonly context?: RuntimeContext | undefined;
+  }, string>;
+  init: import("@modern-js/plugin").AsyncPipeline<{
+    context: RuntimeContext;
+  }, unknown>;
+  pickContext: import("@modern-js/plugin").Pipeline<{
+    context: RuntimeContext;
+    pickedContext: TRuntimeContext;
+  }, TRuntimeContext>;
+}, Setup<{
+  hoc: import("@modern-js/plugin").Pipeline<{
+    App: React.ComponentType<any>;
+  }, React.ComponentType<any>>;
+  provide: import("@modern-js/plugin").Pipeline<{
+    element: JSX.Element;
+    readonly props: AppProps;
+    readonly context: RuntimeContext;
+  }, JSX.Element>;
+  client: import("@modern-js/plugin").AsyncPipeline<{
+    App: React.ComponentType<any>;
+    readonly context?: RuntimeContext | undefined;
+    ModernRender: (App: React.ReactNode) => void;
+    ModernHydrate: (App: React.ReactNode, callback?: () => void) => void;
+  }, void>;
+  server: import("@modern-js/plugin").AsyncPipeline<{
+    App: React.ComponentType<any>;
+    readonly context?: RuntimeContext | undefined;
+  }, string>;
+  init: import("@modern-js/plugin").AsyncPipeline<{
+    context: RuntimeContext;
+  }, unknown>;
+  pickContext: import("@modern-js/plugin").Pipeline<{
+    context: RuntimeContext;
+    pickedContext: TRuntimeContext;
+  }, TRuntimeContext>;
+}, Record<string, never>>> | undefined) => import("@modern-js/plugin").Plugin<{
+  hoc: import("@modern-js/plugin").Pipeline<{
+    App: React.ComponentType<any>;
+  }, React.ComponentType<any>>;
+  provide: import("@modern-js/plugin").Pipeline<{
+    element: JSX.Element;
+    readonly props: AppProps;
+    readonly context: RuntimeContext;
+  }, JSX.Element>;
+  client: import("@modern-js/plugin").AsyncPipeline<{
+    App: React.ComponentType<any>;
+    readonly context?: RuntimeContext | undefined;
+    ModernRender: (App: React.ReactNode) => void;
+    ModernHydrate: (App: React.ReactNode, callback?: () => void) => void;
+  }, void>;
+  server: import("@modern-js/plugin").AsyncPipeline<{
+    App: React.ComponentType<any>;
+    readonly context?: RuntimeContext | undefined;
+  }, string>;
+  init: import("@modern-js/plugin").AsyncPipeline<{
+    context: RuntimeContext;
+  }, unknown>;
+  pickContext: import("@modern-js/plugin").Pipeline<{
+    context: RuntimeContext;
+    pickedContext: TRuntimeContext;
+  }, TRuntimeContext>;
+}, Record<string, never>>;
+export { registerInit, registerPrefetch };

package/dist/types/core/runtime-context.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="react" />
+import { createLoaderManager } from './loader/loaderManager';
+import { runtime } from './plugin';
+export interface RuntimeContext {
+  loaderManager: ReturnType<typeof createLoaderManager>;
+  runner: ReturnType<typeof runtime.init>;
+  [key: string]: any;
+}
+export declare const RuntimeReactContext: import("react").Context<RuntimeContext>;
+export interface TRuntimeContext {
+  initialData?: Record<string, unknown>;
+  [key: string]: any;
+}

package/dist/types/exports/styled.d.ts

@@ -1,3 +1,3 @@
-import styled from '@modern-js/runtime-core/styled';
+import styled from 'styled-components';
 export default styled;
-export * from '@modern-js/runtime-core/styled';
+export * from 'styled-components';

package/dist/types/index.d.ts

@@ -1,16 +1,11 @@
 import type { StateConfig } from './state';
 import type { RouterConfig } from './router';
-export type { RuntimeContext, TRuntimeContext } from '@modern-js/runtime-core';
-export { createApp, createPlugin, useLoader, bootstrap, RuntimeReactContext, registerPrefetch, defineConfig, registerInit, useRuntimeContext } from '@modern-js/runtime-core';
-declare module '@modern-js/runtime-core' {
+export type { Plugin, RuntimeContext, TRuntimeContext, AppConfig } from './core';
+export { createApp, createPlugin, useLoader, bootstrap, RuntimeReactContext, registerPrefetch, defineConfig, registerInit, useRuntimeContext } from './core';
+export { StateConfig, RouterConfig };
+declare module './core' {
   interface AppConfig {
     router?: RouterConfig | boolean;
     state?: StateConfig | boolean;
   }
-}
-declare module '@modern-js/core' {
-  interface RuntimeConfig {
-    router?: RouterConfig | boolean;
-    state?: StateConfig | boolean;
-  }
 }

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

@@ -1,7 +1,7 @@
 import React from 'react';
 import { History, BrowserHistoryBuildOptions, HashHistoryBuildOptions } from 'history';
 import { RouteProps } from 'react-router-dom';
-import type { Plugin } from '@modern-js/runtime-core';
+import type { Plugin } from '../../core';
 declare global {
   interface Window {
     _SERVER_DATA?: {

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

@@ -1,6 +1,6 @@
-import type { Plugin } from '@modern-js/runtime-core';
+import type { Plugin } from '../core';
 import { RenderLevel, SSRServerContext } from './serverRender/type';
-declare module '@modern-js/runtime-core' {
+declare module '../core' {
   interface RuntimeContext {
     ssrContext: SSRServerContext;
   }

package/dist/types/ssr/index.node.d.ts

@@ -1,4 +1,4 @@
-import type { Plugin } from '@modern-js/runtime-core';
+import type { Plugin } from '../core';
 declare const plugin: () => Plugin;
 export default plugin;
 export * from './react';

package/dist/types/ssr/prefetch.d.ts

@@ -1,11 +1,11 @@
-import { RuntimeContext } from '@modern-js/runtime-core';
+import { RuntimeContext } from '../core';
 declare const prefetch: (App: React.ComponentType<any>, context: RuntimeContext) => Promise<{
   initialData: any;
   i18nData: any;
   loadersData?: undefined;
   storeState?: undefined;
 } | {
-  loadersData: Record<string, import("@modern-js/runtime-core/src/loader/loaderManager").LoaderResult>;
+  loadersData: Record<string, import("../core/loader/loaderManager").LoaderResult>;
   initialData: any;
   i18nData: any;
   storeState: any;

package/dist/types/ssr/react/nossr/index.d.ts

@@ -1,2 +1,2 @@
 import React from 'react';
-export declare const NoSSR: (props: React.PropsWithChildren<React.ReactNode>) => React.FunctionComponentElement<{}>;
+export declare const NoSSR: (props: React.PropsWithChildren<unknown>) => React.FunctionComponentElement<{}>;

package/dist/types/ssr/react/withCallback/index.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+export declare const WithCallback: React.FC<{
+  callback: () => void;
+  children: React.ReactElement;
+}>;

package/dist/types/ssr/serverRender/entry.d.ts

@@ -1,4 +1,4 @@
-import { RuntimeContext } from '@modern-js/runtime-core';
+import { RuntimeContext } from '../../core';
 import { ModernSSRReactComponent, SSRServerContext, RenderResult } from './type';
 declare type EntryOptions = {
   ctx: SSRServerContext;

package/dist/types/ssr/serverRender/index.d.ts

@@ -1,4 +1,4 @@
-import { RuntimeContext } from '@modern-js/runtime-core';
+import { RuntimeContext } from '../../core';
 import { ModernSSRReactComponent } from './type';
 declare module '@modern-js/runtime' {
   interface RuntimeContext {

package/dist/types/ssr/serverRender/type.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="react" />
-import type { RuntimeContext } from '@modern-js/runtime-core';
 import type { BaseSSRServerContext } from '@modern-js/types';
+import type { RuntimeContext } from '../../core';
 export declare enum RenderLevel {
   CLIENT_RENDER = 0,
   SERVER_PREFETCH = 1,

package/dist/types/state/runtime/plugin.d.ts

@@ -1,6 +1,6 @@
 import { createStore, Store } from '@modern-js-reduck/store';
-import type { Plugin } from '@modern-js/runtime-core';
-declare module '@modern-js/runtime-core' {
+import type { Plugin } from '../../core';
+declare module '../../core' {
   interface RuntimeContext {
     store: Store;
   }

package/lib/types.d.ts

@@ -0,0 +1,10 @@
+/// <reference path="../dist/types/index.d.ts" />
+
+import { RouterConfig, StateConfig } from "../dist/types";
+
+declare module '@modern-js/core' {
+    interface RuntimeConfig {
+      router?: RouterConfig | boolean;
+      state?: StateConfig | boolean;
+    }
+  }