first commit

frontend/node_modules/@rc-component/context/es/Immutable.d.ts

@@ -0,0 +1,10 @@
+import * as React from 'react';
+export type CompareProps<T extends React.ComponentType<any>> = (prevProps: Readonly<React.ComponentProps<T>>, nextProps: Readonly<React.ComponentProps<T>>) => boolean;
+/**
+ * Create Immutable pair for `makeImmutable` and `responseImmutable`.
+ */
+export default function createImmutable(): {
+    makeImmutable: <T extends React.ComponentType<any>>(Component: T, shouldTriggerRender?: CompareProps<T>) => T;
+    responseImmutable: <T_1 extends React.ComponentType<any>>(Component: T_1, propsAreEqual?: CompareProps<T_1>) => T_1;
+    useImmutableMark: () => number;
+};

frontend/node_modules/@rc-component/context/es/Immutable.js

@@ -0,0 +1,79 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import { supportRef } from "rc-util/es/ref";
+import * as React from 'react';
+/**
+ * Create Immutable pair for `makeImmutable` and `responseImmutable`.
+ */
+export default function createImmutable() {
+  var ImmutableContext = /*#__PURE__*/React.createContext(null);
+
+  /**
+   * Get render update mark by `makeImmutable` root.
+   * Do not deps on the return value as render times
+   * but only use for `useMemo` or `useCallback` deps.
+   */
+  function useImmutableMark() {
+    return React.useContext(ImmutableContext);
+  }
+
+  /**
+  * Wrapped Component will be marked as Immutable.
+  * When Component parent trigger render,
+  * it will notice children component (use with `responseImmutable`) node that parent has updated.
+  * @param Component Passed Component
+  * @param triggerRender Customize trigger `responseImmutable` children re-render logic. Default will always trigger re-render when this component re-render.
+  */
+  function makeImmutable(Component, shouldTriggerRender) {
+    var refAble = supportRef(Component);
+    var ImmutableComponent = function ImmutableComponent(props, ref) {
+      var refProps = refAble ? {
+        ref: ref
+      } : {};
+      var renderTimesRef = React.useRef(0);
+      var prevProps = React.useRef(props);
+
+      // If parent has the context, we do not wrap it
+      var mark = useImmutableMark();
+      if (mark !== null) {
+        return /*#__PURE__*/React.createElement(Component, _extends({}, props, refProps));
+      }
+      if (
+      // Always trigger re-render if not provide `notTriggerRender`
+      !shouldTriggerRender || shouldTriggerRender(prevProps.current, props)) {
+        renderTimesRef.current += 1;
+      }
+      prevProps.current = props;
+      return /*#__PURE__*/React.createElement(ImmutableContext.Provider, {
+        value: renderTimesRef.current
+      }, /*#__PURE__*/React.createElement(Component, _extends({}, props, refProps)));
+    };
+    if (process.env.NODE_ENV !== 'production') {
+      ImmutableComponent.displayName = "ImmutableRoot(".concat(Component.displayName || Component.name, ")");
+    }
+    return refAble ? /*#__PURE__*/React.forwardRef(ImmutableComponent) : ImmutableComponent;
+  }
+
+  /**
+   * Wrapped Component with `React.memo`.
+   * But will rerender when parent with `makeImmutable` rerender.
+   */
+  function responseImmutable(Component, propsAreEqual) {
+    var refAble = supportRef(Component);
+    var ImmutableComponent = function ImmutableComponent(props, ref) {
+      var refProps = refAble ? {
+        ref: ref
+      } : {};
+      useImmutableMark();
+      return /*#__PURE__*/React.createElement(Component, _extends({}, props, refProps));
+    };
+    if (process.env.NODE_ENV !== 'production') {
+      ImmutableComponent.displayName = "ImmutableResponse(".concat(Component.displayName || Component.name, ")");
+    }
+    return refAble ? /*#__PURE__*/React.memo( /*#__PURE__*/React.forwardRef(ImmutableComponent), propsAreEqual) : /*#__PURE__*/React.memo(ImmutableComponent, propsAreEqual);
+  }
+  return {
+    makeImmutable: makeImmutable,
+    responseImmutable: responseImmutable,
+    useImmutableMark: useImmutableMark
+  };
+}

frontend/node_modules/@rc-component/context/es/context.d.ts

