@cccsaurora/howler-ui 2.14.0-dev.259 → 2.14.0-dev.263

package/plugins/store.d.ts

@@ -0,0 +1,95 @@
+import { Hit } from '@cccsaurora/howler-ui/models/entities/generated/Hit';
+import { Event } from 'react-pluggable';
+import { default as HowlerPlugin } from './HowlerPlugin';
+import { AppLeftNavElement } from '../commons/components/app/AppConfigs';
+export declare class HitEvent extends Event {
+    hit: Hit;
+    constructor(type: string, hit: Hit);
+}
+export declare enum MainMenuInsertOperation {
+    Insert = "INSERT",
+    InsertAfter = "AFTER",
+    InsertBefore = "BEFORE"
+}
+declare class HowlerPluginStore {
+    private _pluginStore;
+    plugins: string[];
+    private _leadFormats;
+    private _pivotFormats;
+    private _operations;
+    private _userMenuItems;
+    private _adminMenuItems;
+    private _mainMenuOperations;
+    private _routes;
+    private _sitemaps;
+    install(plugin: HowlerPlugin): void;
+    addLead(format: string): boolean;
+    addPivot(format: string): boolean;
+    addUserMenuItem(menuItem: {
+        i18nKey: string;
+        route: string;
+        icon: JSX.Element;
+    }): void;
+    addAdminMenuItem(menuItem: {
+        i18nKey: string;
+        route: string;
+        icon: JSX.Element;
+    }): void;
+    addMainMenuItem(menuOperation: {
+        operation: string;
+        targetId: string;
+        item: AppLeftNavElement;
+    }): void;
+    addRoute(route: {
+        path: string;
+        element: JSX.Element;
+        children?: [];
+    }): void;
+    addSitemap(sitemap: {
+        path: string;
+        title: string;
+        icon?: JSX.Element;
+        isRoot?: boolean;
+        isLeaf?: boolean;
+        excluded?: boolean;
+        breadcrumbs?: string[];
+        textWidth?: number;
+    }): void;
+    addOperation(format: string): boolean;
+    get leadFormats(): string[];
+    get pivotFormats(): string[];
+    get operations(): string[];
+    get userMenuItems(): {
+        i18nKey: string;
+        route: string;
+        icon: JSX.Element;
+    }[];
+    get adminMenuItems(): {
+        i18nKey: string;
+        route: string;
+        icon: JSX.Element;
+    }[];
+    get mainMenuOperations(): {
+        operation: string;
+        targetId: string;
+        item: AppLeftNavElement;
+    }[];
+    get routes(): {
+        path: string;
+        element: JSX.Element;
+        children?: [];
+    }[];
+    get sitemaps(): {
+        path: string;
+        title: string;
+        icon?: JSX.Element;
+        isRoot?: boolean;
+        isLeaf?: boolean;
+        excluded?: boolean;
+        breadcrumbs?: string[];
+        textWidth?: number;
+    }[];
+    get pluginStore(): import('react-pluggable').PluginStore;
+}
+declare const howlerPluginStore: HowlerPluginStore;
+export default howlerPluginStore;

package/plugins/store.js

