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

package/utils/hitFunctions.d.ts

@@ -0,0 +1,2 @@
+import { Hit } from '@cccsaurora/howler-ui/models/entities/generated/Hit';
+export declare const getUserList: (hit: Hit) => Set<string>;

package/utils/hitFunctions.js

@@ -0,0 +1,12 @@
+const getUserList = (hit) => {
+  var _a, _b, _c, _d;
+  const ids = /* @__PURE__ */ new Set();
+  if (hit) {
+    (_b = (_a = hit.howler) == null ? void 0 : _a.log) == null ? void 0 : _b.forEach((l) => ids.add(l.user));
+    (_d = (_c = hit.howler) == null ? void 0 : _c.comment) == null ? void 0 : _d.forEach((c) => ids.add(c.user), ids);
+  }
+  return ids;
+};
+export {
+  getUserList
+};

package/utils/localStorage.d.ts

@@ -0,0 +1,21 @@
+import { LoginResponse } from '@cccsaurora/howler-ui/api/auth/login';
+import { StorageKey } from './constants';
+/**
+ * **IMPORTANT**: This function should only be used OUTSIDE of the React tree.
+ * If you want to edit localStorage items inside a React component, use
+ * src/components/hooks/useMyLocalStorage.tsx.
+ */
+export declare const removeStored: (name: StorageKey) => void;
+/**
+ * **IMPORTANT**: This function should only be used OUTSIDE of the React tree.
+ * If you want to edit localStorage items inside a React component, use
+ * src/components/hooks/useMyLocalStorage.tsx.
+ */
+export declare const setStored: (name: StorageKey, item: any) => void;
+/**
+ * **IMPORTANT**: This function should only be used OUTSIDE of the React tree.
+ * If you want to edit localStorage items inside a React component, use
+ * src/components/hooks/useMyLocalStorage.tsx.
+ */
+export declare const getStored: <T = string>(name?: StorageKey) => T;
+export declare const saveLoginCredential: (loginRes: LoginResponse) => boolean;

package/utils/localStorage.js

@@ -0,0 +1,35 @@
+import { MY_LOCAL_STORAGE_PREFIX, StorageKey } from "./constants.js";
+const buildName = (name) => `${MY_LOCAL_STORAGE_PREFIX}.${name}`;
+const removeStored = (name) => {
+  localStorage.removeItem(buildName(name));
+};
+const setStored = (name, item) => {
+  localStorage.setItem(buildName(name), JSON.stringify(item));
+};
+const getStored = (name) => {
+  try {
+    return JSON.parse(localStorage.getItem(buildName(name)));
+  } catch (e) {
+    return localStorage.getItem(buildName(name));
+  }
+};
+const saveLoginCredential = (loginRes) => {
+  if (loginRes.app_token) {
+    setStored(StorageKey.APP_TOKEN, loginRes.app_token);
+    if (loginRes.refresh_token) {
+      setStored(StorageKey.REFRESH_TOKEN, loginRes.refresh_token);
+      setStored(StorageKey.PROVIDER, loginRes.provider);
+    }
+    return true;
+  }
+  removeStored(StorageKey.REFRESH_TOKEN);
+  removeStored(StorageKey.APP_TOKEN);
+  removeStored(StorageKey.PROVIDER);
+  return false;
+};
+export {
+  getStored,
+  removeStored,
+  saveLoginCredential,
+  setStored
+};

package/utils/menuUtils.d.ts

