@umijs/plugins 4.0.0-beta.8 → 4.0.0-canary-20240513.3

package/dist/utils/resolveProjectDep.d.ts

@@ -0,0 +1,5 @@
+export declare function resolveProjectDep(opts: {
+    pkg: any;
+    cwd: string;
+    dep: string;
+}): string | undefined;

package/dist/utils/resolveProjectDep.js

@@ -0,0 +1,40 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utils/resolveProjectDep.ts
+var resolveProjectDep_exports = {};
+__export(resolveProjectDep_exports, {
+  resolveProjectDep: () => resolveProjectDep
+});
+module.exports = __toCommonJS(resolveProjectDep_exports);
+var import_path = require("path");
+var import_plugin_utils = require("umi/plugin-utils");
+function resolveProjectDep(opts) {
+  var _a, _b;
+  if (((_a = opts.pkg.dependencies) == null ? void 0 : _a[opts.dep]) || ((_b = opts.pkg.devDependencies) == null ? void 0 : _b[opts.dep])) {
+    return (0, import_path.dirname)(
+      import_plugin_utils.resolve.sync(`${opts.dep}/package.json`, {
+        basedir: opts.cwd
+      })
+    );
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  resolveProjectDep
+});

package/dist/utils/withTmpPath.d.ts

@@ -0,0 +1,6 @@
+import { IApi } from 'umi';
+export declare function withTmpPath(opts: {
+    api: IApi;
+    path: string;
+    noPluginDir?: boolean;
+}): string;

package/dist/utils/withTmpPath.js

@@ -0,0 +1,39 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utils/withTmpPath.ts
+var withTmpPath_exports = {};
+__export(withTmpPath_exports, {
+  withTmpPath: () => withTmpPath
+});
+module.exports = __toCommonJS(withTmpPath_exports);
+var import_path = require("path");
+var import_plugin_utils = require("umi/plugin-utils");
+function withTmpPath(opts) {
+  return (0, import_plugin_utils.winPath)(
+    (0, import_path.join)(
+      opts.api.paths.absTmpPath,
+      opts.api.plugin.key && !opts.noPluginDir ? `plugin-${opts.api.plugin.key}` : "",
+      opts.path
+    )
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  withTmpPath
+});

package/dist/valtio.d.ts

@@ -0,0 +1,3 @@
+import { IApi } from 'umi';
+declare const _default: (api: IApi) => void;
+export default _default;

package/dist/valtio.js

@@ -0,0 +1,81 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/valtio.ts
+var valtio_exports = {};
+__export(valtio_exports, {
+  default: () => valtio_default
+});
+module.exports = __toCommonJS(valtio_exports);
+var import_utils = require("@umijs/utils");
+var import_path = require("path");
+var valtio_default = (api) => {
+  api.describe({
+    key: "valtio",
+    config: {
+      schema({ zod }) {
+        return zod.object({});
+      }
+    },
+    enableBy: api.EnableBy.config
+  });
+  const libPath = (0, import_utils.winPath)(
+    (0, import_path.dirname)(require.resolve("@umijs/valtio/package.json"))
+  );
+  api.onGenerateFiles(() => {
+    api.writeTmpFile({
+      path: "index.ts",
+      content: `
+export {
+  proxy,
+  useSnapshot,
+  snapshot,
+  subscribe,
+  subscribeKey,
+  proxyWithComputed,
+  proxyWithHistory,
+  proxyWithDevtools,
+  proxyMap,
+  proxySet,
+  derive,
+  underive,
+  useProxy,
+  ref,
+  watch,
+} from '${libPath}';
+      `
+    });
+  });
+  api.modifyConfig((memo) => {
+    memo.alias = {
+      ...memo.alias,
+      "@umijs/valtio": libPath
+    };
+    return memo;
+  });
+};

package/libs/dva.tsx

