1

video-gen-admin/node_modules/antd/lib/masonry/Masonry.d.ts

@@ -0,0 +1,46 @@
+import * as React from 'react';
+import type { CSSProperties } from 'react';
+import type { SemanticClassNamesType, SemanticStylesType } from '../_util/hooks';
+import type { Breakpoint } from '../_util/responsiveObserver';
+import type { RowProps } from '../grid';
+import type { MasonryItemType } from './MasonryItem';
+export type Gap = number | undefined;
+export type Key = string | number;
+export type MasonrySemanticName = keyof MasonrySemanticClassNames & keyof MasonrySemanticStyles;
+export type MasonrySemanticClassNames = {
+    root?: string;
+    item?: string;
+};
+export type MasonrySemanticStyles = {
+    root?: React.CSSProperties;
+    item?: React.CSSProperties;
+};
+export type MasonryClassNamesType = SemanticClassNamesType<MasonryProps, MasonrySemanticClassNames>;
+export type MasonryStylesType = SemanticStylesType<MasonryProps, MasonrySemanticStyles>;
+export interface MasonryProps<ItemDataType = any> {
+    prefixCls?: string;
+    className?: string;
+    rootClassName?: string;
+    style?: CSSProperties;
+    classNames?: MasonryClassNamesType;
+    styles?: MasonryStylesType;
+    /** Spacing between items */
+    gutter?: RowProps['gutter'];
+    items?: MasonryItemType<ItemDataType>[];
+    itemRender?: (itemInfo: MasonryItemType<ItemDataType> & {
+        index: number;
+    }) => React.ReactNode;
+    /** Number of columns in the masonry grid layout */
+    columns?: number | Partial<Record<Breakpoint, number>>;
+    /** Trigger when item layout order changed */
+    onLayoutChange?: (sortInfo: {
+        key: React.Key;
+        column: number;
+    }[]) => void;
+    fresh?: boolean;
+}
+export interface MasonryRef {
+    nativeElement: HTMLDivElement;
+}
+declare const _default: (<ItemDataType = any>(props: React.PropsWithChildren<MasonryProps<ItemDataType>> & React.RefAttributes<MasonryRef>) => React.ReactElement) & Pick<React.FC, "displayName">;
+export default _default;

video-gen-admin/node_modules/antd/lib/masonry/Masonry.js