@@ -0,0 +1,89 @@
+import { AppLeftNavElement, AppLeftNavItem } from '../commons/components/app/AppConfigs';
+declare class AppMenuBuilder {
+    private items;
+    private indexMap;
+    constructor(defaultMenu: AppLeftNavElement[]);
+    /**
+     * Applies a collection of Menu Operation objects created by the plugin system
+     *
+     * @param operations Operations created by the plugin system
+     */
+    applyOperations(operations: {
+        operation: string;
+        targetId: string;
+        item: AppLeftNavElement;
+    }[]): void;
+    /**
+     * Get the completed menu structure
+     */
+    get menu(): AppLeftNavElement[];
+    /**
+     * Insert provided menu item at the menu object identified by targetId.
+     *
+     * If the target menu is a group then item will be placed at end of sub items
+     *
+     * If the target menu is a standard item then group will be created and new item added, warning this removes
+     * the route from the new group parent item, be sure to add it back.
+     *
+     * If the target is 'root' then item will be added to end of root menu
+     *
+     * @param targetId Identifier of menu to insert to
+     * @param item Menu Item to insert
+     */
+    insert(targetId: string, item: AppLeftNavElement): void;
+    /**
+     * Insert provided menu item before the menu object identified by targetId.
+     *
+     * @param targetId Identifier of menu to insert to
+     * @param item Menu Item to insert
+     */
+    insertBefore(targetId: string, item: AppLeftNavElement): void;
+    /**
+     * Insert provided menu item after the menu object identified by targetId.
+     *
+     * @param targetId Identifier of menu to insert to
+     * @param item Menu Item to insert
+     */
+    insertAfter(targetId: string, item: AppLeftNavElement): void;
+    /**
+     * Locates menu location in menu structure by menu id.
+     *
+     * @param id Menu Id to search for
+     * @return {index: number, subIndex: number} A dictionary containing indexes needed to access Menu Item
+     */
+    indexOfMenuId(id: string): {
+        index: number;
+        subIndex?: number;
+    };
+    /**
+     *  Grabs a menu by indexes, helper function to account for an index of -1
+     *  to represent the root menu
+     *
+     * @param index First level index
+     * @param subIndex Second level index
+     * @return {} Menu item
+     */
+    menuFromIndex(index: number, subIndex?: number): AppLeftNavElement[] | AppLeftNavElement | AppLeftNavItem;
+    /**
+     * Determine if provided element is a group element
+     *
+     * @param elem Element to check
+     * @private
+     */
+    private isGroupElement;
+    /**
+     * Determine if provided element is an item element
+     *
+     * @param elem Element to check
+     * @private
+     */
+    private isItemElement;
+    /**
+     * Creates a flat list of menu items and subitems by menu id
+     * for quick lookup.
+     *
+     * @private
+     */
+    private updateMenuMap;
+}
+export default AppMenuBuilder;

package/utils/menuUtils.js