@@ -0,0 +1,105 @@
+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 { createPluginStore, Event } from "/home/runner/work/howler/howler/ui/node_modules/.pnpm/react-pluggable@0.4.3_react@18.3.1/node_modules/react-pluggable/dist/react-pluggable.esm.js";
+class HitEvent extends Event {
+  constructor(type, hit) {
+    super(type);
+    __publicField(this, "hit");
+    this.hit = hit;
+  }
+}
+var MainMenuInsertOperation = /* @__PURE__ */ ((MainMenuInsertOperation2) => {
+  MainMenuInsertOperation2["Insert"] = "INSERT";
+  MainMenuInsertOperation2["InsertAfter"] = "AFTER";
+  MainMenuInsertOperation2["InsertBefore"] = "BEFORE";
+  return MainMenuInsertOperation2;
+})(MainMenuInsertOperation || {});
+class HowlerPluginStore {
+  constructor() {
+    __publicField(this, "_pluginStore", createPluginStore());
+    __publicField(this, "plugins", []);
+    __publicField(this, "_leadFormats", []);
+    __publicField(this, "_pivotFormats", []);
+    __publicField(this, "_operations", []);
+    __publicField(this, "_userMenuItems", []);
+    __publicField(this, "_adminMenuItems", []);
+    __publicField(this, "_mainMenuOperations", []);
+    __publicField(this, "_routes", []);
+    __publicField(this, "_sitemaps", []);
+  }
+  install(plugin) {
+    console.log(`Installing plugin ${plugin.getPluginName()} by ${plugin.author}`);
+    this.plugins.push(plugin.name);
+    this.pluginStore.install(plugin);
+  }
+  addLead(format) {
+    if (this._leadFormats.includes(format)) {
+      return false;
+    }
+    this._leadFormats.push(format);
+    return true;
+  }
+  addPivot(format) {
+    if (this._pivotFormats.includes(format)) {
+      return false;
+    }
+    this._pivotFormats.push(format);
+    return true;
+  }
+  addUserMenuItem(menuItem) {
+    this._userMenuItems.push(menuItem);
+  }
+  addAdminMenuItem(menuItem) {
+    this._adminMenuItems.push(menuItem);
+  }
+  addMainMenuItem(menuOperation) {
+    this._mainMenuOperations.push(menuOperation);
+  }
+  addRoute(route) {
+    this._routes.push(route);
+  }
+  addSitemap(sitemap) {
+    this._sitemaps.push(sitemap);
+  }
+  addOperation(format) {
+    if (this._operations.includes(format)) {
+      return false;
+    }
+    this._operations.push(format);
+    return true;
+  }
+  get leadFormats() {
+    return this._leadFormats;
+  }
+  get pivotFormats() {
+    return this._pivotFormats;
+  }
+  get operations() {
+    return this._operations;
+  }
+  get userMenuItems() {
+    return this._userMenuItems;
+  }
+  get adminMenuItems() {
+    return this._adminMenuItems;
+  }
+  get mainMenuOperations() {
+    return this._mainMenuOperations;
+  }
+  get routes() {
+    return this._routes;
+  }
+  get sitemaps() {
+    return this._sitemaps;
+  }
+  get pluginStore() {
+    return this._pluginStore;
+  }
+}
+const howlerPluginStore = new HowlerPluginStore();
+export {
+  HitEvent,
+  MainMenuInsertOperation,
+  howlerPluginStore as default
+};

package/rest/AxiosClient.d.ts

@@ -0,0 +1,10 @@
+import { HowlerResponse } from '@cccsaurora/howler-ui/api';
+import { default as RestClient } from '@cccsaurora/howler-ui/rest';
+export default class AxiosClient implements RestClient {
+    private cache;
+    private client;
+    constructor();
+    fetch<R>(url: string, method?: 'get' | 'post' | 'put' | 'delete' | 'patch', body?: any, params?: URLSearchParams, headers?: HeadersInit): Promise<[HowlerResponse<R>, number, {
+        [index: string]: any;
+    }]>;
+}

package/rest/AxiosClient.js

