first commit

frontend/node_modules/@rc-component/context/lib/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/lib/Immutable.js

@@ -0,0 +1,89 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = createImmutable;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _ref = require("rc-util/lib/ref");
+var React = _interopRequireWildcard(require("react"));
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+/**
+ * Create Immutable pair for `makeImmutable` and `responseImmutable`.
+ */
+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 = (0, _ref.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, (0, _extends2.default)({}, 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, (0, _extends2.default)({}, 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 = (0, _ref.supportRef)(Component);
+    var ImmutableComponent = function ImmutableComponent(props, ref) {
+      var refProps = refAble ? {
+        ref: ref
+      } : {};
+      useImmutableMark();
+      return /*#__PURE__*/React.createElement(Component, (0, _extends2.default)({}, 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/lib/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/lib/context.js

@@ -0,0 +1,100 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createContext = createContext;
+exports.useContext = useContext;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _useEvent = _interopRequireDefault(require("rc-util/lib/hooks/useEvent"));
+var _useLayoutEffect = _interopRequireDefault(require("rc-util/lib/hooks/useLayoutEffect"));
+var _isEqual = _interopRequireDefault(require("rc-util/lib/isEqual"));
+var React = _interopRequireWildcard(require("react"));
+var _reactDom = require("react-dom");
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+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 = (0, _slicedToArray2.default)(_React$useState, 1),
+      context = _React$useState2[0];
+    (0, _useLayoutEffect.default)(function () {
+      (0, _reactDom.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 */
+
+function useContext(holder, selector) {
+  var eventSelector = (0, _useEvent.default)(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 = (0, _slicedToArray2.default)(_React$useState3, 2),
+    forceUpdate = _React$useState4[1];
+  (0, _useLayoutEffect.default)(function () {
+    if (!context) {
+      return;
+    }
+    function trigger(nextValue) {
+      var nextSelectorValue = eventSelector(nextValue);
+      if (!(0, _isEqual.default)(valueRef.current, nextSelectorValue, true)) {
+        forceUpdate({});
+      }
+    }
+    listeners.add(trigger);
+    return function () {
+      listeners.delete(trigger);
+    };
+  }, [context]);
+  return valueRef.current;
+}

frontend/node_modules/@rc-component/context/lib/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/lib/index.js

@@ -0,0 +1,36 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "createContext", {
+  enumerable: true,
+  get: function get() {
+    return _context.createContext;
+  }
+});
+Object.defineProperty(exports, "createImmutable", {
+  enumerable: true,
+  get: function get() {
+    return _Immutable.default;
+  }
+});
+exports.responseImmutable = exports.makeImmutable = void 0;
+Object.defineProperty(exports, "useContext", {
+  enumerable: true,
+  get: function get() {
+    return _context.useContext;
+  }
+});
+exports.useImmutableMark = void 0;
+var _context = require("./context");
+var _Immutable = _interopRequireDefault(require("./Immutable"));
+// For legacy usage, we export it directly
+var _createImmutable = (0, _Immutable.default)(),
+  makeImmutable = _createImmutable.makeImmutable,
+  responseImmutable = _createImmutable.responseImmutable,
+  useImmutableMark = _createImmutable.useImmutableMark;
+exports.useImmutableMark = useImmutableMark;
+exports.responseImmutable = responseImmutable;
+exports.makeImmutable = makeImmutable;