1

video-gen-admin/node_modules/@rc-component/resize-observer/es/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/es/Collection.js

@@ -0,0 +1,34 @@
+import * as React from 'react';
+export const CollectionContext = /*#__PURE__*/React.createContext(null);
+/**
+ * Collect all the resize event from children ResizeObserver
+ */
+export 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/es/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/es/SingleObserver/index.js

@@ -0,0 +1,43 @@
+import { getDOM } from "@rc-component/util/es/Dom/findDOMNode";
+import { supportRef, useComposeRef, getNodeRef } from "@rc-component/util/es/ref";
+import * as React from 'react';
+import { CollectionContext } from "../Collection";
+import useResizeObserver from "../useResizeObserver";
+function SingleObserver(props, ref) {
+  const {
+    children,
+    disabled,
+    onResize,
+    data
+  } = props;
+  const elementRef = React.useRef(null);
+  const onCollectionResize = React.useContext(CollectionContext);
+
+  // =========================== Children ===========================
+  const isRenderProps = typeof children === 'function';
+  const mergedChildren = isRenderProps ? children(elementRef) : children;
+
+  // ============================= Ref ==============================
+  const canRef = !isRenderProps && /*#__PURE__*/React.isValidElement(mergedChildren) && supportRef(mergedChildren);
+  const originRef = canRef ? getNodeRef(mergedChildren) : null;
+  const mergedRef = useComposeRef(originRef, elementRef);
+  const getDomElement = () => {
+    return getDOM(elementRef.current);
+  };
+  React.useImperativeHandle(ref, () => getDomElement());
+
+  // =========================== Observe ============================
+  useResizeObserver(!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';
+}
+export default RefSingleObserver;

video-gen-admin/node_modules/@rc-component/resize-observer/es/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/es/index.js

@@ -0,0 +1,37 @@
+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); }
+import * as React from 'react';
+import toArray from "@rc-component/util/es/Children/toArray";
+import { warning } from "@rc-component/util/es/warning";
+import SingleObserver from "./SingleObserver";
+import { Collection } from "./Collection";
+const INTERNAL_PREFIX_KEY = 'rc-observer-key';
+import { _rs } from "./utils/observerUtil";
+export { /** @private Test only for mock trigger resize event */
+_rs };
+export { default as useResizeObserver } from "./useResizeObserver";
+function ResizeObserver(props, ref) {
+  const {
+    children
+  } = props;
+  const childNodes = typeof children === 'function' ? [children] : toArray(children);
+  if (process.env.NODE_ENV !== 'production') {
+    if (childNodes.length > 1) {
+      warning(false, 'Find more than one child node with `children` in ResizeObserver. Please use ResizeObserver.Collection instead.');
+    } else if (childNodes.length === 0) {
+      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, _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;
+export default RefResizeObserver;

video-gen-admin/node_modules/@rc-component/resize-observer/es/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/es/useResizeObserver.js

@@ -0,0 +1,81 @@
+import * as React from 'react';
+import { observe, unobserve } from "./utils/observerUtil";
+import { useEvent } from '@rc-component/util';
+export default function useResizeObserver(enabled, getTarget, onDelayResize, onSyncResize) {
+  // ============================= Size =============================
+  const sizeRef = React.useRef({
+    width: -1,
+    height: -1,
+    offsetWidth: -1,
+    offsetHeight: -1
+  });
+
+  // =========================== Observe ============================
+
+  // Handler
+  const onInternalResize = 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) {
+      observe(target, onInternalResize);
+    } else if (enabled && isFuncTarget) {
+      funcTargetIdRef.current += 1;
+    }
+    return () => {
+      if (target) {
+        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/es/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/es/utils/observerUtil.js

@@ -0,0 +1,41 @@
+// =============================== 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
+export const _el = process.env.NODE_ENV !== 'production' ? elementListeners : null; // eslint-disable-line
+export const _rs = process.env.NODE_ENV !== 'production' ? onResize : null; // eslint-disable-line
+
+// ============================== Observe ==============================
+export function observe(element, callback) {
+  if (!elementListeners.has(element)) {
+    elementListeners.set(element, new Set());
+    ensureResizeObserver().observe(element);
+  }
+  elementListeners.get(element).add(callback);
+}
+export function unobserve(element, callback) {
+  if (elementListeners.has(element)) {
+    elementListeners.get(element).delete(callback);
+    if (!elementListeners.get(element).size) {
+      ensureResizeObserver().unobserve(element);
+      elementListeners.delete(element);
+    }
+  }
+}