module-menu 0.3.26 → 0.3.27

package/src/.umi/core/pluginConfig.d.ts

@@ -0,0 +1,304 @@
+// Created by Umi Plugin
+
+export interface IConfigFromPlugins {
+"404"?: boolean
+routes?: {
+/**
+ * Any valid URL path
+ */
+path?: string
+/**
+ * A React component to render only when the location matches.
+ */
+component?: (string | (() => any))
+wrappers?: string[]
+/**
+ * navigate to a new location
+ */
+redirect?: string
+/**
+ * When true, the active class/style will only be applied if the location is matched exactly.
+ */
+exact?: boolean
+routes?: any[]
+[k: string]: any
+}[]
+history?: {
+type?: ("browser" | "hash" | "memory")
+options?: {
+
+}
+}
+polyfill?: {
+imports?: string[]
+}
+alias?: {
+
+}
+analyze?: {
+analyzerMode?: ("server" | "static" | "disabled")
+analyzerHost?: string
+analyzerPort?: any
+openAnalyzer?: boolean
+generateStatsFile?: boolean
+statsFilename?: string
+logLevel?: ("info" | "warn" | "error" | "silent")
+defaultSizes?: ("stat" | "parsed" | "gzip")
+[k: string]: any
+}
+/**
+ * postcss autoprefixer, default flexbox: no-2009
+ */
+autoprefixer?: {
+
+}
+base?: string
+chainWebpack?: (() => any)
+chunks?: string[]
+/**
+ * more css-loader options see https://webpack.js.org/loaders/css-loader/#options
+ */
+cssLoader?: {
+url?: (boolean | (() => any))
+import?: (boolean | (() => any))
+modules?: (boolean | string | {
+
+})
+sourceMap?: boolean
+importLoaders?: number
+onlyLocals?: boolean
+esModule?: boolean
+localsConvention?: ("asIs" | "camelCase" | "camelCaseOnly" | "dashes" | "dashesOnly")
+}
+cssModulesTypescriptLoader?: {
+mode?: ("emit" | "verify")
+}
+cssnano?: {
+
+}
+copy?: any[]
+define?: {
+
+}
+devScripts?: {
+
+}
+/**
+ * devServer configs
+ */
+devServer?: {
+/**
+ * devServer port, default 8000
+ */
+port?: number
+host?: string
+https?: ({
+key?: string
+cert?: string
+http2?: boolean
+[k: string]: any
+} | boolean)
+headers?: {
+
+}
+writeToDisk?: (boolean | (() => any))
+[k: string]: any
+}
+devtool?: string
+/**
+ * Code splitting for performance optimization
+ */
+dynamicImport?: {
+/**
+ * loading the component before loaded
+ */
+loading?: string
+}
+/**
+ * Code splitting for import statement syntax
+ */
+dynamicImportSyntax?: {
+
+}
+exportStatic?: {
+htmlSuffix?: boolean
+dynamicRoot?: boolean
+supportWin?: boolean
+/**
+ * extra render paths only enable in ssr
+ */
+extraRoutePaths?: (() => any)
+}
+externals?: ({
+
+} | string | (() => any))
+extraBabelIncludes?: any[]
+extraBabelPlugins?: any[]
+extraBabelPresets?: any[]
+extraPostCSSPlugins?: any[]
+/**
+ * fork-ts-checker-webpack-plugin options see https://github.com/TypeStrong/fork-ts-checker-webpack-plugin#options
+ */
+forkTSChecker?: {
+async?: boolean
+typescript?: (boolean | {
+
+})
+eslint?: {
+
+}
+issue?: {
+
+}
+formatter?: (string | {
+
+})
+logger?: {
+
+}
+[k: string]: any
+}
+fastRefresh?: {
+
+}
+hash?: boolean
+ignoreMomentLocale?: boolean
+inlineLimit?: number
+lessLoader?: {
+
+}
+manifest?: {
+fileName?: string
+publicPath?: ""
+basePath?: string
+writeToFileEmit?: boolean
+}
+/**
+ * open mfsu feature
+ */
+mfsu?: {
+development?: {
+output?: string
+}
+production?: {
+output?: string
+}
+mfName?: string
+exportAllMembers?: {
+
+}
+chunks?: string[]
+ignoreNodeBuiltInModules?: boolean
+}
+mountElementId?: ""
+mpa?: {
+
+}
+nodeModulesTransform?: {
+type?: ("all" | "none")
+exclude?: string[]
+}
+outputPath?: ""
+plugins?: string[]
+postcssLoader?: {
+
+}
+presets?: string[]
+proxy?: {
+
+}
+publicPath?: string
+runtimePublicPath?: boolean
+ssr?: {
+/**
+ * force execing Page getInitialProps functions
+ */
+forceInitial?: boolean
+/**
+ * remove window.g_initialProps in html
+ */
+removeWindowInitialProps?: boolean
+/**
+ * disable serve-side render in umi dev mode.
+ */
+devServerRender?: boolean
+mode?: ("stream" | "string")
+/**
+ * static markup in static site
+ */
+staticMarkup?: boolean
+}
+singular?: boolean
+styleLoader?: {
+
+}
+targets?: {
+
+}
+terserOptions?: {
+
+}
+theme?: {
+
+}
+runtimeHistory?: {
+
+}
+webpack5?: {
+lazyCompilation?: {
+entries?: boolean
+imports?: boolean
+test?: any
+}
+}
+workerLoader?: {
+
+}
+favicon?: string
+headScripts?: any[]
+links?: any[]
+metas?: any[]
+scripts?: any[]
+styles?: any[]
+title?: string
+mock?: {
+exclude?: string[]
+}
+antd?: {
+dark?: boolean
+compact?: boolean
+mobile?: boolean
+disableBabelPluginImport?: boolean
+config?: {
+
+}
+}
+dva?: {
+disableModelsReExport?: boolean
+/**
+ * lazy load dva model avoiding the import modules from umi undefined
+ */
+lazyLoad?: boolean
+extraModels?: string[]
+hmr?: boolean
+immer?: (boolean | {
+
+})
+skipModelValidate?: boolean
+}
+locale?: {
+default?: string
+useLocalStorage?: boolean
+baseNavigator?: boolean
+title?: boolean
+antd?: boolean
+baseSeparator?: string
+}
+layout?: {
+
+}
+request?: {
+dataField?: ""
+}
+[k: string]: any
+}