@@ -0,0 +1,247 @@
+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 { MainMenuInsertOperation } from "../plugins/store.js";
+import { isNil } from "/home/runner/work/howler/howler/ui/node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/lodash.js";
+class AppMenuBuilder {
+  constructor(defaultMenu) {
+    __publicField(this, "items");
+    __publicField(this, "indexMap");
+    this.items = defaultMenu;
+    this.updateMenuMap();
+  }
+  /**
+   * Applies a collection of Menu Operation objects created by the plugin system
+   *
+   * @param operations Operations created by the plugin system
+   */
+  applyOperations(operations) {
+    for (const operation of operations) {
+      switch (operation.operation) {
+        case MainMenuInsertOperation.Insert:
+          this.insert(operation.targetId, operation.item);
+          break;
+        case MainMenuInsertOperation.InsertBefore:
+          this.insertBefore(operation.targetId, operation.item);
+          break;
+        case MainMenuInsertOperation.InsertAfter:
+          this.insertAfter(operation.targetId, operation.item);
+          break;
+      }
+      this.updateMenuMap();
+    }
+  }
+  /**
+   * Get the completed menu structure
+   */
+  get menu() {
+    return this.items;
+  }
+  /**
+   * Insert provided menu item at the menu object identified by targetId.
+   *
+   * If the target menu is a group then item will be placed at end of sub items
+   *
+   * If the target menu is a standard item then group will be created and new item added, warning this removes
+   * the route from the new group parent item, be sure to add it back.
+   *
+   * If the target is 'root' then item will be added to end of root menu
+   *
+   * @param targetId Identifier of menu to insert to
+   * @param item Menu Item to insert
+   */
+  insert(targetId, item) {
+    const menuLocation = this.indexOfMenuId(targetId);
+    const target = this.menuFromIndex(menuLocation.index, menuLocation.subIndex);
+    if (!Array.isArray(target) && this.isGroupElement(target)) {
+      if (item.type === "divider") {
+        console.warn(
+          `Skipping DIVIDER Operation: INSERT on Target: ${targetId}, Dividers cannot be inserted to sub-menus`
+        );
+        return;
+      }
+      const group = target.element;
+      const newItem = { ...item.element, nested: true };
+      group.items = [...group.items, newItem];
+      return;
+    }
+    if (Array.isArray(target)) {
+      target.push(item);
+      return;
+    }
+    if (menuLocation.index !== -1 && isNil(menuLocation.subIndex)) {
+      if (item.type === "divider") {
+        console.warn(
+          `Skipping DIVIDER Operation: INSERT on Target: ${targetId}, Dividers cannot be inserted to sub-menus`
+        );
+        return;
+      }
+      if (!this.isItemElement(target)) {
+        return;
+      }
+      const header = target.element;
+      const inserted = { ...item.element, nested: true };
+      const newGroup = {
+        type: "group",
+        element: {
+          id: header.id,
+          open: true,
+          i18nKey: header.i18nKey,
+          title: header.text,
+          userPropValidators: header.userPropValidators,
+          icon: header.icon,
+          items: [inserted]
+        }
+      };
+      this.items[menuLocation.index] = newGroup;
+      return;
+    }
+  }
+  /**
+   * Insert provided menu item before the menu object identified by targetId.
+   *
+   * @param targetId Identifier of menu to insert to
+   * @param item Menu Item to insert
+   */
+  insertBefore(targetId, item) {
+    const menuLocation = this.indexOfMenuId(targetId);
+    if (!isNil(menuLocation.subIndex)) {
+      if (item.type === "divider") {
+        console.warn(
+          `Skipping DIVIDER Operation: INSERT on Target: ${targetId}, Dividers cannot be inserted to sub-menus`
+        );
+        return;
+      }
+      const parentElement = this.menuFromIndex(menuLocation.index);
+      if (!Array.isArray(parentElement) && this.isGroupElement(parentElement)) {
+        const group = parentElement.element;
+        const newItem = { ...item.element, nested: true };
+        group.items = [
+          ...group.items.slice(0, menuLocation.subIndex),
+          newItem,
+          ...group.items.slice(menuLocation.subIndex)
+        ];
+      }
+      return;
+    }
+    if (menuLocation.index < 0) {
+      menuLocation.index = 0;
+    }
+    this.items = [...this.items.slice(0, menuLocation.index), item, ...this.items.slice(menuLocation.index)];
+  }
+  /**
+   * Insert provided menu item after the menu object identified by targetId.
+   *
+   * @param targetId Identifier of menu to insert to
+   * @param item Menu Item to insert
+   */
+  insertAfter(targetId, item) {
+    const menuLocation = this.indexOfMenuId(targetId);
+    if (!isNil(menuLocation.subIndex)) {
+      if (item.type === "divider") {
+        console.warn(
+          `Skipping DIVIDER Operation: INSERT on Target: ${targetId}, Dividers cannot be inserted to sub-menus`
+        );
+        return;
+      }
+      const parentElement = this.menuFromIndex(menuLocation.index);
+      if (!Array.isArray(parentElement) && this.isGroupElement(parentElement)) {
+        const group = parentElement.element;
+        const newItem = { ...item.element, nested: true };
+        group.items = [
+          ...group.items.slice(0, menuLocation.subIndex + 1),
+          newItem,
+          ...group.items.slice(menuLocation.subIndex + 1)
+        ];
+      }
+      return;
+    }
+    if (menuLocation.index < 0) {
+      menuLocation.index = this.items.length;
+    }
+    this.items = [...this.items.slice(0, menuLocation.index + 1), item, ...this.items.slice(menuLocation.index + 1)];
+  }
+  /**
+   * Locates menu location in menu structure by menu id.
+   *
+   * @param id Menu Id to search for
+   * @return {index: number, subIndex: number} A dictionary containing indexes needed to access Menu Item
+   */
+  indexOfMenuId(id) {
+    if (id === "root") {
+      return { index: -1 };
+    } else if (id in this.indexMap) {
+      if ("parent" in this.indexMap[id]) {
+        return { index: this.indexMap[id].parent, subIndex: this.indexMap[id].index };
+      }
+      return { index: this.indexMap[id].index };
+    } else {
+      throw new Error(`Menu element with id of '${id}' not found.`);
+    }
+  }
+  /**
+   *  Grabs a menu by indexes, helper function to account for an index of -1
+   *  to represent the root menu
+   *
+   * @param index First level index
+   * @param subIndex Second level index
+   * @return {} Menu item
+   */
+  menuFromIndex(index, subIndex) {
+    if (index === -1) {
+      return this.items;
+    }
+    if (isNil(subIndex)) {
+      return this.items[index];
+    }
+    const menuItem = this.items[index];
+    if (menuItem.type === "group") {
+      return menuItem.element.items[subIndex];
+    }
+    throw new Error(`Menu item at index ${index} is not a group and does not have sub-items.`);
+  }
+  /**
+   * Determine if provided element is a group element
+   *
+   * @param elem Element to check
+   * @private
+   */
+  isGroupElement(elem) {
+    return !!elem && typeof elem === "object" && elem.type === "group";
+  }
+  /**
+   * Determine if provided element is an item element
+   *
+   * @param elem Element to check
+   * @private
+   */
+  isItemElement(elem) {
+    return !!elem && typeof elem === "object" && elem.type === "item";
+  }
+  /**
+   * Creates a flat list of menu items and subitems by menu id
+   * for quick lookup.
+   *
+   * @private
+   */
+  updateMenuMap() {
+    const indexMap = {};
+    for (let index = 0; index < this.items.length; index++) {
+      const menuItem = this.items[index];
+      if (menuItem.type === "divider") {
+        continue;
+      }
+      indexMap[menuItem.element.id] = { index };
+      if (menuItem.type === "group") {
+        for (let subIndex = 0; subIndex < menuItem.element.items.length; subIndex++) {
+          const subMenuItem = menuItem.element.items[subIndex];
+          indexMap[subMenuItem.id] = { index: subIndex, parent: index };
+        }
+      }
+    }
+    this.indexMap = indexMap;
+  }
+}
+export {
+  AppMenuBuilder as default
+};

