@cniot/android-pda-components 0.2.29 → 0.2.30

package/es/index.es.js

@@ -0,0 +1,2198 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+import React, { useState, useEffect, useRef, cloneElement, useCallback } from "react";
+import ReactDOM from "react-dom";
+var global = "";
+var classnames = { exports: {} };
+/*!
+  Copyright (c) 2018 Jed Watson.
+  Licensed under the MIT License (MIT), see
+  http://jedwatson.github.io/classnames
+*/
+(function(module) {
+  (function() {
+    var hasOwn = {}.hasOwnProperty;
+    function classNames2() {
+      var classes = [];
+      for (var i = 0; i < arguments.length; i++) {
+        var arg = arguments[i];
+        if (!arg)
+          continue;
+        var argType = typeof arg;
+        if (argType === "string" || argType === "number") {
+          classes.push(arg);
+        } else if (Array.isArray(arg)) {
+          if (arg.length) {
+            var inner = classNames2.apply(null, arg);
+            if (inner) {
+              classes.push(inner);
+            }
+          }
+        } else if (argType === "object") {
+          if (arg.toString === Object.prototype.toString) {
+            for (var key in arg) {
+              if (hasOwn.call(arg, key) && arg[key]) {
+                classes.push(key);
+              }
+            }
+          } else {
+            classes.push(arg.toString());
+          }
+        }
+      }
+      return classes.join(" ");
+    }
+    if (module.exports) {
+      classNames2.default = classNames2;
+      module.exports = classNames2;
+    } else {
+      window.classNames = classNames2;
+    }
+  })();
+})(classnames);
+var classNames = classnames.exports;
+var index$u = "";
+function getTypeClass$2(type) {
+  return {
+    "center": "op-overlay center",
+    "top": "op-overlay top",
+    "bottom": "op-overlay bottom"
+  }[type] || "op-overlay";
+}
+function Overlay$1(props) {
+  const { verticalPosition = "center", visible = true, closable = false, onClosed = () => {
+  } } = props;
+  const [hidden, setHidden] = useState(!visible);
+  useEffect(() => {
+    setHidden(!visible);
+  }, [visible]);
+  const option = {};
+  if (closable) {
+    option.onClick = (e) => {
+      setHidden(true);
+      onClosed();
+    };
+  }
+  useEffect(() => {
+    setHidden(!visible);
+  }, [visible]);
+  return !hidden ? /* @__PURE__ */ React.createElement("div", __spreadValues({
+    className: getTypeClass$2(verticalPosition)
+  }, option), props.children) : null;
+}
+var index$t = "";
+const blankFunc$6 = () => {
+};
+class PdaTitle extends React.Component {
+  constructor(props) {
+    super(props);
+    __publicField(this, "state", {
+      showMenu: false
+    });
+  }
+  render() {
+    const { className, goBack = true, goBackHandle = blankFunc$6, icon = "scan", title = "\u4EFB\u52A1", menuList = null } = this.props;
+    const { showMenu } = this.state;
+    return /* @__PURE__ */ React.createElement("div", {
+      className: classNames({ [className]: true, "pda-header": true })
+    }, /* @__PURE__ */ React.createElement("div", {
+      className: "header-click-area",
+      onClick: goBack ? goBackHandle : blankFunc$6
+    }, goBack && /* @__PURE__ */ React.createElement("div", {
+      className: "pda-goback"
+    }), icon && /* @__PURE__ */ React.createElement("div", {
+      className: classNames({ "pda-header-icon": true, ["pda-header-icon-" + icon]: true })
+    })), /* @__PURE__ */ React.createElement("p", {
+      className: classNames({ "pda-title-text": true })
+    }, title), menuList ? /* @__PURE__ */ React.createElement("div", {
+      className: "pda-header-more",
+      onClick: (e) => {
+        this.setState({ showMenu: true });
+      }
+    }) : null, /* @__PURE__ */ React.createElement(Overlay$1, {
+      visible: showMenu,
+      verticalPosition: "bottom",
+      closable: true,
+      onClosed: (e) => this.setState({ showMenu: false })
+    }, /* @__PURE__ */ React.createElement("div", {
+      className: "pda-menus"
+    }, menuList)));
+  }
+}
+var keycode$1 = { exports: {} };
+(function(module, exports) {
+  function keyCode(searchInput) {
+    if (searchInput && typeof searchInput === "object") {
+      var hasKeyCode = searchInput.which || searchInput.keyCode || searchInput.charCode;
+      if (hasKeyCode)
+        searchInput = hasKeyCode;
+    }
+    if (typeof searchInput === "number")
+      return names[searchInput];
+    var search = String(searchInput);
+    var foundNamedKey = codes[search.toLowerCase()];
+    if (foundNamedKey)
+      return foundNamedKey;
+    var foundNamedKey = aliases[search.toLowerCase()];
+    if (foundNamedKey)
+      return foundNamedKey;
+    if (search.length === 1)
+      return search.charCodeAt(0);
+    return void 0;
+  }
+  keyCode.isEventKey = function isEventKey(event, nameOrCode) {
+    if (event && typeof event === "object") {
+      var keyCode2 = event.which || event.keyCode || event.charCode;
+      if (keyCode2 === null || keyCode2 === void 0) {
+        return false;
+      }
+      if (typeof nameOrCode === "string") {
+        var foundNamedKey = codes[nameOrCode.toLowerCase()];
+        if (foundNamedKey) {
+          return foundNamedKey === keyCode2;
+        }
+        var foundNamedKey = aliases[nameOrCode.toLowerCase()];
+        if (foundNamedKey) {
+          return foundNamedKey === keyCode2;
+        }
+      } else if (typeof nameOrCode === "number") {
+        return nameOrCode === keyCode2;
+      }
+      return false;
+    }
+  };
+  exports = module.exports = keyCode;
+  var codes = exports.code = exports.codes = {
+    "backspace": 8,
+    "tab": 9,
+    "enter": 13,
+    "shift": 16,
+    "ctrl": 17,
+    "alt": 18,
+    "pause/break": 19,
+    "caps lock": 20,
+    "esc": 27,
+    "space": 32,
+    "page up": 33,
+    "page down": 34,
+    "end": 35,
+    "home": 36,
+    "left": 37,
+    "up": 38,
+    "right": 39,
+    "down": 40,
+    "insert": 45,
+    "delete": 46,
+    "command": 91,
+    "left command": 91,
+    "right command": 93,
+    "numpad *": 106,
+    "numpad +": 107,
+    "numpad -": 109,
+    "numpad .": 110,
+    "numpad /": 111,
+    "num lock": 144,
+    "scroll lock": 145,
+    "my computer": 182,
+    "my calculator": 183,
+    ";": 186,
+    "=": 187,
+    ",": 188,
+    "-": 189,
+    ".": 190,
+    "/": 191,
+    "`": 192,
+    "[": 219,
+    "\\": 220,
+    "]": 221,
+    "'": 222
+  };
+  var aliases = exports.aliases = {
+    "windows": 91,
+    "\u21E7": 16,
+    "\u2325": 18,
+    "\u2303": 17,
+    "\u2318": 91,
+    "ctl": 17,
+    "control": 17,
+    "option": 18,
+    "pause": 19,
+    "break": 19,
+    "caps": 20,
+    "return": 13,
+    "escape": 27,
+    "spc": 32,
+    "spacebar": 32,
+    "pgup": 33,
+    "pgdn": 34,
+    "ins": 45,
+    "del": 46,
+    "cmd": 91
+  };
+  /*!
+   * Programatically add the following
+   */
+  for (i = 97; i < 123; i++)
+    codes[String.fromCharCode(i)] = i - 32;
+  for (var i = 48; i < 58; i++)
+    codes[i - 48] = i;
+  for (i = 1; i < 13; i++)
+    codes["f" + i] = i + 111;
+  for (i = 0; i < 10; i++)
+    codes["numpad " + i] = i + 96;
+  var names = exports.names = exports.title = {};
+  for (i in codes)
+    names[codes[i]] = i;
+  for (var alias in aliases) {
+    codes[alias] = aliases[alias];
+  }
+})(keycode$1, keycode$1.exports);
+var keycode = keycode$1.exports;
+var index$s = "";
+function Button(props) {
+  const { type = "default", onClick, className = "", tabIndex = 1, dataClick = "" } = props;
+  let opt = {};
+  if (dataClick) {
+    opt["data-click"] = dataClick;
+  }
+  return /* @__PURE__ */ React.createElement("button", __spreadValues({
+    className: `pda-button pda-button-${type} ${className}`,
+    onClick,
+    tabIndex
+  }, opt), props.children);
+}
+function ButtonGroup(props) {
+  return /* @__PURE__ */ React.createElement("div", {
+    className: "button-group"
+  }, props.children);
+}
+Button.Group = ButtonGroup;
+var index$r = "";
+const SPECIAL_KEY_MAP = ["fn"];
+const empty$3 = () => {
+};
+function index$q(props) {
+  const {
+    onBack,
+    icon,
+    title,
+    menus = [],
+    onClickMenuItem = empty$3,
+    onScanBarcode,
+    cancelMenuText,
+    menuShortcutKey,
+    backShortcutKey
+  } = props;
+  const [showMenus, setShowMenus] = React.useState(false);
+  React.useEffect(function() {
+    if (menuShortcutKey) {
+      return bindShortcutKey(getShortcutKeyCodes(menuShortcutKey), function() {
+        setShowMenus(true);
+      });
+    }
+  }, [menuShortcutKey]);
+  React.useEffect(function() {
+    if (backShortcutKey && onBack) {
+      return bindShortcutKey(getShortcutKeyCodes(backShortcutKey), function() {
+        onBack("back");
+      });
+    }
+  }, [backShortcutKey, onBack]);
+  React.useEffect(() => {
+    return onKeyBoradBack(function() {
+      onBack && onBack("back");
+    });
+  }, []);
+  React.useEffect(() => {
+    return addEventListener(document, "BarcodeScan", function(e) {
+      onScanBarcode && onScanBarcode(e.param.scanData);
+    });
+  }, [onScanBarcode]);
+  return /* @__PURE__ */ React.createElement("div", {
+    className: "pda-header"
+  }, /* @__PURE__ */ React.createElement("div", {
+    className: "header-click-area"
+  }, onBack ? /* @__PURE__ */ React.createElement("div", {
+    className: "pda-goback",
+    onClick: () => onBack("back")
+  }) : null, icon && /* @__PURE__ */ React.createElement("div", {
+    className: `pda-header-icon pda-header-icon-${icon}`
+  })), /* @__PURE__ */ React.createElement("div", {
+    className: "pda-title-text"
+  }, title), menus && menus.length ? /* @__PURE__ */ React.createElement("div", {
+    className: "pda-header-more",
+    onClick: () => setShowMenus(true)
+  }) : null, /* @__PURE__ */ React.createElement(Overlay$1, {
+    visible: showMenus,
+    verticalPosition: "bottom",
+    closable: false,
+    onClosed: () => setShowMenus(false)
+  }, /* @__PURE__ */ React.createElement("div", {
+    className: "pda-menus"
+  }, menus.map((item, index2) => {
+    return /* @__PURE__ */ React.createElement(Button, {
+      onClick: () => {
+        setShowMenus(false);
+        onClickMenuItem(item);
+      },
+      key: item.key || index2
+    }, item.label);
+  }), cancelMenuText ? /* @__PURE__ */ React.createElement("div", {
+    style: { marginTop: 20 }
+  }, /* @__PURE__ */ React.createElement(Button, {
+    onClick: () => setShowMenus(false)
+  }, cancelMenuText)) : null)));
+}
+function getShortcutKeyCodes(shortcutKey) {
+  const shortcutKeys = shortcutKey.indexOf(",") > -1 ? shortcutKey.split(",") : [shortcutKey];
+  return shortcutKeys.map((k) => {
+    if (SPECIAL_KEY_MAP.indexOf(k.toLowerCase()) > -1) {
+      return k.toLowerCase();
+    }
+    const kc = keycode(k);
+    if (kc === void 0) {
+      console.warn("OPButton.shortcutKey error key value by:", k);
+    }
+    return kc;
+  }).filter((k) => k !== void 0);
+}
+function bindShortcutKey(keys, callback) {
+  function keyUpCallback(event) {
+    const key = event.key.toLowerCase();
+    const keyCode = SPECIAL_KEY_MAP.indexOf(key) > -1 ? key : event.keyCode;
+    if (keys.indexOf(keyCode) > -1) {
+      callback && callback(event);
+    }
+  }
+  document.addEventListener("keyup", keyUpCallback);
+  return function() {
+    document.removeEventListener("keyup", keyUpCallback);
+  };
+}
+function onKeyBoradBack(fn) {
+  function keyPressed(data) {
+    if (data.param.originValue == "back") {
+      fn && fn();
+    }
+  }
+  document.addEventListener("keyPressed", keyPressed, false);
+  return function() {
+    document.removeEventListener("keyPressed", keyPressed);
+  };
+}
+function addEventListener(node, eventName, fn) {
+  node.addEventListener(eventName, fn, false);
+  return function() {
+    node.removeEventListener(eventName, fn);
+  };
+}
+var index$p = "";
+class PdaInfoCard$2 extends React.Component {
+  constructor(props) {
+    super(props);
+  }
+  render() {
+    const { className = "", title, highlightInfo, subTitle, subHighlightInfo, subHighlightSubInfo, infoImage, tagText, highlightInfoCN, highlightSubInfo, percentage, highlightSubInfoCN, boldInfo, infoList = [], style = {}, theme = "light" } = this.props;
+    return /* @__PURE__ */ React.createElement("div", {
+      className: classNames({ [className]: true, "pda-info-card": true, "pda-info-card-dark": theme === "dark" }),
+      style
+    }, /* @__PURE__ */ React.createElement("div", {
+      className: "pda-info-card-title-section"
+    }, /* @__PURE__ */ React.createElement("div", {
+      className: "pda-info-card-title"
+    }, title), tagText ? /* @__PURE__ */ React.createElement("div", {
+      className: "pda-info-card-tag"
+    }, /* @__PURE__ */ React.createElement("div", {
+      className: "pda-info-card-tag-text"
+    }, tagText)) : null), /* @__PURE__ */ React.createElement("div", {
+      className: "pda-info-card-highlight-section"
+    }, /* @__PURE__ */ React.createElement("div", null, /* @__PURE__ */ React.createElement("div", {
+      className: "pda-info-card-highlight"
+    }, /* @__PURE__ */ React.createElement("span", {
+      className: "pda-info-card-highlight1"
+    }, highlightInfo), /* @__PURE__ */ React.createElement("span", {
+      className: "pda-info-card-highlight1CN"
+    }, highlightInfoCN), /* @__PURE__ */ React.createElement("span", {
+      className: "pda-info-card-highlight2"
+    }, highlightSubInfo), /* @__PURE__ */ React.createElement("span", {
+      className: "pda-info-card-highlight2CN"
+    }, highlightSubInfoCN)), subTitle ? /* @__PURE__ */ React.createElement("div", {
+      className: "pda-info-card-title"
+    }, subTitle) : null, subHighlightInfo ? /* @__PURE__ */ React.createElement("div", {
+      className: "pda-info-card-highlight"
+    }, /* @__PURE__ */ React.createElement("span", {
+      className: "pda-info-card-highlight1"
+    }, subHighlightInfo), /* @__PURE__ */ React.createElement("span", {
+      className: "pda-info-card-highlight2"
+    }, subHighlightSubInfo)) : null), infoImage ? /* @__PURE__ */ React.createElement("img", {
+      src: infoImage,
+      width: 150,
+      height: 150
+    }) : null), percentage !== void 0 ? /* @__PURE__ */ React.createElement("div", {
+      className: "pda-info-card-progress"
+    }, /* @__PURE__ */ React.createElement("div", {
+      className: "pda-info-card-progress-inside",
+      style: { width: `${percentage * 100}%` }
+    })) : null, /* @__PURE__ */ React.createElement("div", {
+      className: "pda-info-card-bold"
+    }, boldInfo), infoList.map((item, index2) => {
+      return /* @__PURE__ */ React.createElement("div", {
+        key: index2,
+        className: "pda-info-card-list"
+      }, /* @__PURE__ */ React.createElement("span", null, item.label || ""), "\xA0\xA0", /* @__PURE__ */ React.createElement("span", null, item.content || ""));
+    }));
+  }
+}
+PdaInfoCard$2.IMAGE_1 = "https://img.alicdn.com/imgextra/i2/O1CN01qYuxip1ME9zhdL9XG_!!6000000001402-2-tps-150-150.png";
+var index$o = "";
+class PdaListItem extends React.Component {
+  constructor(props) {
+    super(props);
+  }
+  render() {
+    const { className, header, onClick = () => {
+    }, onHeightLightClick = () => {
+    }, onIconClick = () => {
+    }, highlightText, highlightSubText, stateTextList = [], stateList = [], subInfoList = [], style = {}, icon } = this.props;
+    return /* @__PURE__ */ React.createElement("div", {
+      className: classNames({ [className]: true, "pda-list-item": true }),
+      style,
+      onClick
+    }, !!header ? /* @__PURE__ */ React.createElement("div", {
+      className: "pda-listitem-header"
+    }, header) : null, /* @__PURE__ */ React.createElement("div", {
+      onClick: onHeightLightClick,
+      className: classNames({ "pda-listitem-highlight": true })
+    }, /* @__PURE__ */ React.createElement("div", null, highlightText), /* @__PURE__ */ React.createElement("div", null, highlightSubText)), /* @__PURE__ */ React.createElement("div", {
+      className: "pda-listitem-state-text"
+    }, stateTextList.map((item, index2) => {
+      return /* @__PURE__ */ React.createElement("span", {
+        key: index2
+      }, item.label || "", "\uFF5C");
+    })), /* @__PURE__ */ React.createElement("div", {
+      className: "pda-listitem-state-block"
+    }, stateList.map((item, index2) => {
+      const type = item && item.type ? item.type : "default";
+      return /* @__PURE__ */ React.createElement("div", {
+        key: index2,
+        className: type
+      }, item.label || "");
+    })), icon ? /* @__PURE__ */ React.createElement("div", {
+      onClick: onIconClick,
+      className: "pda-listitem-icon"
+    }, /* @__PURE__ */ React.createElement("div", {
+      className: classNames({ "listitem-icon-container": true, ["listitem-icon-" + icon]: true })
+    })) : null, subInfoList.map((item, index2) => {
+      return /* @__PURE__ */ React.createElement("div", {
+        key: index2,
+        className: "pda-listitem-subinfo"
+      }, /* @__PURE__ */ React.createElement("span", null, item.label || ""), "\xA0\xA0", /* @__PURE__ */ React.createElement("span", null, item.content || ""));
+    }));
+  }
+}
+var index$n = "";
+function empty$2() {
+}
+function Confirm(props) {
+  const { title = "title", message = null, subMessage = [], okText = "okText", cancelText = null, okDataClick = null, cancelDataClick = null, onClick = empty$2, type = "primary", insertButtons = [], appendButtons = [] } = props;
+  return /* @__PURE__ */ React.createElement("div", {
+    className: classNames({ "confirm-wrap": true, ["confirm-" + type]: true })
+  }, /* @__PURE__ */ React.createElement("div", {
+    className: "confirm-content"
+  }, /* @__PURE__ */ React.createElement("div", {
+    className: "confirm-title"
+  }, title), message ? /* @__PURE__ */ React.createElement("div", {
+    className: "confirm-message"
+  }, message) : null, subMessage.length ? /* @__PURE__ */ React.createElement("div", {
+    className: "confirm-sub-message"
+  }, subMessage.map((item, index2) => {
+    const { label, content } = item;
+    return /* @__PURE__ */ React.createElement("div", {
+      className: "confirm-sub-block",
+      key: label ? label : index2
+    }, /* @__PURE__ */ React.createElement("p", {
+      className: "confirm-sub-label"
+    }, label ? label + " : " : ""), /* @__PURE__ */ React.createElement("p", {
+      className: "confirm-sub-content"
+    }, content || ""));
+  })) : null), /* @__PURE__ */ React.createElement("div", {
+    className: "confirm-btns"
+  }, insertButtons.length > 0 ? /* @__PURE__ */ React.createElement(Button.Group, null, insertButtons.map((item, index2) => /* @__PURE__ */ React.createElement(Button, {
+    key: index2,
+    onClick: () => onClick(item.value),
+    dataClick: item.dataClick
+  }, item.label))) : null, /* @__PURE__ */ React.createElement(Button.Group, null, cancelText ? /* @__PURE__ */ React.createElement(Button, {
+    className: "confirm-cancel-button",
+    onClick: () => onClick(false),
+    dataClick: cancelDataClick
+  }, cancelText) : null, /* @__PURE__ */ React.createElement(Button, {
+    type: "primary",
+    onClick: () => onClick(true),
+    dataClick: okDataClick
+  }, okText)), appendButtons.length > 0 ? /* @__PURE__ */ React.createElement(Button.Group, null, appendButtons.map((item, index2) => /* @__PURE__ */ React.createElement(Button, {
+    key: index2,
+    onClick: () => onClick(item.value),
+    dataClick: item.dataClick
+  }, item.label))) : null));
+}
+var index$m = "";
+function WindVaneLog(param) {
+  const params = {
+    domain: "logger",
+    method: "deviceLog",
+    params: param
+  };
+  WindVane.call("WindvanePlugin", "invoke", JSON.stringify(params), function(e) {
+  }, function(e) {
+  });
+}
+function resolveContainer(getContainer) {
+  const container = typeof getContainer === "function" ? getContainer() : getContainer;
+  return container || document.body;
+}
+function isUndefined(v) {
+  return v === void 0;
+}
+function mergeProps(...items) {
+  function customizer(objValue, srcValue) {
+    return isUndefined(srcValue) ? objValue : srcValue;
+  }
+  let ret = Object.assign({}, items[0]);
+  for (let i = 1; i < items.length; i++) {
+    ret = Object.assign(ret, items[i], customizer);
+  }
+  return ret;
+}
+function playSound(sound) {
+  if (window.WindVane) {
+    var params = {
+      domain: "audio",
+      method: "playSound",
+      params: { sound }
+    };
+    WindVane.call("WindvanePlugin", "invoke", JSON.stringify(params));
+  }
+}
+function getTypeClass$1(type) {
+  return {
+    "success": "toast-wrap success",
+    "warning": "toast-wrap warning",
+    "error": "toast-wrap error"
+  }[type] || "toast-wrap";
+}
+function Toast(props) {
+  const { title = "title", message = "message", type = "success", duration = null } = props;
+  const [hidden, setHidden] = useState(false);
+  useEffect(() => {
+    if (window.WindVane) {
+      if (type === "warning") {
+        playSound("error1");
+        window.WindVane.call("WVMotion", "vibrate", { duration: 400 });
+      } else if (type === "error") {
+        playSound("error2");
+        window.WindVane.call("WVMotion", "vibrate", { duration: 200 });
+        setTimeout(() => {
+          window.WindVane.call("WVMotion", "vibrate", { duration: 300 });
+        }, 250);
+      }
+    }
+  }, []);
+  if (duration) {
+    setTimeout(() => {
+      setHidden(true);
+    }, duration);
+  }
+  return !hidden ? /* @__PURE__ */ React.createElement("div", {
+    className: getTypeClass$1(type)
+  }, /* @__PURE__ */ React.createElement("div", {
+    className: "toast-title"
+  }, title), /* @__PURE__ */ React.createElement("div", {
+    className: "toast-message"
+  }, message)) : null;
+}
+const defaultProps$1 = {
+  maskClickable: true,
+  stopPropagation: ["click"]
+};
+const InternalToast = (p) => {
+  const props = mergeProps(defaultProps$1, p);
+  const { maskClickable, content, icon, position, title, message, type, visible } = props;
+  return /* @__PURE__ */ React.createElement(Overlay$1, {
+    visible,
+    verticalPosition: "bottom",
+    closable: true
+  }, /* @__PURE__ */ React.createElement(Toast, {
+    title,
+    message,
+    type
+  }));
+};
+const containers = [];
+function unmount(container) {
+  const unmountResult = ReactDOM.unmountComponentAtNode(container);
+  if (unmountResult && container.parentNode) {
+    container.parentNode.removeChild(container);
+  }
+}
+const defaultProps = {
+  duration: 2e3
+};
+function show(p) {
+  const props = mergeProps(defaultProps, p);
+  let timer = 0;
+  const { getContainer = () => document.body } = props;
+  const container = document.createElement("div");
+  const bodyContainer = resolveContainer(getContainer);
+  bodyContainer.appendChild(container);
+  clear();
+  containers.push(container);
+  function TempToast() {
+    const [visible, setVisible] = useState(true);
+    useEffect(() => {
+      return () => {
+        props.afterClose && props.afterClose();
+      };
+    }, []);
+    useEffect(() => {
+      if (props.duration === 0) {
+        return;
+      }
+      timer = window.setTimeout(() => {
+        setVisible(false);
+      }, props.duration);
+      return () => {
+        window.clearTimeout(timer);
+      };
+    }, []);
+    return /* @__PURE__ */ React.createElement(InternalToast, __spreadProps(__spreadValues({}, props), {
+      getContainer: () => container,
+      visible,
+      afterClose: () => {
+        unmount(container);
+      }
+    }));
+  }
+  ReactDOM.render(/* @__PURE__ */ React.createElement(TempToast, null), container);
+}
+function clear() {
+  while (true) {
+    const container = containers.pop();
+    if (!container)
+      break;
+    unmount(container);
+  }
+}
+Toast.show = show;
+Toast.clear = clear;
+function Alert(props) {
+  const { service, data = {} } = props;
+  const onClickCallback = React.useCallback(function() {
+    service.onNext(true);
+  }, [service]);
+  return /* @__PURE__ */ React.createElement(Overlay$1, {
+    verticalPosition: "bottom"
+  }, /* @__PURE__ */ React.createElement(Confirm, __spreadProps(__spreadValues({}, data), {
+    onClick: onClickCallback
+  })));
+}
+function Start(props) {
+  const { action, appManager, service } = props;
+  const onReStart = React.useCallback(function() {
+    service.onStart(appManager.config.appId);
+  });
+  return /* @__PURE__ */ React.createElement("div", {
+    style: {
+      display: "flex",
+      flexDirection: "column",
+      justifyContent: "center",
+      alignItems: "center",
+      width: "100vw",
+      height: "100vh"
+    }
+  }, /* @__PURE__ */ React.createElement(Button, {
+    type: "primary",
+    onClick: onReStart
+  }, "\u5F00\u59CB\u4F5C\u4E1A"), /* @__PURE__ */ React.createElement("br", null), /* @__PURE__ */ React.createElement("div", null, appManager.config.appId), /* @__PURE__ */ React.createElement("div", null, appManager.config.groupId));
+}
+function confirm(props) {
+  const { service, data = {} } = props;
+  const onClickCallback = React.useCallback(function(v) {
+    service.onNext(v);
+  }, [service]);
+  return /* @__PURE__ */ React.createElement(Overlay$1, {
+    verticalPosition: "bottom"
+  }, /* @__PURE__ */ React.createElement(Confirm, __spreadProps(__spreadValues({}, data), {
+    onClick: onClickCallback
+  })));
+}
+var index$l = "";
+function getTypeClass(type) {
+  return {
+    "center": "op-overlay center",
+    "top": "op-overlay top",
+    "bottom": "op-overlay bottom"
+  }[type] || "op-overlay";
+}
+function Overlay(props) {
+  const { verticalPosition = "center", visible = true, closable = false, onClosed = () => {
+  } } = props;
+  const [hidden, setHidden] = useState(!visible);
+  useEffect(() => {
+    setHidden(!visible);
+  }, [visible]);
+  const option = {};
+  if (closable) {
+    option.onClick = (e) => {
+      setHidden(true);
+      onClosed();
+    };
+  }
+  useEffect(() => {
+    setHidden(!visible);
+  }, [visible]);
+  return !hidden ? /* @__PURE__ */ React.createElement("div", __spreadValues({
+    className: getTypeClass(verticalPosition)
+  }, option), props.children) : null;
+}
+var index$k = "";
+function Prompt(props) {
+  const inputRef = React.useRef();
+  const { data = {}, onNext } = props;
+  const { placeholder, defaultValue, title = "\u8BF7\u8F93\u5165", type = "text", okText = "\u786E\u8BA4", cancelText = "\u53D6\u6D88" } = data;
+  return /* @__PURE__ */ React.createElement(Overlay, {
+    verticalPosition: "center",
+    closable: false
+  }, /* @__PURE__ */ React.createElement("div", {
+    className: "prompt-dialog"
+  }, /* @__PURE__ */ React.createElement("div", null, /* @__PURE__ */ React.createElement("h1", {
+    className: "prompt-title"
+  }, title), /* @__PURE__ */ React.createElement("input", {
+    className: "prompt-input",
+    autoFocus: true,
+    ref: inputRef,
+    placeholder,
+    type,
+    defaultValue,
+    onKeyUp: (e) => {
+      if (e.keyCode === 13) {
+        onNext(getInputValue(inputRef.current));
+      }
+    }
+  }), /* @__PURE__ */ React.createElement("div", {
+    className: "prompt-btns"
+  }, cancelText ? /* @__PURE__ */ React.createElement(Button, {
+    onClick: () => onNext("back")
+  }, cancelText) : null, /* @__PURE__ */ React.createElement(Button, {
+    type: "primary",
+    onClick: () => {
+      onNext(getInputValue(inputRef.current));
+    }
+  }, okText)))));
+}
+function getInputValue(input) {
+  const value = input.value || "";
+  return String(value).trim();
+}
+function toast(props) {
+  const { data = {}, onNext, service } = props;
+  const { title, level, message, duration = null } = data;
+  const [hidden, setHidden] = useState(false);
+  React.useEffect(() => {
+    if (data.hasNext === void 0) {
+      onNext("");
+    }
+    let timeout = null;
+    if (duration) {
+      timeout = setTimeout(() => {
+        setHidden(true);
+      }, duration);
+    }
+    return () => {
+      clearTimeout(timeout);
+    };
+  }, [data]);
+  return !hidden ? /* @__PURE__ */ React.createElement(Overlay$1, {
+    verticalPosition: "bottom"
+  }, /* @__PURE__ */ React.createElement("div", {
+    style: { width: "90%" }
+  }, /* @__PURE__ */ React.createElement(Toast, {
+    type: level,
+    title,
+    message: splitMessage(message)
+  }))) : null;
+}
+function splitMessage(message) {
+  var msg = String(message).split("by Error:");
+  return msg[1] || msg[0];
+}
+var index$j = "";
+function NotFound(props) {
+  return /* @__PURE__ */ React.createElement("div", {
+    style: { padding: "20%" }
+  }, /* @__PURE__ */ React.createElement("h1", null, "404 ", /* @__PURE__ */ React.createElement("small", {
+    style: { fontSize: "60%" }
+  }, "Not found")), /* @__PURE__ */ React.createElement("div", null, props.action.getPage()));
+}
+function _extends() {
+  _extends = Object.assign || function(target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+    return target;
+  };
+  return _extends.apply(this, arguments);
+}
+var r, B = r || (r = {});
+B.Pop = "POP";
+B.Push = "PUSH";
+B.Replace = "REPLACE";
+var C = function(b) {
+  return b;
+};
+function E(b) {
+  b.preventDefault();
+  b.returnValue = "";
+}
+function F() {
+  var b = [];
+  return { get length() {
+    return b.length;
+  }, push: function(h) {
+    b.push(h);
+    return function() {
+      b = b.filter(function(k) {
+        return k !== h;
+      });
+    };
+  }, call: function(h) {
+    b.forEach(function(k) {
+      return k && k(h);
+    });
+  } };
+}
+function H() {
+  return Math.random().toString(36).substr(2, 8);
+}
+function I(b) {
+  var h = b.pathname, k = b.search;
+  b = b.hash;
+  return (h === void 0 ? "/" : h) + (k === void 0 ? "" : k) + (b === void 0 ? "" : b);
+}
+function J(b) {
+  var h = {};
+  if (b) {
+    var k = b.indexOf("#");
+    0 <= k && (h.hash = b.substr(k), b = b.substr(0, k));
+    k = b.indexOf("?");
+    0 <= k && (h.search = b.substr(k), b = b.substr(0, k));
+    b && (h.pathname = b);
+  }
+  return h;
+}
+function createHashHistory(b) {
+  function h() {
+    var a = J(m.location.hash.substr(1)), e = a.pathname, l = a.search;
+    a = a.hash;
+    var g = u.state || {};
+    return [g.idx, C({ pathname: e === void 0 ? "/" : e, search: l === void 0 ? "" : l, hash: a === void 0 ? "" : a, state: g.usr || null, key: g.key || "default" })];
+  }
+  function k() {
+    if (t)
+      c.call(t), t = null;
+    else {
+      var a = r.Pop, e = h(), l = e[0];
+      e = e[1];
+      if (c.length)
+        if (l != null) {
+          var g = q - l;
+          g && (t = { action: a, location: e, retry: function() {
+            p(-1 * g);
+          } }, p(g));
+        } else
+          ;
+      else
+        A(a);
+    }
+  }
+  function x(a) {
+    var e = document.querySelector("base"), l = "";
+    e && e.getAttribute("href") && (e = m.location.href, l = e.indexOf("#"), l = l === -1 ? e : e.slice(0, l));
+    return l + "#" + (typeof a === "string" ? a : I(a));
+  }
+  function z(a, e) {
+    e === void 0 && (e = null);
+    return C(_extends({}, d, typeof a === "string" ? J(a) : a, { state: e, key: H() }));
+  }
+  function A(a) {
+    v = a;
+    a = h();
+    q = a[0];
+    d = a[1];
+    f.call({ action: v, location: d });
+  }
+  function y(a, e) {
+    function l() {
+      y(a, e);
+    }
+    var g = r.Push, n = z(a, e);
+    if (!c.length || (c.call({ action: g, location: n, retry: l }), false)) {
+      var G = [{ usr: n.state, key: n.key, idx: q + 1 }, x(n)];
+      n = G[0];
+      G = G[1];
+      try {
+        u.pushState(n, "", G);
+      } catch (K) {
+        m.location.assign(G);
+      }
+      A(g);
+    }
+  }
+  function w(a, e) {
+    function l() {
+      w(a, e);
+    }
+    var g = r.Replace, n = z(a, e);
+    c.length && (c.call({
+      action: g,
+      location: n,
+      retry: l
+    }), 1) || (n = [{ usr: n.state, key: n.key, idx: q }, x(n)], u.replaceState(n[0], "", n[1]), A(g));
+  }
+  function p(a) {
+    u.go(a);
+  }
+  b === void 0 && (b = {});
+  b = b.window;
+  var m = b === void 0 ? document.defaultView : b, u = m.history, t = null;
+  m.addEventListener("popstate", k);
+  m.addEventListener("hashchange", function() {
+    var a = h()[1];
+    I(a) !== I(d) && k();
+  });
+  var v = r.Pop;
+  b = h();
+  var q = b[0], d = b[1], f = F(), c = F();
+  q == null && (q = 0, u.replaceState(_extends({}, u.state, { idx: q }), ""));
+  return {
+    get action() {
+      return v;
+    },
+    get location() {
+      return d;
+    },
+    createHref: x,
+    push: y,
+    replace: w,
+    go: p,
+    back: function() {
+      p(-1);
+    },
+    forward: function() {
+      p(1);
+    },
+    listen: function(a) {
+      return f.push(a);
+    },
+    block: function(a) {
+      var e = c.push(a);
+      c.length === 1 && m.addEventListener("beforeunload", E);
+      return function() {
+        e();
+        c.length || m.removeEventListener("beforeunload", E);
+      };
+    }
+  };
+}
+var index$i = "";
+function Debug(props) {
+  const { appManager } = props;
+  const pages = Array.from(appManager.pageManager.keys()).reverse();
+  React.useEffect(function() {
+    const history = createHashHistory();
+    const unListen = history.listen(({ action, location }) => {
+      const pathname = location.pathname;
+      appManager.mockToPage(pathname, {});
+    });
+    return unListen;
+  }, []);
+  return /* @__PURE__ */ React.createElement("div", {
+    className: "local-debug-side"
+  }, /* @__PURE__ */ React.createElement("ul", null, pages.map((pathname) => /* @__PURE__ */ React.createElement("li", {
+    key: pathname
+  }, /* @__PURE__ */ React.createElement("a", {
+    href: `#${pathname}`
+  }, pathname)))));
+}
+function Loading$1(props) {
+  const [showLoading, setShowLoading] = React.useState(false);
+  const edgeService = props.edgeService;
+  React.useEffect(function() {
+    let currentLoading = false;
+    const throttleSetShowLoading = function(loading) {
+      currentLoading = loading;
+      if (loading) {
+        setTimeout(function() {
+          if (currentLoading === loading) {
+            setShowLoading(true);
+          }
+        }, 350);
+      } else {
+        setTimeout(function() {
+          if (currentLoading === loading) {
+            setShowLoading(false);
+          }
+        }, 100);
+      }
+    };
+    edgeService.on("IO_STATUS", throttleSetShowLoading);
+    return function() {
+      edgeService.off("IO_STATUS", throttleSetShowLoading);
+    };
+  }, [edgeService]);
+  return showLoading ? /* @__PURE__ */ React.createElement("div", {
+    style: { position: "absolute", left: 0, top: 0, zIndex: 100 }
+  }, "LOADING...") : null;
+}
+function PlaySound({ data, service, action }) {
+  const { sound } = data;
+  if (window.WindVane) {
+    var params = {
+      domain: "audio",
+      method: "playSound",
+      params: { sound }
+    };
+    WindVane.call("WindvanePlugin", "invoke", JSON.stringify(params));
+  }
+  service.onNext({});
+  return null;
+}
+var index$h = {
+  Alert,
+  Start,
+  Toast: toast,
+  Confirm: confirm,
+  NotFound,
+  Debug,
+  Prompt,
+  Loading: Loading$1,
+  PlaySound
+};
+var index$g = "";
+function Presentation(props) {
+  const {
+    image = Presentation.IMAGE_1,
+    text = "",
+    subText = "",
+    transparent
+  } = props;
+  return /* @__PURE__ */ React.createElement("div", {
+    className: transparent ? "presentation-card transparent" : "presentation-card"
+  }, /* @__PURE__ */ React.createElement("img", {
+    src: image
+  }), text ? /* @__PURE__ */ React.createElement("div", {
+    className: "text"
+  }, text) : null, subText ? /* @__PURE__ */ React.createElement("div", {
+    className: "sub-text"
+  }, subText) : null);
+}
+Presentation.IMAGE_1 = "https://img.alicdn.com/imgextra/i3/O1CN019Ivkor1ksy3pMGDsz_!!6000000004740-2-tps-280-322.png";
+Presentation.IMAGE_2 = "https://img.alicdn.com/imgextra/i1/O1CN01lhSunu1X4VPw1Mlas_!!6000000002870-2-tps-352-158.png";
+Presentation.IMAGE_3 = "https://img.alicdn.com/imgextra/i1/O1CN01mreYXo1XfbUsQ7hip_!!6000000002951-2-tps-322-144.png";
+Presentation.IMAGE_4 = "https://img.alicdn.com/imgextra/i3/O1CN017gNM8F1Fmmcfti7Dg_!!6000000000530-1-tps-414-286.gif";
+var index$f = "";
+function empty$1() {
+}
+function List(props) {
+  const { dataSource = [], onClickItem, onItemClick = empty$1 } = props;
+  return /* @__PURE__ */ React.createElement("div", {
+    className: "android-pda-list"
+  }, dataSource.map((item, index2) => {
+    return /* @__PURE__ */ React.createElement(DefaultItem, {
+      key: item.key || index2,
+      dataSource: item,
+      onClick: onClickItem || onItemClick
+    });
+  }), props.children);
+}
+function DefaultItem(props) {
+  const dataSource = props.dataSource || {
+    title: props.title,
+    subTitle: props.subTitle,
+    extra: props.extra,
+    tags: props.tags
+  };
+  const { title, subTitle, extra, tags = [], tabIndex } = dataSource;
+  const { onClick } = props;
+  return /* @__PURE__ */ React.createElement("div", {
+    className: "default-item",
+    onClick: () => {
+      onClick(props.dataSource);
+    },
+    tabIndex
+  }, /* @__PURE__ */ React.createElement("div", {
+    className: "text"
+  }, /* @__PURE__ */ React.createElement("div", null, title), /* @__PURE__ */ React.createElement("div", {
+    className: "sub-text"
+  }, subTitle), /* @__PURE__ */ React.createElement("div", {
+    className: "sub-tags"
+  }, tags.map((text) => {
+    return /* @__PURE__ */ React.createElement("div", {
+      className: "sub-tag-item",
+      key: text
+    }, text);
+  }))), /* @__PURE__ */ React.createElement("div", {
+    className: "extra"
+  }, extra));
+}
+List.Item = DefaultItem;
+var index$e = "";
+const blankFunc$5 = () => {
+};
+class BaseLayoutContainer extends React.Component {
+  constructor(props) {
+    super(props);
+    this.state = {
+      showLoading: false
+    };
+    this._handleKeyUp = (e) => {
+      const { onScan = blankFunc$5, onEnter = blankFunc$5, onEsc = blankFunc$5, onDelete = blankFunc$5, scanMode = null } = this.props;
+      const { code, keyCode, key } = e;
+      if (code === "Enter") {
+        e.preventDefault();
+        onEnter(e);
+        return;
+      }
+      if (code === "Delete") {
+        e.preventDefault();
+        onDelete(e);
+        return;
+      }
+      if (code === "Esc") {
+        e.preventDefault();
+        onEsc(e);
+        return;
+      }
+    };
+    this._handleBeforeUnload = (e) => {
+      e.returnValue = "\u786E\u5B9A\u79BB\u5F00\u5F53\u524D\u9875\u9762\u5417\uFF1F";
+      return true;
+    };
+    this._handleUnload = (e) => {
+      WindVane.call("WindvanePlugin", "invoke", "{'domain': 'rfid', 'method': 'stopRfidScan', 'params':null}", function(e2) {
+      }, function(e2) {
+      });
+      const stopParam = {
+        tag: "stopRfid",
+        level: "d",
+        message: "stop rfid scan!!!"
+      };
+      WindVaneLog(stopParam);
+      WindVaneLog(stopParam);
+    };
+  }
+  componentDidMount() {
+    window.onunload = this._handleUnload;
+    document.addEventListener("keyup", this._handleKeyUp);
+  }
+  componentWillUnmount() {
+    window.onbeforeunload = null;
+    window.onunload = null;
+    document.removeEventListener("keyup", this._handleKeyUp);
+  }
+  shouldComponentUpdate(nextProps, nextState) {
+    if (nextProps.loading && !this.props.loading) {
+      this.setState({
+        showLoading: true
+      });
+      if (nextProps.loadingTimeout) {
+        setTimeout(() => {
+          this.setState({
+            showLoading: false
+          });
+        }, nextProps.loadingTimeout);
+      }
+    }
+    if (!nextProps.loading && this.state.showLoading) {
+      this.setState({
+        showLoading: false
+      });
+    }
+    return true;
+  }
+  render() {
+    const props = this.props;
+    const { style = {}, header, footer, loading } = this.props;
+    return /* @__PURE__ */ React.createElement("div", {
+      className: classNames({ "baselayout-wrapper": true }),
+      style
+    }, header && /* @__PURE__ */ React.createElement("div", {
+      className: classNames({ "baselayout-header": true })
+    }, header), /* @__PURE__ */ React.createElement("div", {
+      className: classNames({ "baselayout-container": true })
+    }, props.children), footer && /* @__PURE__ */ React.createElement("div", {
+      className: classNames({ "baselayout-footer": true })
+    }, footer), this.state.showLoading ? /* @__PURE__ */ React.createElement("div", {
+      className: "loading"
+    }) : null);
+  }
+}
+const blankFunc$4 = () => {
+};
+class RfidOnce$1 extends React.Component {
+  constructor(props) {
+    super(props);
+    this._rfidBeginScan = false;
+    this._handleRfidScan = (e) => {
+      const { onRfidOnce, onRfidBoxOnce, onRfidPalletOnce } = this.props;
+      const data = e.param;
+      const isBox = data.rfidData.startsWith("0F006");
+      const isPallet = data.rfidData.startsWith("0F011");
+      playSound("single_recog");
+      if (isPallet) {
+        let rfidData = data.rfidData;
+        data.originData = rfidData;
+        data.rfidData = rfidData.substr(5, 12);
+      }
+      if (onRfidBoxOnce && isBox) {
+        this._stopWork();
+        onRfidBoxOnce(data);
+      } else if (onRfidPalletOnce && isPallet) {
+        this._stopWork();
+        onRfidPalletOnce(data);
+      }
+      if (onRfidOnce) {
+        this._stopWork();
+        onRfidOnce(data);
+      }
+    };
+    this._startWork = (e) => {
+      document.addEventListener("ContinuousRfidScan", this._handleRfidScan);
+      WindVane.call("WindvanePlugin", "invoke", "{'domain': 'rfid', 'method': 'startScan', 'params': null}", function(e2) {
+      }, function(e2) {
+      });
+      this._rfidBeginScan = true;
+    };
+    this._stopWork = (e) => {
+      document.removeEventListener("ContinuousRfidScan", this._handleRfidScan);
+      WindVane.call("WindvanePlugin", "invoke", "{'domain': 'rfid', 'method': 'stopRfidScan', 'params':null}", function(e2) {
+      }, function(e2) {
+      });
+    };
+    this._handleKeyDown = (e) => {
+      const { code, keyCode, key } = e;
+      if (code === "F22" || code === "F23" || code === "F24" || code === "F9" || code === "F16") {
+        if (!this._rfidBeginScan) {
+          this._startWork();
+        }
+      }
+    };
+    this._handleKeyUp = (e) => {
+      const { code, keyCode, key } = e;
+      if (code === "F22" || code === "F23" || code === "F24" || code === "F9" || code === "F16") {
+        this._stopWork();
+        this._rfidBeginScan = false;
+      }
+    };
+  }
+  componentDidMount() {
+    document.addEventListener("keydown", this._handleKeyDown);
+    document.addEventListener("keyup", this._handleKeyUp);
+    WindVane.call("WindvanePlugin", "invoke", "{'domain': 'keyboard', 'method': 'changeScanMode', 'params': {'scanMode': 'RFID'}}", function(e) {
+    }, function(e) {
+    });
+  }
+  componentWillUnmount() {
+    document.removeEventListener("keydown", this._handleKeyDown);
+    document.removeEventListener("keyup", this._handleKeyUp);
+    this._stopWork();
+  }
+  render() {
+    const props = this.props;
+    const _a = props, { onRfidOnce = blankFunc$4 } = _a, opts = __objRest(_a, ["onRfidOnce"]);
+    return /* @__PURE__ */ React.createElement(BaseLayoutContainer, __spreadValues({}, opts));
+  }
+}
+const blankFunc$3 = () => {
+};
+class RfidOnce extends React.Component {
+  constructor(props) {
+    super(props);
+    this._rfidBeginScan = false;
+    this._handleRfidScan = (e) => {
+      const { onRfidScan, onRfidBoxScan, onRfidPalletScan } = this.props;
+      const data = e.param;
+      const isBox = data.rfidData.startsWith("0F006");
+      const isPallet = data.rfidData.startsWith("0F011");
+      if (isPallet) {
+        let rfidData = data.rfidData;
+        data.originData = rfidData;
+        data.rfidData = rfidData.substr(5, 12);
+      }
+      if (isBox && onRfidBoxScan) {
+        onRfidBoxScan(data);
+      } else if (isPallet && onRfidPalletScan) {
+        onRfidPalletScan(data);
+      }
+      if (onRfidScan) {
+        onRfidScan(data);
+      }
+    };
+    this._startWork = (e) => {
+      document.addEventListener("ContinuousRfidScan", this._handleRfidScan);
+      WindVane.call("WindvanePlugin", "invoke", "{'domain': 'rfid', 'method': 'startScan', 'params': null}", function(e2) {
+      }, function(e2) {
+      });
+      this._rfidBeginScan = true;
+    };
+    this._stopWork = (e) => {
+      document.removeEventListener("ContinuousRfidScan", this._handleRfidScan);
+      WindVane.call("WindvanePlugin", "invoke", "{'domain': 'rfid', 'method': 'stopRfidScan', 'params':null}", function(e2) {
+      }, function(e2) {
+      });
+    };
+    this._handleKeyDown = (e) => {
+      const { code, keyCode, key } = e;
+      if (code === "F22" || code === "F23" || code === "F24" || code === "F9" || code === "F16") {
+        if (!this._rfidBeginScan) {
+          this._startWork();
+        }
+      }
+    };
+    this._handleKeyUp = (e) => {
+      const { code, keyCode, key } = e;
+      if (code === "F22" || code === "F23" || code === "F24" || code === "F9" || code === "F16") {
+        this._stopWork();
+        this._rfidBeginScan = false;
+      }
+    };
+  }
+  componentDidMount() {
+    const { autoRfidScan = false, rfidReaderSleep } = this.props;
+    WindVane.call("WindvanePlugin", "invoke", "{'domain': 'keyboard', 'method': 'changeScanMode', 'params': {'scanMode': 'RFID'}}", function(e) {
+    }, function(e) {
+    });
+    if (!autoRfidScan) {
+      document.addEventListener("keydown", this._handleKeyDown);
+      document.addEventListener("keyup", this._handleKeyUp);
+    } else {
+      if (!rfidReaderSleep) {
+        this._startWork();
+      }
+    }
+  }
+  componentWillUnmount() {
+    document.removeEventListener("keydown", this._handleKeyDown);
+    document.removeEventListener("keyup", this._handleKeyUp);
+    this._stopWork();
+  }
+  shouldComponentUpdate(nextProps, nextState) {
+    if (this.props.autoRfidScan && this.props.rfidReaderSleep !== nextProps.rfidReaderSleep) {
+      if (!nextProps.rfidReaderSleep) {
+        this._startWork();
+      } else {
+        this._stopWork();
+      }
+    }
+    return true;
+  }
+  render() {
+    const props = this.props;
+    const _a = props, { onRfidScan = blankFunc$3, autoRfidScan } = _a, opts = __objRest(_a, ["onRfidScan", "autoRfidScan"]);
+    return /* @__PURE__ */ React.createElement(BaseLayoutContainer, __spreadValues({}, opts));
+  }
+}
+__publicField(RfidOnce, "defaultProps", {
+  rfidReaderSleep: false
+});
+const blankFunc$2 = () => {
+};
+class BarcodeScan extends React.Component {
+  constructor(props) {
+    super(props);
+    this._barcodeBeginScan = false;
+    this._handleBarcodeScan = (e) => {
+      const { onBarcodeScan } = this.props;
+      this._stopWork();
+      playSound("scan");
+      onBarcodeScan && onBarcodeScan(e.param);
+    };
+    this._startWork = (e) => {
+      document.addEventListener("BarcodeScan", this._handleBarcodeScan);
+      this._barcodeBeginScan = true;
+    };
+    this._stopWork = (e) => {
+      document.removeEventListener("BarcodeScan", this._handleBarcodeScan);
+    };
+    this._handleKeyDown = (e) => {
+      const { code, keyCode, key } = e;
+      if (code === "F22" || code === "F23" || code === "F24" || code === "F9" || code === "F16") {
+        if (!this._barcodeBeginScan) {
+          this._startWork();
+        }
+      }
+    };
+    this._handleKeyUp = (e) => {
+      const { code, keyCode, key } = e;
+      if (code === "F22" || code === "F23" || code === "F24" || code === "F9" || code === "F16") {
+        this._stopWork();
+        this._barcodeBeginScan = false;
+      }
+    };
+    this.onScanBarcode = this.onScanBarcode.bind(this);
+  }
+  onScanBarcode(e) {
+    this.props.onScanBarcode && this.props.onScanBarcode(e.param);
+  }
+  componentDidMount() {
+    const { onBarcodeScan } = this.props;
+    if (onBarcodeScan) {
+      document.addEventListener("keydown", this._handleKeyDown);
+      document.addEventListener("keyup", this._handleKeyUp);
+    }
+    document.addEventListener("BarcodeScan", this.onScanBarcode);
+    WindVane.call("WindvanePlugin", "invoke", "{'domain': 'keyboard', 'method': 'changeScanMode', 'params': {'scanMode': 'barcode'}}", function(e) {
+    }, function(e) {
+    });
+  }
+  componentWillUnmount() {
+    const { onBarcodeScan } = this.props;
+    if (onBarcodeScan) {
+      document.removeEventListener("keydown", this._handleKeyDown);
+      document.removeEventListener("keyup", this._handleKeyUp);
+    }
+    document.removeEventListener("BarcodeScan", this.onScanBarcode);
+  }
+  render() {
+    const props = this.props;
+    const _a = props, { onBarcodeScan = blankFunc$2 } = _a, opts = __objRest(_a, ["onBarcodeScan"]);
+    return /* @__PURE__ */ React.createElement(BaseLayoutContainer, __spreadValues({}, opts));
+  }
+}
+class BaseLayout extends React.Component {
+  constructor(props) {
+    super(props);
+  }
+  render() {
+    const props = this.props;
+    const { onBarcodeScan, onScanBarcode, onRfidOnce, onRfidBoxOnce, onRfidPalletOnce, onRfidScan, onRfidBoxScan, onRfidPalletScan } = props;
+    if (onRfidOnce || onRfidBoxOnce || onRfidPalletOnce) {
+      return /* @__PURE__ */ React.createElement(RfidOnce$1, __spreadValues({}, props));
+    }
+    if (onRfidScan || onRfidBoxScan || onRfidPalletScan) {
+      return /* @__PURE__ */ React.createElement(RfidOnce, __spreadValues({}, props));
+    }
+    if (onBarcodeScan || onScanBarcode) {
+      return /* @__PURE__ */ React.createElement(BarcodeScan, __spreadValues({}, props));
+    }
+    return /* @__PURE__ */ React.createElement(BaseLayoutContainer, __spreadValues({}, props));
+  }
+}
+var index$d = "";
+const blankFunc$1 = () => {
+};
+function Keyborard(props) {
+  const { label = "\u67E5\u8BE2", onWakeKeyboard = blankFunc$1, onClick = blankFunc$1, onHidden = blankFunc$1, type = "tel", placeholder = "\u8BF7\u8F93\u5165" } = props;
+  const inputRef = useRef(null);
+  const [visible, setVisible] = useState(true);
+  useEffect(() => {
+    const handleKeyUp = (e) => {
+      const { code, keyCode, key } = e;
+      if (code === "Enter") {
+        e.preventDefault();
+        onClick(inputRef.current.value, e);
+        onHidden(true);
+        setVisible(false);
+        return;
+      }
+    };
+    requestAnimationFrame(() => {
+      inputRef.current.focus();
+      onWakeKeyboard();
+    });
+    document.addEventListener("keyup", handleKeyUp);
+    return () => {
+      document.removeEventListener("keyup", handleKeyUp);
+    };
+  }, []);
+  if (!visible)
+    return null;
+  return /* @__PURE__ */ React.createElement("div", {
+    className: "wakekeyborard-overlay",
+    onClick: (e) => {
+      if (e.target.className && e.target.className.includes("wakekeyborard-overlay")) {
+        onHidden(false);
+        setVisible(false);
+      }
+    }
+  }, /* @__PURE__ */ React.createElement("div", {
+    className: "wakekeyborard-inputbox"
+  }, /* @__PURE__ */ React.createElement("input", {
+    ref: inputRef,
+    type,
+    placeholder
+  }), /* @__PURE__ */ React.createElement(Button, {
+    type: "cutout",
+    onClick: (e) => {
+      onClick(inputRef.current.value, e);
+      onHidden(true);
+      setVisible(false);
+    }
+  }, label)));
+}
+const blankFunc = () => {
+};
+function WakeKeyborard(props) {
+  const [inputVisible, setInputVisible] = useState(props.autoWakeup || false);
+  const _a = props, { onClick = blankFunc, onHidden = blankFunc } = _a, keyborardProps = __objRest(_a, ["onClick", "onHidden"]);
+  return /* @__PURE__ */ React.createElement("div", {
+    className: "wakekeyborard"
+  }, inputVisible ? /* @__PURE__ */ React.createElement(Keyborard, __spreadValues({
+    onClick: (v, e) => {
+      onClick(v);
+      setInputVisible(!inputVisible);
+    },
+    onHidden: (s) => {
+      setInputVisible(false);
+      onHidden(s);
+    }
+  }, keyborardProps)) : null, !inputVisible ? /* @__PURE__ */ React.createElement("div", {
+    className: "wakekeyborard-icon",
+    onClick: (e) => {
+      setInputVisible(!inputVisible);
+    }
+  }) : null);
+}
+WakeKeyborard.Keyborard = Keyborard;
+var index$c = "";
+var index$b = "";
+class PdaInfoCard$1 extends React.Component {
+  constructor(props) {
+    super(props);
+  }
+  render() {
+    const { className, title, isActive, infoList = [], style = {}, index: index2, isLast } = this.props;
+    return /* @__PURE__ */ React.createElement("div", {
+      className: classNames({ [className]: true, "pda-step-card": true }),
+      style
+    }, /* @__PURE__ */ React.createElement("div", {
+      className: "pda-step-indictor"
+    }, /* @__PURE__ */ React.createElement("div", {
+      className: classNames({ "pda-step-indictor-top": true, "pda-step-indictor-top-hidden": index2 === 0 })
+    }), /* @__PURE__ */ React.createElement("div", {
+      className: classNames({ "pda-step-indictor-center": true, "pda-step-indictor-center-active": isActive })
+    }), /* @__PURE__ */ React.createElement("div", {
+      className: classNames({ "pda-step-indictor-bottom": true, "pda-step-indictor-bottom-hidden": isLast })
+    })), /* @__PURE__ */ React.createElement("div", {
+      className: classNames({ "pda-step": true, "pda-step-dark": !isActive })
+    }, /* @__PURE__ */ React.createElement("div", {
+      className: "pda-step-title"
+    }, title), infoList.map((item, index22) => {
+      return /* @__PURE__ */ React.createElement("div", {
+        key: index22,
+        className: "pda-step-list"
+      }, /* @__PURE__ */ React.createElement("span", null, item.label || ""), "\xA0\xA0", /* @__PURE__ */ React.createElement("span", null, item.content || ""));
+    })));
+  }
+}
+class PdaInfoCard extends React.Component {
+  constructor(props) {
+    super(props);
+  }
+  render() {
+    const { className, style = {}, theme = "light", current = 0, children } = this.props;
+    return /* @__PURE__ */ React.createElement("div", {
+      className: classNames({ [className]: true }),
+      style
+    }, (children || []).map((child, index2) => {
+      const childProps = __spreadValues({
+        index: index2,
+        isLast: index2 === (children || []).length - 1
+      }, child.props);
+      if (index2 === current) {
+        childProps.isActive = true;
+      } else {
+        childProps.isActive = false;
+      }
+      return cloneElement(child, childProps);
+    }));
+  }
+}
+__publicField(PdaInfoCard, "Step", PdaInfoCard$1);
+var index$a = "";
+class PdaFinishCard extends React.Component {
+  constructor(props) {
+    super(props);
+  }
+  componentDidMount() {
+    if (this.props.isError) {
+      playSound("success3");
+    } else {
+      playSound("success2");
+    }
+  }
+  render() {
+    const { className, title, infoList = [], isError = false, buttonMultiLines = false, style = {}, onClick = () => {
+    }, okText = "\u8FD4\u56DE\u9996\u9875", cancelText = null } = this.props;
+    const footer = /* @__PURE__ */ React.createElement(Button.Group, null, cancelText ? /* @__PURE__ */ React.createElement(Button, {
+      style: buttonMultiLines ? { height: "auto", lineHeight: "50px" } : {},
+      type: "dark",
+      onClick: () => onClick(false)
+    }, cancelText) : null, /* @__PURE__ */ React.createElement(Button, {
+      type: "primary",
+      style: buttonMultiLines ? { height: "auto", lineHeight: "normal" } : {},
+      onClick: () => onClick(true)
+    }, okText));
+    return /* @__PURE__ */ React.createElement(BaseLayout, {
+      footer
+    }, /* @__PURE__ */ React.createElement("div", {
+      className: "pda-finish-card-top"
+    }, /* @__PURE__ */ React.createElement("img", {
+      className: "pda-finish-card-img",
+      src: isError ? PdaFinishCard.ERROR_SUCCESS : PdaFinishCard.SUCCESS
+    }), /* @__PURE__ */ React.createElement("p", {
+      className: "pda-finish-card-title"
+    }, title), infoList.map((item, index2) => {
+      return /* @__PURE__ */ React.createElement("p", {
+        key: index2,
+        className: "pda-finish-card-list"
+      }, /* @__PURE__ */ React.createElement("span", null, item.label || ""), /* @__PURE__ */ React.createElement("span", null, item.content || ""));
+    })));
+  }
+}
+PdaFinishCard.SUCCESS = "https://img.alicdn.com/imgextra/i3/O1CN01OL2UYg24792knbTtC_!!6000000007343-1-tps-506-415.gif";
+PdaFinishCard.ERROR_SUCCESS = "https://img.alicdn.com/imgextra/i3/O1CN01p5Oc5t1VMFWtBomQc_!!6000000002638-1-tps-600-456.gif";
+var index$9 = "";
+class PdaDistanceCard extends React.Component {
+  constructor(props) {
+    super(props);
+  }
+  render() {
+    const { className, title, infoText, percentage = 0, style = {} } = this.props;
+    const distanceImg = "https://img.alicdn.com/imgextra/i3/O1CN01EFksWL1DBZCu0H1JH_!!6000000000178-2-tps-21-30.png";
+    const indictorImg = "https://img.alicdn.com/imgextra/i1/O1CN01YEhCSg1aObe8UZq7K_!!6000000003320-2-tps-379-17.png";
+    return /* @__PURE__ */ React.createElement("div", {
+      className: classNames({ [className]: true, "pda-distance-card": true }),
+      style
+    }, /* @__PURE__ */ React.createElement("p", {
+      className: "pda-distance-card-highlight"
+    }, /* @__PURE__ */ React.createElement("span", {
+      className: "pda-distance-card-highlight1"
+    }, title)), /* @__PURE__ */ React.createElement("div", {
+      className: "pda-distance-indictor"
+    }, /* @__PURE__ */ React.createElement("img", {
+      src: distanceImg,
+      width: 20,
+      height: 29
+    }), /* @__PURE__ */ React.createElement("p", null, infoText)), /* @__PURE__ */ React.createElement("div", {
+      className: "pda-distance-card-progress"
+    }, /* @__PURE__ */ React.createElement("div", {
+      className: "pda-distance-card-progress-inside",
+      style: { width: `${percentage * 100}%` }
+    }), /* @__PURE__ */ React.createElement("img", {
+      className: "pda-distance-card-progress-indictor",
+      src: indictorImg
+    })), /* @__PURE__ */ React.createElement("div", {
+      className: "pda-distance-label"
+    }, /* @__PURE__ */ React.createElement("p", null, "\u8FDC"), /* @__PURE__ */ React.createElement("p", null, "\u8FD1")));
+  }
+}
+var index$8 = "";
+function SubCard(props) {
+  const { title, context, name, tag, attrs = [], style } = props;
+  return /* @__PURE__ */ React.createElement("div", {
+    className: "android-sub-card",
+    style
+  }, /* @__PURE__ */ React.createElement("div", {
+    className: "android-sub-card-title-section"
+  }, /* @__PURE__ */ React.createElement("div", {
+    className: "android-sub-card-title"
+  }, title), tag ? /* @__PURE__ */ React.createElement("div", {
+    className: "android-sub-card-tag"
+  }, /* @__PURE__ */ React.createElement("div", {
+    className: tag.type
+  }, tag.label || "")) : null), /* @__PURE__ */ React.createElement("div", {
+    className: "android-sub-card-context"
+  }, context), name ? /* @__PURE__ */ React.createElement("div", {
+    className: "android-sub-card-name"
+  }, name) : null, /* @__PURE__ */ React.createElement("div", {
+    className: "android-sub-card-attrs"
+  }, attrs.map((text) => {
+    return /* @__PURE__ */ React.createElement("div", {
+      key: text
+    }, text);
+  })));
+}
+var index$7 = "";
+function SelectCard(props) {
+  const { title, label, select = true, onClick = (e) => {
+  } } = props;
+  return /* @__PURE__ */ React.createElement("div", {
+    className: "select-card"
+  }, /* @__PURE__ */ React.createElement("p", null, title), /* @__PURE__ */ React.createElement("div", {
+    className: "select-card-content",
+    onClick
+  }, label, " ", select ? /* @__PURE__ */ React.createElement("span", {
+    className: "select-icon"
+  }) : null, " "));
+}
+var index$6 = "";
+function empty() {
+}
+function index$5(props) {
+  const { dataSource = [], onClickItem = empty } = props;
+  let tabIndex = 1;
+  return /* @__PURE__ */ React.createElement("div", {
+    className: "pda-app-list"
+  }, dataSource.map((item) => {
+    return /* @__PURE__ */ React.createElement("div", {
+      className: "pda-app-group",
+      key: item.groupName
+    }, /* @__PURE__ */ React.createElement("h2", {
+      className: "group-name"
+    }, item.groupName), /* @__PURE__ */ React.createElement("div", {
+      className: "group-apps"
+    }, item.list.map((it) => {
+      return /* @__PURE__ */ React.createElement("div", {
+        className: "app-item",
+        key: it.name,
+        autoFocus: tabIndex === 1,
+        tabIndex: tabIndex++,
+        onClick: () => onClickItem(it)
+      }, /* @__PURE__ */ React.createElement("span", {
+        className: "app-name"
+      }, it.name), /* @__PURE__ */ React.createElement("span", {
+        className: "app-subname"
+      }, it.subname));
+    })));
+  }));
+}
+var index$4 = "";
+function usePersistFn(fn) {
+  var fnRef = useRef(fn);
+  fnRef.current = fn;
+  var persistFn = useRef();
+  if (!persistFn.current) {
+    persistFn.current = function() {
+      var args = [];
+      for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+      }
+      return fnRef.current.apply(this, args);
+    };
+  }
+  return persistFn.current;
+}
+var __awaiter = function(thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function(resolve) {
+      resolve(value);
+    });
+  }
+  return new (P || (P = Promise))(function(resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+};
+var __generator = function(thisArg, body) {
+  var _ = {
+    label: 0,
+    sent: function sent() {
+      if (t[0] & 1)
+        throw t[1];
+      return t[1];
+    },
+    trys: [],
+    ops: []
+  }, f, y, t, g;
+  return g = {
+    next: verb(0),
+    "throw": verb(1),
+    "return": verb(2)
+  }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+    return this;
+  }), g;
+  function verb(n) {
+    return function(v) {
+      return step([n, v]);
+    };
+  }
+  function step(op) {
+    if (f)
+      throw new TypeError("Generator is already executing.");
+    while (_) {
+      try {
+        if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
+          return t;
+        if (y = 0, t)
+          op = [op[0] & 2, t.value];
+        switch (op[0]) {
+          case 0:
+          case 1:
+            t = op;
+            break;
+          case 4:
+            _.label++;
+            return {
+              value: op[1],
+              done: false
+            };
+          case 5:
+            _.label++;
+            y = op[1];
+            op = [0];
+            continue;
+          case 7:
+            op = _.ops.pop();
+            _.trys.pop();
+            continue;
+          default:
+            if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+              _ = 0;
+              continue;
+            }
+            if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+              _.label = op[1];
+              break;
+            }
+            if (op[0] === 6 && _.label < t[1]) {
+              _.label = t[1];
+              t = op;
+              break;
+            }
+            if (t && _.label < t[2]) {
+              _.label = t[2];
+              _.ops.push(op);
+              break;
+            }
+            if (t[2])
+              _.ops.pop();
+            _.trys.pop();
+            continue;
+        }
+        op = body.call(thisArg, _);
+      } catch (e) {
+        op = [6, e];
+        y = 0;
+      } finally {
+        f = t = 0;
+      }
+    }
+    if (op[0] & 5)
+      throw op[1];
+    return {
+      value: op[0] ? op[1] : void 0,
+      done: true
+    };
+  }
+};
+var __read = function(o, n) {
+  var m = typeof Symbol === "function" && o[Symbol.iterator];
+  if (!m)
+    return o;
+  var i = m.call(o), r2, ar = [], e;
+  try {
+    while ((n === void 0 || n-- > 0) && !(r2 = i.next()).done) {
+      ar.push(r2.value);
+    }
+  } catch (error) {
+    e = {
+      error
+    };
+  } finally {
+    try {
+      if (r2 && !r2.done && (m = i["return"]))
+        m.call(i);
+    } finally {
+      if (e)
+        throw e.error;
+    }
+  }
+  return ar;
+};
+var __spread = function() {
+  for (var ar = [], i = 0; i < arguments.length; i++) {
+    ar = ar.concat(__read(arguments[i]));
+  }
+  return ar;
+};
+function useLockFn(fn) {
+  var _this = this;
+  var lockRef = useRef(false);
+  return useCallback(function() {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+      args[_i] = arguments[_i];
+    }
+    return __awaiter(_this, void 0, void 0, function() {
+      var ret, e_1;
+      return __generator(this, function(_a) {
+        switch (_a.label) {
+          case 0:
+            if (lockRef.current)
+              return [
+                2
+              ];
+            lockRef.current = true;
+            _a.label = 1;
+          case 1:
+            _a.trys.push([1, 3, , 4]);
+            return [
+              4,
+              fn.apply(void 0, __spread(args))
+            ];
+          case 2:
+            ret = _a.sent();
+            lockRef.current = false;
+            return [
+              2,
+              ret
+            ];
+          case 3:
+            e_1 = _a.sent();
+            lockRef.current = false;
+            throw e_1;
+          case 4:
+            return [
+              2
+            ];
+        }
+      });
+    });
+  }, [fn]);
+}
+const overflowScrollReg = /scroll|auto/i;
+function isElement(node) {
+  const ELEMENT_NODE_TYPE = 1;
+  return node.tagName !== "HTML" && node.tagName !== "BODY" && node.nodeType === ELEMENT_NODE_TYPE;
+}
+function getScrollParent(el, root) {
+  let node = el;
+  while (node && node !== root && isElement(node)) {
+    const { overflowY } = window.getComputedStyle(node);
+    if (overflowScrollReg.test(overflowY)) {
+      return node;
+    }
+    node = node.parentNode;
+  }
+  return root;
+}
+function Loading(props) {
+  return /* @__PURE__ */ React.createElement("div", {
+    style: {
+      color: props.color || "#999"
+    }
+  }, /* @__PURE__ */ React.createElement("svg", {
+    height: "1em",
+    viewBox: "0 0 100 40",
+    style: { verticalAlign: "-0.125em" }
+  }, /* @__PURE__ */ React.createElement("g", {
+    stroke: "none",
+    strokeWidth: "1",
+    fill: "none",
+    fillRule: "evenodd"
+  }, /* @__PURE__ */ React.createElement("g", {
+    transform: "translate(-100.000000, -71.000000)"
+  }, /* @__PURE__ */ React.createElement("g", {
+    transform: "translate(95.000000, 71.000000)"
+  }, /* @__PURE__ */ React.createElement("g", {
+    transform: "translate(5.000000, 0.000000)"
+  }, [0, 1, 2].map((i) => /* @__PURE__ */ React.createElement("rect", {
+    key: i,
+    fill: "currentColor",
+    x: 20 + i * 26,
+    y: "16",
+    width: "8",
+    height: "8",
+    rx: "2"
+  }, /* @__PURE__ */ React.createElement("animate", {
+    attributeName: "y",
+    from: "16",
+    to: "16",
+    dur: "2s",
+    begin: `${i * 0.2}s`,
+    repeatCount: "indefinite",
+    values: "16; 6; 26; 16; 16",
+    keyTimes: "0; 0.1; 0.3; 0.4; 1",
+    id: "circ-anim"
+  })))))))));
+}
+function isWindow(element) {
+  return element === window;
+}
+function InfiniteScroll(props) {
+  const { className, hasMore, loadMore, threshold = 0, style } = props;
+  const doLoadMore = useLockFn(async () => {
+    await loadMore();
+  });
+  const elementRef = useRef(null);
+  const check = usePersistFn(() => {
+    if (!hasMore)
+      return;
+    const element = elementRef.current;
+    if (!element)
+      return;
+    const parent = getScrollParent(element);
+    if (!parent)
+      return;
+    const elementTop = element.getBoundingClientRect().top;
+    const current = isWindow(parent) ? window.innerHeight : parent.getBoundingClientRect().bottom;
+    if (current >= elementTop - threshold) {
+      doLoadMore();
+    }
+  });
+  useEffect(() => {
+    check();
+  });
+  useEffect(() => {
+    const element = elementRef.current;
+    if (!element)
+      return;
+    const parent = getScrollParent(element);
+    if (!parent)
+      return;
+    function onScroll() {
+      check();
+    }
+    parent.addEventListener("scroll", onScroll);
+    return () => {
+      parent.removeEventListener("scroll", onScroll);
+    };
+  }, []);
+  return /* @__PURE__ */ React.createElement("div", {
+    className: classNames({ [className]: true, "pda-infinite-scroll": true }),
+    style,
+    ref: elementRef
+  }, hasMore ? /* @__PURE__ */ React.createElement("div", {
+    className: "pda-infinite-scroll-view"
+  }, /* @__PURE__ */ React.createElement("span", null, "\u52A0\u8F7D\u4E2D"), /* @__PURE__ */ React.createElement(Loading, null)) : /* @__PURE__ */ React.createElement("div", {
+    className: "pda-infinite-scroll-view"
+  }, /* @__PURE__ */ React.createElement("span", null, "\u6CA1\u6709\u66F4\u591A\u4E86~")));
+}
+var index$3 = "";
+function ActionSheet(props) {
+  const { className = "", visible, actions = [], stickyToBottomActions = [], stickyToBottomDirection = "column", infiniteScroll = null } = props;
+  return /* @__PURE__ */ React.createElement("div", {
+    className: classNames({ [className]: true, "action-sheet": true, "show": visible })
+  }, /* @__PURE__ */ React.createElement("div", {
+    className: "action-sheet-container"
+  }, /* @__PURE__ */ React.createElement("div", {
+    className: "action-sheet-body"
+  }, actions.map((item, index2) => {
+    return /* @__PURE__ */ React.createElement("div", {
+      onClick: () => {
+        item.onClick(item.key);
+      },
+      className: "action-sheet-item",
+      key: index2
+    }, item.title);
+  }), infiniteScroll ? /* @__PURE__ */ React.createElement(InfiniteScroll, __spreadValues({}, infiniteScroll)) : null), stickyToBottomActions.length > 0 ? /* @__PURE__ */ React.createElement("div", {
+    className: classNames({ "action-sheet-sticky-bottom": true, ["action-sheet-sticky-bottom-" + stickyToBottomDirection]: true })
+  }, stickyToBottomActions.map((item, index2) => {
+    return /* @__PURE__ */ React.createElement("div", {
+      onClick: () => {
+        item.onClick(item.key);
+      },
+      className: "action-sheet-item",
+      key: index2
+    }, item.title);
+  })) : null));
+}
+var index$2 = "";
+function Tag(props) {
+  const { className = void 0, label = "label", type = "success" } = props;
+  return /* @__PURE__ */ React.createElement("div", {
+    className: classNames({ [className]: true, "pda-tag": true, ["pda-tag-" + type]: true })
+  }, label);
+}
+var index$1 = "";
+function SimpleCard(props) {
+  const { className = void 0, title = "", content = "", type = "default", onClick = () => {
+  } } = props;
+  return title || content ? /* @__PURE__ */ React.createElement("div", {
+    className: classNames({ [className]: true, "simple-card": true, ["simple-card-" + type]: true }),
+    onClick
+  }, /* @__PURE__ */ React.createElement("p", {
+    className: "simple-card-title"
+  }, title), /* @__PURE__ */ React.createElement("p", {
+    className: "simple-card-content"
+  }, content)) : null;
+}
+var index = "";
+function SimpleCardBlock(props) {
+  const { className = void 0, dataSource = [], title = "", tag } = props;
+  return /* @__PURE__ */ React.createElement("div", {
+    className: classNames({ [className]: true, "simple-card-block": true })
+  }, /* @__PURE__ */ React.createElement("div", {
+    className: "simple-card-block-header"
+  }, /* @__PURE__ */ React.createElement("p", {
+    className: "simple-card-block-title"
+  }, title), tag ? /* @__PURE__ */ React.createElement("div", {
+    style: { marginLeft: 12 }
+  }, /* @__PURE__ */ React.createElement(Tag, __spreadValues({}, tag))) : null), dataSource.length > 0 ? /* @__PURE__ */ React.createElement("div", {
+    className: "simple-card-block-content"
+  }, dataSource.map((item, index2) => {
+    return /* @__PURE__ */ React.createElement(SimpleCard, __spreadValues({
+      key: index2
+    }, item));
+  }), /* @__PURE__ */ React.createElement("div", {
+    style: { display: "inline-block", padding: "12px  18px" }
+  }), /* @__PURE__ */ React.createElement("div", {
+    style: { display: "inline-block", padding: "0  18px", margin: 0 }
+  })) : null);
+}
+const ListItem = PdaListItem;
+export { ActionSheet, index$5 as AppList, BaseLayout, Button, Confirm, PdaDistanceCard as DistanceCard, PdaFinishCard as FinishCard, index$q as Header, InfiniteScroll, PdaInfoCard$2 as InfoCard, Keyborard, List, ListItem, Overlay$1 as Overlay, index$h as PageFlowSystemPages, Presentation, SelectCard, SimpleCard, SimpleCardBlock, PdaInfoCard as Steps, SubCard, Tag, PdaListItem as TaskCard, PdaTitle as Title, Toast, WakeKeyborard };