package/src/.umi/core/pluginRegister.ts

@@ -0,0 +1,15 @@
+// @ts-nocheck
+import { plugin } from './plugin';
+import * as Plugin_0 from '../plugin-initial-state/runtime';
+import * as Plugin_1 from '../plugin-model/runtime';
+
+  plugin.register({
+    apply: Plugin_0,
+    path: '../plugin-initial-state/runtime',
+  });
+  plugin.register({
+    apply: Plugin_1,
+    path: '../plugin-model/runtime',
+  });
+
+export const __mfsu = 1;

package/src/.umi/core/polyfill.ts

@@ -0,0 +1,4 @@
+// @ts-nocheck
+import 'core-js';
+import 'regenerator-runtime/runtime';
+export {};

package/src/.umi/core/routes.ts

@@ -0,0 +1,24 @@
+// @ts-nocheck
+import React from 'react';
+import { ApplyPluginsType } from '/Users/huarui/work/module-menu/node_modules/@umijs/runtime';
+import * as umiExports from './umiExports';
+import { plugin } from './plugin';
+
+export function getRoutes() {
+  const routes = [
+  {
+    "path": "/",
+    "component": require('@/pages/index').default,
+    "exact": true
+  }
+];
+
+  // allow user to extend routes
+  plugin.applyPlugins({
+    key: 'patchRoutes',
+    type: ApplyPluginsType.event,
+    args: { routes },
+  });
+
+  return routes;
+}

package/src/.umi/core/umiExports.ts

@@ -0,0 +1,7 @@
+// @ts-nocheck
+export { history } from './history';
+export { plugin } from './plugin';
+export * from '../plugin-initial-state/exports';
+export * from '../plugin-model/useModel';
+export * from '../plugin-request/request';
+export * from '../plugin-helmet/exports';

package/src/.umi/plugin-helmet/exports.ts

@@ -0,0 +1,3 @@
+// @ts-nocheck
+// @ts-ignore
+export { Helmet } from '/Users/huarui/work/module-menu/node_modules/react-helmet';

package/src/.umi/plugin-initial-state/Provider.tsx

@@ -0,0 +1,37 @@
+// @ts-nocheck
+
+import React, { useRef, useEffect } from "react";
+import { plugin } from "../core/umiExports";
+import { ApplyPluginsType } from 'umi';
+import { useModel } from "../plugin-model/useModel";
+if (typeof useModel !== "function") {
+  throw new Error(
+    "[plugin-initial-state]: useModel is not a function, @umijs/plugin-model is required."
+  );
+}
+
+interface Props {
+  children: React.ReactNode;
+}
+export default (props: Props) => {
+  const { children } = props;
+  const appLoaded = useRef(false);
+  // 获取用户的配置，暂时只支持 loading
+  const useRuntimeConfig =
+    plugin.applyPlugins({
+      key: "initialStateConfig",
+      type: ApplyPluginsType.modify,
+      initialValue: {},
+    }) || {};
+  const { loading = false } = useModel("@@initialState") || {};
+  useEffect(() => {
+    if (!loading) {
+      appLoaded.current = true;
+    }
+  }, [loading]);
+  // initial state loading 时，阻塞渲染
+  if (loading && !appLoaded.current) {
+    return useRuntimeConfig.loading || null;
+  }
+  return children;
+};

