@cccsaurora/clue-ui 0.15.0 → 1.0.0-dev.49

package/sortBy-B-UKp4GT.js

@@ -0,0 +1,100 @@
+import { b as baseExtremum, a as baseGt, i as isIterateeCall } from "./_baseExtremum-B1o1zHjR.js";
+import { b as baseIteratee } from "./_baseIteratee-p6Nj07-n.js";
+import { s as setToString, o as overRest, b as baseFlatten } from "./_baseFlatten-D4huXoEI.js";
+import { a as arrayMap, b as baseGet } from "./_baseGet-BSK_nnoz.js";
+import { b as baseEach } from "./_createAggregator-BpVy5xMi.js";
+import { i as isArrayLike, f as baseUnary } from "./_getTag-D3ToyefI.js";
+import { i as isSymbol } from "./isSymbol-Xd2FsJyp.js";
+import { i as identity } from "./identity-CPGTqrE4.js";
+import { i as isArray } from "./_Map-kgDsDYxq.js";
+function baseRest(func, start) {
+  return setToString(overRest(func, start, identity), func + "");
+}
+function baseMap(collection, iteratee) {
+  var index = -1, result = isArrayLike(collection) ? Array(collection.length) : [];
+  baseEach(collection, function(value, key, collection2) {
+    result[++index] = iteratee(value, key, collection2);
+  });
+  return result;
+}
+function maxBy(array, iteratee) {
+  return array && array.length ? baseExtremum(array, baseIteratee(iteratee), baseGt) : void 0;
+}
+function baseSortBy(array, comparer) {
+  var length = array.length;
+  array.sort(comparer);
+  while (length--) {
+    array[length] = array[length].value;
+  }
+  return array;
+}
+function compareAscending(value, other) {
+  if (value !== other) {
+    var valIsDefined = value !== void 0, valIsNull = value === null, valIsReflexive = value === value, valIsSymbol = isSymbol(value);
+    var othIsDefined = other !== void 0, othIsNull = other === null, othIsReflexive = other === other, othIsSymbol = isSymbol(other);
+    if (!othIsNull && !othIsSymbol && !valIsSymbol && value > other || valIsSymbol && othIsDefined && othIsReflexive && !othIsNull && !othIsSymbol || valIsNull && othIsDefined && othIsReflexive || !valIsDefined && othIsReflexive || !valIsReflexive) {
+      return 1;
+    }
+    if (!valIsNull && !valIsSymbol && !othIsSymbol && value < other || othIsSymbol && valIsDefined && valIsReflexive && !valIsNull && !valIsSymbol || othIsNull && valIsDefined && valIsReflexive || !othIsDefined && valIsReflexive || !othIsReflexive) {
+      return -1;
+    }
+  }
+  return 0;
+}
+function compareMultiple(object, other, orders) {
+  var index = -1, objCriteria = object.criteria, othCriteria = other.criteria, length = objCriteria.length, ordersLength = orders.length;
+  while (++index < length) {
+    var result = compareAscending(objCriteria[index], othCriteria[index]);
+    if (result) {
+      if (index >= ordersLength) {
+        return result;
+      }
+      var order = orders[index];
+      return result * (order == "desc" ? -1 : 1);
+    }
+  }
+  return object.index - other.index;
+}
+function baseOrderBy(collection, iteratees, orders) {
+  if (iteratees.length) {
+    iteratees = arrayMap(iteratees, function(iteratee) {
+      if (isArray(iteratee)) {
+        return function(value) {
+          return baseGet(value, iteratee.length === 1 ? iteratee[0] : iteratee);
+        };
+      }
+      return iteratee;
+    });
+  } else {
+    iteratees = [identity];
+  }
+  var index = -1;
+  iteratees = arrayMap(iteratees, baseUnary(baseIteratee));
+  var result = baseMap(collection, function(value, key, collection2) {
+    var criteria = arrayMap(iteratees, function(iteratee) {
+      return iteratee(value);
+    });
+    return { "criteria": criteria, "index": ++index, "value": value };
+  });
+  return baseSortBy(result, function(object, other) {
+    return compareMultiple(object, other, orders);
+  });
+}
+var sortBy = baseRest(function(collection, iteratees) {
+  if (collection == null) {
+    return [];
+  }
+  var length = iteratees.length;
+  if (length > 1 && isIterateeCall(collection, iteratees[0], iteratees[1])) {
+    iteratees = [];
+  } else if (length > 2 && isIterateeCall(iteratees[0], iteratees[1], iteratees[2])) {
+    iteratees = [iteratees[0]];
+  }
+  return baseOrderBy(collection, baseFlatten(iteratees), []);
+});
+export {
+  baseOrderBy as a,
+  baseMap as b,
+  maxBy as m,
+  sortBy as s
+};

