@qsxy/element-plus-react 1.0.0-next.1

package/dist/Form/utils/util.js

@@ -0,0 +1,68 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Form/utils/util.ts
+var util_exports = {};
+__export(util_exports, {
+  getErrorMsg: () => getErrorMsg,
+  getName: () => getName
+});
+module.exports = __toCommonJS(util_exports);
+var import_get = __toESM(require("lodash/get"));
+var import_Util = require("../../Util");
+function getName(path) {
+  if ((0, import_Util.isEmpty)(path)) {
+    return "";
+  } else if (path instanceof Array) {
+    return path.join(".");
+  } else if (typeof path === "number") {
+    return path + "";
+  }
+  return path;
+}
+function getErrorMsg(options, type, rule) {
+  let message = (0, import_get.default)(options, `validateMessages.${type}`);
+  if ((0, import_Util.isNotEmpty)(message)) {
+    if (typeof message === "function") {
+      return message(rule);
+    } else {
+      if (/(?<=\$\{)(\w*)(?=\})/g.test(message)) {
+        message.match(/(?<=\$\{)(\w*)(?=\})/g).forEach((item) => {
+          message = message.replace(`\${${item}}`, rule[item] || "");
+        });
+      }
+      return message;
+    }
+  }
+  return message;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getErrorMsg,
+  getName
+});

package/dist/Form/utils/validateUtil.d.ts

@@ -0,0 +1,2 @@
+import type { InternalNamePath, RuleError, RuleObject, StoreValue, ValidateOptions } from '../typings';
+export declare function validateRules(namePath: InternalNamePath, value: StoreValue, rules: RuleObject[], options: ValidateOptions, validateFirst: boolean | 'parallel', messageVariables?: Record<string, string>): Promise<RuleError[]>;

package/dist/Form/utils/validateUtil.js