@@ -0,0 +1,26 @@
+import * as React from 'react';
+export type Selector<ContextProps, SelectorValue = ContextProps> = (value: ContextProps) => SelectorValue;
+export type Trigger<ContextProps> = (value: ContextProps) => void;
+export type Listeners<ContextProps> = Set<Trigger<ContextProps>>;
+export interface Context<ContextProps> {
+    getValue: () => ContextProps;
+    listeners: Listeners<ContextProps>;
+}
+export interface ContextSelectorProviderProps<T> {
+    value: T;
+    children?: React.ReactNode;
+}
+export interface SelectorContext<ContextProps> {
+    Context: React.Context<Context<ContextProps>>;
+    Provider: React.ComponentType<ContextSelectorProviderProps<ContextProps>>;
+    defaultValue?: ContextProps;
+}
+export declare function createContext<ContextProps>(defaultValue?: ContextProps): SelectorContext<ContextProps>;
+/** e.g. useSelect(userContext) => user */
+export declare function useContext<ContextProps>(holder: SelectorContext<ContextProps>): ContextProps;
+/** e.g. useSelect(userContext, user => user.name) => user.name */
+export declare function useContext<ContextProps, SelectorValue>(holder: SelectorContext<ContextProps>, selector: Selector<ContextProps, SelectorValue>): SelectorValue;
+/** e.g. useSelect(userContext, ['name', 'age']) => user { name, age } */
+export declare function useContext<ContextProps, SelectorValue extends Partial<ContextProps>>(holder: SelectorContext<ContextProps>, selector: (keyof ContextProps)[]): SelectorValue;
+/** e.g. useSelect(userContext, 'name') => user.name */
+export declare function useContext<ContextProps, PropName extends keyof ContextProps>(holder: SelectorContext<ContextProps>, selector: PropName): ContextProps[PropName];

frontend/node_modules/@rc-component/context/es/context.js

@@ -0,0 +1,89 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import useEvent from "rc-util/es/hooks/useEvent";
+import useLayoutEffect from "rc-util/es/hooks/useLayoutEffect";
+import isEqual from "rc-util/es/isEqual";
+import * as React from 'react';
+import { unstable_batchedUpdates } from 'react-dom';
+export function createContext(defaultValue) {
+  var Context = /*#__PURE__*/React.createContext(undefined);
+  var Provider = function Provider(_ref) {
+    var value = _ref.value,
+      children = _ref.children;
+    var valueRef = React.useRef(value);
+    valueRef.current = value;
+    var _React$useState = React.useState(function () {
+        return {
+          getValue: function getValue() {
+            return valueRef.current;
+          },
+          listeners: new Set()
+        };
+      }),
+      _React$useState2 = _slicedToArray(_React$useState, 1),
+      context = _React$useState2[0];
+    useLayoutEffect(function () {
+      unstable_batchedUpdates(function () {
+        context.listeners.forEach(function (listener) {
+          listener(value);
+        });
+      });
+    }, [value]);
+    return /*#__PURE__*/React.createElement(Context.Provider, {
+      value: context
+    }, children);
+  };
+  return {
+    Context: Context,
+    Provider: Provider,
+    defaultValue: defaultValue
+  };
+}
+
+/** e.g. useSelect(userContext) => user */
+
+/** e.g. useSelect(userContext, user => user.name) => user.name */
+
+/** e.g. useSelect(userContext, ['name', 'age']) => user { name, age } */
+
+/** e.g. useSelect(userContext, 'name') => user.name */
+
+export function useContext(holder, selector) {
+  var eventSelector = useEvent(typeof selector === 'function' ? selector : function (ctx) {
+    if (selector === undefined) {
+      return ctx;
+    }
+    if (!Array.isArray(selector)) {
+      return ctx[selector];
+    }
+    var obj = {};
+    selector.forEach(function (key) {
+      obj[key] = ctx[key];
+    });
+    return obj;
+  });
+  var context = React.useContext(holder === null || holder === void 0 ? void 0 : holder.Context);
+  var _ref2 = context || {},
+    listeners = _ref2.listeners,
+    getValue = _ref2.getValue;
+  var valueRef = React.useRef();
+  valueRef.current = eventSelector(context ? getValue() : holder === null || holder === void 0 ? void 0 : holder.defaultValue);
+  var _React$useState3 = React.useState({}),
+    _React$useState4 = _slicedToArray(_React$useState3, 2),
+    forceUpdate = _React$useState4[1];
+  useLayoutEffect(function () {
+    if (!context) {
+      return;
+    }
+    function trigger(nextValue) {
+      var nextSelectorValue = eventSelector(nextValue);
+      if (!isEqual(valueRef.current, nextSelectorValue, true)) {
+        forceUpdate({});
+      }
+    }
+    listeners.add(trigger);
+    return function () {
+      listeners.delete(trigger);
+    };
+  }, [context]);
+  return valueRef.current;
+}

frontend/node_modules/@rc-component/context/es/index.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+import type { SelectorContext } from './context';
+import { createContext, useContext } from './context';
+import createImmutable from './Immutable';
+declare const makeImmutable: <T extends import("react").ComponentType<any>>(Component: T, shouldTriggerRender?: import("./Immutable").CompareProps<T>) => T, responseImmutable: <T extends import("react").ComponentType<any>>(Component: T, propsAreEqual?: import("./Immutable").CompareProps<T>) => T, useImmutableMark: () => number;
+export { createContext, useContext, createImmutable, makeImmutable, responseImmutable, useImmutableMark, };
+export type { SelectorContext };

frontend/node_modules/@rc-component/context/es/index.js

@@ -0,0 +1,9 @@
+import { createContext, useContext } from "./context";
+import createImmutable from "./Immutable";
+
+// For legacy usage, we export it directly
+var _createImmutable = createImmutable(),
+  makeImmutable = _createImmutable.makeImmutable,
+  responseImmutable = _createImmutable.responseImmutable,
+  useImmutableMark = _createImmutable.useImmutableMark;
+export { createContext, useContext, createImmutable, makeImmutable, responseImmutable, useImmutableMark };