ranui 0.1.5 → 0.1.7

package/dist/index-b90299ca.js

@@ -0,0 +1,43 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+const f7170ee498e0dd32cbdcb63fba8f75cc = '@keyframes skeleton{0%{transform:translate(-37.5%)}to{transform:translate(37.5%)}}.ran-skeleton{position:relative;z-index:0;overflow:hidden;background:0 0;width:100%;height:16px;background:rgba(0,0,0,.06);border-radius:4px}.ran-skeleton:after{position:absolute;top:0;inset-inline-end:-150%;bottom:0;inset-inline-start:-150%;background:linear-gradient(90deg,rgba(0,0,0,.06) 25%,rgba(0,0,0,.15) 37%,rgba(0,0,0,.06) 63%);animation-name:skeleton;animation-duration:1.4s;animation-timing-function:ease;animation-iteration-count:infinite;content:""}\n';
+function Skeleton() {
+  if (typeof window !== "undefined" && !customElements.get("r-skeleton")) {
+    class CustomElement extends HTMLElement {
+      constructor() {
+        super();
+        __publicField(this, "_div");
+        this._div = document.createElement("div");
+        this._div.setAttribute("class", "ran-skeleton");
+        const shadowRoot = this.attachShadow({ mode: "closed" });
+        const F7170EE498E0DD32CBDCB63FBA8F75CC = document.createElement("style");
+        F7170EE498E0DD32CBDCB63FBA8F75CC.textContent = f7170ee498e0dd32cbdcb63fba8f75cc;
+        shadowRoot.appendChild(F7170EE498E0DD32CBDCB63FBA8F75CC);
+        shadowRoot.appendChild(this._div);
+      }
+      static get observedAttributes() {
+        return ["disabled"];
+      }
+      connectedCallback() {
+      }
+      disconnectCallback() {
+      }
+      attributeChangedCallback(name, oldValue, newValue) {
+      }
+    }
+    window.customElements.define("r-skeleton", CustomElement);
+  }
+}
+const index = Skeleton();
+const index$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  default: index
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  index as a,
+  index$1 as i
+};

package/dist/index-d2d69b06.js

