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

package/dist/Select/SelectDropdown.js

@@ -0,0 +1,194 @@
+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/Select/SelectDropdown.tsx
+var SelectDropdown_exports = {};
+__export(SelectDropdown_exports, {
+  default: () => SelectDropdown_default
+});
+module.exports = __toCommonJS(SelectDropdown_exports);
+var import_classnames = __toESM(require("classnames"));
+var import_trim = __toESM(require("lodash/trim"));
+var import_react = __toESM(require("react"));
+var import_scroll_into_view_if_needed = __toESM(require("scroll-into-view-if-needed"));
+var import_Divider = require("../Divider");
+var import_Icon = require("../Icon");
+var import_Input = require("../Input");
+var import_Scrollbar = require("../Scrollbar");
+var import_Util = require("../Util");
+var import_hooks = require("../hooks");
+var import_Option = __toESM(require("./Option"));
+var import_SelectContext = require("./SelectContext");
+var SelectDropdown = (0, import_react.forwardRef)((props, ref) => {
+  const {
+    value,
+    filterable,
+    multiple = false,
+    filterMethod,
+    loadingText,
+    noMatchText,
+    noDataText,
+    searchInstance,
+    createItem,
+    setCreateItem,
+    createInputRef,
+    onChoose,
+    popperInstRef,
+    contentRef
+  } = props;
+  const { b, e, be, is } = (0, import_hooks.useClassNames)("select");
+  const ulRef = (0, import_react.useRef)(null);
+  const [hover, setHover] = (0, import_react.useState)(value);
+  const [searchText, setSearchText] = (0, import_react.useState)("");
+  (0, import_react.useEffect)(() => {
+    var _a;
+    if (popperInstRef.current && popperInstRef.current.update) {
+      (_a = popperInstRef.current) == null ? void 0 : _a.update();
+    }
+  }, [searchText]);
+  const onClearSearch = (0, import_react.useCallback)((event) => {
+    event == null ? void 0 : event.stopPropagation();
+    setSearchText("");
+  }, []);
+  const onSearch = (0, import_react.useCallback)(
+    (val) => {
+      const keywords = (0, import_trim.default)(val + "");
+      if (keywords === searchText) {
+        return;
+      } else if ((0, import_Util.isEmpty)(keywords)) {
+        setSearchText("");
+      }
+      setSearchText(keywords);
+    },
+    [searchText]
+  );
+  const filterAction = (0, import_react.useCallback)(
+    (p) => {
+      if ((0, import_Util.isNotEmpty)(searchText) && (0, import_Util.isNotEmpty)(p.value)) {
+        if (filterMethod) {
+          const filterResult = filterMethod(p.label ?? p.value.toString(), searchText);
+          return filterResult;
+        } else {
+          const regex = new RegExp(searchText, "gi");
+          const res = null !== (p.label ?? p.value.toString()).match(regex);
+          return res;
+        }
+      } else {
+        return true;
+      }
+    },
+    [filterMethod, searchText]
+  );
+  const scrollToSelected = (0, import_react.useCallback)(() => {
+    var _a;
+    const node = (_a = ulRef.current) == null ? void 0 : _a.querySelectorAll(".selected");
+    if (node && node.length > 0) {
+      (0, import_scroll_into_view_if_needed.default)(node[0], {
+        scrollMode: "if-needed",
+        block: "center"
+      });
+    }
+  }, []);
+  (0, import_react.useImperativeHandle)(ref, () => ({
+    clear: () => setSearchText(""),
+    hover: setHover,
+    scrollToSelected
+  }));
+  const loading = (0, import_react.useMemo)(
+    () => /* @__PURE__ */ import_react.default.createElement(import_Option.default, { className: "no-data", value: "" }, loadingText),
+    [loadingText]
+  );
+  const options = (0, import_react.useMemo)(() => {
+    if ((0, import_Util.isNotEmpty)(searchText)) {
+      let match = false;
+      return props.children ? /* @__PURE__ */ import_react.default.createElement(import_react.default.Fragment, null, import_react.Children.toArray(props.children).map((item) => {
+        let nodeType = item == null ? void 0 : item.type;
+        nodeType = (nodeType == null ? void 0 : nodeType.displayName) || nodeType;
+        if (nodeType === "Select.Option") {
+          if (filterAction(item.props)) {
+            match = true;
+            return item;
+          }
+        } else if (nodeType === "OptionGroup") {
+          if (item.props.children) {
+            const matchChildren = import_react.Children.toArray(item.props.children).filter(
+              (item1) => {
+                if (filterAction(item1.props)) {
+                  match = true;
+                  return item1;
+                }
+              }
+            );
+            return matchChildren.length > 0 ? (0, import_react.cloneElement)(item, item.props, matchChildren) : null;
+          } else {
+            return null;
+          }
+        }
+      }), !match && /* @__PURE__ */ import_react.default.createElement(import_Option.default, { className: "no-data", value: "", key: "noMatchText" }, noMatchText)) : null;
+    } else if ((0, import_Util.isNotEmpty)(createItem)) {
+      if (!multiple && value === createItem) {
+        return /* @__PURE__ */ import_react.default.createElement(import_react.default.Fragment, null, createItem && !multiple && /* @__PURE__ */ import_react.default.createElement(import_Option.default, { value: createItem, label: createItem }), props.children);
+      }
+      return /* @__PURE__ */ import_react.default.createElement(
+        import_Option.default,
+        {
+          value: createItem,
+          label: createItem,
+          onClick: () => {
+            if (multiple) {
+              setCreateItem("");
+              if (createInputRef.current) {
+                createInputRef.current.value = "";
+              }
+            }
+          }
+        }
+      );
+    } else {
+      if (import_react.Children.count(props.children) > 0) {
+        return props.children;
+      } else {
+        return /* @__PURE__ */ import_react.default.createElement(import_Option.default, { className: "no-data", value: "" }, noDataText);
+      }
+    }
+  }, [searchText, createItem, props.children, noMatchText, filterAction, multiple, value, setCreateItem, createInputRef, noDataText]);
+  return /* @__PURE__ */ import_react.default.createElement("div", { className: (0, import_classnames.default)(b`dorpdown`, is({ multiple })), onClick: (event) => event.stopPropagation(), ref: contentRef }, /* @__PURE__ */ import_react.default.createElement(import_react.default.Fragment, null, filterable && /* @__PURE__ */ import_react.default.createElement("div", { className: e`search`, onClick: (event) => event.stopPropagation() }, /* @__PURE__ */ import_react.default.createElement(
+    import_Input.Input,
+    {
+      ref: searchInstance,
+      placeholder: "请输入关键词",
+      clearable: true,
+      plain: true,
+      debounceInput: true,
+      onClear: onClearSearch,
+      onChange: onSearch,
+      prefix: /* @__PURE__ */ import_react.default.createElement(import_Icon.Icon, { prefix: "fal", name: "search" })
+    }
+  ), /* @__PURE__ */ import_react.default.createElement(import_Divider.Divider, { style: { margin: 0 } })), /* @__PURE__ */ import_react.default.createElement(import_SelectContext.SelectContext.Provider, { value: { value, onChoose, hover, setHover, multiple } }, /* @__PURE__ */ import_react.default.createElement(import_Scrollbar.Scrollbar, { wrapClass: be("dropdown", "wrap") }, /* @__PURE__ */ import_react.default.createElement("ul", { className: be("dropdown", "list"), ref: ulRef }, props.loading ? loading : options)))));
+});
+var SelectDropdown_default = SelectDropdown;

