@cccsaurora/clue-ui 0.15.0-dev.28 → 0.15.0-dev.29

package/utils/graph.js

@@ -0,0 +1,79 @@
+const cyrb53 = (str, seed = 0) => {
+  let h1 = 3735928559 ^ seed, h2 = 1103547991 ^ seed;
+  for (let i = 0, ch; i < str.length; i++) {
+    ch = str.charCodeAt(i);
+    h1 = Math.imul(h1 ^ ch, 2654435761);
+    h2 = Math.imul(h2 ^ ch, 1597334677);
+  }
+  h1 = Math.imul(h1 ^ h1 >>> 16, 2246822507);
+  h1 ^= Math.imul(h2 ^ h2 >>> 13, 3266489909);
+  h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507);
+  h2 ^= Math.imul(h1 ^ h1 >>> 13, 3266489909);
+  return parseFloat(`0.${4294967296 * (2097151 & h2) + (h1 >>> 0)}`);
+};
+const cssImportant = (property) => `${property} !important`;
+const findNode = (nodeId, flatNodes) => {
+  return flatNodes.find((node) => node.id === nodeId);
+};
+const getPathToRoot = (nodeId, data) => {
+  function getRoot(currNodeId, results) {
+    if (results.has(currNodeId)) {
+      return results;
+    }
+    let newResults = results.add(currNodeId);
+    const currNode = findNode(currNodeId, data.flat());
+    if (currNode == null ? void 0 : currNode.edges) {
+      currNode == null ? void 0 : currNode.edges.forEach((parent) => {
+        newResults = getRoot(parent, results);
+      });
+    }
+    return newResults;
+  }
+  return getRoot(nodeId, /* @__PURE__ */ new Set());
+};
+const getAllChildren = (nodeId, data) => {
+  function getChildren(currNodeId, results) {
+    if (results.has(currNodeId)) {
+      return results;
+    }
+    let newResults = results.add(currNodeId);
+    const currNode = findNode(currNodeId, data.flat());
+    const directChildren = data.flat().filter((n) => {
+      var _a;
+      return (_a = n.edges) == null ? void 0 : _a.includes(currNode == null ? void 0 : currNode.id);
+    });
+    if (directChildren) {
+      directChildren.forEach((child) => {
+        newResults = getChildren(child.id, newResults);
+      });
+    }
+    return newResults;
+  }
+  return getChildren(nodeId, /* @__PURE__ */ new Set());
+};
+const getSubGraphNodeSet = (nodeId, data) => {
+  if (!data) {
+    return new Set(nodeId);
+  }
+  const ancestors = getPathToRoot(nodeId, data);
+  const descendents = getAllChildren(nodeId, data);
+  return /* @__PURE__ */ new Set([nodeId, ...ancestors, ...descendents]);
+};
+const createSubGraph = (nodeId, dataset) => {
+  const subGraphNodes = getSubGraphNodeSet(nodeId, dataset.data);
+  const newData = dataset.data.map(
+    (level) => level.filter((node) => subGraphNodes.has(node.id)).map((node) => {
+      var _a;
+      return { ...node, edges: (_a = node == null ? void 0 : node.edges) == null ? void 0 : _a.filter((edge) => subGraphNodes.has(edge)) };
+    })
+  ).filter((level) => level.length > 0);
+  return newData;
+};
+export {
+  createSubGraph,
+  cssImportant,
+  cyrb53,
+  getAllChildren,
+  getPathToRoot,
+  getSubGraphNodeSet
+};

package/utils/hashUtil.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Creates a hash from the input string.
+ * @param value The value to hash.
+ * @returns The hashed value.
+ */
+export declare function simpleHash(value: string): string;

package/utils/hashUtil.js

@@ -0,0 +1,11 @@
+function simpleHash(value) {
+  let hash = 0;
+  for (let i = 0; i < value.length; i++) {
+    const char = value.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+  }
+  return (hash >>> 0).toString(36).padStart(7, "0");
+}
+export {
+  simpleHash
+};

package/utils/line.d.ts