@@ -0,0 +1,225 @@
+import "./vendor-f71e6f68.js";
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+const NEW_LISTENER = "NEW_LISTENER";
+class SyncHook {
+  constructor() {
+    __publicField(this, "_events");
+    __publicField(this, "on", (eventName, eventItem) => {
+      if (this._events[eventName] && eventName !== Symbol.for(NEW_LISTENER)) {
+        this.emit(Symbol.for(NEW_LISTENER), eventName);
+      }
+      const callbacks = this._events[eventName] || [];
+      if (typeof eventItem === "function") {
+        callbacks.push({
+          name: eventName,
+          callback: eventItem
+        });
+      } else {
+        callbacks.push(eventItem);
+      }
+      this._events[eventName] = callbacks;
+    });
+    __publicField(this, "emit", (eventName, ...args) => {
+      const callbacks = this._events[eventName] || [];
+      callbacks.forEach((item) => {
+        const { callback } = item;
+        callback(...args);
+      });
+    });
+    __publicField(this, "once", (eventName, eventItem) => {
+      let one;
+      if (typeof eventItem === "function") {
+        one = {
+          name: eventName,
+          callback: (...args) => {
+            eventItem(...args);
+            this.off(eventName, one);
+          },
+          initialCallback: eventItem
+        };
+      } else {
+        const { callback } = eventItem;
+        one = {
+          name: eventName,
+          callback: (...args) => {
+            callback(...args);
+            this.off(eventName, one);
+          },
+          initialCallback: callback
+        };
+      }
+      this.on(eventName, one);
+    });
+    __publicField(this, "off", (eventName, eventItem) => {
+      const callbacks = this._events[eventName] || [];
+      const newCallbacks = callbacks.filter((item) => {
+        if (typeof eventItem === "function") {
+          return item.callback !== eventItem && item.initialCallback !== eventItem;
+        } else {
+          const { callback } = eventItem;
+          return item.callback !== callback && item.initialCallback !== callback;
+        }
+      });
+      this._events[eventName] = newCallbacks;
+    });
+    this._events = {};
+  }
+}
+const str2Xml = (xmlStr, format = "text/xml") => {
+  if (window.DOMParser)
+    return new window.DOMParser().parseFromString(xmlStr, format).documentElement;
+  if (typeof window.ActiveXObject !== "undefined" && new window.ActiveXObject("Microsoft.XMLDOM")) {
+    const xmlDoc = new window.ActiveXObject("Microsoft.XMLDOM");
+    xmlDoc.async = "false";
+    xmlDoc.loadXML(xmlStr);
+    return xmlDoc;
+  }
+  return void 0;
+};
+function vnode$1(sel, data, children, text, elm) {
+  const key = data === void 0 ? void 0 : data.key;
+  return { sel, data, children, text, elm, key };
+}
+vnode$1("", {}, [], void 0, void 0);
+const throttle$1 = (fn, wait = 300) => {
+  let timer;
+  return function() {
+    const context = this;
+    const args = arguments;
+    if (!timer) {
+      timer = setTimeout(() => {
+        timer = null;
+        fn.apply(context, args);
+      }, wait);
+    }
+  };
+};
+const noop = () => {
+};
+const judgeDevice = () => {
+  if (typeof window !== "undefined") {
+    const ua = navigator.userAgent.toLowerCase();
+    if (/ipad|ipod/.test(ua))
+      return "ipad";
+    if (/android/.test(ua))
+      return "android";
+    if (/iphone/.test(ua))
+      return "iphone";
+    return "pc";
+  }
+  return "pc";
+};
+function formatDuration(time) {
+  return time < 10 ? `0${time}` : time;
+}
+function timestampToTime(timestamp) {
+  let date = /* @__PURE__ */ new Date();
+  if (timestamp) {
+    date = new Date(timestamp);
+  }
+  date.format = (format = "YYYY-MM-DD HH:mm:ss") => {
+    const year = date.getFullYear();
+    const month = formatDuration(date.getMonth() + 1);
+    const day = formatDuration(date.getDate());
+    const hour = formatDuration(date.getHours());
+    const minute = formatDuration(date.getMinutes());
+    const second = formatDuration(date.getSeconds());
+    return format.replace(/Y+/gi, `${year}`).replace(/M+/g, `${month}`).replace(/D+/gi, `${day}`).replace(/H+/gi, `${hour}`).replace(/m+/g, `${minute}`).replace(/S+/gi, `${second}`);
+  };
+  return date;
+}
+const getPixelRatio = (context) => {
+  const backingStore = context.backingStorePixelRatio || context.webkitBackingStorePixelRatio || context.mozBackingStorePixelRatio || context.msBackingStorePixelRatio || context.oBackingStorePixelRatio || 1;
+  return (window.devicePixelRatio || 1) / backingStore;
+};
+const addClassToElement = (element, addClass) => {
+  if (typeof document === "undefined")
+    return void 0;
+  const classList = element.classList;
+  if (!classList.contains(addClass)) {
+    classList.add(addClass);
+  }
+};
+const removeClassToElement = (element, removeClass) => {
+  if (typeof document === "undefined")
+    return void 0;
+  const classList = element.classList;
+  if (classList.contains(removeClass)) {
+    classList.remove(removeClass);
+  }
+};
+const timeFormat = (time) => {
+  if (time === 0)
+    return "00:00";
+  if (!time)
+    return "";
+  const hour = Math.trunc(time / 3600);
+  const minute = Math.trunc(time % 3600 / 60);
+  const second = formatDuration(Math.trunc(time - hour * 3600 - minute * 60));
+  if (hour === 0) {
+    return `${formatDuration(minute)}:${second}`;
+  }
+  return `${formatDuration(hour)}:${formatDuration(minute)}:${second}`;
+};
+const perToNum = (str = "") => {
+  if (str.length === 0)
+    return 0;
+  if (str.endsWith("%")) {
+    const value = Number(str.replace("%", ""));
+    return value > 1 ? value / 100 : value;
+  } else {
+    return Number(str);
+  }
+};
+const range = (num, min = 0, max = 1) => {
+  return Math.min(max, Math.max(min, num));
+};
+const createDocumentFragment = (list) => {
+  if (typeof document === "undefined")
+    return void 0;
+  const Fragment = document.createDocumentFragment();
+  list.forEach((item) => Fragment.appendChild(item));
+  return Fragment;
+};
+const heap = new Array(128).fill(void 0);
+heap.push(void 0, null, true, false);
+heap.length;
+const cachedTextDecoder = typeof TextDecoder !== "undefined" ? new TextDecoder("utf-8", { ignoreBOM: true, fatal: true }) : { decode: () => {
+  throw Error("TextDecoder not available");
+} };
+if (typeof TextDecoder !== "undefined") {
+  cachedTextDecoder.decode();
+}
+const cachedTextEncoder = typeof TextEncoder !== "undefined" ? new TextEncoder("utf-8") : { encode: () => {
+  throw Error("TextEncoder not available");
+} };
+typeof cachedTextEncoder.encodeInto === "function" ? function(arg, view) {
+  return cachedTextEncoder.encodeInto(arg, view);
+} : function(arg, view) {
+  const buf = cachedTextEncoder.encode(arg);
+  view.set(buf);
+  return {
+    read: arg.length,
+    written: buf.length
+  };
+};
+export {
+  SyncHook as S,
+  addClassToElement as a,
+  timeFormat as b,
+  createDocumentFragment as c,
+  range as d,
+  throttle$1 as e,
+  getPixelRatio as g,
+  judgeDevice as j,
+  noop as n,
+  perToNum as p,
+  removeClassToElement as r,
+  str2Xml as s,
+  timestampToTime as t
+};