package/dist/Select/index.d.ts

@@ -0,0 +1,3 @@
+export { default as Option } from './Option';
+export { default as Select } from './Select';
+export type { SelectOptionGroupProps, SelectOptionProps, SelectProps, SelectRef } from './typings';

package/dist/Select/index.js

@@ -0,0 +1,42 @@
+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/Select/index.ts
+var Select_exports = {};
+__export(Select_exports, {
+  Option: () => import_Option.default,
+  Select: () => import_Select.default
+});
+module.exports = __toCommonJS(Select_exports);
+var import_Option = __toESM(require("./Option"));
+var import_Select = __toESM(require("./Select"));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Option,
+  Select
+});

package/dist/Select/typings.d.ts

@@ -0,0 +1,73 @@
+import React, { RefObject } from 'react';
+import { InputRef } from '../Input';
+import { PopperOptionRef, PopperOptions } from '../Popper';
+import { AnimationEventProps, BaseProps, FormControlBaseProps, NativeProps, TypeAttributes } from '../types/common';
+export type ValueType = string | number | (string | number)[];
+export type SelectRef = {
+    inputInstance?: RefObject<InputRef>;
+    searchInstance?: RefObject<InputRef>;
+    popperInstRef: RefObject<PopperOptionRef>;
+    label: string;
+    setLabel: (label: string) => void;
+    getValue: () => ValueType;
+    setValue: (value: ValueType) => void;
+    onClear: (event?: any) => void;
+    setVisible: (value: boolean) => void;
+};
+type Child = React.ReactElement<SelectOptionGroupProps | SelectOptionProps> | React.ReactElement<SelectOptionGroupProps | SelectOptionProps>[];
+export interface SelectProps<V = ValueType> extends Omit<FormControlBaseProps<V>, 'onChange'>, BaseProps<Child | Child[]>, NativeProps, AnimationEventProps, PopperOptions {
+    multiple?: boolean;
+    disabled?: boolean;
+    valueKey?: string;
+    clearable?: boolean;
+    placeholder?: string;
+    filterable?: boolean;
+    filterMethod?: (val: ValueType, searchText: string) => boolean;
+    noDataText?: React.ReactElement | string;
+    noMatchText?: React.ReactElement | string;
+    loading?: boolean;
+    loadingText?: React.ReactElement | string;
+    max?: boolean;
+    required?: boolean;
+    error?: boolean;
+    warning?: boolean;
+    maxWidth?: number;
+    collapseTags?: boolean;
+    maxCollapseTags?: number;
+    collapseTagsTooltip?: boolean;
+    collapseTips?: (collapseNum: number, total: number) => string;
+    allowCreate?: boolean;
+    plain?: boolean;
+    prepend?: React.ReactElement<any> | string | number;
+    append?: React.ReactElement | string | number;
+    size?: TypeAttributes.Size;
+    appendToBody?: boolean;
+    onChange?: (value: ValueType, label?: string | (string | number)[]) => void;
+    onLoadSuccess?: (value: ValueType, label?: (string | number | undefined)[]) => void;
+}
+export interface SelectOptionProps extends BaseProps, NativeProps {
+    value: string | number;
+    label?: string;
+    disabled?: boolean;
+    onClick?: (value: ValueType, label: string, e: Event) => void;
+}
+export interface SelectOptionGroupProps extends BaseProps<React.ReactElement<SelectOptionProps> | React.ReactElement<SelectOptionProps>[]>, NativeProps {
+    label: string;
+    disabled?: boolean;
+}
+export interface SelectDropdownProps extends SelectProps {
+    value: ValueType;
+    searchInstance: RefObject<InputRef>;
+    createItem: string;
+    setCreateItem: (createItem: string) => void;
+    onChoose: (val: string, text: string, event: any) => void;
+    contentRef: RefObject<HTMLDivElement>;
+    createInputRef: RefObject<HTMLInputElement>;
+    popperInstRef: RefObject<PopperOptionRef>;
+}
+export interface SelectDropdownRef {
+    clear: () => void;
+    hover: (value: ValueType) => void;
+    scrollToSelected: () => void;
+}
+export {};

