@modern-js/runtime 2.0.0-canary.0 → 2.0.0

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

@@ -1,86 +1,198 @@
-import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
-import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
-import { useContext } from 'react';
-import { createStore } from '@modern-js-reduck/store';
-import { Provider } from '@modern-js-reduck/react';
-import hoistNonReactStatics from 'hoist-non-react-statics';
+function _arrayLikeToArray(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _arrayWithHoles(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _defineProperty(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _iterableToArrayLimit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _nonIterableRest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _objectSpread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _defineProperty(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _objectSpreadProps(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _slicedToArray(arr, i) {
+    return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+}
+function _unsupportedIterableToArray(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+import { jsx } from "react/jsx-runtime";
+import { useContext } from "react";
+import { createStore } from "@modern-js-reduck/store";
+import { Provider } from "@modern-js-reduck/react";
+import hoistNonReactStatics from "hoist-non-react-statics";
 import { immer, effects, autoActions, devtools } from "../plugins";
 import { RuntimeReactContext } from "../../core";
 import { isBrowser } from "../../common";
-import { jsx as _jsx } from "react/jsx-runtime";
 var StatePluginHandleMap = {
-  immer: immer,
-  effects: effects,
-  autoActions: autoActions,
-  devtools: devtools
+    immer: immer,
+    effects: effects,
+    autoActions: autoActions,
+    devtools: devtools
 };
-var getStoreConfig = function getStoreConfig(config) {
-  var internalPlugins = ['immer', 'effects', 'autoActions', 'devtools'];
-  var plugins = [];
-  internalPlugins.filter(function (plugin) {
-    return config[plugin] !== false;
-  }).forEach(function (plugin) {
-    return plugins.push(StatePluginHandleMap[plugin](config[plugin]));
-  });
-  var storeConfig = {};
-  for (var _i = 0, _Object$entries = Object.entries(config); _i < _Object$entries.length; _i++) {
-    var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
-      key = _Object$entries$_i[0],
-      value = _Object$entries$_i[1];
-    if (internalPlugins.includes(key)) {
-      plugins.push(StatePluginHandleMap[key](value));
-    } else {
-      storeConfig[key] = value;
+var getStoreConfig = function(config) {
+    var internalPlugins = [
+        "immer",
+        "effects",
+        "autoActions",
+        "devtools"
+    ];
+    var plugins = [];
+    internalPlugins.filter(function(plugin) {
+        return config[plugin] !== false;
+    }).forEach(function(plugin) {
+        return plugins.push(StatePluginHandleMap[plugin](config[plugin]));
+    });
+    var storeConfig = {};
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = Object.entries(config)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var _value = _slicedToArray(_step.value, 2), key = _value[0], value = _value[1];
+            if (!internalPlugins.includes(key)) {
+                storeConfig[key] = value;
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
     }
-  }
-  storeConfig.plugins = plugins;
-  return storeConfig;
+    storeConfig.plugins = plugins;
+    return storeConfig;
 };
-var state = function state(config) {
-  return {
-    name: '@modern-js/plugin-state',
-    setup: function setup() {
-      return {
-        hoc: function hoc(_ref, next) {
-          var App = _ref.App;
-          var getStateApp = function getStateApp(props) {
-            // eslint-disable-next-line react-hooks/rules-of-hooks
-            var context = useContext(RuntimeReactContext);
-            return /*#__PURE__*/_jsx(Provider, {
-              store: context.store,
-              config: getStoreConfig(config),
-              children: /*#__PURE__*/_jsx(App, _objectSpread({}, props))
-            });
-          };
-          return next({
-            App: hoistNonReactStatics(getStateApp, App)
-          });
-        },
-        init: function init(_ref2, next) {
-          var context = _ref2.context;
-          var storeConfig = getStoreConfig(config || {});
-          if (isBrowser()) {
-            var _window, _window$_SSR_DATA, _window$_SSR_DATA$dat;
-            storeConfig.initialState = storeConfig.initialState || ((_window = window) === null || _window === void 0 ? void 0 : (_window$_SSR_DATA = _window._SSR_DATA) === null || _window$_SSR_DATA === void 0 ? void 0 : (_window$_SSR_DATA$dat = _window$_SSR_DATA.data) === null || _window$_SSR_DATA$dat === void 0 ? void 0 : _window$_SSR_DATA$dat.storeState) || {};
-          }
-          context.store = createStore(storeConfig);
-          return next({
-            context: context
-          });
-        },
-        pickContext: function pickContext(_ref3, next) {
-          var context = _ref3.context,
-            pickedContext = _ref3.pickedContext;
-          return next({
-            context: context,
-            pickedContext: _objectSpread(_objectSpread({}, pickedContext), {}, {
-              store: context.store
-            })
-          });
+var state = function(config) {
+    return {
+        name: "@modern-js/plugin-state",
+        setup: function() {
+            var storeConfig = getStoreConfig(config);
+            return {
+                hoc: function hoc(param, next) {
+                    var App = param.App;
+                    var getStateApp = function(props) {
+                        var context = useContext(RuntimeReactContext);
+                        return /* @__PURE__ */ jsx(Provider, {
+                            store: context.store,
+                            config: storeConfig,
+                            children: /* @__PURE__ */ jsx(App, _objectSpread({}, props))
+                        });
+                    };
+                    return next({
+                        App: hoistNonReactStatics(getStateApp, App)
+                    });
+                },
+                init: function init(param, next) {
+                    var context = param.context;
+                    if (isBrowser()) {
+                        var ref, ref1;
+                        storeConfig.initialState = storeConfig.initialState || (window === null || window === void 0 ? void 0 : (ref = window._SSR_DATA) === null || ref === void 0 ? void 0 : (ref1 = ref.data) === null || ref1 === void 0 ? void 0 : ref1.storeState) || {};
+                    }
+                    context.store = createStore(storeConfig);
+                    return next({
+                        context: context
+                    });
+                },
+                pickContext: function pickContext(param, next) {
+                    var context = param.context, pickedContext = param.pickedContext;
+                    return next({
+                        context: context,
+                        pickedContext: _objectSpreadProps(_objectSpread({}, pickedContext), {
+                            store: context.store
+                        })
+                    });
+                }
+            };
         }
-      };
-    }
-  };
+    };
 };
-export default state;
-export * from "../plugins";
+var plugin_default = state;
+export * from "../plugins";
+export { plugin_default as default };

package/dist/js/treeshaking/state/types.js

@@ -1 +1 @@
-export {};
+"use strict";

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

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

package/dist/types/config.d.ts

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

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

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

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

@@ -5,7 +5,7 @@ export declare enum LoaderStatus {
   fulfilled = 2,
   rejected = 3,
 }
-export declare type LoaderResult = {
+export type LoaderResult = {
   loading: boolean;
   reloading: boolean;
   data: any;
@@ -24,7 +24,7 @@ declare const createLoader: (id: string, initialData: Partial<LoaderResult> | un
   onChange: (handler: (status: LoaderStatus, result: LoaderResult) => void) => () => void;
   load: () => Promise<any>;
 };
-declare type ManagerOption = {
+type ManagerOption = {
   /**
    * whether current manage only exec static loader
    */
@@ -35,6 +35,7 @@ declare type ManagerOption = {
  * 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>>;
@@ -52,5 +53,5 @@ export declare const createLoaderManager: (initialDataMap: Record<string, Loader
     load: () => Promise<any>;
   } | undefined;
 };
-export declare type Loader = ReturnType<typeof createLoader>;
+export type Loader = ReturnType<typeof createLoader>;
 export {};

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

@@ -20,26 +20,31 @@ export interface LoaderOptions<Params = any, TData = any, TError extends Error =
   /**
    * 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>;
+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;

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

@@ -30,13 +30,17 @@ declare const runtimeHooks: {
   }, TRuntimeContext>;
 };
 /** All hooks of runtime plugin. */
-export declare type RuntimeHooks = typeof runtimeHooks;
+
+export type RuntimeHooks = typeof runtimeHooks;
 /** All hook callbacks of runtime plugin. */
-export declare type RuntimeHookCallbacks = ToThreads<RuntimeHooks>;
+
+export type RuntimeHookCallbacks = ToThreads<RuntimeHooks>;
 /** All apis for runtime plugin. */
-export declare type PluginAPI = CommonAPI<RuntimeHooks>;
+
+export type PluginAPI = CommonAPI<RuntimeHooks>;
 /** Plugin options of a runtime plugin. */
-export declare type Plugin = PluginOptions<RuntimeHooks, Setup<RuntimeHooks>>;
+
+export 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>;
@@ -67,6 +71,7 @@ export declare const createRuntime: () => import("@modern-js/plugin").Manager<{
 /**
  * register init hook. It would be revoked both ssr and csr.
  */
+
 declare const registerInit: (App: React.ComponentType, _init: (context: RuntimeContext) => any | Promise<any>) => void;
 export declare const runtime: import("@modern-js/plugin").Manager<{
   hoc: import("@modern-js/plugin").Pipeline<{
@@ -173,7 +178,7 @@ export declare const createPlugin: (setup?: Setup<{
     context: RuntimeContext;
     pickedContext: TRuntimeContext;
   }, TRuntimeContext>;
-}, Record<string, never>>, Record<string, unknown>, any, any> | undefined) => import("@modern-js/plugin").Plugin<{
+}, Record<string, never>>, Record<string, unknown>> | undefined) => import("@modern-js/plugin").Plugin<{
   hoc: import("@modern-js/plugin").Pipeline<{
     App: React.ComponentType<any>;
   }, React.ComponentType<any>>;

package/dist/types/document/DocumentContext.d.ts

@@ -1,5 +1,5 @@
 import React from 'react';
-declare type DocumentProps = {
+type DocumentProps = {
   [x: string]: any;
   config?: any;
   templateParams: {

package/dist/types/document/DocumentStructrueContext.d.ts

@@ -1,7 +1,8 @@
 import React, { ReactNode } from 'react';
-declare type DocumentStructrueContextProps = {
+type DocumentStructrueContextProps = {
   hasSetHead?: boolean;
   hasSetScripts?: boolean;
+  hasSetLinks?: boolean;
   hasSetBody?: boolean;
   hasSetRoot?: boolean;
   docChild?: ReactNode;

package/dist/types/document/Links.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export declare function Links(): JSX.Element;

package/dist/types/document/Script.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+export declare function Script(props: {
+  content: () => void;
+}): JSX.Element;

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

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

package/dist/types/document/constants.d.ts

@@ -8,7 +8,10 @@ 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_NO_SCRIPTE_PLACEHOLDER: string;
+export declare const DOCUMENT_SCRIPT_PLACEHOLDER_START: string;
+export declare const DOCUMENT_SCRIPT_PLACEHOLDER_END: string;
 export declare const PLACEHOLDER_REPLACER_MAP: {
   [x: string]: string;
 };

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

@@ -4,5 +4,7 @@ export * from './DocumentStructrueContext';
 export * from './Head';
 export * from './Body';
 export * from './Root';
+export * from './Links';
 export * from './Scripts';
+export * from './Script';
 export * from './constants';

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

@@ -16,6 +16,6 @@ export declare const hook: (attacher: ({
   afterRender: (hook: AfterRenderHook) => void;
   afterMatch: (hook: AfterMatchHook) => void;
 }) => void;
-export declare type AfterRenderHook = (context: AfterRenderContext, next: NextFunction) => void;
-export declare type AfterMatchHook = (context: AfterMatchContext, next: NextFunction) => void;
-export declare type Middleware = (context: MiddlewareContext, next: NextFunction) => Promise<void> | void;
+export type AfterRenderHook = (context: AfterRenderContext, next: NextFunction) => void;
+export type AfterMatchHook = (context: AfterMatchContext, next: NextFunction) => void;
+export type Middleware = (context: MiddlewareContext, next: NextFunction) => Promise<void> | void;

package/dist/types/index.d.ts

@@ -4,5 +4,6 @@ export type { Plugin } from './core';
 export type { AppConfig } from './common';
 export { isBrowser } from './common';
 export type { BaseRuntimeContext, RuntimeContext, BaseTRuntimeContext, TRuntimeContext } from './runtime-context';
+export type { RuntimeUserConfig } from './config';
 export { createApp, createPlugin, useLoader, bootstrap, RuntimeReactContext, defineConfig, registerInit, useRuntimeContext } from './core';
 export { StateConfig, RouterConfig };

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

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

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

@@ -1,7 +1,7 @@
-import type { Plugin } from '../../core';
+import { Plugin } from '../../core';
 import type { RouterConfig, Routes } from './types';
 export declare let finalRouteConfig: RouterConfig['routesConfig'];
-export declare let beforeRenderRouter: boolean;
+export declare let beforeCreateRouter: boolean;
 export declare function modifyRoutes(modifyFunction: (routes: Routes) => Routes): void;
 export declare const routerPlugin: ({
   serverBase,

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

@@ -11,21 +11,23 @@ declare global {
     };
   }
 }
-export declare type SingleRouteConfig = RouteProps & {
+export type SingleRouteConfig = RouteProps & {
   redirect?: string;
   routes?: SingleRouteConfig[];
   key?: string;
   /**
    * layout component
    */
+
   layout?: React.ComponentType;
   /**
    * component would be rendered when route macthed.
    */
+
   component?: React.ComponentType;
 };
-export declare type RouterConfig = {
-  legacy?: boolean;
+export type RouterConfig = {
+  mode?: 'react-router-5';
   routesConfig: {
     globalApp?: React.ComponentType<any>;
     routes: (NestedRoute | PageRoute)[];
@@ -35,4 +37,4 @@ export declare type RouterConfig = {
   basename?: string;
   createRoutes?: () => RouteObject[];
 };
-export declare type Routes = RouterConfig['routesConfig']['routes'];
+export type Routes = RouterConfig['routesConfig']['routes'];

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

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

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

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

package/dist/types/ssr/react/prerender/type.d.ts

@@ -1,4 +1,4 @@
-export declare type SprProps = {
+export type SprProps = {
   interval: number;
   staleLimit: number | boolean;
   level: number;
@@ -7,22 +7,22 @@ export declare type SprProps = {
   fallback: boolean;
   matches: MetaKeyMatch | null;
 };
-export declare type GeneralizedProps = SprProps & {
+export type GeneralizedProps = SprProps & {
   [propName: string]: any;
 };
-export declare type SprConstructor = {
+export type SprConstructor = {
   config: () => SprProps;
 };
-export declare type MetaKeyMap = {
+export type MetaKeyMap = {
   header?: string[];
   query?: string[];
 };
-declare type MatchMap = {
+type MatchMap = {
   [propName: string]: {
     [propName: string]: string;
   };
 };
-export declare type MetaKeyMatch = {
+export type MetaKeyMatch = {
   header?: MatchMap;
   query?: MatchMap;
 };

package/dist/types/ssr/serverRender/renderToStream/buildTemplate.after.d.ts

@@ -1,5 +1,5 @@
 import { RenderLevel, SSRServerContext } from '../types';
-declare type BuildShellAfterTemplateOptions = {
+type BuildShellAfterTemplateOptions = {
   ssrContext: SSRServerContext;
   renderLevel: RenderLevel;
 };

package/dist/types/ssr/serverRender/renderToStream/buildTemplate.share.d.ts

@@ -1,3 +1,3 @@
 export declare const HEAD_REG_EXP: RegExp;
-export declare type BuildTemplateCb = (headTemplate: string) => string;
+export type BuildTemplateCb = (headTemplate: string) => string;
 export declare function buildTemplate(template: string, callbacks: BuildTemplateCb[]): string;

package/dist/types/ssr/serverRender/renderToStream/renderToPipe.d.ts

@@ -3,6 +3,6 @@
 import { Writable } from 'stream';
 import { RenderToPipeableStreamOptions } from 'react-dom/server';
 import { RuntimeContext } from '../types';
-export declare type Pipe<T extends Writable> = (output: T) => Promise<T | string>;
+export type Pipe<T extends Writable> = (output: T) => Promise<T | string>;
 declare function renderToPipe(rootElement: React.ReactElement, context: RuntimeContext, options?: RenderToPipeableStreamOptions): Pipe<Writable>;
 export default renderToPipe;

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

@@ -1,4 +1,4 @@
-export declare type InjectTemplate = {
+export type InjectTemplate = {
   shellBefore?: string;
   shellAfter?: string;
 };

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

@@ -1,6 +1,6 @@
 import { RuntimeContext, ModernSSRReactComponent, SSRPluginConfig } from '../types';
 import { SSRServerContext, RenderResult } from './type';
-declare type EntryOptions = {
+type EntryOptions = {
   ctx: SSRServerContext;
   App: ModernSSRReactComponent;
   config: SSRPluginConfig;

package/dist/types/ssr/serverRender/renderToString/template.d.ts

@@ -1,4 +1,4 @@
-declare type Filter = (str: string) => string;
+type Filter = (str: string) => string;
 export declare class Fragment {
   static filterMap: {
     [key: string]: Filter;