@chaomingd/design 0.0.68

package/dist/esm/PixelPlayer/useAutoLayoutContainer.d.ts

@@ -0,0 +1,2 @@
+import type { RefObject } from 'react';
+export declare const useAutoLayoutContainer: (videoRef: RefObject<HTMLVideoElement>, positionOrigin: 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right') => RefObject<HTMLDivElement>;

package/dist/esm/PixelPlayer/useAutoLayoutContainer.js

@@ -0,0 +1,53 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion -- assert it is not null */
+
+import { useEffect, useRef } from 'react';
+export var useAutoLayoutContainer = function useAutoLayoutContainer(videoRef, positionOrigin) {
+  var containerRef = useRef(null);
+  useEffect(function () {
+    var positionStyles = {
+      'top-left': {
+        top: 0,
+        left: 0
+      },
+      'top-right': {
+        top: 0,
+        right: 0
+      },
+      'bottom-left': {
+        bottom: 0,
+        left: 0
+      },
+      'bottom-right': {
+        bottom: 0,
+        right: 0
+      }
+    };
+    // 暂不支持自适应
+    var setup = function setup() {
+      if (!containerRef.current) {
+        requestAnimationFrame(setup);
+        return;
+      }
+      var clientWidth = containerRef.current.clientWidth;
+      var clientHeight = containerRef.current.clientHeight;
+      if (clientHeight === 0 && clientWidth === 0) {
+        // 重新查询
+        requestAnimationFrame(setup);
+        return;
+      }
+      var ratio = clientWidth / clientHeight;
+      var height = "".concat(clientHeight, "px");
+      var width = "".concat(clientWidth, "px");
+      var defaultRatio = 1920 / 1080;
+      if (ratio > defaultRatio) {
+        videoRef.current.style.width = width;
+      } else {
+        videoRef.current.style.height = height;
+      }
+      videoRef.current.style.position = 'absolute';
+      Object.assign(videoRef.current.style, positionStyles[positionOrigin]);
+    };
+    setup();
+  }, []);
+  return containerRef;
+};

package/dist/esm/PixelPlayer/useVideoWithCustomEvent.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+import { type PeerStream } from './lib/peer-stream';
+type EventHandlers = Record<string, (event: Event) => void>;
+export declare const useVideoWithCustomEvent: (eventHandlers: EventHandlers) => import("react").RefObject<PeerStream>;
+export {};

package/dist/esm/PixelPlayer/useVideoWithCustomEvent.js

@@ -0,0 +1,37 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import { useEffect, useRef } from 'react';
+function lowercaseFirstLetter(word) {
+  return word.charAt(0).toLowerCase() + word.slice(1);
+}
+export var useVideoWithCustomEvent = function useVideoWithCustomEvent(eventHandlers) {
+  var videoRef = useRef(null);
+  useEffect(function () {
+    var addEventListeners = function addEventListeners() {
+      Object.entries(eventHandlers).forEach(function (_ref) {
+        var _videoRef$current;
+        var _ref2 = _slicedToArray(_ref, 2),
+          eventHandlerName = _ref2[0],
+          eventHandler = _ref2[1];
+        var eventName = lowercaseFirstLetter(eventHandlerName.replace(/^on/, ''));
+        (_videoRef$current = videoRef.current) === null || _videoRef$current === void 0 || _videoRef$current.addEventListener(eventName, eventHandler);
+      });
+    };
+    var removeEventListeners = function removeEventListeners() {
+      Object.entries(eventHandlers).forEach(function (_ref3) {
+        var _videoRef$current2;
+        var _ref4 = _slicedToArray(_ref3, 2),
+          eventHandlerName = _ref4[0],
+          eventHandler = _ref4[1];
+        var eventName = lowercaseFirstLetter(eventHandlerName.replace(/^on/, ''));
+        (_videoRef$current2 = videoRef.current) === null || _videoRef$current2 === void 0 || _videoRef$current2.removeEventListener(eventName, eventHandler);
+      });
+    };
+    addEventListeners();
+
+    // Cleanup function
+    return function () {
+      removeEventListeners();
+    };
+  }, [eventHandlers]);
+  return videoRef;
+};

package/dist/esm/Resizer/index.d.ts

@@ -0,0 +1,17 @@
+import { IConfig as IResizerConfig } from '@chaomingd/hooks';
+import { HTMLAttributes, MutableRefObject } from 'react';
+import './index.less';
+export interface ResizerProps extends HTMLAttributes<HTMLDivElement> {
+    resizerConfig?: Omit<IResizerConfig, 'elRef'>;
+    thumbClassName?: string;
+    thumbStyle?: ResizerProps['style'];
+    containerRef?: MutableRefObject<HTMLDivElement | null>;
+    manu?: boolean;
+    thumbColor?: string;
+    onResize?: (size: {
+        width: number;
+        height: number;
+    }) => void;
+}
+declare const _default: import("react").NamedExoticComponent<ResizerProps>;
+export default _default;

package/dist/esm/Resizer/index.js

@@ -0,0 +1,73 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+var _excluded = ["children", "resizerConfig", "thumbClassName", "style", "thumbStyle", "containerRef", "className", "manu", "thumbColor", "onResize"];
+import { useResizer } from '@chaomingd/hooks';
+import classNames from 'classnames';
+import { memo, useRef, useState } from 'react';
+import "./index.less";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { jsxs as _jsxs } from "react/jsx-runtime";
+var Resizer = function Resizer(_ref) {
+  var children = _ref.children,
+    resizerConfig = _ref.resizerConfig,
+    thumbClassName = _ref.thumbClassName,
+    style = _ref.style,
+    thumbStyle = _ref.thumbStyle,
+    containerRef = _ref.containerRef,
+    className = _ref.className,
+    manu = _ref.manu,
+    thumbColor = _ref.thumbColor,
+    onResize = _ref.onResize,
+    props = _objectWithoutProperties(_ref, _excluded);
+  var thumbRef = useRef();
+  var elRef = useRef(null);
+  var _useState = useState(false),
+    _useState2 = _slicedToArray(_useState, 2),
+    resizing = _useState2[0],
+    setResizing = _useState2[1];
+  var direction = (resizerConfig === null || resizerConfig === void 0 ? void 0 : resizerConfig.direction) || 'left';
+  useResizer(_objectSpread(_objectSpread({
+    elRef: thumbRef,
+    firstUpdate: true
+  }, resizerConfig || {}), {}, {
+    updator: function updator(state) {
+      var _resizerConfig$updato;
+      var el = elRef.current;
+      if (!el) return;
+      if (manu !== true) {
+        if (direction === 'left' || direction === 'right') {
+          el.style.width = state.deltaX + 'px';
+        } else {
+          el.style.height = state.deltaY + 'px';
+        }
+      }
+      resizerConfig === null || resizerConfig === void 0 || (_resizerConfig$updato = resizerConfig.updator) === null || _resizerConfig$updato === void 0 || _resizerConfig$updato.call(resizerConfig, state);
+      onResize === null || onResize === void 0 || onResize({
+        width: state.deltaX,
+        height: state.deltaY
+      });
+    },
+    resizingChange: setResizing
+  }));
+  return /*#__PURE__*/_jsxs("div", _objectSpread(_objectSpread({}, props), {}, {
+    ref: function ref(el) {
+      elRef.current = el;
+      if (containerRef) {
+        containerRef.current = el;
+      }
+    },
+    style: _objectSpread(_objectSpread({}, style), {}, {
+      transition: resizing ? 'none' : undefined
+    }),
+    className: classNames('laf-resizer', className),
+    children: [/*#__PURE__*/_jsx("div", {
+      ref: thumbRef,
+      style: _objectSpread(_objectSpread({}, thumbStyle || {}), {}, {
+        '--laf-resizer-thumb-color': thumbColor
+      }),
+      className: classNames('laf-resizer-thumb', thumbClassName, resizing && 'laf-resizer-thumb-resizing', "laf-resizer-thumb-direction-".concat(direction))
+    }), children]
+  }));
+};
+export default /*#__PURE__*/memo(Resizer);

package/dist/esm/Resizer/index.less

@@ -0,0 +1,73 @@
+.laf-resizer {
+  position: relative;
+
+  &-thumb {
+    position: absolute;
+    z-index: 1000;
+    background-color: transparent;
+    transition: background-color 0.3s;
+    user-select: none;
+
+    &:hover {
+      background-color: var(--laf-resizer-thumb-color);
+    }
+
+    &-resizing {
+      background-color: var(--laf-resizer-thumb-color);
+
+      &::after {
+        display: block;
+      }
+    }
+
+    &::after {
+      content: '';
+      position: absolute;
+      top: 50%;
+      left: 50%;
+      transform: translate(-50%, -50%);
+      width: 200px;
+      height: 200px;
+      min-width: 100%;
+      min-height: 100%;
+      cursor: inherit;
+      display: none;
+    }
+
+    &-direction-left {
+      width: 2px;
+      left: 0;
+      top: 0;
+      transform: translateX(-50%);
+      height: 100%;
+      cursor: col-resize;
+    }
+
+    &-direction-right {
+      width: 2px;
+      right: 0;
+      top: 0;
+      transform: translateX(50%);
+      height: 100%;
+      cursor: col-resize;
+    }
+
+    &-direction-top {
+      width: 100%;
+      left: 0;
+      top: 0;
+      transform: translateY(-50%);
+      height: 2px;
+      cursor: row-resize;
+    }
+
+    &-direction-bottom {
+      width: 100%;
+      left: 0;
+      bottom: 0;
+      transform: translateY(50%);
+      height: 2px;
+      cursor: row-resize;
+    }
+  }
+}

package/dist/esm/SetupAntApp/index.d.ts

@@ -0,0 +1 @@
+export default function SetupAntApp(): null;

package/dist/esm/SetupAntApp/index.js

@@ -0,0 +1,10 @@
+import { useEffect } from 'react';
+import { App } from 'antd';
+import { setAntApp } from "../getAntApp";
+export default function SetupAntApp() {
+  var antApp = App.useApp();
+  useEffect(function () {
+    setAntApp(antApp);
+  }, []);
+  return null;
+}

package/dist/esm/Transition/index.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import { TransitionProps } from './type';
+declare const Transition: ({ children, visible, exitUnMount, transitionName, duration, appear, ...props }: TransitionProps) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | null;
+export default Transition;

package/dist/esm/Transition/index.js

@@ -0,0 +1,132 @@
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+var _excluded = ["children", "visible", "exitUnMount", "transitionName", "duration", "appear"];
+import { useModel } from '@chaomingd/store';
+import { useLatest, useUnmount } from 'ahooks';
+import { useEffect, useMemo, useRef } from 'react';
+import { ETransitionStatus } from "./type";
+import { DEFAULT_DURATION, getDuration } from "./utils";
+var Transition = function Transition(_ref) {
+  var children = _ref.children,
+    visible = _ref.visible,
+    _ref$exitUnMount = _ref.exitUnMount,
+    exitUnMount = _ref$exitUnMount === void 0 ? true : _ref$exitUnMount,
+    transitionName = _ref.transitionName,
+    _ref$duration = _ref.duration,
+    duration = _ref$duration === void 0 ? DEFAULT_DURATION : _ref$duration,
+    _ref$appear = _ref.appear,
+    appear = _ref$appear === void 0 ? true : _ref$appear,
+    props = _objectWithoutProperties(_ref, _excluded);
+  var propsRef = useLatest(props);
+  var transitionModel = useModel({
+    state: {
+      status: visible && !appear ? ETransitionStatus.entered : ETransitionStatus.exited
+    }
+  });
+  var transitionClassNames = useMemo(function () {
+    var baseClassNames;
+    if (!transitionName) {
+      baseClassNames = ['transtion'];
+    } else {
+      baseClassNames = typeof transitionName === 'string' ? [transitionName] : transitionName;
+    }
+    return baseClassNames.map(function (baseClassName) {
+      var classNames = {};
+      Object.keys(ETransitionStatus).forEach(function (status) {
+        classNames[status] = "".concat(baseClassName, "-").concat(status);
+      });
+      return classNames;
+    });
+  }, [transitionName]);
+  var _transitionModel$useG = transitionModel.useGetState(),
+    status = _transitionModel$useG.status;
+  var transitionClassNamesWithStatus = useMemo(function () {
+    return transitionClassNames.map(function (item) {
+      return item[status];
+    });
+  }, [transitionClassNames, status]);
+  var transitionTimerRef = useRef();
+  var enteringTimerRef = useRef();
+  useEffect(function () {
+    clearTimeout(transitionTimerRef.current);
+    clearTimeout(enteringTimerRef.current);
+    var _transitionModel$getS = transitionModel.getState(),
+      currentStatus = _transitionModel$getS.status;
+    if (visible) {
+      if (![ETransitionStatus.entering, ETransitionStatus.entered].includes(currentStatus)) {
+        var _propsRef$current, _propsRef$current$onE;
+        transitionModel.setState({
+          status: ETransitionStatus.enter
+        });
+        (_propsRef$current = propsRef.current) === null || _propsRef$current === void 0 || (_propsRef$current$onE = _propsRef$current.onEnter) === null || _propsRef$current$onE === void 0 || _propsRef$current$onE.call(_propsRef$current);
+      }
+    } else {
+      if (![ETransitionStatus.exited, ETransitionStatus.exiting].includes(currentStatus)) {
+        var _propsRef$current2, _propsRef$current2$on;
+        transitionModel.setState({
+          status: ETransitionStatus.exit
+        });
+        (_propsRef$current2 = propsRef.current) === null || _propsRef$current2 === void 0 || (_propsRef$current2$on = _propsRef$current2.onExit) === null || _propsRef$current2$on === void 0 || _propsRef$current2$on.call(_propsRef$current2);
+      }
+    }
+    // eslint-disable-next-line
+  }, [visible]);
+  // entering
+  useEffect(function () {
+    if ([ETransitionStatus.enter, ETransitionStatus.exit].includes(status)) {
+      clearTimeout(enteringTimerRef.current);
+      enteringTimerRef.current = setTimeout(function () {
+        if (status === ETransitionStatus.enter) {
+          var _propsRef$current3, _propsRef$current3$on;
+          transitionModel.setState({
+            status: ETransitionStatus.entering
+          });
+          (_propsRef$current3 = propsRef.current) === null || _propsRef$current3 === void 0 || (_propsRef$current3$on = _propsRef$current3.onEntering) === null || _propsRef$current3$on === void 0 || _propsRef$current3$on.call(_propsRef$current3);
+        } else if (status === ETransitionStatus.exit) {
+          var _propsRef$current4, _propsRef$current4$on;
+          transitionModel.setState({
+            status: ETransitionStatus.exiting
+          });
+          (_propsRef$current4 = propsRef.current) === null || _propsRef$current4 === void 0 || (_propsRef$current4$on = _propsRef$current4.onExiting) === null || _propsRef$current4$on === void 0 || _propsRef$current4$on.call(_propsRef$current4);
+        }
+      }, 17);
+    }
+    // eslint-disable-next-line
+  }, [status]);
+  // entered
+  useEffect(function () {
+    if ([ETransitionStatus.entering, ETransitionStatus.exiting].includes(status)) {
+      clearTimeout(transitionTimerRef.current);
+      transitionTimerRef.current = setTimeout(function () {
+        if (status === ETransitionStatus.entering) {
+          var _propsRef$current5, _propsRef$current5$on;
+          transitionModel.setState({
+            status: ETransitionStatus.entered
+          });
+          (_propsRef$current5 = propsRef.current) === null || _propsRef$current5 === void 0 || (_propsRef$current5$on = _propsRef$current5.onEntered) === null || _propsRef$current5$on === void 0 || _propsRef$current5$on.call(_propsRef$current5);
+        } else if (status === ETransitionStatus.exiting) {
+          var _propsRef$current6, _propsRef$current6$on;
+          transitionModel.setState({
+            status: ETransitionStatus.exited
+          });
+          (_propsRef$current6 = propsRef.current) === null || _propsRef$current6 === void 0 || (_propsRef$current6$on = _propsRef$current6.onExited) === null || _propsRef$current6$on === void 0 || _propsRef$current6$on.call(_propsRef$current6);
+        }
+      }, getDuration({
+        duration: duration,
+        status: ETransitionStatus.entering === status ? ETransitionStatus.enter : ETransitionStatus.exit
+      }));
+    }
+    // eslint-disable-next-line
+  }, [status]);
+  useUnmount(function () {
+    clearTimeout(transitionTimerRef.current);
+    clearTimeout(enteringTimerRef.current);
+  });
+  if (exitUnMount) {
+    if (status === ETransitionStatus.exited) return null;
+  }
+  if (typeof children === 'function') {
+    return children(status, transitionClassNamesWithStatus[0], transitionClassNamesWithStatus);
+  }
+  return children;
+};
+export default Transition;

package/dist/esm/Transition/type.d.ts

@@ -0,0 +1,33 @@
+import { ReactElement } from 'react';
+export interface TransitionProps {
+    visible?: boolean;
+    appear?: boolean;
+    exitUnMount?: boolean;
+    children: ReactElement | ((status: ETransitionStatus, transitionName: string, transitionNames: string[]) => ReactElement);
+    duration?: number | {
+        enter: number;
+        exit: number;
+    };
+    transitionName?: string | string[];
+    onEnter?: () => any;
+    onEntering?: () => any;
+    onEntered?: () => any;
+    onExit?: () => any;
+    onExiting?: () => any;
+    onExited?: () => any;
+}
+export declare enum ETransitionStatus {
+    none = "none",
+    enter = "enter",
+    entering = "entering",
+    entered = "entered",
+    exit = "exit",
+    exiting = "exiting",
+    exited = "exited"
+}
+export interface ITransitionState {
+    status: ETransitionStatus;
+}
+export declare const ENTER_STATUS_SQUENCE: ETransitionStatus[];
+export declare const EXIT_STATUS_SQUENCE: ETransitionStatus[];
+export type TransitionClassNames = Record<ETransitionStatus, string>;

package/dist/esm/Transition/type.js

@@ -0,0 +1,12 @@
+export var ETransitionStatus = /*#__PURE__*/function (ETransitionStatus) {
+  ETransitionStatus["none"] = "none";
+  ETransitionStatus["enter"] = "enter";
+  ETransitionStatus["entering"] = "entering";
+  ETransitionStatus["entered"] = "entered";
+  ETransitionStatus["exit"] = "exit";
+  ETransitionStatus["exiting"] = "exiting";
+  ETransitionStatus["exited"] = "exited";
+  return ETransitionStatus;
+}({});
+export var ENTER_STATUS_SQUENCE = [ETransitionStatus.entering, ETransitionStatus.entered];
+export var EXIT_STATUS_SQUENCE = [ETransitionStatus.exiting, ETransitionStatus.exited];

package/dist/esm/Transition/utils.d.ts

@@ -0,0 +1,6 @@
+import { TransitionProps, ETransitionStatus } from './type';
+export declare const DEFAULT_DURATION = 300;
+export declare function getDuration({ duration, status, }: {
+    duration?: TransitionProps['duration'];
+    status: ETransitionStatus;
+}): number;

package/dist/esm/Transition/utils.js

@@ -0,0 +1,15 @@
+export var DEFAULT_DURATION = 300;
+export function getDuration(_ref) {
+  var duration = _ref.duration,
+    status = _ref.status;
+  var dur;
+  if (duration === undefined) {
+    dur = DEFAULT_DURATION;
+  } else if (typeof duration === 'number') {
+    dur = duration;
+  } else {
+    var _duration;
+    dur = (_duration = duration[status]) !== null && _duration !== void 0 ? _duration : DEFAULT_DURATION;
+  }
+  return dur;
+}

package/dist/esm/UploadFile/components/IconButton/index.d.ts

@@ -0,0 +1,11 @@
+import { FC, HTMLAttributes, ReactNode } from 'react';
+import './index.less';
+export interface IButtonIconProps extends HTMLAttributes<HTMLDivElement> {
+    icon?: ReactNode;
+    size?: 'default' | 'middle' | 'small' | 'large';
+    clickable?: boolean;
+    disabled?: boolean;
+    type?: 'primary' | 'default' | 'danger';
+}
+declare const IconButton: FC<IButtonIconProps>;
+export default IconButton;

package/dist/esm/UploadFile/components/IconButton/index.js

@@ -0,0 +1,26 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+var _excluded = ["size", "disabled", "clickable", "icon", "type", "className"];
+import { CSS_PREFIX } from "../../../constants/cssPrefix";
+import classNames from 'classnames';
+import React from 'react';
+import "./index.less";
+import { jsx as _jsx } from "react/jsx-runtime";
+var preCls = "".concat(CSS_PREFIX, "-icon-btn");
+var IconButton = function IconButton(_ref) {
+  var _ref$size = _ref.size,
+    size = _ref$size === void 0 ? 'default' : _ref$size,
+    disabled = _ref.disabled,
+    _ref$clickable = _ref.clickable,
+    clickable = _ref$clickable === void 0 ? true : _ref$clickable,
+    icon = _ref.icon,
+    _ref$type = _ref.type,
+    type = _ref$type === void 0 ? 'default' : _ref$type,
+    className = _ref.className,
+    props = _objectWithoutProperties(_ref, _excluded);
+  return /*#__PURE__*/_jsx("div", _objectSpread(_objectSpread({}, props), {}, {
+    className: classNames(preCls, "".concat(preCls, "-size--").concat(size), clickable && "".concat(preCls, "--clickable"), disabled && "".concat(preCls, "--disabled"), "".concat(preCls, "-type-").concat(type), className),
+    children: icon
+  }));
+};
+export default IconButton;

package/dist/esm/UploadFile/components/IconButton/index.less

@@ -0,0 +1,58 @@
+@import '../../../styles/var.less';
+
+.buttonIconType(@type) {
+  &-type-@{type} {
+    color: ~'var(--cm-icon-btn-@{type}-color)';
+
+    &:hover {
+      color: ~'var(--cm-icon-btn-@{type}-color-hover)';
+    }
+
+    &:active {
+      color: ~'var(--cm-icon-btn-@{type}-color-active)';
+    }
+    
+  }
+  &--disabled&-type-@{type} {
+    color: ~'var(--cm-icon-btn-@{type}-color-disabled)';
+  }
+}
+
+@fontSizeMap: {
+  @large: 32px;
+  @default: 24px;
+  @middle: 18px;
+  @small: 16px;
+}
+
+.buttonSize(@size) {
+  &-size--@{size} {
+    font-size: @fontSizeMap[@@size];
+  }
+}
+
+@preCls: ~'@{prefix}-icon-btn';
+
+.@{preCls} {
+  display: inline-block;
+  line-height: 1em;
+  // size
+  .buttonSize(default);
+  .buttonSize(middle);
+  .buttonSize(small);
+  .buttonSize(large);
+
+  // type
+  .buttonIconType(default);
+  .buttonIconType(primary);
+  .buttonIconType(danger);
+
+  &--clickable {
+    cursor: pointer;
+  }
+
+  &--disabled {
+    cursor: not-allowed;
+  }
+}
+

package/dist/esm/UploadFile/components/Slash.d.ts

@@ -0,0 +1,2 @@
+declare const SlashSvg: () => import("react/jsx-runtime").JSX.Element;
+export default SlashSvg;

package/dist/esm/UploadFile/components/Slash.js

@@ -0,0 +1,15 @@
+import React from 'react';
+import { jsx as _jsx } from "react/jsx-runtime";
+var SlashSvg = function SlashSvg() {
+  return /*#__PURE__*/_jsx("svg", {
+    width: "1em",
+    height: "1em",
+    viewBox: "0 0 16 16",
+    fill: "currentColor",
+    xmlns: "http://www.w3.org/2000/svg",
+    children: /*#__PURE__*/_jsx("path", {
+      d: "M4.06689 13.8119L11.0669 1.6875L11.9329 2.1875L4.93292 14.3119L4.06689 13.8119Z"
+    })
+  });
+};
+export default SlashSvg;

package/dist/esm/UploadFile/components/SvgIcons.d.ts

@@ -0,0 +1,11 @@
+import { HTMLAttributes } from 'react';
+type SvgIconProps = HTMLAttributes<HTMLOrSVGElement>;
+export declare const SlashSvg: (props: SvgIconProps) => import("react/jsx-runtime").JSX.Element;
+export declare const ZipSvg: (props: SvgIconProps) => import("react/jsx-runtime").JSX.Element;
+export declare const RarSvg: (props: SvgIconProps) => import("react/jsx-runtime").JSX.Element;
+export declare const DocSvg: (props: SvgIconProps) => import("react/jsx-runtime").JSX.Element;
+export declare const PdfSvg: (props: SvgIconProps) => import("react/jsx-runtime").JSX.Element;
+export declare const TxtSvg: (props: SvgIconProps) => import("react/jsx-runtime").JSX.Element;
+export declare const CloseSvg: (props: SvgIconProps) => import("react/jsx-runtime").JSX.Element;
+export declare const DeleteSvg: (props: SvgIconProps) => import("react/jsx-runtime").JSX.Element;
+export {};