1

video-gen-admin/node_modules/@rc-component/resize-observer/lib/Collection.d.ts

@@ -0,0 +1,19 @@
+import * as React from 'react';
+import type { SizeInfo } from '.';
+type onCollectionResize = (size: SizeInfo, element: HTMLElement, data: any) => void;
+export declare const CollectionContext: React.Context<onCollectionResize>;
+export interface ResizeInfo {
+    size: SizeInfo;
+    data: any;
+    element: HTMLElement;
+}
+export interface CollectionProps {
+    /** Trigger when some children ResizeObserver changed. Collect by frame render level */
+    onBatchResize?: (resizeInfo: ResizeInfo[]) => void;
+    children?: React.ReactNode;
+}
+/**
+ * Collect all the resize event from children ResizeObserver
+ */
+export declare function Collection({ children, onBatchResize }: CollectionProps): React.JSX.Element;
+export {};

video-gen-admin/node_modules/@rc-component/resize-observer/lib/Collection.js

@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Collection = Collection;
+exports.CollectionContext = void 0;
+var React = _interopRequireWildcard(require("react"));
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+const CollectionContext = exports.CollectionContext = /*#__PURE__*/React.createContext(null);
+/**
+ * Collect all the resize event from children ResizeObserver
+ */
+function Collection({
+  children,
+  onBatchResize
+}) {
+  const resizeIdRef = React.useRef(0);
+  const resizeInfosRef = React.useRef([]);
+  const onCollectionResize = React.useContext(CollectionContext);
+  const onResize = React.useCallback((size, element, data) => {
+    resizeIdRef.current += 1;
+    const currentId = resizeIdRef.current;
+    resizeInfosRef.current.push({
+      size,
+      element,
+      data
+    });
+    Promise.resolve().then(() => {
+      if (currentId === resizeIdRef.current) {
+        onBatchResize?.(resizeInfosRef.current);
+        resizeInfosRef.current = [];
+      }
+    });
+
+    // Continue bubbling if parent exist
+    onCollectionResize?.(size, element, data);
+  }, [onBatchResize, onCollectionResize]);
+  return /*#__PURE__*/React.createElement(CollectionContext.Provider, {
+    value: onResize
+  }, children);
+}

video-gen-admin/node_modules/@rc-component/resize-observer/lib/SingleObserver/index.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+import type { ResizeObserverProps } from '..';
+export interface SingleObserverProps extends ResizeObserverProps {
+    children: React.ReactElement | ((ref: React.RefObject<Element>) => React.ReactElement);
+}
+declare const RefSingleObserver: React.ForwardRefExoticComponent<SingleObserverProps & React.RefAttributes<HTMLElement>>;
+export default RefSingleObserver;

video-gen-admin/node_modules/@rc-component/resize-observer/lib/SingleObserver/index.js