package/src/.umi/plugin-initial-state/exports.ts

@@ -0,0 +1,7 @@
+// @ts-nocheck
+
+// @ts-ignore
+import { InitialState as InitialStateType } from '../plugin-initial-state/models/initialState';
+
+export type InitialState = InitialStateType;
+export const __PLUGIN_INITIAL_STATE = 1;

package/src/.umi/plugin-initial-state/models/initialState.ts

@@ -0,0 +1,2 @@
+// @ts-nocheck
+export default () => ({ loading: false, refresh: () => {} })

package/src/.umi/plugin-initial-state/runtime.tsx

@@ -0,0 +1,13 @@
+// @ts-nocheck
+import React from 'react';
+import Provider from './Provider';
+
+export function rootContainer(container: React.ReactNode) {
+  return React.createElement(
+    // 这里的 plugin-initial-state 不能从 constant 里取，里面有 path 依赖
+    // 但 webpack-5 没有 node 补丁（包括 path）
+    Provider,
+    null,
+    container,
+  );
+}

package/src/.umi/plugin-model/Provider.tsx

@@ -0,0 +1,39 @@
+// @ts-nocheck
+import React from 'react';
+import initialState from '/Users/huarui/work/module-menu/src/.umi/plugin-initial-state/models/initialState';
+
+// @ts-ignore
+import Dispatcher from './helpers/dispatcher';
+// @ts-ignore
+import Executor from './helpers/executor';
+// @ts-ignore
+import { UmiContext } from './helpers/constant';
+
+export const models = { '@@initialState': initialState,  };
+
+export type Model<T extends keyof typeof models> = {
+  [key in keyof typeof models]: ReturnType<typeof models[T]>;
+};
+
+export type Models<T extends keyof typeof models> = Model<T>[T]
+
+const dispatcher = new Dispatcher!();
+const Exe = Executor!;
+
+export default ({ children }: { children: React.ReactNode }) => {
+
+  return (
+    <UmiContext.Provider value={dispatcher}>
+      {
+        Object.entries(models).map(pair => (
+          <Exe key={pair[0]} namespace={pair[0]} hook={pair[1] as any} onUpdate={(val: any) => {
+            const [ns] = pair as [keyof typeof models, any];
+            dispatcher.data[ns] = val;
+            dispatcher.update(ns);
+          }} />
+        ))
+      }
+      {children}
+    </UmiContext.Provider>
+  )
+}

package/src/.umi/plugin-model/helpers/constant.tsx

@@ -0,0 +1,4 @@
+// @ts-nocheck
+import React from 'react';
+
+export const UmiContext = React.createContext({});

package/src/.umi/plugin-model/helpers/dispatcher.tsx

@@ -0,0 +1,19 @@
+// @ts-nocheck
+export default class Dispatcher {
+  callbacks = {};
+
+  data = {};
+
+  update = (namespace: string) => {
+    (this.callbacks[namespace] || []).forEach(
+      (callback: (val: any) => void) => {
+        try {
+          const data = this.data[namespace];
+          callback(data);
+        } catch (e) {
+          callback(undefined);
+        }
+      },
+    );
+  };
+}

package/src/.umi/plugin-model/helpers/executor.tsx