@@ -0,0 +1,68 @@
+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 axios, { AxiosError } from "/home/runner/work/howler/howler/ui/node_modules/.pnpm/axios@1.12.0/node_modules/axios/index.js";
+import axiosRetry, { exponentialDelay, isNetworkError } from "/home/runner/work/howler/howler/ui/node_modules/.pnpm/axios-retry@3.9.1/node_modules/axios-retry/lib/esm/index.js";
+import { getAxiosCache, setAxiosCache } from "../utils/sessionStorage.js";
+class AxiosCache {
+  constructor(_axios) {
+    _axios.interceptors.response.use(async (res) => {
+      const cache = getAxiosCache();
+      if (res.status >= 200 && res.status < 300 && res.headers.etag) {
+        setAxiosCache(res.headers.etag, res.data);
+      }
+      if (res.status === 304) {
+        const etag = res.config.headers["If-Match"];
+        if (etag) {
+          res.data = cache[etag];
+        }
+      }
+      return res;
+    });
+  }
+}
+class AxiosClient {
+  constructor() {
+    // @ts-ignore
+    __publicField(this, "cache");
+    __publicField(this, "client");
+    this.client = axios.create({
+      validateStatus: (status) => status >= 200 && status < 300 || status === 304
+    });
+    this.cache = new AxiosCache(this.client);
+    axiosRetry(this.client, {
+      retries: 3,
+      retryCondition: (err) => {
+        var _a, _b;
+        return (
+          // Don't retry 502s, as we assume the server handles retries in those cases
+          isNetworkError(err) || ((_a = err == null ? void 0 : err.response) == null ? void 0 : _a.status) >= 500 && ((_b = err == null ? void 0 : err.response) == null ? void 0 : _b.status) !== 502
+        );
+      },
+      retryDelay: exponentialDelay
+    });
+  }
+  async fetch(url, method = "get", body, params, headers) {
+    var _a;
+    const config = {
+      url,
+      params,
+      method,
+      withCredentials: true,
+      data: JSON.stringify(body),
+      headers
+    };
+    try {
+      const response = await this.client(config);
+      return [response.data, response.status, response.headers];
+    } catch (e) {
+      if (e instanceof AxiosError && ((_a = e.response) == null ? void 0 : _a.data)) {
+        return [e.response.data, e.response.status, e.response.headers];
+      }
+      throw e;
+    }
+  }
+}
+export {
+  AxiosClient as default
+};

package/rest/FetchClient.d.ts

@@ -0,0 +1,7 @@
+import { HowlerResponse } from '@cccsaurora/howler-ui/api';
+import { default as RestClient } from '@cccsaurora/howler-ui/rest';
+export default class FetchClient implements RestClient {
+    fetch<R>(url: string, method?: 'get' | 'post' | 'put' | 'delete', body?: any, params?: URLSearchParams, headers?: HeadersInit): Promise<[HowlerResponse<R>, number, {
+        [index: string]: any;
+    }]>;
+}

package/rest/FetchClient.js

@@ -0,0 +1,19 @@
+class FetchClient {
+  async fetch(url, method = "get", body, params, headers) {
+    const _url = `${url}${params ? `?${params.toString()}` : ""}`;
+    const response = await fetch(_url, {
+      method,
+      credentials: "same-origin",
+      headers,
+      body: body ? JSON.stringify(body) : null
+    });
+    if (response.status === 204) {
+      return null;
+    }
+    const json = await response.json();
+    return [json, response.status, response.headers];
+  }
+}
+export {
+  FetchClient as default
+};

package/rest/index.d.ts

@@ -0,0 +1,6 @@
+import { HowlerResponse } from '@cccsaurora/howler-ui/api';
+export default interface RestClient {
+    fetch<R>(url: string, method: 'get' | 'post' | 'put' | 'delete', body?: any, params?: URLSearchParams, headers?: HeadersInit): Promise<[HowlerResponse<R>, number, {
+        [index: string]: any;
+    }]>;
+}

package/rest/index.js

@@ -0,0 +1 @@
+

package/tests/MockLocalStorage.d.ts

@@ -0,0 +1,5 @@
+export default class MockLocalStorage {
+    constructor();
+    get length(): number;
+    get __STORE__(): this;
+}

package/tests/server-handlers.d.ts

@@ -0,0 +1,5 @@
+export declare const MOCK_RESPONSES: {
+    [path: string]: any;
+};
+declare const handlers: import('msw').HttpHandler[];
+export { handlers };

package/tests/server.d.ts

@@ -0,0 +1,3 @@
+import { http } from 'msw';
+declare const server: import('msw/node').SetupServerApi;
+export { http, server };

package/utils/Throttler.d.ts

@@ -0,0 +1,9 @@
+export default class Throttler {
+    private throttleId;
+    private delayId;
+    private msec;
+    constructor(msec: number);
+    throttle(fn: () => void): void;
+    debounce(fn: () => void): void;
+    delayAsync(fn: (...args: any[]) => Promise<any>, ...args: any[]): Promise<any>;
+}