@@ -0,0 +1,52 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _findDOMNode = require("@rc-component/util/lib/Dom/findDOMNode");
+var _ref = require("@rc-component/util/lib/ref");
+var React = _interopRequireWildcard(require("react"));
+var _Collection = require("../Collection");
+var _useResizeObserver = _interopRequireDefault(require("../useResizeObserver"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+function SingleObserver(props, ref) {
+  const {
+    children,
+    disabled,
+    onResize,
+    data
+  } = props;
+  const elementRef = React.useRef(null);
+  const onCollectionResize = React.useContext(_Collection.CollectionContext);
+
+  // =========================== Children ===========================
+  const isRenderProps = typeof children === 'function';
+  const mergedChildren = isRenderProps ? children(elementRef) : children;
+
+  // ============================= Ref ==============================
+  const canRef = !isRenderProps && /*#__PURE__*/React.isValidElement(mergedChildren) && (0, _ref.supportRef)(mergedChildren);
+  const originRef = canRef ? (0, _ref.getNodeRef)(mergedChildren) : null;
+  const mergedRef = (0, _ref.useComposeRef)(originRef, elementRef);
+  const getDomElement = () => {
+    return (0, _findDOMNode.getDOM)(elementRef.current);
+  };
+  React.useImperativeHandle(ref, () => getDomElement());
+
+  // =========================== Observe ============================
+  (0, _useResizeObserver.default)(!disabled, getDomElement, onResize, (sizeInfo, target) => {
+    onCollectionResize?.(sizeInfo, target, data);
+  });
+
+  // ============================ Render ============================
+  return canRef ? /*#__PURE__*/React.cloneElement(mergedChildren, {
+    ref: mergedRef
+  }) : mergedChildren;
+}
+const RefSingleObserver = /*#__PURE__*/React.forwardRef(SingleObserver);
+if (process.env.NODE_ENV !== 'production') {
+  RefSingleObserver.displayName = 'SingleObserver';
+}
+var _default = exports.default = RefSingleObserver;

video-gen-admin/node_modules/@rc-component/resize-observer/lib/index.d.ts

@@ -0,0 +1,26 @@
+import * as React from 'react';
+import { Collection } from './Collection';
+import { _rs } from './utils/observerUtil';
+export { 
+/** @private Test only for mock trigger resize event */
+_rs, };
+export { default as useResizeObserver } from './useResizeObserver';
+export interface SizeInfo {
+    width: number;
+    height: number;
+    offsetWidth: number;
+    offsetHeight: number;
+}
+export type OnResize = (size: SizeInfo, element: HTMLElement) => void;
+export interface ResizeObserverProps {
+    /** Pass to ResizeObserver.Collection with additional data */
+    data?: any;
+    children: React.ReactNode | ((ref: React.RefObject<any>) => React.ReactElement);
+    disabled?: boolean;
+    /** Trigger if element resized. Will always trigger when first time render. */
+    onResize?: OnResize;
+}
+declare const RefResizeObserver: React.ForwardRefExoticComponent<ResizeObserverProps & React.RefAttributes<any>> & {
+    Collection: typeof Collection;
+};
+export default RefResizeObserver;

video-gen-admin/node_modules/@rc-component/resize-observer/lib/index.js

@@ -0,0 +1,56 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "_rs", {
+  enumerable: true,
+  get: function () {
+    return _observerUtil._rs;
+  }
+});
+exports.default = void 0;
+Object.defineProperty(exports, "useResizeObserver", {
+  enumerable: true,
+  get: function () {
+    return _useResizeObserver.default;
+  }
+});
+var React = _interopRequireWildcard(require("react"));
+var _toArray = _interopRequireDefault(require("@rc-component/util/lib/Children/toArray"));
+var _warning = require("@rc-component/util/lib/warning");
+var _SingleObserver = _interopRequireDefault(require("./SingleObserver"));
+var _Collection = require("./Collection");
+var _observerUtil = require("./utils/observerUtil");
+var _useResizeObserver = _interopRequireDefault(require("./useResizeObserver"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+const INTERNAL_PREFIX_KEY = 'rc-observer-key';
+function ResizeObserver(props, ref) {
+  const {
+    children
+  } = props;
+  const childNodes = typeof children === 'function' ? [children] : (0, _toArray.default)(children);
+  if (process.env.NODE_ENV !== 'production') {
+    if (childNodes.length > 1) {
+      (0, _warning.warning)(false, 'Find more than one child node with `children` in ResizeObserver. Please use ResizeObserver.Collection instead.');
+    } else if (childNodes.length === 0) {
+      (0, _warning.warning)(false, '`children` of ResizeObserver is empty. Nothing is in observe.');
+    }
+  }
+  return childNodes.map((child, index) => {
+    const key = child?.key || `${INTERNAL_PREFIX_KEY}-${index}`;
+    return /*#__PURE__*/React.createElement(_SingleObserver.default, _extends({}, props, {
+      key: key,
+      ref: index === 0 ? ref : undefined
+    }), child);
+  });
+}
+const RefResizeObserver = /*#__PURE__*/React.forwardRef(ResizeObserver);
+if (process.env.NODE_ENV !== 'production') {
+  RefResizeObserver.displayName = 'ResizeObserver';
+}
+RefResizeObserver.Collection = _Collection.Collection;
+var _default = exports.default = RefResizeObserver;

video-gen-admin/node_modules/@rc-component/resize-observer/lib/useResizeObserver.d.ts

@@ -0,0 +1,2 @@
+import type { OnResize } from '.';
+export default function useResizeObserver(enabled: boolean, getTarget: HTMLElement | (() => HTMLElement), onDelayResize?: OnResize, onSyncResize?: OnResize): void;

video-gen-admin/node_modules/@rc-component/resize-observer/lib/useResizeObserver.js

@@ -0,0 +1,89 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = useResizeObserver;
+var React = _interopRequireWildcard(require("react"));
+var _observerUtil = require("./utils/observerUtil");
+var _util = require("@rc-component/util");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+function useResizeObserver(enabled, getTarget, onDelayResize, onSyncResize) {
+  // ============================= Size =============================
+  const sizeRef = React.useRef({
+    width: -1,
+    height: -1,
+    offsetWidth: -1,
+    offsetHeight: -1
+  });
+
+  // =========================== Observe ============================
+
+  // Handler
+  const onInternalResize = (0, _util.useEvent)(target => {
+    const {
+      width,
+      height
+    } = target.getBoundingClientRect();
+    const {
+      offsetWidth,
+      offsetHeight
+    } = target;
+
+    /**
+     * Resize observer trigger when content size changed.
+     * In most case we just care about element size,
+     * let's use `boundary` instead of `contentRect` here to avoid shaking.
+     */
+    const fixedWidth = Math.floor(width);
+    const fixedHeight = Math.floor(height);
+    if (sizeRef.current.width !== fixedWidth || sizeRef.current.height !== fixedHeight || sizeRef.current.offsetWidth !== offsetWidth || sizeRef.current.offsetHeight !== offsetHeight) {
+      const size = {
+        width: fixedWidth,
+        height: fixedHeight,
+        offsetWidth,
+        offsetHeight
+      };
+      sizeRef.current = size;
+
+      // IE is strange, right?
+      const mergedOffsetWidth = offsetWidth === Math.round(width) ? width : offsetWidth;
+      const mergedOffsetHeight = offsetHeight === Math.round(height) ? height : offsetHeight;
+      const sizeInfo = {
+        ...size,
+        offsetWidth: mergedOffsetWidth,
+        offsetHeight: mergedOffsetHeight
+      };
+
+      // Call the callback immediately, let the caller decide whether to defer
+      // onResize(sizeInfo, target);
+      onSyncResize?.(sizeInfo, target);
+
+      // defer the callback but not defer to next frame
+      Promise.resolve().then(() => {
+        onDelayResize?.(sizeInfo, target);
+      });
+    }
+  });
+
+  // Dynamic observe
+  const isFuncTarget = typeof getTarget === 'function';
+  const funcTargetIdRef = React.useRef(0);
+  React.useEffect(() => {
+    const target = isFuncTarget ? getTarget() : getTarget;
+    if (target && enabled) {
+      (0, _observerUtil.observe)(target, onInternalResize);
+    } else if (enabled && isFuncTarget) {
+      funcTargetIdRef.current += 1;
+    }
+    return () => {
+      if (target) {
+        (0, _observerUtil.unobserve)(target, onInternalResize);
+      }
+    };
+  }, [enabled,
+  // If function target resolves after a parent render, the bumped ref value
+  // lets the next render re-run this effect without watching the function identity.
+  isFuncTarget ? funcTargetIdRef.current : getTarget]);
+}

video-gen-admin/node_modules/@rc-component/resize-observer/lib/utils/observerUtil.d.ts

@@ -0,0 +1,7 @@
+export type ResizeListener = (element: Element) => void;
+declare function onResize(entities: ResizeObserverEntry[]): void;
+export declare const _el: Map<Element, Set<ResizeListener>>;
+export declare const _rs: typeof onResize;
+export declare function observe(element: Element, callback: ResizeListener): void;
+export declare function unobserve(element: Element, callback: ResizeListener): void;
+export {};

video-gen-admin/node_modules/@rc-component/resize-observer/lib/utils/observerUtil.js

@@ -0,0 +1,49 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports._rs = exports._el = void 0;
+exports.observe = observe;
+exports.unobserve = unobserve;
+// =============================== Const ===============================
+const elementListeners = new Map();
+function onResize(entities) {
+  entities.forEach(entity => {
+    const {
+      target
+    } = entity;
+    elementListeners.get(target)?.forEach(listener => listener(target));
+  });
+}
+
+// Delay create ResizeObserver since it's not supported in server side
+let observer;
+function ensureResizeObserver() {
+  if (!observer) {
+    observer = new ResizeObserver(onResize);
+  }
+  return observer;
+}
+
+// Dev env only
+const _el = exports._el = process.env.NODE_ENV !== 'production' ? elementListeners : null; // eslint-disable-line
+const _rs = exports._rs = process.env.NODE_ENV !== 'production' ? onResize : null; // eslint-disable-line
+
+// ============================== Observe ==============================
+function observe(element, callback) {
+  if (!elementListeners.has(element)) {
+    elementListeners.set(element, new Set());
+    ensureResizeObserver().observe(element);
+  }
+  elementListeners.get(element).add(callback);
+}
+function unobserve(element, callback) {
+  if (elementListeners.has(element)) {
+    elementListeners.get(element).delete(callback);
+    if (!elementListeners.get(element).size) {
+      ensureResizeObserver().unobserve(element);
+      elementListeners.delete(element);
+    }
+  }
+}