@@ -0,0 +1,212 @@
+"use strict";
+"use client";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var React = _interopRequireWildcard(require("react"));
+var _motion = require("@rc-component/motion");
+var _resizeObserver = _interopRequireDefault(require("@rc-component/resize-observer"));
+var _useLayoutEffect = _interopRequireDefault(require("@rc-component/util/lib/hooks/useLayoutEffect"));
+var _isEqual = _interopRequireDefault(require("@rc-component/util/lib/isEqual"));
+var _ref = require("@rc-component/util/lib/ref");
+var _clsx = require("clsx");
+var _hooks = require("../_util/hooks");
+var _is = require("../_util/is");
+var _responsiveObserver = require("../_util/responsiveObserver");
+var _context = require("../config-provider/context");
+var _useCSSVarCls = _interopRequireDefault(require("../config-provider/hooks/useCSSVarCls"));
+var _useBreakpoint = _interopRequireDefault(require("../grid/hooks/useBreakpoint"));
+var _useGutter = _interopRequireDefault(require("../grid/hooks/useGutter"));
+var _genStyleUtils = require("../theme/util/genStyleUtils");
+var _useDelay = _interopRequireDefault(require("./hooks/useDelay"));
+var _usePositions = _interopRequireDefault(require("./hooks/usePositions"));
+var _useRefs = _interopRequireDefault(require("./hooks/useRefs"));
+var _MasonryItem = _interopRequireDefault(require("./MasonryItem"));
+var _style = _interopRequireDefault(require("./style"));
+const Masonry = /*#__PURE__*/React.forwardRef((props, ref) => {
+  const {
+    rootClassName,
+    className,
+    style,
+    classNames,
+    styles,
+    columns,
+    prefixCls: customizePrefixCls,
+    gutter = 0,
+    items,
+    itemRender,
+    onLayoutChange,
+    fresh
+  } = props;
+  // ======================= MISC =======================
+  const {
+    getPrefixCls,
+    direction,
+    className: contextClassName,
+    style: contextStyle,
+    classNames: contextClassNames,
+    styles: contextStyles
+  } = (0, _context.useComponentConfig)('masonry');
+  const prefixCls = getPrefixCls('masonry', customizePrefixCls);
+  const rootPrefixCls = getPrefixCls();
+  const rootCls = (0, _useCSSVarCls.default)(prefixCls);
+  const [hashId, cssVarCls] = (0, _style.default)(prefixCls, rootCls);
+  const [varName, varRef] = (0, _genStyleUtils.genCssVar)(rootPrefixCls, 'masonry');
+  // ======================= Refs =======================
+  const containerRef = React.useRef(null);
+  React.useImperativeHandle(ref, () => ({
+    nativeElement: containerRef.current
+  }));
+  const [setItemRef, getItemRef] = (0, _useRefs.default)();
+  // ======================= Item =======================
+  const [mergedItems, setMergedItems] = React.useState([]);
+  React.useEffect(() => {
+    setMergedItems(items || []);
+  }, [items]);
+  // ==================== Breakpoint ====================
+  const screens = (0, _useBreakpoint.default)();
+  const gutters = (0, _useGutter.default)(gutter, screens);
+  const [horizontalGutter = 0, verticalGutter = horizontalGutter] = gutters;
+  // ====================== Layout ======================
+  const columnCount = React.useMemo(() => {
+    if (!columns) {
+      return 3;
+    }
+    if ((0, _is.isNumber)(columns)) {
+      return columns;
+    }
+    // Find first matching responsive breakpoint
+    const matchingBreakpoint = _responsiveObserver.responsiveArray.find(breakpoint => screens[breakpoint] && columns[breakpoint] !== undefined);
+    if (matchingBreakpoint) {
+      return columns[matchingBreakpoint];
+    }
+    return columns.xs ?? 1;
+  }, [columns, screens]);
+  // =========== Merged Props for Semantic ==========
+  const mergedProps = {
+    ...props,
+    columns: columnCount
+  };
+  const [mergedClassNames, mergedStyles] = (0, _hooks.useMergeSemantic)([contextClassNames, classNames], [contextStyles, styles], {
+    props: mergedProps
+  });
+  // ================== Items Position ==================
+  const [itemHeights, setItemHeights] = React.useState([]);
+  const collectItemSize = (0, _useDelay.default)(() => {
+    const nextItemsHeight = mergedItems.map((item, index) => {
+      const itemKey = item.key ?? index;
+      const itemEle = getItemRef(itemKey);
+      const rect = itemEle?.getBoundingClientRect();
+      return [itemKey, rect ? rect.height : 0, item.column];
+    });
+    setItemHeights(prevItemsHeight => (0, _isEqual.default)(prevItemsHeight, nextItemsHeight) ? prevItemsHeight : nextItemsHeight);
+  });
+  const [itemPositions, totalHeight] = (0, _usePositions.default)(itemHeights, columnCount, verticalGutter);
+  const itemWithPositions = React.useMemo(() => mergedItems.map((item, index) => {
+    const key = item.key ?? index;
+    return {
+      item,
+      itemIndex: index,
+      // CSSMotion will transform key to string.
+      // Let's keep the original key here.
+      itemKey: key,
+      key,
+      position: itemPositions.get(key)
+    };
+  }), [mergedItems, itemPositions]);
+  React.useEffect(() => {
+    collectItemSize();
+  }, [mergedItems, columnCount]);
+  // Trigger for `onLayoutChange`
+  const [itemColumns, setItemColumns] = React.useState([]);
+  (0, _useLayoutEffect.default)(() => {
+    if (onLayoutChange && itemWithPositions.every(({
+      position
+    }) => position)) {
+      setItemColumns(prevItemColumns => {
+        const nextItemColumns = itemWithPositions.map(({
+          item,
+          position
+        }) => [item, position.column]);
+        return (0, _isEqual.default)(prevItemColumns, nextItemColumns) ? prevItemColumns : nextItemColumns;
+      });
+    }
+  }, [itemWithPositions]);
+  (0, _useLayoutEffect.default)(() => {
+    if (onLayoutChange && items && items.length === itemColumns.length) {
+      onLayoutChange(itemColumns.map(([item, column]) => ({
+        ...item,
+        column
+      })));
+    }
+  }, [itemColumns]);
+  // ====================== Render ======================
+  return /*#__PURE__*/React.createElement(_resizeObserver.default, {
+    onResize: collectItemSize
+  }, /*#__PURE__*/React.createElement("div", {
+    ref: containerRef,
+    className: (0, _clsx.clsx)(prefixCls, contextClassName, mergedClassNames.root, rootClassName, className, hashId, cssVarCls, {
+      [`${prefixCls}-rtl`]: direction === 'rtl'
+    }),
+    style: {
+      height: totalHeight,
+      ...mergedStyles.root,
+      ...contextStyle,
+      ...style
+    },
+    // Listen for image events
+    onLoad: collectItemSize,
+    onError: collectItemSize
+  }, /*#__PURE__*/React.createElement(_motion.CSSMotionList, {
+    keys: itemWithPositions,
+    component: false,
+    // Motion config
+    motionAppear: true,
+    motionLeave: true,
+    motionName: `${prefixCls}-item-fade`
+  }, (motionInfo, motionRef) => {
+    const {
+      item,
+      itemKey,
+      position = {},
+      itemIndex,
+      key,
+      className: motionClassName,
+      style: motionStyle
+    } = motionInfo;
+    const {
+      column: columnIndex = 0
+    } = position;
+    const itemStyle = {
+      [varName('item-width')]: `calc((100% + ${horizontalGutter}px) / ${columnCount})`,
+      insetInlineStart: `calc(${varRef('item-width')} * ${columnIndex})`,
+      width: `calc(${varRef('item-width')} - ${horizontalGutter}px)`,
+      top: position.top,
+      position: 'absolute'
+    };
+    return /*#__PURE__*/React.createElement(_MasonryItem.default, {
+      prefixCls: prefixCls,
+      key: key,
+      item: item,
+      style: {
+        ...motionStyle,
+        ...mergedStyles.item,
+        ...itemStyle
+      },
+      className: (0, _clsx.clsx)(mergedClassNames.item, motionClassName),
+      ref: (0, _ref.composeRef)(motionRef, ele => setItemRef(itemKey, ele)),
+      index: itemIndex,
+      itemRender: itemRender,
+      column: columnIndex,
+      onResize: fresh ? collectItemSize : null
+    });
+  })));
+});
+if (process.env.NODE_ENV !== 'production') {
+  Masonry.displayName = 'Masonry';
+}
+var _default = exports.default = Masonry;