package/dist/Select/typings.js

@@ -0,0 +1,17 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Select/typings.ts
+var typings_exports = {};
+module.exports = __toCommonJS(typings_exports);

package/dist/Skeleton/PlaceholderGraph.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+export interface SkeletonGraphProps {
+    height?: number;
+    width?: number;
+    active?: boolean;
+    classPrefix?: string;
+    className?: string;
+    style?: React.CSSProperties;
+}
+declare const SkeletonGraph: React.ForwardRefExoticComponent<SkeletonGraphProps & React.RefAttributes<HTMLDivElement>>;
+export default SkeletonGraph;

package/dist/Skeleton/PlaceholderGraph.js

@@ -0,0 +1,46 @@
+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/Skeleton/PlaceholderGraph.tsx
+var PlaceholderGraph_exports = {};
+__export(PlaceholderGraph_exports, {
+  default: () => PlaceholderGraph_default
+});
+module.exports = __toCommonJS(PlaceholderGraph_exports);
+var import_classnames = __toESM(require("classnames"));
+var import_react = __toESM(require("react"));
+var import_hooks = require("../hooks");
+var SkeletonGraph = (0, import_react.forwardRef)((props, ref) => {
+  const { className, width, height = 200, style, active, classPrefix = "placeholder", ...rest } = props;
+  const { wb } = (0, import_hooks.useClassNames)(classPrefix);
+  const classes = (0, import_classnames.default)(className, wb("graph", { active }));
+  const styles = { width: width || "100%", height, ...style };
+  return /* @__PURE__ */ import_react.default.createElement("div", { ...rest, ref, className: classes, style: styles });
+});
+SkeletonGraph.displayName = "ElSkeletonGraph";
+var PlaceholderGraph_default = SkeletonGraph;