package/utils/Throttler.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);
+class Throttler {
+  constructor(msec) {
+    __publicField(this, "throttleId", null);
+    __publicField(this, "delayId", null);
+    __publicField(this, "msec", null);
+    this.msec = msec;
+    this.debounce = this.debounce.bind(this);
+  }
+  throttle(fn) {
+    if (!this.throttleId) {
+      fn();
+      this.throttleId = setTimeout(() => {
+        this.throttleId = null;
+      }, this.msec);
+    }
+  }
+  debounce(fn) {
+    if (this.delayId) {
+      clearTimeout(this.delayId);
+    }
+    this.delayId = setTimeout(fn, this.msec);
+  }
+  delayAsync(fn, ...args) {
+    if (this.delayId) {
+      clearTimeout(this.delayId);
+    }
+    return new Promise((resolve, reject) => {
+      this.delayId = setTimeout(async () => {
+        try {
+          resolve(await (fn == null ? void 0 : fn(...args)));
+        } catch (error) {
+          reject(error);
+        }
+      }, this.msec);
+    });
+  }
+}
+export {
+  Throttler as default
+};

package/utils/actionUtils.d.ts

@@ -0,0 +1,31 @@
+import { ActionOperation, ActionOperationStep } from '@cccsaurora/howler-ui/models/ActionTypes';
+import { Operation } from '@cccsaurora/howler-ui/models/entities/generated/Operation';
+/**
+ * A simple validation function to ensure we have all the necessary arguments filled out.
+ * @param step The step to validate
+ * @param values The context to validate on
+ * @returns whether all the necessary arguments have been filled in the given step
+ */
+export declare const checkArgsAreFilled: (step: ActionOperationStep, values: string) => boolean;
+/**
+ * Take the raw options object as specified by the server and get a list of usable options, filtered using the current values suppled for the action entry.
+ * @param options The raw list of options from the server
+ * @param arg The argument for which we are parsing options
+ * @param context The values provided so far by the user
+ * @returns a list of options matching the current context
+ */
+export declare const getOptionsByContext: (options: ActionOperationStep["options"], arg: string, context: string) => string[];
+/**
+ * Get a list of arguments to display based on the current context, using the current values supplied for the action entry.
+ * @param args a complete list of all arguments in the action
+ * @param values the current list of values provided by the user
+ * @returns A list of arguments to display
+ */
+export declare const getArgsByContext: (args: ActionOperationStep["args"], values: string) => string[];
+/**
+ * Check to see if a given action has all the data necessary to execute successfully
+ * @param data The user-provided data
+ * @param action The action to validate
+ * @returns whether the action is ready to execute
+ */
+export declare const operationReady: (data: Operation["data_json"], action: ActionOperation) => boolean;

package/utils/actionUtils.js

@@ -0,0 +1,41 @@
+const checkArgsAreFilled = (step, values) => {
+  if (!values) {
+    return false;
+  }
+  const parsedValues = JSON.parse(values);
+  return Object.keys(step.args).every((arg) => !!parsedValues[arg]);
+};
+const buildContext = (values = "{}") => Object.entries(JSON.parse(values)).map((tuple) => tuple.join(":"));
+const getOptionsByContext = (options, arg, context) => {
+  if (!options[arg]) {
+    return [];
+  }
+  if (Array.isArray(options[arg])) {
+    return options[arg];
+  }
+  const matchingKey = buildContext(context).find((key) => !!options[arg][key]);
+  return options[arg][matchingKey] ?? [];
+};
+const getArgsByContext = (args, values) => Object.entries(args).filter(([_, conditions]) => {
+  if (conditions.length < 1) {
+    return true;
+  }
+  const context = buildContext(values);
+  return conditions.some((c) => context.includes(c));
+}).map(([arg, _]) => arg);
+const operationReady = (data, action) => {
+  if (!data) {
+    return false;
+  }
+  const parsedData = JSON.parse(data);
+  return action && getArgsByContext(
+    action.steps.reduce((acc, _step) => ({ ...acc, ..._step.args }), {}),
+    data
+  ).every((v) => !!parsedData[v]);
+};
+export {
+  checkArgsAreFilled,
+  getArgsByContext,
+  getOptionsByContext,
+  operationReady
+};