video-gen-admin/node_modules/antd/lib/masonry/MasonryItem.d.ts

@@ -0,0 +1,20 @@
+import React from 'react';
+import type { MasonryProps } from './Masonry';
+export interface MasonryItemType<T = any> {
+    key: React.Key;
+    column?: number;
+    height?: number;
+    children?: React.ReactNode;
+    data: T;
+}
+interface MasonryItemProps<T = any> extends Pick<MasonryProps, 'itemRender'> {
+    prefixCls: string;
+    item: MasonryItemType<T>;
+    style: React.CSSProperties;
+    className?: string;
+    index: number;
+    column: number;
+    onResize: VoidFunction | null;
+}
+declare const MasonryItem: React.ForwardRefExoticComponent<MasonryItemProps<any> & React.RefAttributes<HTMLDivElement>>;
+export default MasonryItem;

video-gen-admin/node_modules/antd/lib/masonry/MasonryItem.js

@@ -0,0 +1,49 @@
+"use strict";
+"use client";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var _resizeObserver = _interopRequireDefault(require("@rc-component/resize-observer"));
+var _clsx = require("clsx");
+const MasonryItem = /*#__PURE__*/_react.default.forwardRef((props, ref) => {
+  const {
+    item,
+    style,
+    prefixCls,
+    itemRender,
+    className,
+    index,
+    column,
+    onResize
+  } = props;
+  const itemPrefix = `${prefixCls}-item`;
+  // ====================== Render ======================
+  const renderNode = (0, _react.useMemo)(() => {
+    return item.children ?? itemRender?.({
+      ...item,
+      index,
+      column
+    });
+  }, [item, itemRender, column, index]);
+  let returnNode = /*#__PURE__*/_react.default.createElement("div", {
+    ref: ref,
+    style: style,
+    className: (0, _clsx.clsx)(itemPrefix, className)
+  }, renderNode);
+  // Listen for resize
+  if (onResize) {
+    returnNode = /*#__PURE__*/_react.default.createElement(_resizeObserver.default, {
+      onResize: onResize
+    }, returnNode);
+  }
+  return returnNode;
+});
+if (process.env.NODE_ENV !== 'production') {
+  MasonryItem.displayName = 'MasonryItem';
+}
+var _default = exports.default = MasonryItem;

