@modern-js/runtime 1.3.4 → 1.4.1

package/dist/js/treeshaking/state/cli/index.js

@@ -0,0 +1,100 @@
+import path from 'path';
+import { getEntryOptions, createRuntimeExportsUtils, PLUGIN_SCHEMAS } from '@modern-js/utils';
+import "../types";
+var PLUGIN_IDENTIFIER = 'state';
+export default (function () {
+  return {
+    name: '@modern-js/plugin-state',
+    required: ['@modern-js/runtime'],
+    setup: function setup(api) {
+      var stateConfigMap = new Map();
+      var pluginsExportsUtils;
+      var stateModulePath = path.resolve(__dirname, '../');
+      return {
+        config: function config() {
+          var appContext = api.useAppContext();
+          pluginsExportsUtils = createRuntimeExportsUtils(appContext.internalDirectory, 'plugins');
+          return {
+            source: {
+              alias: {
+                '@modern-js/runtime/plugins': pluginsExportsUtils.getPath()
+              }
+            }
+          };
+        },
+        modifyEntryImports: function modifyEntryImports(_ref) {
+          var _getEntryOptions;
+
+          var entrypoint = _ref.entrypoint,
+              imports = _ref.imports;
+          var entryName = entrypoint.entryName;
+          var userConfig = api.useResolvedConfigContext();
+
+          var _api$useAppContext = api.useAppContext(),
+              packageName = _api$useAppContext.packageName;
+
+          var stateConfig = (_getEntryOptions = getEntryOptions(entryName, userConfig.runtime, userConfig.runtimeByEntries, packageName)) === null || _getEntryOptions === void 0 ? void 0 : _getEntryOptions.state;
+          stateConfigMap.set(entryName, stateConfig);
+
+          var getEnabledPlugins = function getEnabledPlugins() {
+            var internalPlugins = ['immer', 'effects', 'autoActions', 'devtools'];
+            return internalPlugins.filter(function (name) {
+              return stateConfig[name] !== false;
+            });
+          };
+
+          if (stateConfig) {
+            imports.push({
+              value: '@modern-js/runtime/plugins',
+              specifiers: [{
+                imported: PLUGIN_IDENTIFIER
+              }]
+            });
+            imports.push({
+              value: '@modern-js/runtime/model',
+              specifiers: getEnabledPlugins().map(function (imported) {
+                return {
+                  imported: imported
+                };
+              }),
+              initialize: "\n                const createStatePlugins = (config) => {\n                  const plugins = [];\n\n                  ".concat(getEnabledPlugins().map(function (name) {
+                return "\n                      plugins.push(".concat(name, "(config['").concat(name, "']));\n                      ");
+              }).join('\n'), "\n\n                  return plugins;\n                }\n              ")
+            });
+          }
+
+          return {
+            entrypoint: entrypoint,
+            imports: imports
+          };
+        },
+        modifyEntryRuntimePlugins: function modifyEntryRuntimePlugins(_ref2) {
+          var entrypoint = _ref2.entrypoint,
+              plugins = _ref2.plugins;
+          var stateOptions = stateConfigMap.get(entrypoint.entryName);
+
+          if (stateOptions) {
+            var isBoolean = typeof stateOptions === 'boolean';
+            var options = isBoolean ? '{}' : JSON.stringify(stateOptions);
+            options = "".concat(options.substr(0, options.length - 1)).concat(isBoolean ? '' : ',', "plugins: createStatePlugins(").concat(JSON.stringify(stateConfigMap.get(entrypoint.entryName)), ")}");
+            plugins.push({
+              name: PLUGIN_IDENTIFIER,
+              options: options
+            });
+          }
+
+          return {
+            entrypoint: entrypoint,
+            plugins: plugins
+          };
+        },
+        validateSchema: function validateSchema() {
+          return PLUGIN_SCHEMAS['@modern-js/plugin-state'];
+        },
+        addRuntimeExports: function addRuntimeExports() {
+          pluginsExportsUtils.addExport("export { default as state } from '".concat(stateModulePath, "'"));
+        }
+      };
+    }
+  };
+});

package/dist/js/treeshaking/state/index.js

@@ -0,0 +1,2 @@
+export { default } from "./runtime";
+export * from "./runtime";

package/dist/js/treeshaking/state/plugins.js