package/sumBy-MYkDPHZL.js

@@ -0,0 +1,8 @@
+import { b as baseIteratee } from "./_baseIteratee-p6Nj07-n.js";
+import { b as baseSum } from "./_baseSum-D0WC1dN0.js";
+function sumBy(array, iteratee) {
+  return array && array.length ? baseSum(array, baseIteratee(iteratee)) : 0;
+}
+export {
+  sumBy as s
+};

package/tabs-xGuUGsJd.js

@@ -0,0 +1,254 @@
+const convert = (
+  // Note: overloads in JSDoc can’t yet use different `@template`s.
+  /**
+   * @type {(
+   *   (<Condition extends string>(test: Condition) => (node: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & {type: Condition}) &
+   *   (<Condition extends Props>(test: Condition) => (node: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & Condition) &
+   *   (<Condition extends TestFunction>(test: Condition) => (node: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & Predicate<Condition, Node>) &
+   *   ((test?: null | undefined) => (node?: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node) &
+   *   ((test?: Test) => Check)
+   * )}
+   */
+  /**
+   * @param {Test} [test]
+   * @returns {Check}
+   */
+  function(test) {
+    if (test === null || test === void 0) {
+      return ok;
+    }
+    if (typeof test === "function") {
+      return castFactory(test);
+    }
+    if (typeof test === "object") {
+      return Array.isArray(test) ? anyFactory(test) : propsFactory(test);
+    }
+    if (typeof test === "string") {
+      return typeFactory(test);
+    }
+    throw new Error("Expected function, string, or object as test");
+  }
+);
+function anyFactory(tests) {
+  const checks = [];
+  let index = -1;
+  while (++index < tests.length) {
+    checks[index] = convert(tests[index]);
+  }
+  return castFactory(any);
+  function any(...parameters) {
+    let index2 = -1;
+    while (++index2 < checks.length) {
+      if (checks[index2].apply(this, parameters)) return true;
+    }
+    return false;
+  }
+}
+function propsFactory(check) {
+  const checkAsRecord = (
+    /** @type {Record<string, unknown>} */
+    check
+  );
+  return castFactory(all);
+  function all(node) {
+    const nodeAsRecord = (
+      /** @type {Record<string, unknown>} */
+      /** @type {unknown} */
+      node
+    );
+    let key;
+    for (key in check) {
+      if (nodeAsRecord[key] !== checkAsRecord[key]) return false;
+    }
+    return true;
+  }
+}
+function typeFactory(check) {
+  return castFactory(type);
+  function type(node) {
+    return node && node.type === check;
+  }
+}
+function castFactory(testFunction) {
+  return check;
+  function check(value, index, parent) {
+    return Boolean(
+      looksLikeANode(value) && testFunction.call(
+        this,
+        value,
+        typeof index === "number" ? index : void 0,
+        parent || void 0
+      )
+    );
+  }
+}
+function ok() {
+  return true;
+}
+function looksLikeANode(value) {
+  return value !== null && typeof value === "object" && "type" in value;
+}
+function color(d) {
+  return d;
+}
+const empty = [];
+const CONTINUE = true;
+const EXIT = false;
+const SKIP = "skip";
+function visitParents(tree, test, visitor, reverse) {
+  let check;
+  if (typeof test === "function" && typeof visitor !== "function") {
+    reverse = visitor;
+    visitor = test;
+  } else {
+    check = test;
+  }
+  const is = convert(check);
+  const step = reverse ? -1 : 1;
+  factory(tree, void 0, [])();
+  function factory(node, index, parents) {
+    const value = (
+      /** @type {Record<string, unknown>} */
+      node && typeof node === "object" ? node : {}
+    );
+    if (typeof value.type === "string") {
+      const name = (
+        // `hast`
+        typeof value.tagName === "string" ? value.tagName : (
+          // `xast`
+          typeof value.name === "string" ? value.name : void 0
+        )
+      );
+      Object.defineProperty(visit2, "name", {
+        value: "node (" + color(node.type + (name ? "<" + name + ">" : "")) + ")"
+      });
+    }
+    return visit2;
+    function visit2() {
+      let result = empty;
+      let subresult;
+      let offset;
+      let grandparents;
+      if (!test || is(node, index, parents[parents.length - 1] || void 0)) {
+        result = toResult(visitor(node, parents));
+        if (result[0] === EXIT) {
+          return result;
+        }
+      }
+      if ("children" in node && node.children) {
+        const nodeAsParent = (
+          /** @type {UnistParent} */
+          node
+        );
+        if (nodeAsParent.children && result[0] !== SKIP) {
+          offset = (reverse ? nodeAsParent.children.length : -1) + step;
+          grandparents = parents.concat(nodeAsParent);
+          while (offset > -1 && offset < nodeAsParent.children.length) {
+            const child = nodeAsParent.children[offset];
+            subresult = factory(child, offset, grandparents)();
+            if (subresult[0] === EXIT) {
+              return subresult;
+            }
+            offset = typeof subresult[1] === "number" ? subresult[1] : offset + step;
+          }
+        }
+      }
+      return result;
+    }
+  }
+}
+function toResult(value) {
+  if (Array.isArray(value)) {
+    return value;
+  }
+  if (typeof value === "number") {
+    return [CONTINUE, value];
+  }
+  return value === null || value === void 0 ? empty : [value];
+}
+function visit(tree, testOrVisitor, visitorOrReverse, maybeReverse) {
+  let reverse;
+  let test;
+  let visitor;
+  if (typeof testOrVisitor === "function" && typeof visitorOrReverse !== "function") {
+    test = void 0;
+    visitor = testOrVisitor;
+    reverse = visitorOrReverse;
+  } else {
+    test = testOrVisitor;
+    visitor = visitorOrReverse;
+    reverse = maybeReverse;
+  }
+  visitParents(tree, test, overload, reverse);
+  function overload(node, parents) {
+    const parent = parents[parents.length - 1];
+    const index = parent ? parent.children.indexOf(node) : void 0;
+    return visitor(node, index, parent);
+  }
+}
+function findTabs(index, parent) {
+  const { children } = parent;
+  const tabs = [];
+  while (index++ < children.length) {
+    const child = children[index];
+    if (child && child.type === "code") {
+      const metaString = `${child.lang ?? ""} ${child.meta ?? ""}`.trim();
+      if (!metaString) break;
+      const [tabtitle] = metaString.match(new RegExp(`(?<=tab=("|'))(.*?)(?=("|'))`)) ?? [""];
+      if (!tabtitle) {
+        console.warn("Failed to parse tab title.");
+        break;
+      }
+      tabs.push({ title: tabtitle, lang: child.lang, value: child.value });
+    } else {
+      break;
+    }
+  }
+  return tabs;
+}
+const codeTabs = () => {
+  return (tree, file) => {
+    visit(tree, "code", (node, index, parent) => {
+      const metaString = `${node.lang ?? ""} ${node.meta ?? ""}`.trim();
+      if (!metaString) {
+        return;
+      }
+      const [tab] = metaString.match(new RegExp(`(?<=tab=("|'))(.*?)(?=("|'))`)) ?? [""];
+      if (!tab && metaString.includes("tab=")) {
+        file.message("Invalid tab title", node, "remark-code-title");
+        return;
+      }
+      if (!tab) {
+        return;
+      }
+      const tabs = [{ title: tab, lang: node.lang, value: node.value }, ...findTabs(index, parent)];
+      if (tabs.length > 1) {
+        const tabsNode = {
+          type: "code",
+          lang: "tabs",
+          value: JSON.stringify(tabs)
+        };
+        parent.children.splice(index, tabs.length, tabsNode);
+        return index + tabs.length - 1;
+      } else {
+        const titleNode = {
+          type: "paragraph",
+          data: {
+            hName: "div",
+            hProperties: {
+              "data-remark-code-title": true,
+              "data-language": node.lang
+            }
+          },
+          children: [{ type: "text", value: tab }]
+        };
+        parent.children.splice(index, 0, titleNode);
+        return index + 2;
+      }
+    });
+  };
+};
+export {
+  codeTabs as c,
+  visit as v
+};