package/utils/sessionStorage.d.ts

@@ -0,0 +1,7 @@
+import { StorageKey } from './constants';
+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,50 @@
+import Throttler from "./Throttler.js";
+import { MY_SESSION_STORAGE_PREFIX, StorageKey } from "./constants.js";
+const buildName = (name) => `${MY_SESSION_STORAGE_PREFIX}.${name}`;
+const {
+  _getStored: getStored,
+  _removeStored: removeStored,
+  _setStored: setStored
+} = (() => {
+  const throttler = new Throttler(3e3);
+  let changes = {};
+  const _getStored = (name) => {
+    return {
+      ...JSON.parse(sessionStorage.getItem(buildName(name))),
+      ...changes[buildName(name)]
+    };
+  };
+  const _removeStored = (name) => {
+    delete changes[buildName(name)];
+    sessionStorage.removeItem(buildName(name));
+  };
+  const _setStored = (name, item) => {
+    changes[buildName(name)] = item;
+    throttler.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 = {};
+    });
+  };
+  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 {
+  getAxiosCache,
+  getStored,
+  removeStored,
+  setAxiosCache,
+  setStored
+};

package/utils/socketUtils.d.ts

@@ -0,0 +1,8 @@
+import { RecievedDataType } from '@cccsaurora/howler-ui/components/app/providers/SocketProvider';
+import { HitUpdate } from '@cccsaurora/howler-ui/models/socket/HitUpdate';
+/**
+ * Checks to see if the data recieved from the socket is a hit update
+ * @param data The data recieved from the socket
+ * @returns whether the data is a hit update
+ */
+export declare const isHitUpdate: (data: any) => data is RecievedDataType<HitUpdate>;

package/utils/socketUtils.js