@@ -0,0 +1,13 @@
+import { plugin as effectsPlugin } from '@modern-js-reduck/plugin-effects';
+import autoActionsPlugin from '@modern-js-reduck/plugin-auto-actions';
+import immerPlugin from '@modern-js-reduck/plugin-immutable';
+export { default as devtools } from '@modern-js-reduck/plugin-devtools';
+export var effects = function effects() {
+  return effectsPlugin;
+};
+export var immer = function immer() {
+  return immerPlugin;
+};
+export var autoActions = function autoActions() {
+  return autoActionsPlugin;
+};

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

@@ -0,0 +1,4 @@
+export * from '@modern-js-reduck/react';
+export { model, createStore } from '@modern-js-reduck/store';
+export { default } from "./plugin";
+export * from "./plugin";

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

@@ -0,0 +1,63 @@
+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 { isBrowser } from "../../common";
+import { jsx as _jsx } from "react/jsx-runtime";
+
+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: config,
+              children: /*#__PURE__*/_jsx(App, _objectSpread({}, props))
+            });
+          };
+
+          return next({
+            App: hoistNonReactStatics(getStateApp, App)
+          });
+        },
+        init: function init(_ref2, next) {
+          var context = _ref2.context;
+          var storeConfig = 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);
+          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
+            })
+          });
+        }
+      };
+    }
+  };
+};
+
+export default state;
+export * from "../plugins";

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

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

package/dist/types/common.d.ts

@@ -0,0 +1 @@
+export declare const isBrowser: () => boolean;

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

@@ -1 +1,2 @@
-export * from '@modern-js/plugin-state';
+export { default as state } from '../state';
+export * from '../state';

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

@@ -1 +1,2 @@
-export * from '@modern-js/plugin-router';
+export { default as router } from '../router';
+export * from '../router';

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

@@ -1,2 +1 @@
-export * from '@modern-js/bff-runtime';
 export declare const hook: (attacher: any) => any;

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

@@ -1 +1,2 @@
-export * from '@modern-js/plugin-ssr';
+export { default as ssr } from '../ssr';
+export * from '../ssr';

package/dist/types/index.d.ts

@@ -1,5 +1,5 @@
-import type { RouterConfig } from '@modern-js/plugin-router';
-import type { StateConfig } from '@modern-js/plugin-state';
+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' {
@@ -7,4 +7,10 @@ declare module '@modern-js/runtime-core' {
     router?: RouterConfig | boolean;
     state?: StateConfig | boolean;
   }
+}
+declare module '@modern-js/core' {
+  interface RuntimeConfig {
+    router?: RouterConfig | boolean;
+    state?: StateConfig | boolean;
+  }
 }

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

@@ -0,0 +1,5 @@
+import type { CliPlugin } from '@modern-js/core';
+
+declare const _default: () => CliPlugin;
+
+export default _default;

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

@@ -0,0 +1,2 @@
+export { default } from './runtime';
+export * from './runtime';

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

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

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

@@ -0,0 +1,6 @@
+import { routerPlugin } from './plugin';
+import type { SingleRouteConfig, HistoryConfig, RouterConfig } from './plugin';
+export type { SingleRouteConfig, HistoryConfig, RouterConfig };
+export default routerPlugin;
+export * from 'react-router-dom';
+export * from 'history';

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

@@ -0,0 +1,51 @@
+import React from 'react';
+import { History, BrowserHistoryBuildOptions, HashHistoryBuildOptions } from 'history';
+import { RouteProps } from 'react-router-dom';
+import type { Plugin } from '@modern-js/runtime-core';
+declare global {
+  interface Window {
+    _SERVER_DATA?: {
+      router: {
+        baseUrl: string;
+        params: Record<string, string>;
+      };
+    };
+  }
+}
+export declare 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 HistoryConfig = {
+  supportHtml5History: true;
+  historyOptions: BrowserHistoryBuildOptions;
+} | {
+  supportHtml5History: false;
+  historyOptions: HashHistoryBuildOptions;
+};
+export declare type RouterConfig = Partial<HistoryConfig> & {
+  routesConfig?: {
+    globalApp?: React.ComponentType<any>;
+    routes?: SingleRouteConfig[];
+  };
+  history?: History;
+  serverBase?: string[];
+};
+export declare const routerPlugin: ({
+  serverBase,
+  history: customHistory,
+  supportHtml5History,
+  routesConfig,
+  historyOptions
+}: RouterConfig) => Plugin;

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

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+import { RouterConfig } from './plugin';
+export declare function renderRoutes(routesConfig: RouterConfig['routesConfig'], extraProps?: any): JSX.Element;
+export declare function getLocation(serverContext: any): string;
+export declare const urlJoin: (...parts: string[]) => string;
+export declare function standardSlash(str: string): string;

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