package/text/Frequency.d.ts

@@ -0,0 +1,9 @@
+import { TypographyProps } from '@mui/material';
+import { Annotation } from "../types/lookup";
+import { FC } from 'react';
+
+declare const FrequencyText: FC<{
+    annotations: Annotation[];
+    value: string;
+} & TypographyProps>;
+export default FrequencyText;

package/text/Frequency.js

@@ -0,0 +1,49 @@
+import { jsx } from "react/jsx-runtime";
+import { Typography } from "@mui/material";
+import { useMemo } from "react";
+import { s as sumBy } from "../sumBy-MYkDPHZL.js";
+import { i as isNull, a as isUndefined } from "../isUndefined-CE8h73dH.js";
+const FrequencyText = ({
+  annotations,
+  value,
+  ...otherProps
+}) => {
+  const frequencyAnnotations = useMemo(
+    () => annotations.filter((annotation) => annotation.type === "frequency"),
+    [annotations]
+  );
+  const frequency = useMemo(
+    () => frequencyAnnotations.length > 0 ? sumBy(frequencyAnnotations, (annotation) => annotation.value) : null,
+    [frequencyAnnotations]
+  );
+  const color = useMemo(() => {
+    if (isNull(frequency) || isUndefined(frequency)) {
+      return null;
+    }
+    if (frequency < 1) {
+      return "error";
+    }
+    if (frequency < 1e3) {
+      return "secondary";
+    }
+    if (frequency < 1e6) {
+      return "disabled";
+    }
+    return null;
+  }, [frequency]);
+  if (isNull(frequency) || isUndefined(frequency)) {
+    return /* @__PURE__ */ jsx(Typography, { ...otherProps, color, children: value });
+  }
+  return /* @__PURE__ */ jsx(
+    Typography,
+    {
+      ...otherProps,
+      color: color ?? otherProps.color,
+      sx: { fontWeight: !isNull(frequency) && !isUndefined(frequency) && frequency < 10 ? "bold" : "inherit" },
+      children: value
+    }
+  );
+};
+export {
+  FrequencyText as default
+};