@@ -0,0 +1,6 @@
+const isHitUpdate = (data) => {
+  return data.version && data.hit;
+};
+export {
+  isHitUpdate
+};

package/utils/stringUtils.d.ts

@@ -0,0 +1,8 @@
+export declare const nameToInitials: (string: string) => string[];
+export declare const maxLenStr: (str: string, len: number) => string;
+export declare const safeFieldValue: (data: string | number | boolean) => string;
+export declare const safeFieldValueURI: (data: string | number | boolean) => string;
+export declare const sanitizeLuceneQuery: (query: string) => string;
+export declare const safeStringPropertyCompare: (propertyPath: string) => (a: unknown, b: unknown) => any;
+export declare const sanitizeMultilineLucene: (query: string) => string;
+export declare const validateRegex: (regex: string) => boolean;

package/utils/stringUtils.js

@@ -0,0 +1,52 @@
+import { get } from "/home/runner/work/howler/howler/ui/node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/lodash.js";
+const nameToInitials = (string) => {
+  const parts = string.split(" ").slice(0, 2);
+  if (string.includes(",")) {
+    parts.reverse();
+  }
+  return parts.map((p) => p.charAt(0).toUpperCase());
+};
+const maxLenStr = (str, len) => {
+  if (str.length > len) {
+    return `${str.substr(0, len - 3)}...`;
+  }
+  return str;
+};
+const safeFieldValue = (data) => {
+  const temp = String(data);
+  return `"${temp.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+};
+const safeFieldValueURI = (data) => {
+  return `${encodeURIComponent(safeFieldValue(data))}`;
+};
+const sanitizeLuceneQuery = (query) => {
+  return query.replace(/([\^"~*?:\\/()[\]{}\-!])/g, "\\$1").replace("&&", "\\&&").replace("||", "\\||");
+};
+const safeStringPropertyCompare = (propertyPath) => {
+  return (a, b) => {
+    const aVal = get(a, propertyPath);
+    const bVal = get(b, propertyPath);
+    return aVal && bVal ? aVal.localeCompare(bVal) : aVal ? 1 : 0;
+  };
+};
+const sanitizeMultilineLucene = (query) => {
+  return query.replace(/#.+/g, "").replace(/\n{2,}/, "\n");
+};
+const validateRegex = (regex) => {
+  try {
+    new RegExp(regex);
+    return true;
+  } catch {
+    return false;
+  }
+};
+export {
+  maxLenStr,
+  nameToInitials,
+  safeFieldValue,
+  safeFieldValueURI,
+  safeStringPropertyCompare,
+  sanitizeLuceneQuery,
+  sanitizeMultilineLucene,
+  validateRegex
+};

package/utils/utils.d.ts

@@ -0,0 +1,33 @@
+export declare const bytesToSize: (bytes: number | null) => string;
+export declare const humanReadableNumber: (num: number | null) => string;
+export declare const getProvider: () => string;
+export declare const searchResultsDisplay: (count: number, max?: number) => string;
+export declare const formatDate: (date: number | string | Date) => string;
+export declare const compareTimestamp: (a: string, b: string) => number;
+export declare const twitterShort: (date: string | Date | number) => string;
+export declare const hashCode: (s: string) => number;
+export declare const stringToColor: (string: string) => 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;
+};
+type Timestamp = {
+    timestamp?: string;
+};
+export declare const sortByTimestamp: <T extends Timestamp>(arr: T[]) => T[];
+export declare const getTimeRange: (arr: string[]) => [string, string];
+export declare const removeEmpty: (obj: any, aggressive?: boolean) => any;
+export declare const searchObject: (o: any, query: string, returnFlat?: boolean) => any;
+export declare const convertDateToLucene: (date: string) => string;
+export declare const convertCustomDateRangeToLucene: (startDate: string, endDate: string) => string;
+export declare const convertLuceneToDate: (lucene: string) => string;
+export declare const tryParse: (json: string) => any;
+export declare const flattenDeep: (data: {
+    [index: string]: any;
+}) => {
+    [index: string]: any;
+};
+export {};