@@ -0,0 +1,5 @@
+import type { CliPlugin } from '@modern-js/core';
+
+declare const _default: () => CliPlugin;
+
+export default _default;

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

@@ -0,0 +1,18 @@
+import type { Plugin } from '@modern-js/runtime-core';
+import { RenderLevel, SSRServerContext } from './serverRender/type';
+declare module '@modern-js/runtime-core' {
+  interface RuntimeContext {
+    ssrContext: SSRServerContext;
+  }
+  interface TRuntimeContext {
+    request: SSRServerContext['request'];
+    response: SSRServerContext['response'];
+  }
+  interface SSRContainer {
+    renderLevel: RenderLevel;
+    context?: SSRServerContext;
+  }
+}
+declare const ssr: () => Plugin;
+export default ssr;
+export * from './react';

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

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

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

@@ -0,0 +1,13 @@
+import { RuntimeContext } from '@modern-js/runtime-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>;
+  initialData: any;
+  i18nData: any;
+  storeState: any;
+}>;
+export default prefetch;

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

@@ -0,0 +1,2 @@
+export { PreRender } from './prerender';
+export { NoSSR } from './nossr';

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

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

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

@@ -0,0 +1 @@
+export declare const PreRender: any;

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

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

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

@@ -0,0 +1,6 @@
+import { GeneralizedProps, MetaKeyMap, MetaKeyMatch } from './type';
+export declare const getInnermostProperty: (propsList: GeneralizedProps[], propName: string) => any;
+export declare const getOutermostProperty: (propsList: GeneralizedProps[], propName: string) => any;
+export declare const aggKeysFromPropsList: (propsList: GeneralizedProps[], propName: string) => MetaKeyMap;
+export declare const aggMatchesFromPropsList: (propsList: GeneralizedProps[], propName: string) => MetaKeyMatch;
+export declare function exist(target: any): boolean;

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

@@ -0,0 +1,20 @@
+import { RuntimeContext } from '@modern-js/runtime-core';
+import { ModernSSRReactComponent, SSRServerContext, RenderResult } from './type';
+declare type EntryOptions = {
+  ctx: SSRServerContext;
+  App: ModernSSRReactComponent;
+};
+export default class Entry {
+  entryName: string;
+  result: RenderResult;
+  metrics: SSRServerContext['metrics'];
+  logger: SSRServerContext['logger'];
+  private readonly App;
+  private readonly fragments;
+  constructor(options: EntryOptions);
+  renderToHtml(context: RuntimeContext): Promise<string>;
+  private prefetch;
+  private renderToString;
+  private getSSRDataScript;
+}
+export {};

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

@@ -0,0 +1,2 @@
+import { HelmetData } from 'react-helmet';
+export default function helmet(content: string, helmetData: HelmetData): string;

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

@@ -0,0 +1,8 @@
+import { RuntimeContext } from '@modern-js/runtime-core';
+import { ModernSSRReactComponent } from './type';
+declare module '@modern-js/runtime' {
+  interface RuntimeContext {
+    ssrContext?: any;
+  }
+}
+export declare const render: (ctx: RuntimeContext, _: string | undefined, App: ModernSSRReactComponent) => Promise<string>;

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

@@ -0,0 +1,2 @@
+import { RenderHandler } from './type';
+export declare const toHtml: RenderHandler;

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

@@ -0,0 +1 @@
+export declare const time: () => () => number;

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

@@ -0,0 +1,3 @@
+import React from 'react';
+import { RenderHandler, RenderEntry } from './type';
+export declare function reduce(jsx: React.ReactElement, renderer: RenderEntry, middleware: RenderHandler[]): string;

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

@@ -0,0 +1,2 @@
+import { RenderHandler } from './type';
+export declare const toHtml: RenderHandler;

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