@@ -0,0 +1,195 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Form/utils/validateUtil.ts
+var validateUtil_exports = {};
+__export(validateUtil_exports, {
+  validateRules: () => validateRules
+});
+module.exports = __toCommonJS(validateUtil_exports);
+var import_async_validator = __toESM(require("async-validator"));
+var import_react = require("react");
+var import_Util = require("../../Util");
+var import_messages = require("./messages");
+var import_valueUtil = require("./valueUtil");
+var AsyncValidator = import_async_validator.default;
+function replaceMessage(template, kv) {
+  return template.replace(/\$\{\w+\}/g, (str) => {
+    const key = str.slice(2, -1);
+    return kv[key];
+  });
+}
+var CODE_LOGIC_ERROR = "CODE_LOGIC_ERROR";
+async function validateRule(name, value, rule, options, messageVariables) {
+  const cloneRule = { ...rule };
+  delete cloneRule.ruleIndex;
+  if (cloneRule.validator) {
+    const originValidator = cloneRule.validator;
+    cloneRule.validator = (...args) => {
+      try {
+        return originValidator(...args);
+      } catch (error) {
+        console.error(error);
+        return Promise.reject(CODE_LOGIC_ERROR);
+      }
+    };
+  }
+  let subRuleField = null;
+  if (cloneRule && cloneRule.type === "array" && cloneRule.defaultField) {
+    subRuleField = cloneRule.defaultField;
+    delete cloneRule.defaultField;
+  }
+  const validator = new AsyncValidator({
+    [name]: [cloneRule]
+  });
+  const messages = (0, import_valueUtil.setValues)({}, import_messages.defaultValidateMessages, options.validateMessages);
+  validator.messages(messages);
+  let result = [];
+  try {
+    await Promise.resolve(validator.validate({ [name]: value }, { ...options }));
+  } catch (errObj) {
+    if (errObj.errors) {
+      result = errObj.errors.map(({ message }, index) => {
+        const mergedMessage = message === CODE_LOGIC_ERROR ? messages.default : message;
+        return (0, import_react.isValidElement)(mergedMessage) ? (0, import_react.cloneElement)(mergedMessage, { key: `error_${index}` }) : mergedMessage;
+      });
+    } else {
+      console.error(errObj);
+      result = [messages.default];
+    }
+  }
+  if (!result.length && subRuleField) {
+    const subResults = await Promise.all(
+      value.map((subValue, i) => validateRule(`${name}.${i}`, subValue, subRuleField, options, messageVariables))
+    );
+    return subResults.reduce((prev, errors) => [...prev, ...errors], []);
+  }
+  const kv = {
+    ...rule,
+    name,
+    label: typeof (options == null ? void 0 : options.label) === "string" ? options.label : "",
+    enum: (rule.enum || []).join(", "),
+    ...messageVariables
+  };
+  const fillVariableResult = result.map((error) => {
+    if (typeof error === "string") {
+      return replaceMessage(error, kv);
+    }
+    return error;
+  });
+  return fillVariableResult;
+}
+function validateRules(namePath, value, rules, options, validateFirst, messageVariables) {
+  const name = namePath.join(".");
+  const filledRules = rules.map((currentRule, ruleIndex) => {
+    const originValidatorFunc = currentRule.validator;
+    const cloneRule = {
+      ...currentRule,
+      ruleIndex
+    };
+    if (originValidatorFunc) {
+      cloneRule.validator = (rule, val, callback) => {
+        let hasPromise = false;
+        const wrappedCallback = (...args) => {
+          Promise.resolve().then(() => {
+            (0, import_Util.warning)(!hasPromise, "Your validator function has already return a promise. `callback` will be ignored.");
+            if (!hasPromise) {
+              callback(...args);
+            }
+          });
+        };
+        const promise = originValidatorFunc(rule, val, wrappedCallback);
+        hasPromise = promise && typeof promise.then === "function" && typeof promise.catch === "function";
+        (0, import_Util.warning)(hasPromise, "`callback` is deprecated. Please return a promise instead.");
+        if (hasPromise) {
+          promise.then(() => {
+            callback();
+          }).catch((err) => {
+            callback(err || " ");
+          });
+        }
+      };
+    }
+    return cloneRule;
+  }).sort(({ warningOnly: w1, ruleIndex: i1 }, { warningOnly: w2, ruleIndex: i2 }) => {
+    if (!!w1 === !!w2) {
+      return i1 - i2;
+    }
+    if (w1) {
+      return 1;
+    }
+    return -1;
+  });
+  let summaryPromise;
+  if (validateFirst === true) {
+    summaryPromise = new Promise(async (resolve, reject) => {
+      for (let i = 0; i < filledRules.length; i += 1) {
+        const rule = filledRules[i];
+        const errors = await validateRule(name, value, rule, options, messageVariables);
+        if (errors.length) {
+          reject([{ errors, rule }]);
+          return;
+        }
+      }
+      resolve([]);
+    });
+  } else {
+    const rulePromises = filledRules.map((rule) => validateRule(name, value, rule, options, messageVariables).then((errors) => ({ errors, rule })));
+    summaryPromise = (validateFirst ? finishOnFirstFailed(rulePromises) : finishOnAllFailed(rulePromises)).then((errors) => {
+      return Promise.reject(errors);
+    });
+  }
+  summaryPromise.catch((e) => e);
+  return summaryPromise;
+}
+async function finishOnAllFailed(rulePromises) {
+  return Promise.all(rulePromises).then((errorsList) => {
+    const errors = [].concat(...errorsList);
+    return errors;
+  });
+}
+async function finishOnFirstFailed(rulePromises) {
+  let count = 0;
+  return new Promise((resolve) => {
+    rulePromises.forEach((promise) => {
+      promise.then((ruleError) => {
+        if (ruleError.errors.length) {
+          resolve([ruleError]);
+        }
+        count += 1;
+        if (count === rulePromises.length) {
+          resolve([]);
+        }
+      });
+    });
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  validateRules
+});

package/dist/Form/utils/valueUtil.d.ts

@@ -0,0 +1,14 @@
+import type { EventArgs, InternalNamePath, NamePath, Store, StoreValue } from '../typings';
+export declare function getNamePath(path: NamePath | null): InternalNamePath;
+export declare function getValue(store: Store, namePath: InternalNamePath): any;
+export declare function setValue(store: Store, namePath: InternalNamePath, value: StoreValue, removeIfUndefined?: boolean): Store;
+export declare function cloneByNamePathList(store: Store, namePathList: InternalNamePath[]): Store;
+export declare function containsNamePath(namePathList: InternalNamePath[], namePath: InternalNamePath): boolean;
+export declare function setValues<T>(store: T, ...restValues: T[]): T;
+export declare function matchNamePath(namePath: InternalNamePath, changedNamePath: InternalNamePath | null): boolean;
+type SimilarObject = string | number | {};
+export declare function isSimilar(source: SimilarObject, target: SimilarObject): boolean;
+export declare function defaultGetValueFromEvent(valuePropName: string, ...args: EventArgs): any;
+export declare function move<T>(array: T[], moveIndex: number, toIndex: number): T[];
+export declare function toNamePathStr(name: NamePath): string;
+export {};

package/dist/Form/utils/valueUtil.js

@@ -0,0 +1,160 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Form/utils/valueUtil.ts
+var valueUtil_exports = {};
+__export(valueUtil_exports, {
+  cloneByNamePathList: () => cloneByNamePathList,
+  containsNamePath: () => containsNamePath,
+  defaultGetValueFromEvent: () => defaultGetValueFromEvent,
+  getNamePath: () => getNamePath,
+  getValue: () => getValue,
+  isSimilar: () => isSimilar,
+  matchNamePath: () => matchNamePath,
+  move: () => move,
+  setValue: () => setValue,
+  setValues: () => setValues,
+  toNamePathStr: () => toNamePathStr
+});
+module.exports = __toCommonJS(valueUtil_exports);
+var import_cloneDeep = __toESM(require("./cloneDeep"));
+var import_get = __toESM(require("./get"));
+var import_set = __toESM(require("./set"));
+var import_typeUtil = require("./typeUtil");
+function getNamePath(path) {
+  return (0, import_typeUtil.toArray)(path);
+}
+function getValue(store, namePath) {
+  const value = (0, import_get.default)(store, namePath);
+  return value;
+}
+function setValue(store, namePath, value, removeIfUndefined = false) {
+  if ((namePath == null ? void 0 : namePath.length) > 0) {
+    const newStore = (0, import_set.default)(store, namePath, value, removeIfUndefined);
+    return newStore;
+  }
+  return store;
+}
+function cloneByNamePathList(store, namePathList) {
+  let newStore = {};
+  namePathList.forEach((namePath) => {
+    const value = getValue(store, namePath);
+    newStore = setValue(newStore, namePath, value);
+  });
+  return newStore;
+}
+function containsNamePath(namePathList, namePath) {
+  return namePathList && namePathList.some((path) => matchNamePath(path, namePath));
+}
+function isObject(obj) {
+  return typeof obj === "object" && obj !== null && Object.getPrototypeOf(obj) === Object.prototype;
+}
+function internalSetValues(store, values) {
+  const newStore = Array.isArray(store) ? [...store] : { ...store };
+  if (!values) {
+    return newStore;
+  }
+  Object.keys(values).forEach((key) => {
+    const prevValue = newStore[key];
+    const value = values[key];
+    const recursive = isObject(prevValue) && isObject(value);
+    newStore[key] = recursive ? internalSetValues(prevValue, value || {}) : (0, import_cloneDeep.default)(value);
+  });
+  return newStore;
+}
+function setValues(store, ...restValues) {
+  return restValues.reduce((current, newStore) => internalSetValues(current, newStore), store);
+}
+function matchNamePath(namePath, changedNamePath) {
+  if (!namePath || !changedNamePath || namePath.length !== changedNamePath.length) {
+    return false;
+  }
+  return namePath.every((nameUnit, i) => changedNamePath[i] === nameUnit);
+}
+function isSimilar(source, target) {
+  if (source === target) {
+    return true;
+  }
+  if (!source && target || source && !target) {
+    return false;
+  }
+  if (!source || !target || typeof source !== "object" || typeof target !== "object") {
+    return false;
+  }
+  const sourceKeys = Object.keys(source);
+  const targetKeys = Object.keys(target);
+  const keys = /* @__PURE__ */ new Set([...sourceKeys, ...targetKeys]);
+  return [...keys].every((key) => {
+    const sourceValue = source[key];
+    const targetValue = target[key];
+    if (typeof sourceValue === "function" && typeof targetValue === "function") {
+      return true;
+    }
+    return sourceValue === targetValue;
+  });
+}
+function defaultGetValueFromEvent(valuePropName, ...args) {
+  const event = args[0];
+  if (event && event.target && typeof event.target === "object" && valuePropName in event.target) {
+    return event.target[valuePropName];
+  }
+  return event;
+}
+function move(array, moveIndex, toIndex) {
+  const { length } = array;
+  if (moveIndex < 0 || moveIndex >= length || toIndex < 0 || toIndex >= length) {
+    return array;
+  }
+  const item = array[moveIndex];
+  const diff = moveIndex - toIndex;
+  if (diff > 0) {
+    return [...array.slice(0, toIndex), item, ...array.slice(toIndex, moveIndex), ...array.slice(moveIndex + 1, length)];
+  }
+  if (diff < 0) {
+    return [...array.slice(0, moveIndex), ...array.slice(moveIndex + 1, toIndex + 1), item, ...array.slice(toIndex + 1, length)];
+  }
+  return array;
+}
+function toNamePathStr(name) {
+  const namePath = (0, import_typeUtil.toArray)(name);
+  return namePath.join("_");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cloneByNamePathList,
+  containsNamePath,
+  defaultGetValueFromEvent,
+  getNamePath,
+  getValue,
+  isSimilar,
+  matchNamePath,
+  move,
+  setValue,
+  setValues,
+  toNamePathStr
+});