video-gen-admin/node_modules/antd/lib/masonry/hooks/useDelay.d.ts

@@ -0,0 +1 @@
+export default function useDelay(callback: VoidFunction): () => void;

video-gen-admin/node_modules/antd/lib/masonry/hooks/useDelay.js

@@ -0,0 +1,23 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = useDelay;
+var React = _interopRequireWildcard(require("react"));
+var _util = require("@rc-component/util");
+var _raf = _interopRequireDefault(require("@rc-component/util/lib/raf"));
+function useDelay(callback) {
+  const idRef = React.useRef(0);
+  const clearRaf = () => {
+    _raf.default.cancel(idRef.current);
+  };
+  React.useEffect(() => clearRaf, []);
+  const triggerFn = (0, _util.useEvent)(() => {
+    clearRaf();
+    idRef.current = (0, _raf.default)(callback);
+  });
+  return triggerFn;
+}

video-gen-admin/node_modules/antd/lib/masonry/hooks/usePositions.d.ts

@@ -0,0 +1,12 @@
+import type { Key } from 'react';
+export type ItemHeightData = [key: Key, height: number, column?: number];
+export type ItemPositions = Map<Key, {
+    column: number;
+    top: number;
+}>;
+/**
+ * Auto arrange the items in the masonry layout.
+ * Always get stable positions by order
+ * instead of dynamic adjust for next item height.
+ */
+export default function usePositions(itemHeights: ItemHeightData[], columnCount: number, verticalGutter: number): readonly [ItemPositions, number];

video-gen-admin/node_modules/antd/lib/masonry/hooks/usePositions.js

@@ -0,0 +1,40 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = usePositions;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var React = _interopRequireWildcard(require("react"));
+// Disabled the rule since `fill` is safe here
+// but `Array.from` will increase bundle size.
+/* eslint-disable unicorn/no-new-array */
+
+/**
+ * Auto arrange the items in the masonry layout.
+ * Always get stable positions by order
+ * instead of dynamic adjust for next item height.
+ */
+function usePositions(itemHeights, columnCount, verticalGutter) {
+  // ==================== Auto Order ====================
+  const [orderItemPositions, orderTotalHeight] = React.useMemo(() => {
+    const columnHeights = new Array(columnCount).fill(0);
+    const itemPositions = new Map();
+    for (let i = 0; i < itemHeights.length; i += 1) {
+      const [itemKey, itemHeight, itemColumn] = itemHeights[i];
+      let targetColumnIndex = itemColumn ?? columnHeights.indexOf(Math.min.apply(Math, (0, _toConsumableArray2.default)(columnHeights)));
+      targetColumnIndex = Math.min(targetColumnIndex, columnCount - 1);
+      const top = columnHeights[targetColumnIndex];
+      itemPositions.set(itemKey, {
+        column: targetColumnIndex,
+        top
+      });
+      columnHeights[targetColumnIndex] += itemHeight + verticalGutter;
+    }
+    return [itemPositions, Math.max(0, Math.max.apply(Math, (0, _toConsumableArray2.default)(columnHeights)) - verticalGutter)];
+  }, [columnCount, itemHeights, verticalGutter]);
+  // ====================== Return ======================
+  return [orderItemPositions, orderTotalHeight];
+}