@@ -0,0 +1,28 @@
+export declare const buildHorizontalLine: ({ paddingAtLevel, numLines, distanceX, distanceY, childX, childY, childHeight, parentX, parentY, linePaddingX, nodeLocations, dest, arcRadius }: {
+    paddingAtLevel: any;
+    numLines: any;
+    distanceX: any;
+    distanceY: any;
+    childX: any;
+    childY: any;
+    childHeight: any;
+    parentX: any;
+    parentY: any;
+    linePaddingX: any;
+    nodeLocations: any;
+    dest: any;
+    arcRadius: any;
+}) => string[];
+export declare const buildVerticalLine: ({ paddingAtLevel, numLines, distanceX, distanceY, childX, childY, childHeight, parentX, parentY, linePaddingX, arcRadius }: {
+    paddingAtLevel: any;
+    numLines: any;
+    distanceX: any;
+    distanceY: any;
+    childX: any;
+    childY: any;
+    childHeight: any;
+    parentX: any;
+    parentY: any;
+    linePaddingX: any;
+    arcRadius: any;
+}) => string[];

package/utils/line.js

@@ -0,0 +1,136 @@
+const buildHorizontalLine = ({
+  paddingAtLevel,
+  numLines,
+  distanceX,
+  distanceY,
+  childX,
+  childY,
+  childHeight,
+  parentX,
+  parentY,
+  linePaddingX,
+  nodeLocations,
+  dest,
+  arcRadius
+}) => {
+  const d = [];
+  const verticalLineX = childX - (paddingAtLevel - numLines) * linePaddingX;
+  if (distanceX === 0) {
+    if (distanceY === 0) {
+      d.push(
+        `M ${parentX} ${parentY}`,
+        `L ${parentX - linePaddingX + 3} ${parentY}`,
+        `A 3 3 90 0 0 ${verticalLineX} ${parentY + 3}`
+      );
+      d.push(
+        `L ${verticalLineX} ${nodeLocations[dest.id][1] - 3}`,
+        `A 3 3 90 0 0 ${verticalLineX + 3} ${nodeLocations[dest.id][1]}`,
+        `L ${childX} ${nodeLocations[dest.id][1]}`
+      );
+    } else {
+      d.push(`M ${parentX} ${parentY}`, `L ${verticalLineX + arcRadius} ${parentY}`);
+      if (Math.sign(distanceY) < 0) {
+        d.push(
+          `A ${arcRadius} ${arcRadius} 90 0 1 ${verticalLineX} ${parentY - arcRadius}`,
+          `L ${verticalLineX} ${childY + arcRadius}`,
+          `A ${arcRadius} ${arcRadius} 90 0 1 ${verticalLineX + arcRadius} ${childY}`
+        );
+      } else {
+        d.push(
+          `A ${arcRadius} ${arcRadius} 90 0 0 ${verticalLineX} ${parentY + arcRadius}`,
+          `L ${verticalLineX} ${childY - arcRadius}`,
+          `A ${arcRadius} ${arcRadius} 90 0 0 ${verticalLineX + arcRadius} ${childY}`
+        );
+      }
+      d.push(`L ${childX} ${childY}`);
+    }
+  } else {
+    d.push(`M ${parentX} ${parentY}`);
+    if (Math.sign(distanceY) < 0) {
+      if (Math.sign(distanceX) < 0) {
+        d.push(
+          `L ${verticalLineX + arcRadius} ${parentY}`,
+          `A ${arcRadius} ${arcRadius} 90 0 1 ${verticalLineX} ${parentY - arcRadius}`
+        );
+      } else {
+        d.push(
+          `L ${verticalLineX - arcRadius} ${parentY}`,
+          `A ${arcRadius} ${arcRadius} 90 0 0 ${verticalLineX} ${parentY - arcRadius}`
+        );
+      }
+      d.push(
+        `L ${verticalLineX} ${childY + childHeight / 2 + arcRadius}`,
+        `A ${arcRadius} ${arcRadius} 90 0 1 ${verticalLineX + arcRadius} ${childY + childHeight / 2}`
+      );
+    } else {
+      if (Math.sign(distanceX) < 0) {
+        d.push(
+          `L ${verticalLineX + arcRadius} ${parentY}`,
+          `A ${arcRadius} ${arcRadius} 90 0 0 ${verticalLineX} ${parentY + arcRadius}`
+        );
+      } else {
+        d.push(
+          `L ${verticalLineX - arcRadius} ${parentY}`,
+          `A ${arcRadius} ${arcRadius} 90 0 1 ${verticalLineX} ${parentY + arcRadius}`
+        );
+      }
+      d.push(
+        `L ${verticalLineX} ${childY + childHeight / 2 - arcRadius}`,
+        `A ${arcRadius} ${arcRadius} 90 0 0 ${verticalLineX + arcRadius} ${childY + childHeight / 2}`
+      );
+    }
+    d.push(`L ${childX} ${childY + childHeight / 2}`);
+  }
+  return d;
+};
+const buildVerticalLine = ({
+  paddingAtLevel,
+  numLines,
+  distanceX,
+  distanceY,
+  childX,
+  childY,
+  childHeight,
+  parentX,
+  parentY,
+  linePaddingX,
+  arcRadius
+}) => {
+  const d = [];
+  const verticalLineX = (Math.sign(distanceY) < 0 ? childX : parentX) - (paddingAtLevel - numLines) * linePaddingX;
+  if (distanceX === 0) {
+    d.push(`M ${parentX} ${parentY}`, `L ${childX} ${childY}`);
+  } else {
+    d.push(`M ${parentX} ${parentY}`);
+    if (Math.sign(distanceY) < 0) {
+      if (Math.sign(distanceX) < 0) {
+        d.push(
+          `L ${verticalLineX + arcRadius} ${parentY}`,
+          `A ${arcRadius} ${arcRadius} 90 0 1 ${verticalLineX} ${parentY - arcRadius}`,
+          `L ${verticalLineX} ${childY + childHeight / 2 + arcRadius}`,
+          `A ${arcRadius} ${arcRadius} 90 0 1 ${verticalLineX + arcRadius} ${childY + childHeight / 2}`
+        );
+      } else {
+        d.push(
+          `L ${verticalLineX - arcRadius} ${parentY}`,
+          `A ${arcRadius} ${arcRadius} 90 0 0 ${verticalLineX} ${parentY - arcRadius}`,
+          `L ${verticalLineX} ${childY + childHeight / 2 + arcRadius}`,
+          `A ${arcRadius} ${arcRadius} 90 0 0 ${verticalLineX - arcRadius} ${childY + childHeight / 2}`
+        );
+      }
+    } else {
+      d.push(
+        `L ${verticalLineX + arcRadius} ${parentY}`,
+        `A ${arcRadius} ${arcRadius} 90 0 0 ${verticalLineX} ${parentY + arcRadius}`,
+        `L ${verticalLineX} ${childY + childHeight / 2 - arcRadius}`,
+        `A ${arcRadius} ${arcRadius} 90 0 0 ${verticalLineX + arcRadius} ${childY + childHeight / 2}`
+      );
+    }
+    d.push(`L ${childX} ${childY + childHeight / 2}`);
+  }
+  return d;
+};
+export {
+  buildHorizontalLine,
+  buildVerticalLine
+};