@@ -0,0 +1,14 @@
+declare type Filter = (str: string) => string;
+export declare class Fragment {
+  static filterMap: {
+    [key: string]: Filter;
+  };
+  isVariable: boolean;
+  content: string;
+  filters: Filter[];
+  path: string[];
+  constructor(template: string);
+  getValue(data: any): any;
+}
+export declare function toFragments(filename: string): Fragment[];
+export {};

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

@@ -0,0 +1,32 @@
+/// <reference types="react" />
+import type { RuntimeContext } from '@modern-js/runtime-core';
+import type { BaseSSRServerContext } from '@modern-js/types';
+export declare enum RenderLevel {
+  CLIENT_RENDER = 0,
+  SERVER_PREFETCH = 1,
+  SERVER_RENDER = 2,
+}
+export declare type SSRServerContext = BaseSSRServerContext & {
+  request: BaseSSRServerContext['request'] & {
+    userAgent: string;
+    cookie: string;
+  };
+};
+export declare type ModernSSRReactComponent = React.ComponentType<any> & {
+  init: (context: RuntimeContext) => Promise<void>;
+  prefetch: (context: RuntimeContext) => Promise<Record<string, any>>;
+};
+export interface RenderEntry {
+  entryName: string;
+  result: RenderResult;
+  loadableManifest: string | undefined;
+}
+export declare type RenderHandler = (jsx: React.ReactElement, renderer: RenderEntry, next: (jsx: React.ReactElement) => string) => string;
+export declare type RenderResult = {
+  renderLevel: RenderLevel;
+  html?: string;
+  chunksMap: {
+    js: string;
+    css: string;
+  };
+};

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

@@ -0,0 +1,8 @@
+import { BaseSSRServerContext } from '@modern-js/types';
+import { SSRServerContext } from './serverRender/type';
+export declare const formatServer: (request: BaseSSRServerContext['request']) => SSRServerContext['request'];
+export declare const formatClient: (request: BaseSSRServerContext['request']) => SSRServerContext['request'];
+export declare const mockResponse: () => {
+  setHeader(): void;
+  status(): void;
+};

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

@@ -0,0 +1,5 @@
+import type { CliPlugin } from '@modern-js/core';
+
+declare const _default: () => CliPlugin;
+
+export default _default;

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

@@ -0,0 +1,2 @@
+export { default } from './runtime';
+export * from './runtime';

package/dist/types/state/plugins.d.ts

@@ -0,0 +1,4 @@
+export { default as devtools } from '@modern-js-reduck/plugin-devtools';
+export declare const effects: () => (context: import("@modern-js-reduck/store/dist/types/types/plugin").PluginContext) => import("@modern-js-reduck/store/dist/types/types/plugin").PluginLifeCycle;
+export declare const immer: () => (context: import("@modern-js-reduck/store/dist/types/types/plugin").PluginContext) => import("@modern-js-reduck/store/dist/types/types/plugin").PluginLifeCycle;
+export declare const autoActions: () => (context: import("@modern-js-reduck/store/dist/types/types/plugin").PluginContext) => import("@modern-js-reduck/store/dist/types/types/plugin").PluginLifeCycle;

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

@@ -0,0 +1,4 @@
+export * from '@modern-js-reduck/react';
+export { model, createStore } from '@modern-js-reduck/store';
+export { default } from './plugin';
+export * from './plugin';

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

@@ -0,0 +1,17 @@
+import { createStore, Store } from '@modern-js-reduck/store';
+import type { Plugin } from '@modern-js/runtime-core';
+declare module '@modern-js/runtime-core' {
+  interface RuntimeContext {
+    store: Store;
+  }
+  interface TRuntimeContext {
+    store: Store;
+  }
+  interface SSRData {
+    storeState: any;
+  }
+}
+export declare type StateConfig = Parameters<typeof createStore>[0];
+declare const state: (config: StateConfig) => Plugin;
+export default state;
+export * from '../plugins';

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

@@ -0,0 +1,17 @@
+import { createStore } from '@modern-js-reduck/store';
+import { ReduxLoggerOptions } from 'redux-logger';
+export declare type PluginOptions = Parameters<typeof createStore>[0] & {
+  /**
+   * If it's false, the logger will be disabled.
+   * If it's a object, it means options will pass to createLogger function
+   */
+  logger?: false | ReduxLoggerOptions;
+  effects?: any;
+  /**
+   * Default: false
+   * When it's true, will remove immer plugin
+   */
+
+  disableImmer?: boolean;
+  devtools?: any;
+};