video-gen-admin/node_modules/antd/lib/masonry/hooks/useRefs.d.ts

@@ -0,0 +1,2 @@
+import * as React from 'react';
+export default function useRefs(): readonly [(key: React.Key, element: HTMLDivElement | null) => void, (key: React.Key) => HTMLDivElement | null | undefined];

video-gen-admin/node_modules/antd/lib/masonry/hooks/useRefs.js

@@ -0,0 +1,19 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = useRefs;
+var React = _interopRequireWildcard(require("react"));
+function useRefs() {
+  const ref = React.useRef(null);
+  if (ref.current === null) {
+    ref.current = new Map();
+  }
+  const setRef = (key, element) => {
+    ref.current.set(key, element);
+  };
+  const getRef = key => ref.current.get(key);
+  return [setRef, getRef];
+}

video-gen-admin/node_modules/antd/lib/masonry/index.d.ts

@@ -0,0 +1,3 @@
+import Masonry from './Masonry';
+export type { MasonryProps, MasonrySemanticClassNames, MasonrySemanticName, MasonrySemanticStyles, } from './Masonry';
+export default Masonry;

video-gen-admin/node_modules/antd/lib/masonry/index.js

@@ -0,0 +1,10 @@
+"use strict";
+"use client";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _Masonry = _interopRequireDefault(require("./Masonry"));
+var _default = exports.default = _Masonry.default;

video-gen-admin/node_modules/antd/lib/masonry/style/index.d.ts

@@ -0,0 +1,9 @@
+import type { CSSObject } from '@ant-design/cssinjs';
+import type { FullToken, GenerateStyle } from '../../theme/internal';
+export interface ComponentToken {
+}
+export interface MasonryToken extends FullToken<'Masonry'> {
+}
+export declare const genMasonryStyle: GenerateStyle<MasonryToken, CSSObject>;
+declare const _default: (prefixCls: string, rootCls?: string) => readonly [string, string];
+export default _default;

video-gen-admin/node_modules/antd/lib/masonry/style/index.js

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.genMasonryStyle = exports.default = void 0;
+var _internal = require("../../theme/internal");
+const genMasonryStyle = token => {
+  const {
+    componentCls
+  } = token;
+  const itemCls = `${componentCls}-item`;
+  return {
+    [componentCls]: {
+      position: 'relative',
+      boxSizing: 'border-box',
+      display: 'flex',
+      flexDirection: 'column',
+      flexWrap: 'wrap',
+      '&-rtl': {
+        direction: 'rtl'
+      },
+      [`& > ${itemCls}`]: {
+        boxSizing: 'border-box',
+        // Motion
+        '&-fade': {
+          '&-appear': {
+            transition: `opacity ${token.motionDurationSlow} ${token.motionEaseOut}`,
+            opacity: 0,
+            '&-active': {
+              opacity: 1
+            }
+          },
+          '&-leave': {
+            transition: `opacity ${token.motionDurationFast} ${token.motionEaseOut}`,
+            opacity: 1,
+            '&-active': {
+              opacity: 0
+            }
+          }
+        },
+        [`&:not(${itemCls}-fade)`]: {
+          transition: ['left', 'right', 'top'].map(prop => `${prop} ${token.motionDurationSlow} ${token.motionEaseOut}`).join(',')
+        }
+      }
+    }
+  };
+};
+exports.genMasonryStyle = genMasonryStyle;
+var _default = exports.default = (0, _internal.genStyleHooks)('Masonry', genMasonryStyle);