package/utils/constants.d.ts

@@ -0,0 +1,79 @@
+import { ReactElement } from 'react';
+export declare const HOWLER_API: any;
+export declare const LOCAL: boolean;
+export declare const VERSION: any;
+export declare const MY_LOCAL_STORAGE_PREFIX = "howler.ui";
+export declare const MY_SESSION_STORAGE_PREFIX = "howler.ui.cache";
+export declare const ESCALATION_COLORS: {
+    alert: string;
+    evidence: string;
+    hit: string;
+};
+export declare const STATUS_COLORS: {
+    open: string;
+    'in-progress': string;
+    resolved: string;
+};
+export declare const PROVIDER_COLORS: {
+    HBS: "#303f9f";
+    NBS: "#ff4081";
+    CBS: "#00796b";
+    howler: string;
+    unknown: "#616161";
+};
+export declare enum StorageKey {
+    DISABLE_FEATURE_WARNING = "disable.feature.warning",
+    DEFAULT_VIEW = "default.view",
+    PROVIDER = "provider",
+    REFRESH_TOKEN = "refresh_token",
+    USERNAME = "username",
+    APP_TOKEN = "app_token",
+    TOKEN_EXPIRY = "token_expiry",
+    NEXT_LOCATION = "next.location",
+    NEXT_SEARCH = "next.search",
+    LAYOUT_TYPE = "layout.type",
+    SHOW_DETAILS = "hit.panel.details",
+    TIMEZONE = "timezone",
+    DEV_MODE = "dev_mode",
+    DASHBOARD_LAYOUT = "dashboard_layout",
+    DEFAULT_FIELDS = "default_fields",
+    HIT_LAYOUT = "hit_layout",
+    HIT_SHORTCUTS = "hit_shortcuts",
+    FORCE_DROPDOWN = "force_dropdown",
+    VIEWER_ORIENTATION = "viewer_orientation",
+    ETAG = "etag",
+    AXIOS_CACHE = "axios.cache",
+    LAST_SEEN = "hit_last_seen",
+    MOCK_SEARCH_QUERY_STORE = "mock_search_query_store",
+    MOCK_FAVOURITES_STORE = "mock_favourite_store",
+    COMPACT_JSON = "compact_json_view",
+    FLATTEN_JSON = "flatten_json_view",
+    FORCE_DRAWER = "force_drawer",
+    LAST_VIEW = "last_view",
+    ONLY_RULES = "only_rules",
+    PAGE_COUNT = "page_count",
+    SEARCH_PANE_WIDTH = "search_pane_width",
+    GRID_COLLAPSE_COLUMN = "grid_collapse_column",
+    QUERY_HISTORY = "query_history",
+    LOGIN_NONCE = "login_nonce",
+    DISPLAY_TYPE = "display_type"
+}
+export declare const MOCK_SEARCH_QUERY_STORE = "howler.ui.mock_search_query_store";
+export declare const MOCK_FAVOURITES_STORE = "howler.ui.mock_favourite_store";
+export declare const VALID_ACTION_TRIGGERS: string[];
+export declare const minutes: number[];
+export declare const hours: number[];
+/**
+ * Precomputed crontabs for the intervals. This will introduce some natural load-balancing as jobs run at completely different minutes/hours.
+ */
+export declare const RULE_INTERVALS: {
+    key: string;
+    crontab: string;
+}[];
+export declare const DATE_RANGES: string[];
+interface LabelData {
+    icon?: ReactElement;
+    color?: string;
+}
+export declare const LABEL_TYPES: Record<string, LabelData>;
+export {};

package/utils/constants.js

