@cccsaurora/clue-ui 1.1.3 → 1.2.0-dev.106

package/utils/utils.js

@@ -1,12 +1,12 @@
-import { d as a, b as i, r as p, s as c, t as h } from "../utils-BnmI_6N8.js";
+import { d, b, r, s, t } from "../utils-7OtvGnmf.js";
 import "./time.js";
-import "../_Map-DXNg_Z-q.js";
-import "../isEmpty-g47Qir2A.js";
-import "../isNil-CjWwlQS3.js";
+import "../_Map-kgDsDYxq.js";
+import "../isEmpty-BQkZubqU.js";
+import "../isNil-CIubwp4T.js";
 export {
-  a as delay,
-  i as filterEnrichments,
-  p as removeEmpty,
-  c as searchObject,
-  h as twitterShort
+  d as delay,
+  b as filterEnrichments,
+  r as removeEmpty,
+  s as searchObject,
+  t as twitterShort
 };

package/utils/window.js

@@ -1,13 +1,24 @@
-const i = (e) => {
-  typeof window > "u" || window.dispatchEvent(e);
-}, d = (e, n, t) => {
-  typeof window > "u" || window.removeEventListener(e, n, t);
-}, o = (e, n, t) => {
-  if (!(typeof window > "u"))
-    return window.addEventListener(e, n, t), () => d(e, n, t);
+const safeDispatchEvent = (event) => {
+  if (typeof window === "undefined") {
+    return;
+  }
+  window.dispatchEvent(event);
+};
+const safeRemoveEventListener = (type, listener, options) => {
+  if (typeof window === "undefined") {
+    return;
+  }
+  window.removeEventListener(type, listener, options);
+};
+const safeAddEventListener = (type, listener, options) => {
+  if (typeof window === "undefined") {
+    return;
+  }
+  window.addEventListener(type, listener, options);
+  return () => safeRemoveEventListener(type, listener, options);
 };
 export {
-  o as safeAddEventListener,
-  i as safeDispatchEvent,
-  d as safeRemoveEventListener
+  safeAddEventListener,
+  safeDispatchEvent,
+  safeRemoveEventListener
 };

package/utils-7OtvGnmf.js

@@ -0,0 +1,200 @@
+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);
+import { dayjs } from "./utils/time.js";
+import { i as isArray } from "./_Map-kgDsDYxq.js";
+import { i as isEmpty } from "./isEmpty-BQkZubqU.js";
+import { b as baseIsEqual } from "./_baseIsEqual-B5xLoweL.js";
+import { i as isNil } from "./isNil-CIubwp4T.js";
+import { i as isObjectLike, b as baseGetTag } from "./isObjectLike-OAgjjZye.js";
+import { g as getPrototype } from "./_getPrototype-D1LAdQKO.js";
+import { b as baseUniq } from "./_baseUniq-CpupKWcL.js";
+function isBuffer(obj) {
+  return obj && obj.constructor && typeof obj.constructor.isBuffer === "function" && obj.constructor.isBuffer(obj);
+}
+function keyIdentity(key) {
+  return key;
+}
+function flatten(target, opts) {
+  opts = opts || {};
+  const delimiter = opts.delimiter || ".";
+  const maxDepth = opts.maxDepth;
+  const transformKey = opts.transformKey || keyIdentity;
+  const output = {};
+  function step(object, prev, currentDepth) {
+    currentDepth = currentDepth || 1;
+    Object.keys(object).forEach(function(key) {
+      const value = object[key];
+      const isarray = opts.safe && Array.isArray(value);
+      const type = Object.prototype.toString.call(value);
+      const isbuffer = isBuffer(value);
+      const isobject = type === "[object Object]" || type === "[object Array]";
+      const newKey = prev ? prev + delimiter + transformKey(key) : transformKey(key);
+      if (!isarray && !isbuffer && isobject && Object.keys(value).length && (!opts.maxDepth || currentDepth < maxDepth)) {
+        return step(value, newKey, currentDepth + 1);
+      }
+      output[newKey] = value;
+    });
+  }
+  step(target);
+  return output;
+}
+function unflatten(target, opts) {
+  opts = opts || {};
+  const delimiter = opts.delimiter || ".";
+  const overwrite = opts.overwrite || false;
+  const transformKey = opts.transformKey || keyIdentity;
+  const result = {};
+  const isbuffer = isBuffer(target);
+  if (isbuffer || Object.prototype.toString.call(target) !== "[object Object]") {
+    return target;
+  }
+  function getkey(key) {
+    const parsedKey = Number(key);
+    return isNaN(parsedKey) || key.indexOf(".") !== -1 || opts.object ? key : parsedKey;
+  }
+  function addKeys(keyPrefix, recipient, target2) {
+    return Object.keys(target2).reduce(function(result2, key) {
+      result2[keyPrefix + delimiter + key] = target2[key];
+      return result2;
+    }, recipient);
+  }
+  function isEmpty2(val) {
+    const type = Object.prototype.toString.call(val);
+    const isArray2 = type === "[object Array]";
+    const isObject = type === "[object Object]";
+    if (!val) {
+      return true;
+    } else if (isArray2) {
+      return !val.length;
+    } else if (isObject) {
+      return !Object.keys(val).length;
+    }
+  }
+  target = Object.keys(target).reduce(function(result2, key) {
+    const type = Object.prototype.toString.call(target[key]);
+    const isObject = type === "[object Object]" || type === "[object Array]";
+    if (!isObject || isEmpty2(target[key])) {
+      result2[key] = target[key];
+      return result2;
+    } else {
+      return addKeys(
+        key,
+        result2,
+        flatten(target[key], opts)
+      );
+    }
+  }, {});
+  Object.keys(target).forEach(function(key) {
+    const split = key.split(delimiter).map(transformKey);
+    let key1 = getkey(split.shift());
+    let key2 = getkey(split[0]);
+    let recipient = result;
+    while (key2 !== void 0) {
+      if (key1 === "__proto__") {
+        return;
+      }
+      const type = Object.prototype.toString.call(recipient[key1]);
+      const isobject = type === "[object Object]" || type === "[object Array]";
+      if (!overwrite && !isobject && typeof recipient[key1] !== "undefined") {
+        return;
+      }
+      if (overwrite && !isobject || !overwrite && recipient[key1] == null) {
+        recipient[key1] = typeof key2 === "number" && !opts.object ? [] : {};
+      }
+      recipient = recipient[key1];
+      if (split.length > 0) {
+        key1 = getkey(split.shift());
+        key2 = getkey(split[0]);
+      }
+    }
+    recipient[key1] = unflatten(target[key], opts);
+  });
+  return result;
+}
+var objectTag = "[object Object]";
+var funcProto = Function.prototype, objectProto = Object.prototype;
+var funcToString = funcProto.toString;
+var hasOwnProperty = objectProto.hasOwnProperty;
+var objectCtorString = funcToString.call(Object);
+function isPlainObject(value) {
+  if (!isObjectLike(value) || baseGetTag(value) != objectTag) {
+    return false;
+  }
+  var proto = getPrototype(value);
+  if (proto === null) {
+    return true;
+  }
+  var Ctor = hasOwnProperty.call(proto, "constructor") && proto.constructor;
+  return typeof Ctor == "function" && Ctor instanceof Ctor && funcToString.call(Ctor) == objectCtorString;
+}
+function isEqual(value, other) {
+  return baseIsEqual(value, other);
+}
+function uniqWith(array, comparator) {
+  comparator = typeof comparator == "function" ? comparator : void 0;
+  return array && array.length ? baseUniq(array, void 0, comparator) : [];
+}
+const twitterShort = (date) => {
+  if (!date || date === "?") {
+    return "?";
+  }
+  const now = dayjs();
+  const comparedDate = dayjs(date);
+  if (comparedDate.isAfter(now)) {
+    return now.fromNow();
+  }
+  return comparedDate.fromNow();
+};
+const delay = (ms, rejectOnCancel = false) => {
+  let timerId;
+  let onCancel;
+  class TimedPromise extends Promise {
+    constructor() {
+      super(...arguments);
+      __publicField(this, "cancel", () => {
+        if (rejectOnCancel) {
+          onCancel();
+        }
+        clearTimeout(timerId);
+      });
+    }
+  }
+  return new TimedPromise((resolve, reject) => {
+    timerId = setTimeout(resolve, ms);
+    onCancel = reject;
+  });
+};
+const removeEmpty = (obj, aggressive = false) => {
+  if (aggressive && isEmpty(obj)) {
+    return null;
+  } else if (isArray(obj)) {
+    return obj;
+  }
+  return Object.fromEntries(
+    Object.entries(obj ?? {}).filter(([__, v]) => !isNil(v)).map(([k, v]) => [k, isPlainObject(v) || isArray(v) ? removeEmpty(v, aggressive) : v]).filter(([__, v]) => !!v)
+  );
+};
+const searchObject = (o, query) => {
+  try {
+    const regex = new RegExp(query, "i");
+    return unflatten(
+      Object.fromEntries(Object.entries(flatten(o)).filter(([k, v]) => regex.test(k) || regex.test(v))) ?? {}
+    );
+  } catch {
+    return o;
+  }
+};
+const filterEnrichments = (failedEnrichments) => {
+  return uniqWith(failedEnrichments, isEqual);
+};
+export {
+  isPlainObject as a,
+  filterEnrichments as b,
+  delay as d,
+  flatten as f,
+  isEqual as i,
+  removeEmpty as r,
+  searchObject as s,
+  twitterShort as t
+};