@@ -0,0 +1,83 @@
+// @ts-nocheck
+import React, { useEffect, useRef, useMemo } from 'react';
+
+interface ExecutorProps {
+  hook: () => any;
+  onUpdate: (val: any) => void;
+  namespace: string;
+}
+
+export default (props: ExecutorProps) => {
+  const { hook, onUpdate, namespace } = props;
+
+  const updateRef = useRef(onUpdate);
+  updateRef.current = onUpdate;
+  const initialLoad = useRef(false);
+
+  let data: any;
+  try {
+    data = hook();
+    if (
+      process.env.NODE_ENV === 'development' &&
+      typeof document !== 'undefined'
+    ) {
+      try {
+        let count = Object.keys(
+          ((window as any)._umi_useModel_dev_tool_log || {})[namespace] || {},
+        ).length;
+        (window as any)._umi_useModel_dev_tool = Object.assign(
+          (window as any)._umi_useModel_dev_tool || {},
+          {
+            [namespace]: data,
+          },
+        );
+        (window as any)._umi_useModel_dev_tool_log = Object.assign(
+          (window as any)._umi_useModel_dev_tool_log || {},
+          {
+            [namespace]: Object.assign(
+              ((window as any)._umi_useModel_dev_tool_log || {})[namespace] ||
+                {},
+              {
+                [count]: data,
+              },
+            ),
+          },
+        );
+        window.dispatchEvent(
+          new CustomEvent('_umi_useModel_update', {
+            detail: {
+              namespace,
+              time: Date.now(),
+              data,
+              index: count,
+            },
+          }),
+        );
+      } catch (e) {
+        // dev tool 记录失败、可能是低版本浏览器，忽略
+      }
+    }
+  } catch (e) {
+    console.error(
+      `plugin-model: Invoking '${namespace || 'unknown'}' model failed:`,
+      e,
+    );
+  }
+
+  // 首次执行时立刻返回初始值
+  useMemo(() => {
+    updateRef.current(data);
+    initialLoad.current = false;
+  }, []);
+
+  // React 16.13 后 update 函数用 useEffect 包裹
+  useEffect(() => {
+    if (initialLoad.current) {
+      updateRef.current(data);
+    } else {
+      initialLoad.current = true;
+    }
+  });
+
+  return <></>;
+};

package/src/.umi/plugin-model/runtime.tsx

@@ -0,0 +1,12 @@
+// @ts-nocheck
+/* eslint-disable import/no-dynamic-require */
+import React from 'react';
+import Provider from './Provider';
+
+export function rootContainer(container: React.ReactNode) {
+  return React.createElement(
+    Provider,
+    null,
+    container,
+  );
+}

package/src/.umi/plugin-model/useModel.tsx

@@ -0,0 +1,71 @@
+// @ts-nocheck
+import { useState, useEffect, useContext, useRef } from 'react';
+// @ts-ignore
+import isEqual from '/Users/huarui/work/module-menu/node_modules/@umijs/plugin-model/node_modules/fast-deep-equal/index.js';
+// @ts-ignore
+import { UmiContext } from './helpers/constant';
+import { Model, models } from './Provider';
+
+export type Models<T extends keyof typeof models> = Model<T>[T]
+
+export function useModel<T extends keyof Model<T>>(model: T): Model<T>[T]
+export function useModel<T extends keyof Model<T>, U>(model: T, selector: (model: Model<T>[T]) => U): U
+
+export function useModel<T extends keyof Model<T>, U>(
+  namespace: T,
+  updater?: (model: Model<T>[T]) => U
+) : typeof updater extends undefined ? Model<T>[T] : ReturnType<NonNullable<typeof updater>>{
+
+  type RetState = typeof updater extends undefined ? Model<T>[T] : ReturnType<NonNullable<typeof updater>>
+  const dispatcher = useContext<any>(UmiContext);
+  const updaterRef = useRef(updater);
+  updaterRef.current = updater;
+  const [state, setState] = useState<RetState>(
+    () => updaterRef.current ? updaterRef.current(dispatcher.data![namespace]) : dispatcher.data![namespace]
+  );
+  const stateRef = useRef<any>(state);
+  stateRef.current = state;
+
+  const isMount = useRef(false);
+  useEffect(() => {
+    isMount.current = true;
+    return () => {
+      isMount.current = false;
+    }
+  }, [])
+
+  useEffect(() => {
+    const handler = (e: any) => {
+      if(!isMount.current) {
+        // 如果 handler 执行过程中，组件被卸载了，则强制更新全局 data
+        setTimeout(() => {
+          dispatcher.data![namespace] = e;
+          dispatcher.update(namespace);
+        });
+      } else {
+        if(updater && updaterRef.current){
+          const currentState = updaterRef.current(e);
+          const previousState = stateRef.current
+          if(!isEqual(currentState, previousState)){
+            setState(currentState);
+          }
+        } else {
+          setState(e);
+        }
+      }
+    }
+    try {
+      dispatcher.callbacks![namespace]!.add(handler);
+      dispatcher.update(namespace);
+    } catch (e) {
+      dispatcher.callbacks![namespace] = new Set();
+      dispatcher.callbacks![namespace]!.add(handler);
+      dispatcher.update(namespace);
+    }
+    return () => {
+      dispatcher.callbacks![namespace]!.delete(handler);
+    }
+  }, [namespace]);
+
+  return state;
+};