package/utils/loggerUtil.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Utility for logging debug messages if clue is configured to allow debug logging.
+ * @param message The debug message.
+ * @param loggingEnabled the flag to determine if debugging is enabled.
+ */
+export declare function clueDebugLogger(message: string, loggingEnabled: boolean): void;

package/utils/loggerUtil.js

@@ -0,0 +1,8 @@
+function clueDebugLogger(message, loggingEnabled) {
+  if (loggingEnabled) {
+    console.debug(message);
+  }
+}
+export {
+  clueDebugLogger
+};

package/utils/sessionStorage.d.ts

@@ -0,0 +1,9 @@
+import { StorageKey } from "../utils/constants";
+
+export declare const buildName: (name: string) => string;
+declare const getStored: <T = string>(name: StorageKey) => T, removeStored: (name: StorageKey) => void, setStored: (name: StorageKey, item: any) => void;
+export { getStored, removeStored, setStored };
+export declare const getAxiosCache: () => {
+    [index: string]: any;
+};
+export declare const setAxiosCache: (etag: string, value: any) => void;

package/utils/sessionStorage.js

@@ -0,0 +1,51 @@
+import { StorageKey, MY_SESSION_STORAGE_PREFIX } from "./constants.js";
+import { d as debounce } from "../debounce-bV0h5FC5.js";
+const buildName = (name) => `${MY_SESSION_STORAGE_PREFIX}.${name}`;
+const {
+  _getStored: getStored,
+  _removeStored: removeStored,
+  _setStored: setStored
+} = /* @__PURE__ */ (() => {
+  let changes = {};
+  const _getStored = function(name) {
+    return changes[buildName(name)] ?? JSON.parse(sessionStorage.getItem(buildName(name)));
+  };
+  const _removeStored = (name) => {
+    delete changes[buildName(name)];
+    sessionStorage.removeItem(buildName(name));
+  };
+  const _setStored = (name, item) => {
+    changes[buildName(name)] = item;
+    debounce(
+      () => {
+        Object.entries(changes).forEach(([_name, data]) => {
+          try {
+            sessionStorage.setItem(_name, JSON.stringify(data));
+          } catch (e) {
+            console.warn("Quota Error when saving to sessionStorage", e);
+          }
+        });
+        changes = {};
+      },
+      250,
+      { leading: false, trailing: true, maxWait: 800 }
+    );
+  };
+  return { _getStored, _removeStored, _setStored };
+})();
+const getAxiosCache = () => {
+  return getStored(StorageKey.AXIOS_CACHE) ?? {};
+};
+const setAxiosCache = (etag, value) => {
+  const cache = getAxiosCache();
+  cache[etag] = value;
+  setStored(StorageKey.AXIOS_CACHE, cache);
+};
+export {
+  buildName,
+  getAxiosCache,
+  getStored,
+  removeStored,
+  setAxiosCache,
+  setStored
+};