package/dist/Icon/Icon.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { IconProps } from './typings';
+declare const Icon: React.ForwardRefExoticComponent<IconProps & React.RefAttributes<any>>;
+export default Icon;

package/dist/Icon/Icon.js

@@ -0,0 +1,66 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Icon/Icon.tsx
+var Icon_exports = {};
+__export(Icon_exports, {
+  default: () => Icon_default
+});
+module.exports = __toCommonJS(Icon_exports);
+var import_classnames = __toESM(require("classnames"));
+var import_startsWith = __toESM(require("lodash/startsWith"));
+var import_react = __toESM(require("react"));
+var import_hooks = require("../hooks");
+var Icon = (0, import_react.memo)(
+  (0, import_react.forwardRef)((props, ref) => {
+    const { prefix, name, size, rotate, flip, spin, pulse, className, style, onClick, classPrefix = "icon", ...other } = props;
+    const { b } = (0, import_hooks.useClassNames)(classPrefix, "el");
+    const hasFa = (0, import_startsWith.default)(name, "fa-");
+    return /* @__PURE__ */ import_react.default.createElement(
+      "i",
+      {
+        className: (0, import_classnames.default)(b(), prefix, hasFa ? name : `fa-${name}`, className, {
+          [`fa-${size}`]: size,
+          [`fa-rotate-${rotate}`]: rotate,
+          [`fa-flip-${flip}`]: flip,
+          "fa-spin": spin,
+          "fa-pulse": pulse
+        }),
+        style,
+        onClick,
+        ref,
+        ...other
+      }
+    );
+  })
+);
+Icon.defaultProps = {
+  prefix: "far"
+};
+Icon.displayName = "ElIcon";
+var Icon_default = Icon;