@@ -0,0 +1,45 @@
+import React from 'react';
+// @ts-ignore
+import { create, saga, utils } from 'dva-core';
+import {
+  connect,
+  Provider,
+  useDispatch,
+  useSelector,
+  useStore,
+} from 'react-redux';
+export { bindActionCreators } from 'redux';
+export { create, saga, utils };
+export { connect, Provider, useDispatch, useSelector, useStore };
+
+export default function dva(opts: any) {
+  const app = create(opts, {
+    initialReducer: {},
+    setupApp() {},
+  });
+  const oldAppStart = app.start;
+  app.router = router;
+  app.start = start;
+  return app;
+
+  function router(router: any) {
+    app._router = router;
+  }
+
+  function start(elem: any) {
+    // old dva.start() supports passing arguments
+    if (typeof elem !== 'undefined') {
+      throw new Error('dva.start() should not be called with any arguments.');
+    }
+    if (!app._store) {
+      oldAppStart.call(app);
+    }
+    const store = app._store;
+    const router = app._router;
+    return (extraProps: any) => {
+      return (
+        <Provider store={store}>{router({ app, ...extraProps })}</Provider>
+      );
+    };
+  }
+}

package/libs/model.tsx

@@ -0,0 +1,180 @@
+// @ts-ignore
+import type { models as rawModels } from '@@/plugin-model/model';
+import isEqual from 'fast-deep-equal';
+import React, { useContext, useEffect, useMemo, useRef, useState } from 'react';
+
+type Models = typeof rawModels;
+
+type GetNamespaces<M> = {
+  [K in keyof M]: M[K] extends { namespace: string }
+    ? M[K]['namespace']
+    : never;
+}[keyof M];
+
+type Namespaces = GetNamespaces<Models>;
+
+// @ts-ignore
+const Context = React.createContext<{ dispatcher: Dispatcher }>(null);
+
+class Dispatcher {
+  callbacks: Record<Namespaces, Set<Function>> = {};
+  data: Record<Namespaces, unknown> = {};
+  update = (namespace: Namespaces) => {
+    if (this.callbacks[namespace]) {
+      this.callbacks[namespace].forEach((cb) => {
+        try {
+          const data = this.data[namespace];
+          cb(data);
+        } catch (e) {
+          cb(undefined);
+        }
+      });
+    }
+  };
+}
+
+interface ExecutorProps {
+  hook: () => any;
+  onUpdate: (val: any) => void;
+  namespace: string;
+}
+
+function Executor(props: ExecutorProps) {
+  const { hook, onUpdate, namespace } = props;
+
+  const updateRef = useRef(onUpdate);
+  const initialLoad = useRef(false);
+
+  let data: any;
+  try {
+    data = hook();
+  } catch (e) {
+    console.error(
+      `plugin-model: Invoking '${namespace || 'unknown'}' model failed:`,
+      e,
+    );
+  }
+
+  // 首次执行时立刻返回初始值
+  useMemo(() => {
+    updateRef.current(data);
+  }, []);
+
+  // React 16.13 后 update 函数用 useEffect 包裹
+  useEffect(() => {
+    if (initialLoad.current) {
+      updateRef.current(data);
+    } else {
+      initialLoad.current = true;
+    }
+  });
+
+  return null;
+}
+
+const dispatcher = new Dispatcher();
+
+export function Provider(props: {
+  models: Record<string, any>;
+  children: React.ReactNode;
+}) {
+  return (
+    <Context.Provider value={{ dispatcher }}>
+      {Object.keys(props.models).map((namespace) => {
+        return (
+          <Executor
+            key={namespace}
+            hook={props.models[namespace]}
+            namespace={namespace}
+            onUpdate={(val) => {
+              dispatcher.data[namespace] = val;
+              dispatcher.update(namespace);
+            }}
+          />
+        );
+      })}
+      {props.children}
+    </Context.Provider>
+  );
+}
+
+type GetModelByNamespace<M, N> = {
+  [K in keyof M]: M[K] extends { namespace: string; model: unknown }
+    ? M[K]['namespace'] extends N
+      ? M[K]['model'] extends (...args: any) => any
+        ? ReturnType<M[K]['model']>
+        : never
+      : never
+    : never;
+}[keyof M];
+
+type Model<N> = GetModelByNamespace<Models, N>;
+type Selector<N, S> = (model: Model<N>) => S;
+
+type SelectedModel<N, T> = T extends (...args: any) => any
+  ? ReturnType<NonNullable<T>>
+  : Model<N>;
+
+export function useModel<N extends Namespaces>(namespace: N): Model<N>;
+
+export function useModel<N extends Namespaces, S>(
+  namespace: N,
+  selector: Selector<N, S>,
+): SelectedModel<N, typeof selector>;
+
+export function useModel<N extends Namespaces, S>(
+  namespace: N,
+  selector?: Selector<N, S>,
+): SelectedModel<N, typeof selector> {
+  const { dispatcher } = useContext<{ dispatcher: Dispatcher }>(Context);
+  const selectorRef = useRef(selector);
+  selectorRef.current = selector;
+  const [state, setState] = useState(() =>
+    selectorRef.current
+      ? selectorRef.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 = (data: any) => {
+      if (!isMount.current) {
+        // 如果 handler 执行过程中，组件被卸载了，则强制更新全局 data
+        // TODO: 需要加个 example 测试
+        setTimeout(() => {
+          dispatcher.data[namespace] = data;
+          dispatcher.update(namespace);
+        });
+      } else {
+        const currentState = selectorRef.current
+          ? selectorRef.current(data)
+          : data;
+        const previousState = stateRef.current;
+        if (!isEqual(currentState, previousState)) {
+          // 避免 currentState 拿到的数据是老的，从而导致 isEqual 比对逻辑有问题
+          stateRef.current = currentState;
+          setState(currentState);
+        }
+      }
+    };
+
+    dispatcher.callbacks[namespace] ||= new Set() as any; // rawModels 是 umi 动态生成的文件，导致前面 callback[namespace] 的类型无法推导出来，所以用 as any 来忽略掉
+    dispatcher.callbacks[namespace].add(handler);
+    dispatcher.update(namespace);
+
+    return () => {
+      dispatcher.callbacks[namespace].delete(handler);
+    };
+  }, [namespace]);
+
+  return state;
+}