package/toFinite-Bc55msYj.js

@@ -0,0 +1,16 @@
+import { t as toNumber } from "./toNumber-DPxy1FBy.js";
+var INFINITY = 1 / 0, MAX_INTEGER = 17976931348623157e292;
+function toFinite(value) {
+  if (!value) {
+    return value === 0 ? value : 0;
+  }
+  value = toNumber(value);
+  if (value === INFINITY || value === -INFINITY) {
+    var sign = value < 0 ? -1 : 1;
+    return sign * MAX_INTEGER;
+  }
+  return value === value ? value : 0;
+}
+export {
+  toFinite as t
+};

package/toNumber-DPxy1FBy.js

@@ -0,0 +1,39 @@
+import { i as isObject } from "./isObject-FTY-5JQX.js";
+import { i as isSymbol } from "./isSymbol-Xd2FsJyp.js";
+var reWhitespace = /\s/;
+function trimmedEndIndex(string) {
+  var index = string.length;
+  while (index-- && reWhitespace.test(string.charAt(index))) {
+  }
+  return index;
+}
+var reTrimStart = /^\s+/;
+function baseTrim(string) {
+  return string ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, "") : string;
+}
+var NAN = 0 / 0;
+var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
+var reIsBinary = /^0b[01]+$/i;
+var reIsOctal = /^0o[0-7]+$/i;
+var freeParseInt = parseInt;
+function toNumber(value) {
+  if (typeof value == "number") {
+    return value;
+  }
+  if (isSymbol(value)) {
+    return NAN;
+  }
+  if (isObject(value)) {
+    var other = typeof value.valueOf == "function" ? value.valueOf() : value;
+    value = isObject(other) ? other + "" : other;
+  }
+  if (typeof value != "string") {
+    return value === 0 ? value : +value;
+  }
+  value = baseTrim(value);
+  var isBinary = reIsBinary.test(value);
+  return isBinary || reIsOctal.test(value) ? freeParseInt(value.slice(2), isBinary ? 2 : 8) : reIsBadHex.test(value) ? NAN : +value;
+}
+export {
+  toNumber as t
+};

package/types/EnrichmentProps.d.ts

