1

video-gen-admin/node_modules/@rc-component/virtual-list/lib/utils/CacheMap.d.ts

@@ -0,0 +1,16 @@
+import type React from 'react';
+declare class CacheMap {
+    maps: Record<string, number>;
+    id: number;
+    diffRecords: Map<React.Key, number>;
+    constructor();
+    set(key: React.Key, value: number): void;
+    get(key: React.Key): number;
+    /**
+     * CacheMap will record the key changed.
+     * To help to know what's update in the next render.
+     */
+    resetRecord(): void;
+    getRecord(): Map<React.Key, number>;
+}
+export default CacheMap;

video-gen-admin/node_modules/@rc-component/virtual-list/lib/utils/CacheMap.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+// Firefox has low performance of map.
+class CacheMap {
+  maps;
+
+  // Used for cache key
+  // `useMemo` no need to update if `id` not change
+  id = 0;
+  diffRecords = new Map();
+  constructor() {
+    this.maps = Object.create(null);
+  }
+  set(key, value) {
+    // Record prev value
+    this.diffRecords.set(key, this.maps[key]);
+    this.maps[key] = value;
+    this.id += 1;
+  }
+  get(key) {
+    return this.maps[key];
+  }
+
+  /**
+   * CacheMap will record the key changed.
+   * To help to know what's update in the next render.
+   */
+  resetRecord() {
+    this.diffRecords.clear();
+  }
+  getRecord() {
+    return this.diffRecords;
+  }
+}
+var _default = exports.default = CacheMap;

video-gen-admin/node_modules/@rc-component/virtual-list/lib/utils/algorithmUtil.d.ts

@@ -0,0 +1,23 @@
+import type * as React from 'react';
+/**
+ * Get index with specific start index one by one. e.g.
+ * min: 3, max: 9, start: 6
+ *
+ * Return index is:
+ * [0]: 6
+ * [1]: 7
+ * [2]: 5
+ * [3]: 8
+ * [4]: 4
+ * [5]: 9
+ * [6]: 3
+ */
+export declare function getIndexByStartLoc(min: number, max: number, start: number, index: number): number;
+/**
+ * We assume that 2 list has only 1 item diff and others keeping the order.
+ * So we can use dichotomy algorithm to find changed one.
+ */
+export declare function findListDiffIndex<T>(originList: T[], targetList: T[], getKey: (item: T) => React.Key): {
+    index: number;
+    multiple: boolean;
+} | null;

video-gen-admin/node_modules/@rc-component/virtual-list/lib/utils/algorithmUtil.js

@@ -0,0 +1,87 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.findListDiffIndex = findListDiffIndex;
+exports.getIndexByStartLoc = getIndexByStartLoc;
+/**
+ * Get index with specific start index one by one. e.g.
+ * min: 3, max: 9, start: 6
+ *
+ * Return index is:
+ * [0]: 6
+ * [1]: 7
+ * [2]: 5
+ * [3]: 8
+ * [4]: 4
+ * [5]: 9
+ * [6]: 3
+ */
+function getIndexByStartLoc(min, max, start, index) {
+  const beforeCount = start - min;
+  const afterCount = max - start;
+  const balanceCount = Math.min(beforeCount, afterCount) * 2;
+
+  // Balance
+  if (index <= balanceCount) {
+    const stepIndex = Math.floor(index / 2);
+    if (index % 2) {
+      return start + stepIndex + 1;
+    }
+    return start - stepIndex;
+  }
+
+  // One is out of range
+  if (beforeCount > afterCount) {
+    return start - (index - afterCount);
+  }
+  return start + (index - beforeCount);
+}
+
+/**
+ * We assume that 2 list has only 1 item diff and others keeping the order.
+ * So we can use dichotomy algorithm to find changed one.
+ */
+function findListDiffIndex(originList, targetList, getKey) {
+  const originLen = originList.length;
+  const targetLen = targetList.length;
+  let shortList;
+  let longList;
+  if (originLen === 0 && targetLen === 0) {
+    return null;
+  }
+  if (originLen < targetLen) {
+    shortList = originList;
+    longList = targetList;
+  } else {
+    shortList = targetList;
+    longList = originList;
+  }
+  const notExistKey = {
+    __EMPTY_ITEM__: true
+  };
+  function getItemKey(item) {
+    if (item !== undefined) {
+      return getKey(item);
+    }
+    return notExistKey;
+  }
+
+  // Loop to find diff one
+  let diffIndex = null;
+  let multiple = Math.abs(originLen - targetLen) !== 1;
+  for (let i = 0; i < longList.length; i += 1) {
+    const shortKey = getItemKey(shortList[i]);
+    const longKey = getItemKey(longList[i]);
+    if (shortKey !== longKey) {
+      diffIndex = i;
+      multiple = multiple || shortKey !== getItemKey(longList[i + 1]);
+      break;
+    }
+  }
+  return diffIndex === null ? null : {
+    index: diffIndex,
+    multiple
+  };
+}

video-gen-admin/node_modules/@rc-component/virtual-list/lib/utils/isFirefox.d.ts

@@ -0,0 +1,2 @@
+declare const isFF: boolean;
+export default isFF;

video-gen-admin/node_modules/@rc-component/virtual-list/lib/utils/isFirefox.js

@@ -0,0 +1,8 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+const isFF = typeof navigator === 'object' && /Firefox/i.test(navigator.userAgent);
+var _default = exports.default = isFF;

video-gen-admin/node_modules/@rc-component/virtual-list/lib/utils/scrollbarUtil.d.ts

@@ -0,0 +1 @@
+export declare function getSpinSize(containerSize?: number, scrollRange?: number): number;

video-gen-admin/node_modules/@rc-component/virtual-list/lib/utils/scrollbarUtil.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getSpinSize = getSpinSize;
+const MIN_SIZE = 20;
+function getSpinSize(containerSize = 0, scrollRange = 0) {
+  let baseSize = containerSize / scrollRange * containerSize;
+  if (isNaN(baseSize)) {
+    baseSize = 0;
+  }
+  baseSize = Math.max(baseSize, MIN_SIZE);
+  return Math.floor(baseSize);
+}