package/libs/qiankun/master/AntdErrorBoundary.tsx

@@ -0,0 +1,34 @@
+// @ts-nocheck
+/* eslint-disable */
+import { Button, Result } from 'antd';
+import React from 'react';
+import { getLocale } from 'umi';
+
+const defaultLocale = 'en-US';
+
+export const ErrorBoundary = ({ error }: { error: any }) => {
+  console.error(error);
+
+  const currentLocale = getLocale ? getLocale() : defaultLocale;
+
+  return (
+    <Result
+      status="500"
+      title={
+        currentLocale === defaultLocale
+          ? 'Whoops, something went wrong'
+          : '出错了'
+      }
+      subTitle={
+        currentLocale === defaultLocale
+          ? 'This page failed to load, please try again later'
+          : '页面加载失败，请稍后重试'
+      }
+      extra={
+        <Button type="primary" onClick={() => window.location.reload()}>
+          {currentLocale === defaultLocale ? 'Reload' : '再试一次'}
+        </Button>
+      }
+    />
+  );
+};

package/libs/qiankun/master/AntdLoader.tsx

@@ -0,0 +1,15 @@
+// @ts-nocheck
+/* eslint-disable */
+import { Spin } from 'antd';
+import React from 'react';
+
+export default function AntdLoader(props: { loading: boolean }) {
+  const { loading } = props;
+  const style = {
+    position: 'absolute',
+    top: '50%',
+    left: '50%',
+    transform: 'translate(-50%, -50%)',
+  };
+  return <Spin spinning={loading} size="large" style={style} />;
+}

package/libs/qiankun/master/ErrorBoundary.tsx

@@ -0,0 +1,7 @@
+// @ts-nocheck
+/* eslint-disable */
+import React from 'react';
+
+export const ErrorBoundary = ({ error }: { error: any }) => (
+  <div>{error?.message}</div>
+);