@@ -0,0 +1,73 @@
+import { PopoverProps } from '@mui/material';
+
+
+interface EnrichmentProps {
+  /**
+   * The type of the selector to enrich.
+   */
+  type?: string;
+
+  /**
+   * The selector to enrich.
+   */
+  value: string;
+
+  /**
+   * The classification of the selector.
+   */
+  classification?: string;
+
+  /**
+   * Should the component show the extra context icon?
+   */
+  contextIcon?: boolean;
+
+  /**
+   * Should the component show counters?
+   */
+  counters?: boolean;
+
+  /**
+   * Disable the onclick functionality, and don't automatically show the related popup
+   */
+  hideDetails?: boolean;
+
+  /**
+   * Show the preview for extra icons on mouseover?
+   */
+  showPreview?: boolean;
+
+  /**
+   * Should the component hide the loading icon?
+   */
+  hideLoading?: boolean;
+
+  /**
+   * Force the element to show the details popup.
+   */
+  forceDetails?: boolean;
+
+  /**
+   * Callback for when the popup wants to close
+   */
+  setForceDetails?: (value: boolean) => void;
+
+  /**
+   * Should the component show a details icon to open the popup instead of simply clicking the selector?
+   */
+  useDetailsIcon?: boolean;
+
+  /**
+   * Skip enriching the value, thereby only showing cached results?
+   */
+  skipEnrichment?: boolean;
+
+  /**
+   * Props for various subcomponents of the enrichment component.
+   */
+  slotProps?: {
+    popover?: Omit<PopoverProps, 'open'>;
+  };
+}
+
+export default EnrichmentProps;

package/types/RunningActionData.d.ts

@@ -0,0 +1,15 @@
+import { ActionDefinition, ActionResult } from "../api/actions";
+import { Selector } from 'lib/types/lookup';
+import { default as WithActionData } from './WithActionData';
+
+
+interface RunningActionData {
+  id: string;
+  action: ActionDefinition;
+  selectors: Selector[];
+  params: { [index: string]: any };
+  onComplete?: (result: WithActionData<ActionResult>) => void;
+  timeout?: number;
+}
+
+export default RunningActionData;

package/types/WithActionData.d.ts

@@ -0,0 +1,9 @@
+import { ActionDefinition } from './action';
+
+
+export type WithActionData<T> = T & {
+  actionId: string;
+  action: ActionDefinition;
+};
+
+export default WithActionData;

package/types/action.d.ts

@@ -0,0 +1,25 @@
+import { JSONSchema7 } from 'json-schema';
+
+
+export interface ActionDefinition {
+  accept_multiple?: boolean;
+  action_icon?: string;
+  classification: string;
+  extra_schema?: JSON;
+  format?: string;
+  id: string;
+  name: string;
+  params: JSONSchema7;
+  summary?: string;
+  supported_types?: string[];
+}
+
+export interface ActionResult<T = any> {
+  outcome: 'success' | 'failure';
+  summary?: string;
+  output?: T;
+  format?: string;
+  link?: string;
+}
+
+export type ActionDefinitionsResponse = { [type: string]: ActionDefinition };

package/types/config.d.ts

@@ -0,0 +1,16 @@
+export interface ApiType {
+  configuration: {
+    auth: {
+      oauth_providers: string[];
+    };
+    system: {
+      version: string;
+      branch: string;
+      commit: string;
+    };
+    ui: {
+      apps: any[];
+    };
+  };
+  c12nDef: any;
+}

package/types/fetcher.d.ts

@@ -0,0 +1,60 @@
+import { NestedDataset } from './graph';
+
+
+export interface FetcherDefinition {
+  id: string;
+  classification: string;
+  description: string;
+  format: string;
+  supported_types: string[];
+}
+
+interface BaseFetcherResult {
+  outcome: 'success' | 'failure';
+  error: string;
+  link: string;
+  format: string;
+}
+
+export interface FetcherImageResult extends BaseFetcherResult {
+  data: {
+    image: string;
+    alt: string;
+  };
+  format: 'image';
+}
+
+export interface FetcherJsonResult extends BaseFetcherResult {
+  data: any;
+  format: 'json';
+}
+
+export interface FetcherMarkdownResult extends BaseFetcherResult {
+  data: string;
+  format: 'markdown';
+}
+
+export interface FetcherGraphResult extends BaseFetcherResult {
+  data: NestedDataset;
+  format: 'graph';
+}
+
+export interface FetcherStatusResult extends BaseFetcherResult {
+  data: {
+    empty: boolean;
+    labels: { language: string; label: string }[];
+    link?: string;
+    icon?: string;
+    color?: string;
+  };
+  format: 'status';
+}
+
+export type FetcherResult =
+  | FetcherImageResult
+  | FetcherJsonResult
+  | FetcherGraphResult
+  | FetcherMarkdownResult
+  | FetcherStatusResult;
+
+export type FetcherDefinitionsResponse = { [type: string]: FetcherDefinition };