package/utils/utils.d.ts

@@ -0,0 +1,13 @@
+import { FailedRequest } from "../types/lookup";
+
+export declare const twitterShort: (date: string | Date | number) => string;
+export declare const delay: (ms: number, rejectOnCancel?: boolean) => {
+    cancel: () => void;
+    then<TResult1 = void, TResult2 = never>(onfulfilled?: (value: void) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>): Promise<void | TResult>;
+    finally(onfinally?: () => void): Promise<void>;
+    readonly [Symbol.toStringTag]: string;
+};
+export declare const removeEmpty: (obj: any, aggressive?: boolean) => any;
+export declare const searchObject: (o: any, query: string) => any;
+export declare const filterEnrichments: (failedEnrichments: FailedRequest[]) => FailedRequest[];

package/utils/utils.js

@@ -0,0 +1,11 @@
+import { d, b, r, s, t } from "../utils-CxIhC2xH.js";
+import "../isEmpty-BQkZubqU.js";
+import "../_Map-kgDsDYxq.js";
+import "../isNil-CIubwp4T.js";
+export {
+  d as delay,
+  b as filterEnrichments,
+  r as removeEmpty,
+  s as searchObject,
+  t as twitterShort
+};

package/utils/window.d.ts

@@ -0,0 +1,3 @@
+export declare const safeDispatchEvent: (event: Event) => void;
+export declare const safeRemoveEventListener: (type: string, listener: (this: Window, ev: any) => any, options?: boolean | EventListenerOptions) => void;
+export declare const safeAddEventListener: (type: string, listener: (this: Window, ev: any) => any, options?: boolean | AddEventListenerOptions) => () => void;

package/utils/window.js

@@ -0,0 +1,24 @@
+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 {
+  safeAddEventListener,
+  safeDispatchEvent,
+  safeRemoveEventListener
+};