package/dist/Skeleton/PlaceholderGrid.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+export interface PlaceholderGridProps {
+    rows?: number;
+    rowHeight?: number;
+    rowMargin?: number;
+    columns?: number;
+    active?: boolean;
+    classPrefix?: string;
+    className?: string;
+    style?: React.CSSProperties;
+}
+declare const PlaceholderGrid: React.ForwardRefExoticComponent<PlaceholderGridProps & React.RefAttributes<HTMLDivElement>>;
+export default PlaceholderGrid;

package/dist/Skeleton/PlaceholderGrid.js

@@ -0,0 +1,77 @@
+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/Skeleton/PlaceholderGrid.tsx
+var PlaceholderGrid_exports = {};
+__export(PlaceholderGrid_exports, {
+  default: () => PlaceholderGrid_default
+});
+module.exports = __toCommonJS(PlaceholderGrid_exports);
+var import_classnames = __toESM(require("classnames"));
+var import_react = __toESM(require("react"));
+var import_hooks = require("../hooks");
+var PlaceholderGrid = (0, import_react.forwardRef)((props, ref) => {
+  const { className, classPrefix = "placeholder", rows = 5, columns = 5, rowHeight = 10, rowMargin = 20, active, ...rest } = props;
+  const { b, wb } = (0, import_hooks.useClassNames)(classPrefix);
+  const classes = (0, import_classnames.default)(className, wb("grid", { active }));
+  const colItems = [];
+  const firstRowItemWidth = Math.random() * 30 + 30;
+  const itemWidth = firstRowItemWidth / 2;
+  for (let i = 0; i < columns; i++) {
+    const rowItems = [];
+    for (let j = 0; j < rows; j++) {
+      let widthPercent = Math.random() * 50 + 10;
+      if (i > 0) {
+        widthPercent = j > 0 ? itemWidth : firstRowItemWidth;
+      }
+      rowItems.push(
+        /* @__PURE__ */ import_react.default.createElement(
+          "p",
+          {
+            key: j,
+            style: {
+              width: `${widthPercent}%`,
+              height: rowHeight,
+              marginTop: j > 0 ? rowMargin : null
+            }
+          }
+        )
+      );
+    }
+    colItems.push(
+      /* @__PURE__ */ import_react.default.createElement("div", { key: i, className: (0, import_classnames.default)(b`grid-col`) }, rowItems)
+    );
+  }
+  return /* @__PURE__ */ import_react.default.createElement("div", { ...rest, ref, className: classes }, colItems);
+});
+PlaceholderGrid.defaultProps = {
+  rowHeight: 16,
+  rowMargin: 16
+};
+PlaceholderGrid.displayName = "PlaceholderGrid";
+var PlaceholderGrid_default = PlaceholderGrid;

package/dist/Skeleton/PlaceholderParagraph.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+export interface PlaceholderParagraphProps {
+    rows?: number;
+    rowHeight?: number;
+    rowMargin?: number;
+    graph?: boolean | 'circle' | 'square' | 'image';
+    active?: boolean;
+    classPrefix?: string;
+    className?: string;
+    style?: React.CSSProperties;
+}
+declare const PlaceholderParagraph: React.ForwardRefExoticComponent<PlaceholderParagraphProps & React.RefAttributes<HTMLDivElement>>;
+export default PlaceholderParagraph;

package/dist/Skeleton/PlaceholderParagraph.js