package/dist/Icon/IconList/Check.d.ts

@@ -0,0 +1,3 @@
+import { FC } from 'react';
+import { SvgIconProps } from '../typings';
+export declare const Check: FC<SvgIconProps>;

package/dist/Icon/IconList/Check.js

@@ -0,0 +1,66 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Icon/IconList/Check.tsx
+var Check_exports = {};
+__export(Check_exports, {
+  Check: () => Check
+});
+module.exports = __toCommonJS(Check_exports);
+var import_classnames = __toESM(require("classnames"));
+var import_react = __toESM(require("react"));
+var import_hooks = require("../../hooks");
+var Check = (props) => {
+  const { className, style } = props;
+  const { b } = (0, import_hooks.useClassNames)("icon");
+  return /* @__PURE__ */ import_react.default.createElement("div", { className: (0, import_classnames.default)(b(), className), style }, /* @__PURE__ */ import_react.default.createElement(
+    "svg",
+    {
+      "aria-hidden": "true",
+      focusable: "false",
+      "data-prefix": "fa-light",
+      "data-icon": "check",
+      className: "svg-inline--fa fa-check fa-w-16",
+      role: "img",
+      xmlns: "http://www.w3.org/2000/svg",
+      viewBox: "0 0 512 512"
+    },
+    /* @__PURE__ */ import_react.default.createElement(
+      "path",
+      {
+        d: "M475 123L203 395C200 398 196 400 192 400S184 398 181 395L37 251C30 245 30 235 37 229S53 222 59 229L192 361L453 101C459 94 469 94 475 101S482 117 475 123Z",
+        fill: "currentColor"
+      }
+    )
+  ));
+};
+Check.displayName = "Icon.Check";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Check
+});

package/dist/Icon/IconList/Close.d.ts

@@ -0,0 +1,3 @@
+import { FC } from 'react';
+import { SvgIconProps } from '../typings';
+export declare const Close: FC<SvgIconProps>;

package/dist/Icon/IconList/Close.js

@@ -0,0 +1,53 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Icon/IconList/Close.tsx
+var Close_exports = {};
+__export(Close_exports, {
+  Close: () => Close
+});
+module.exports = __toCommonJS(Close_exports);
+var import_classnames = __toESM(require("classnames"));
+var import_react = __toESM(require("react"));
+var import_hooks = require("../../hooks");
+var Close = (props) => {
+  const { className, style } = props;
+  const { b } = (0, import_hooks.useClassNames)("icon");
+  return /* @__PURE__ */ import_react.default.createElement("div", { className: (0, import_classnames.default)(b(), className), style }, /* @__PURE__ */ import_react.default.createElement("svg", { "aria-hidden": "true", focusable: "false", className: "svg-inline--fa fa-xmark fa-w-12", role: "img", xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 384 512" }, /* @__PURE__ */ import_react.default.createElement(
+    "path",
+    {
+      d: "M347 411C341 418 331 418 325 411L192 279L59 411C53 418 43 418 37 411C30 405 30 395 37 389L169 256L37 123C30 117 30 107 37 101C43 94 53 94 59 101L192 233L325 101C331 94 341 94 347 101C354 107 354 117 347 123L215 256L347 389C354 395 354 405 347 411Z",
+      fill: "currentColor"
+    }
+  )));
+};
+Close.displayName = "Icon.Close";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Close
+});

package/dist/Icon/IconList/Delete.d.ts

@@ -0,0 +1,3 @@
+import { FC } from 'react';
+import { SvgIconProps } from '../typings';
+export declare const Delete: FC<SvgIconProps>;