@@ -0,0 +1,131 @@
+import { jsx } from "/home/runner/work/howler/howler/ui/node_modules/.pnpm/react@18.3.1/node_modules/react/jsx-runtime.js";
+import { Star, NewReleases, Timeline, MoodBad, LocalPolice, PsychologyAlt } from "/home/runner/work/howler/howler/ui/node_modules/.pnpm/@mui+icons-material@5.18.0_@mui+material@5.18.0_@emotion+react@11.14.0_@types+react@18._b9cf98cd2d466d3b4f338d38bc895c0b/node_modules/@mui/icons-material/esm/index.js";
+import { grey, teal, pink, indigo, yellow, red, orange, blue } from "/home/runner/work/howler/howler/ui/node_modules/.pnpm/@mui+material@5.18.0_@emotion+react@11.14.0_@types+react@18.3.23_react@18.3.1__@emotion_19a5ee0476da228d66b5ad5c143bb0c3/node_modules/@mui/material/colors/index.js";
+import dayjs from "/home/runner/work/howler/howler/ui/node_modules/.pnpm/dayjs@1.11.13/node_modules/dayjs/dayjs.min.js";
+const HOWLER_API = "REST";
+const LOCAL = HOWLER_API === "MOCK";
+const VERSION = "2.14.0-dev.263";
+const MY_LOCAL_STORAGE_PREFIX = "howler.ui";
+const MY_SESSION_STORAGE_PREFIX = `${MY_LOCAL_STORAGE_PREFIX}.cache`;
+const ESCALATION_COLORS = {
+  alert: "warning",
+  evidence: "error",
+  hit: "primary"
+};
+const STATUS_COLORS = {
+  open: "primary",
+  "in-progress": "warning",
+  resolved: "success"
+};
+const PROVIDER_COLORS = {
+  HBS: indigo[700],
+  NBS: pink.A200,
+  CBS: teal[700],
+  howler: "#1769bb",
+  unknown: grey[700]
+};
+var StorageKey = /* @__PURE__ */ ((StorageKey2) => {
+  StorageKey2["DISABLE_FEATURE_WARNING"] = "disable.feature.warning";
+  StorageKey2["DEFAULT_VIEW"] = "default.view";
+  StorageKey2["PROVIDER"] = "provider";
+  StorageKey2["REFRESH_TOKEN"] = "refresh_token";
+  StorageKey2["USERNAME"] = "username";
+  StorageKey2["APP_TOKEN"] = "app_token";
+  StorageKey2["TOKEN_EXPIRY"] = "token_expiry";
+  StorageKey2["NEXT_LOCATION"] = "next.location";
+  StorageKey2["NEXT_SEARCH"] = "next.search";
+  StorageKey2["LAYOUT_TYPE"] = "layout.type";
+  StorageKey2["SHOW_DETAILS"] = "hit.panel.details";
+  StorageKey2["TIMEZONE"] = "timezone";
+  StorageKey2["DEV_MODE"] = "dev_mode";
+  StorageKey2["DASHBOARD_LAYOUT"] = "dashboard_layout";
+  StorageKey2["DEFAULT_FIELDS"] = "default_fields";
+  StorageKey2["HIT_LAYOUT"] = "hit_layout";
+  StorageKey2["HIT_SHORTCUTS"] = "hit_shortcuts";
+  StorageKey2["FORCE_DROPDOWN"] = "force_dropdown";
+  StorageKey2["VIEWER_ORIENTATION"] = "viewer_orientation";
+  StorageKey2["ETAG"] = "etag";
+  StorageKey2["AXIOS_CACHE"] = "axios.cache";
+  StorageKey2["LAST_SEEN"] = "hit_last_seen";
+  StorageKey2["MOCK_SEARCH_QUERY_STORE"] = "mock_search_query_store";
+  StorageKey2["MOCK_FAVOURITES_STORE"] = "mock_favourite_store";
+  StorageKey2["COMPACT_JSON"] = "compact_json_view";
+  StorageKey2["FLATTEN_JSON"] = "flatten_json_view";
+  StorageKey2["FORCE_DRAWER"] = "force_drawer";
+  StorageKey2["LAST_VIEW"] = "last_view";
+  StorageKey2["ONLY_RULES"] = "only_rules";
+  StorageKey2["PAGE_COUNT"] = "page_count";
+  StorageKey2["SEARCH_PANE_WIDTH"] = "search_pane_width";
+  StorageKey2["GRID_COLLAPSE_COLUMN"] = "grid_collapse_column";
+  StorageKey2["QUERY_HISTORY"] = "query_history";
+  StorageKey2["LOGIN_NONCE"] = "login_nonce";
+  StorageKey2["DISPLAY_TYPE"] = "display_type";
+  return StorageKey2;
+})(StorageKey || {});
+const MOCK_SEARCH_QUERY_STORE = `${MY_LOCAL_STORAGE_PREFIX}.${"mock_search_query_store"}`;
+const MOCK_FAVOURITES_STORE = `${MY_LOCAL_STORAGE_PREFIX}.${"mock_favourite_store"}`;
+const VALID_ACTION_TRIGGERS = ["create", "promote", "demote"];
+const CURRENT_TIME = dayjs();
+const minutes = [CURRENT_TIME.get("minute"), CURRENT_TIME.add(30, "minute").get("minute")].sort();
+const hours = [
+  CURRENT_TIME.get("hour"),
+  CURRENT_TIME.add(3, "hour").get("hour"),
+  CURRENT_TIME.add(6, "hour").get("hour"),
+  CURRENT_TIME.add(9, "hour").get("hour"),
+  CURRENT_TIME.add(12, "hour").get("hour"),
+  CURRENT_TIME.add(15, "hour").get("hour"),
+  CURRENT_TIME.add(18, "hour").get("hour"),
+  CURRENT_TIME.add(21, "hour").get("hour")
+].sort((a, b) => a - b);
+const RULE_INTERVALS = [
+  { key: "rule.interval.thirty.minutes", crontab: `${minutes.join(",")} * * * *` },
+  { key: "rule.interval.one.hour", crontab: `${CURRENT_TIME.get("minute")} * * * *` },
+  { key: "rule.interval.three.hours", crontab: `${CURRENT_TIME.get("minute")} ${hours.join(",")} * * *` },
+  {
+    key: "rule.interval.six.hours",
+    crontab: `${CURRENT_TIME.get("minute")} ${hours.filter((_, index) => index % 2 === hours.indexOf(CURRENT_TIME.get("hour")) % 2).join(",")} * * *`
+  },
+  { key: "rule.interval.one.day", crontab: `${CURRENT_TIME.get("minute")} ${CURRENT_TIME.get("hour")} * * *` }
+];
+const DATE_RANGES = [
+  "date.range.1.day",
+  "date.range.3.day",
+  "date.range.1.week",
+  "date.range.1.month",
+  "date.range.all",
+  "date.range.custom"
+];
+const LABEL_TYPES = {
+  insight: { icon: /* @__PURE__ */ jsx(PsychologyAlt, { fontSize: "small" }), color: "#FFFFFF" },
+  //brain icon
+  mitigation: { icon: /* @__PURE__ */ jsx(LocalPolice, { fontSize: "small" }), color: blue[600] },
+  //police badge
+  victim: { icon: /* @__PURE__ */ jsx(MoodBad, { fontSize: "small" }), color: pink[400] },
+  //crime outline
+  campaign: { icon: /* @__PURE__ */ jsx(Timeline, { fontSize: "small" }), color: orange[900] },
+  //net graph?
+  threat: { icon: /* @__PURE__ */ jsx(NewReleases, { fontSize: "small" }), color: red[400] },
+  operation: { icon: /* @__PURE__ */ jsx(Star, { fontSize: "small" }), color: yellow[600] },
+  generic: {},
+  assignments: {},
+  tuning: {}
+};
+export {
+  DATE_RANGES,
+  ESCALATION_COLORS,
+  HOWLER_API,
+  LABEL_TYPES,
+  LOCAL,
+  MOCK_FAVOURITES_STORE,
+  MOCK_SEARCH_QUERY_STORE,
+  MY_LOCAL_STORAGE_PREFIX,
+  MY_SESSION_STORAGE_PREFIX,
+  PROVIDER_COLORS,
+  RULE_INTERVALS,
+  STATUS_COLORS,
+  StorageKey,
+  VALID_ACTION_TRIGGERS,
+  VERSION,
+  hours,
+  minutes
+};