@@ -0,0 +1,63 @@
+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/Skeleton/PlaceholderParagraph.tsx
+var PlaceholderParagraph_exports = {};
+__export(PlaceholderParagraph_exports, {
+  default: () => PlaceholderParagraph_default
+});
+module.exports = __toCommonJS(PlaceholderParagraph_exports);
+var import_classnames = __toESM(require("classnames"));
+var import_react = __toESM(require("react"));
+var import_hooks = require("../hooks");
+var PlaceholderParagraph = (0, import_react.forwardRef)((props, ref) => {
+  const { className, rows = 2, rowHeight = 16, rowMargin = 16, graph, active, classPrefix = "placeholder", ...rest } = props;
+  const { b, wb } = (0, import_hooks.useClassNames)(classPrefix);
+  const graphShape = graph === true ? "square" : graph;
+  const rowElements = (0, import_react.useMemo)(() => {
+    const rowArr = [];
+    for (let i = 0; i < rows; i++) {
+      const styles = {
+        width: `${Math.random() * 75 + 25}%`,
+        height: rowHeight,
+        marginTop: i > 0 ? rowMargin : Number(rowMargin) / 2
+      };
+      rowArr.push(/* @__PURE__ */ import_react.default.createElement("p", { key: i, style: styles }));
+    }
+    return rowArr;
+  }, [rowHeight, rowMargin, rows]);
+  const classes = (0, import_classnames.default)(className, wb("paragraph", { active }));
+  const graphClasses = b("paragraph-graph", `paragraph-graph-${graphShape}`);
+  return /* @__PURE__ */ import_react.default.createElement("div", { ...rest, ref, className: classes }, graphShape && /* @__PURE__ */ import_react.default.createElement("div", { className: graphClasses }, /* @__PURE__ */ import_react.default.createElement("span", { className: b`paragraph-graph-inner` })), /* @__PURE__ */ import_react.default.createElement("div", { className: b`paragraph-rows` }, rowElements));
+});
+PlaceholderParagraph.defaultProps = {
+  rowHeight: 16,
+  rowMargin: 16
+};
+PlaceholderParagraph.displayName = "PlaceholderParagraph";
+var PlaceholderParagraph_default = PlaceholderParagraph;

package/dist/Skeleton/Skeleton.d.ts

@@ -0,0 +1,11 @@
+import { FC } from 'react';
+import SkeletonGraph from './PlaceholderGraph';
+import PlaceholderGrid from './PlaceholderGrid';
+import PlaceholderParagraph, { PlaceholderParagraphProps } from './PlaceholderParagraph';
+export interface Skeleton extends FC<PlaceholderParagraphProps> {
+    Paragraph: typeof PlaceholderParagraph;
+    Grid: typeof PlaceholderGrid;
+    Graph: typeof SkeletonGraph;
+}
+declare const Skeleton: Skeleton;
+export default Skeleton;

package/dist/Skeleton/Skeleton.js

@@ -0,0 +1,42 @@
+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/Skeleton/Skeleton.tsx
+var Skeleton_exports = {};
+__export(Skeleton_exports, {
+  default: () => Skeleton_default
+});
+module.exports = __toCommonJS(Skeleton_exports);
+var import_PlaceholderGraph = __toESM(require("./PlaceholderGraph"));
+var import_PlaceholderGrid = __toESM(require("./PlaceholderGrid"));
+var import_PlaceholderParagraph = __toESM(require("./PlaceholderParagraph"));
+var Skeleton = import_PlaceholderParagraph.default;
+Skeleton.Paragraph = import_PlaceholderParagraph.default;
+Skeleton.Grid = import_PlaceholderGrid.default;
+Skeleton.Graph = import_PlaceholderGraph.default;
+var Skeleton_default = Skeleton;

package/dist/Skeleton/index.d.ts

@@ -0,0 +1,4 @@
+export type { SkeletonGraphProps } from './PlaceholderGraph';
+export type { PlaceholderGridProps } from './PlaceholderGrid';
+export type { PlaceholderParagraphProps } from './PlaceholderParagraph';
+export { default as Skeleton } from './Skeleton';

package/dist/Skeleton/index.js

@@ -0,0 +1,39 @@
+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/Skeleton/index.ts
+var Skeleton_exports = {};
+__export(Skeleton_exports, {
+  Skeleton: () => import_Skeleton.default
+});
+module.exports = __toCommonJS(Skeleton_exports);
+var import_Skeleton = __toESM(require("./Skeleton"));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Skeleton
+});