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

package/components/app/providers/ParameterProvider.js

@@ -0,0 +1,166 @@
+import { jsx } from "/home/runner/work/howler/howler/ui/node_modules/.pnpm/react@18.3.1/node_modules/react/jsx-runtime.js";
+import { isUndefined, omitBy, isEmpty, pickBy, isNull } from "/home/runner/work/howler/howler/ui/node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/lodash.js";
+import { useRef, useState, useCallback, useEffect, useMemo } from "/home/runner/work/howler/howler/ui/node_modules/.pnpm/react@18.3.1/node_modules/react/index.js";
+import { useLocation, useParams, useSearchParams } from "/home/runner/work/howler/howler/ui/node_modules/.pnpm/react-router-dom@6.30.1_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/react-router-dom/dist/index.js";
+import { createContext, useContextSelector } from "/home/runner/work/howler/howler/ui/node_modules/.pnpm/use-context-selector@2.0.0_react@18.3.1_scheduler@0.23.2/node_modules/use-context-selector/dist/index.js";
+import Throttler from "../../../utils/Throttler.js";
+const ParameterContext = createContext(null);
+const DEFAULT_VALUES = {
+  query: "howler.id:*",
+  sort: "event.created desc",
+  span: "date.range.1.month"
+};
+const WRITE_THROTTLER = new Throttler(100);
+const parseOffset = (_offset) => {
+  if (typeof _offset === "number") {
+    return _offset;
+  }
+  const candidate = parseInt(_offset);
+  return isNaN(candidate) ? 0 : candidate;
+};
+const ParameterProvider = ({ children }) => {
+  const location = useLocation();
+  const routeParams = useParams();
+  const [params, setParams] = useSearchParams();
+  const pendingChanges = useRef({});
+  const [values, _setValues] = useState({
+    selected: params.get("selected"),
+    query: params.get("query") ?? DEFAULT_VALUES.query,
+    sort: params.get("sort") ?? DEFAULT_VALUES.sort,
+    span: params.get("span") ?? DEFAULT_VALUES.span,
+    filter: params.get("filter"),
+    startDate: params.get("start_date"),
+    endDate: params.get("end_date"),
+    offset: parseOffset(params.get("offset")),
+    trackTotalHits: (params.get("track_total_hits") ?? "false") !== "false"
+  });
+  const set = useCallback(
+    (key) => (value) => {
+      if (value === values[key]) {
+        return;
+      }
+      if (key === "selected" && !value && location.pathname.startsWith("/bundles")) {
+        pendingChanges.current[key] = routeParams.id;
+      } else {
+        pendingChanges.current[key] = value ?? DEFAULT_VALUES[key] ?? null;
+      }
+      if (key === "span" && !value.endsWith("custom")) {
+        pendingChanges.current.startDate = null;
+        pendingChanges.current.endDate = null;
+      }
+      WRITE_THROTTLER.debounce(() => {
+        _setValues((_current) => ({ ..._current, ...pendingChanges.current }));
+        pendingChanges.current = {};
+      });
+    },
+    [location.pathname, routeParams.id, values]
+  );
+  const setOffset = useCallback(
+    (_offset) => _setValues((_current) => ({ ..._current, offset: parseOffset(_offset) })),
+    []
+  );
+  const setCustomSpan = useCallback((startDate, endDate) => {
+    _setValues((_values) => ({
+      ..._values,
+      startDate,
+      endDate
+    }));
+  }, []);
+  const getDiff = useCallback(
+    (operation) => {
+      const changes = {};
+      const standardKeys = [
+        ["query", values.query],
+        ["sort", values.sort],
+        ["span", values.span],
+        ["filter", values.filter],
+        ["start_date", values.startDate],
+        ["end_date", values.endDate]
+      ];
+      standardKeys.forEach(([key, value]) => {
+        const fromSearchWithFallback = params.has(key) ? params.get(key) : DEFAULT_VALUES[key] ?? void 0;
+        if (fromSearchWithFallback !== value) {
+          changes[key] = operation === "write" ? value : fromSearchWithFallback;
+        }
+        if (operation === "write") {
+          if (params.has(key) && !isUndefined(changes[key]) && changes[key] === DEFAULT_VALUES[key]) {
+            changes[key] = null;
+          }
+        }
+      });
+      if (operation === "write") {
+        if (location.pathname.startsWith("/bundles") && (!params.has("selected") || values.selected === params.get("selected"))) {
+          changes.selected = null;
+        } else {
+          changes.selected = values.selected;
+        }
+      } else {
+        if (params.has("selected")) {
+          changes.selected = params.get("selected");
+        } else if (location.pathname.startsWith("/bundles")) {
+          changes.selected = routeParams.id;
+        } else {
+          changes.selected = null;
+        }
+      }
+      if (parseOffset(params.get("offset")) !== values.offset) {
+        changes.offset = operation === "write" ? values.offset : parseOffset(params.get("offset"));
+        if (operation === "write" && !changes.offset) {
+          changes.offset = null;
+        }
+      }
+      return omitBy(
+        omitBy(changes, isUndefined),
+        (val, key) => operation === "write" ? val == params.get(key) : val == values[key]
+      );
+    },
+    [values, params, location.pathname, routeParams.id]
+  );
+  useEffect(() => {
+    const changes = getDiff("write");
+    if (!isEmpty(changes)) {
+      const existingParams = Object.fromEntries(params.entries());
+      setParams(
+        (_params) => {
+          const newParams = new URLSearchParams({ ...existingParams, ...changes });
+          Object.entries(pickBy(changes, isNull)).forEach(([key]) => newParams.delete(key));
+          return newParams;
+        },
+        { replace: !changes.query && !Object.keys(changes).includes("offset") }
+      );
+    }
+  }, [values]);
+  useEffect(() => {
+    const changes = getDiff("read");
+    if (!isEmpty(changes)) {
+      _setValues((_current) => ({
+        ..._current,
+        ...changes
+      }));
+    }
+  }, [location.search, location.pathname, routeParams.id]);
+  return /* @__PURE__ */ jsx(
+    ParameterContext.Provider,
+    {
+      value: {
+        ...values,
+        setOffset,
+        setCustomSpan,
+        setSelected: useMemo(() => set("selected"), [set]),
+        setQuery: useMemo(() => set("query"), [set]),
+        setSort: useMemo(() => set("sort"), [set]),
+        setSpan: useMemo(() => set("span"), [set]),
+        setFilter: useMemo(() => set("filter"), [set])
+      },
+      children
+    }
+  );
+};
+const useParameterContextSelector = (selector) => {
+  return useContextSelector(ParameterContext, selector);
+};
+export {
+  ParameterContext,
+  ParameterProvider as default,
+  useParameterContextSelector
+};

package/components/app/providers/SocketProvider.d.ts

@@ -0,0 +1,57 @@
+import { PropsWithChildren } from 'react';
+export type ListenerType<K extends keyof WebSocketEventMap> = (this: WebSocket, ev: WebSocketEventMap[K]) => void;
+/**
+ * The type of the data returned from the server during a WebSocket connection.
+ * The only guaranteed keys are error, message and status.
+ */
+export type RecievedDataType<T = {
+    [index: string]: any;
+}> = T & {
+    error: boolean;
+    message: string;
+    type: string;
+    status: number;
+};
+/**
+ * Enum to help track the status of the Websocket, since the corresponding websocket enums are directly on the object
+ */
+export declare enum Status {
+    CLOSED,
+    CLOSING,
+    CONNECTING,
+    OPEN
+}
+interface SocketContextType {
+    /**
+     * Add a listener for events from the websocket connection.
+     * @param key The unique key used to track this listener
+     * @param v The listener function
+     */
+    addListener: <T = {
+        [index: string]: any;
+    }>(key: string, v: (data: RecievedDataType<T>) => void) => void;
+    /**
+     * Remove a listener from the websocket connection.
+     * @param key The unique key used to track the listener we're removing
+     */
+    removeListener: (key: string) => void;
+    /**
+     * Wrapper function for WebSocket.send(...). Used to send data to the server.
+     */
+    emit: (data: any) => void;
+    /**
+     * The status of the websocket connection.
+     */
+    status: Status;
+    /**
+     * Manually attempt reconnecting to the server.
+     */
+    reconnect: () => void;
+    /**
+     * Helper function to tell if the socket is open
+     */
+    isOpen: () => boolean;
+}
+export declare const SocketContext: import('react').Context<SocketContextType>;
+declare const SocketProvider: React.FC<PropsWithChildren>;
+export default SocketProvider;

package/components/app/providers/SocketProvider.js

@@ -0,0 +1,175 @@
+import { jsx } from "/home/runner/work/howler/howler/ui/node_modules/.pnpm/react@18.3.1/node_modules/react/jsx-runtime.js";
+import { a as api } from "../../../index-BPPnUdfP.js";
+import useMyLocalStorage from "../../hooks/useMyLocalStorage.js";
+import { createContext, useRef, useState, useCallback, useEffect } from "/home/runner/work/howler/howler/ui/node_modules/.pnpm/react@18.3.1/node_modules/react/index.js";
+import { StorageKey } from "../../../utils/constants.js";
+import { setStored, getStored, setAxiosCache } from "../../../utils/sessionStorage.js";
+import { isHitUpdate } from "../../../utils/socketUtils.js";
+var Status = ((Status2) => {
+  Status2[Status2["CLOSED"] = WebSocket.CLOSED] = "CLOSED";
+  Status2[Status2["CLOSING"] = WebSocket.CLOSING] = "CLOSING";
+  Status2[Status2["CONNECTING"] = WebSocket.CONNECTING] = "CONNECTING";
+  Status2[Status2["OPEN"] = WebSocket.OPEN] = "OPEN";
+  return Status2;
+})(Status || {});
+const SocketContext = createContext(null);
+const SocketProvider = ({ children }) => {
+  const { get } = useMyLocalStorage();
+  const socket = useRef();
+  const listeners = useRef({});
+  const appToken = get(StorageKey.APP_TOKEN);
+  const [status, setStatus] = useState(Status.CLOSED);
+  const [retry, setRetry] = useState(true);
+  const [failedAttempts, setFailedAttempts] = useState(0);
+  const onClose = useCallback(
+    (e) => {
+      if (e.code === 1006) {
+        setTimeout(() => setRetry(true), 1e3 * Math.pow(2, failedAttempts));
+        setFailedAttempts(failedAttempts + 1);
+      } else if (e.code === 1008) {
+        try {
+          const data = JSON.parse(e.reason);
+          if (data.status === 401) {
+            api.user.whoami.get().then(() => setRetry(true));
+          } else {
+            console.error(data);
+            setRetry(false);
+          }
+        } catch (err) {
+        }
+      }
+      setStatus(Status.CLOSED);
+    },
+    [failedAttempts]
+  );
+  const onWsError = useCallback(() => {
+    var _a;
+    setStatus(Status.CLOSING);
+    (_a = socket.current) == null ? void 0 : _a.close();
+    setStatus(Status.CLOSED);
+    setTimeout(() => setRetry(true), 1e3 * Math.pow(2, failedAttempts));
+    setFailedAttempts(failedAttempts + 1);
+  }, [failedAttempts]);
+  const onMessageError = useCallback((e) => {
+    try {
+      const data = JSON.parse(e.data);
+      if ((data == null ? void 0 : data.error) || (data == null ? void 0 : data.status) >= 400) {
+        console.warn((data == null ? void 0 : data.message) || "Websocket Error");
+      }
+    } catch (err) {
+      console.warn("Websocket Error");
+    }
+  }, []);
+  const onBeforeUnload = useCallback(() => {
+    var _a;
+    return (_a = socket.current) == null ? void 0 : _a.close();
+  }, []);
+  useEffect(() => {
+    if ([Status.OPEN, Status.CONNECTING].includes(status)) {
+      if (status === Status.OPEN) {
+        setRetry(false);
+      }
+      return;
+    }
+    if (!retry || !appToken) return;
+    setRetry(false);
+    setStatus(Status.CONNECTING);
+    const host = window.location.host.includes("localhost") ? "localhost:5000" : window.location.host;
+    const protocol = window.location.protocol.startsWith("http:") ? "ws" : "wss";
+    const ws = new WebSocket(`${protocol}://${host}/socket/v1/connect`);
+    ws.addEventListener("close", onClose);
+    ws.addEventListener("error", onWsError);
+    ws.addEventListener("message", onMessageError);
+    ws.addEventListener("open", () => {
+      socket.current = ws;
+      ws.send(appToken);
+      const onAuth = (e) => {
+        ws.removeEventListener("message", onAuth);
+        const data = JSON.parse(e.data);
+        if (!data.error) {
+          console.debug(data.message);
+          setStatus(Status.OPEN);
+          setRetry(false);
+          setFailedAttempts(0);
+        } else {
+          console.error(data.message);
+        }
+      };
+      ws.addEventListener("message", onAuth);
+    });
+    window.addEventListener("beforeunload", onBeforeUnload);
+  }, [appToken, status, onBeforeUnload, onClose, onWsError, onMessageError, retry]);
+  useEffect(() => {
+    if (status === Status.OPEN) {
+      Object.values(listeners.current).forEach((l) => {
+        var _a, _b;
+        (_a = socket.current) == null ? void 0 : _a.removeEventListener("message", l);
+        (_b = socket.current) == null ? void 0 : _b.addEventListener("message", l);
+      });
+    }
+  }, [listeners, status]);
+  useEffect(() => {
+    if (!socket.current) return;
+    if ([Status.CLOSED, Status.CLOSING].includes(status)) {
+      socket.current.removeEventListener("close", onClose);
+      socket.current.removeEventListener("error", onWsError);
+      socket.current.removeEventListener("message", onMessageError);
+      Object.values(listeners.current).forEach((l) => socket.current.removeEventListener("message", l));
+      listeners.current = {};
+      window.removeEventListener("beforeunload", onBeforeUnload);
+      socket.current.close();
+      socket.current = null;
+    }
+  }, [status, socket, appToken, onBeforeUnload, onClose, onWsError, onMessageError]);
+  const addListener = useCallback((key, callback) => {
+    var _a, _b;
+    if (listeners.current[key]) {
+      (_a = socket.current) == null ? void 0 : _a.removeEventListener("message", listeners[key]);
+    }
+    const wrapped = (ev) => {
+      const parsedData = JSON.parse(ev.data);
+      if (isHitUpdate(parsedData) && parsedData.status < 300) {
+        setStored(StorageKey.ETAG, {
+          ...getStored(StorageKey.ETAG),
+          [parsedData.hit.howler.id]: parsedData.version
+        });
+        setAxiosCache(parsedData.version, {
+          api_response: parsedData.hit,
+          api_error_message: "",
+          api_server_version: "",
+          api_status_code: parsedData.status
+        });
+      }
+      callback(parsedData);
+    };
+    (_b = socket.current) == null ? void 0 : _b.addEventListener("message", wrapped);
+    listeners.current[key] = wrapped;
+  }, []);
+  const removeListener = useCallback((key) => {
+    var _a;
+    (_a = socket.current) == null ? void 0 : _a.removeEventListener("message", listeners.current[key]);
+    delete listeners.current[key];
+  }, []);
+  const emit = useCallback(
+    (data) => {
+      var _a;
+      if (typeof data !== "string") {
+        data = JSON.stringify(data);
+      }
+      if (status !== Status.OPEN || !socket.current) {
+        console.warn("socket closed, not sending");
+        return;
+      }
+      (_a = socket.current) == null ? void 0 : _a.send(data);
+    },
+    [status]
+  );
+  const isOpen = useCallback(() => status === Status.OPEN, [status]);
+  const reconnect = useCallback(() => setRetry(true), []);
+  return /* @__PURE__ */ jsx(SocketContext.Provider, { value: { addListener, removeListener, emit, status, reconnect, isOpen }, children });
+};
+export {
+  SocketContext,
+  Status,
+  SocketProvider as default
+};

package/components/app/providers/UserListProvider.d.ts

@@ -0,0 +1,12 @@
+import { HowlerUser } from '@cccsaurora/howler-ui/models/entities/HowlerUser';
+import { FC, PropsWithChildren } from 'react';
+interface UserListContextType {
+    users: {
+        [id: string]: HowlerUser;
+    };
+    searchUsers: (query: string) => void;
+    fetchUsers: (ids: Set<string>) => void;
+}
+export declare const UserListContext: import('react').Context<UserListContextType>;
+declare const UserListProvider: FC<PropsWithChildren>;
+export default UserListProvider;

package/components/app/providers/UserListProvider.js

@@ -0,0 +1,40 @@
+import { jsx } from "/home/runner/work/howler/howler/ui/node_modules/.pnpm/react@18.3.1/node_modules/react/jsx-runtime.js";
+import { a as api } from "../../../index-BPPnUdfP.js";
+import useMyApi from "../../hooks/useMyApi.js";
+import { createContext, useState, useCallback } from "/home/runner/work/howler/howler/ui/node_modules/.pnpm/react@18.3.1/node_modules/react/index.js";
+const UserListContext = createContext(null);
+const UserListProvider = ({ children }) => {
+  const { dispatchApi } = useMyApi();
+  const [users, setUsers] = useState({});
+  const searchUsers = useCallback(
+    async (query) => {
+      var _a, _b;
+      const newUsers = (_b = (_a = await dispatchApi(api.search.user.post({ query, rows: 1e3 }), {
+        throwError: false,
+        logError: false,
+        showError: false
+      })) == null ? void 0 : _a.items) == null ? void 0 : _b.reduce((dict, user) => ({ ...dict, [user.username]: user }), {});
+      setUsers((_users) => ({
+        ..._users,
+        ...newUsers
+      }));
+    },
+    [dispatchApi]
+  );
+  const fetchUsers = useCallback(
+    async (ids) => {
+      ids.delete("Unknown");
+      const idsToGet = Array.from(ids.values()).filter((id) => !Object.keys(users).includes(id));
+      if (idsToGet.length <= 0) {
+        return;
+      }
+      await searchUsers(`id:${[...idsToGet].join(" OR ")}`);
+    },
+    [searchUsers, users]
+  );
+  return /* @__PURE__ */ jsx(UserListContext.Provider, { value: { users, fetchUsers, searchUsers }, children });
+};
+export {
+  UserListContext,
+  UserListProvider as default
+};

package/components/app/providers/ViewProvider.d.ts

@@ -0,0 +1,23 @@
+import { View } from '@cccsaurora/howler-ui/models/entities/generated/View';
+import { FC, PropsWithChildren } from 'react';
+export interface ViewContextType {
+    defaultView: string;
+    setDefaultView: (viewId: string) => void;
+    views: {
+        [viewId: string]: View;
+    };
+    addFavourite: (id: string) => Promise<void>;
+    removeFavourite: (id: string) => Promise<void>;
+    fetchViews: (ids?: string[]) => Promise<View[]>;
+    addView: (v: View) => Promise<View>;
+    editView: (id: string, newView: Partial<Omit<View, 'view_id' | 'owner'>>) => Promise<View>;
+    removeView: (id: string) => Promise<void>;
+    getCurrentView: (config?: {
+        viewId?: string;
+        lazy?: boolean;
+    }) => Promise<View>;
+}
+export declare const ViewContext: import('use-context-selector').Context<ViewContextType>;
+declare const ViewProvider: FC<PropsWithChildren>;
+export declare const useViewContextSelector: <Selected>(selector: (value: ViewContextType) => Selected) => Selected;
+export default ViewProvider;

package/components/app/providers/ViewProvider.js

@@ -0,0 +1,163 @@
+import { jsx } from "/home/runner/work/howler/howler/ui/node_modules/.pnpm/react@18.3.1/node_modules/react/jsx-runtime.js";
+import { a as api } from "../../../index-BPPnUdfP.js";
+import "../../../commons/components/app/AppContexts.js";
+import { useState, useCallback, useEffect } from "/home/runner/work/howler/howler/ui/node_modules/.pnpm/react@18.3.1/node_modules/react/index.js";
+import "../../../i18n.js";
+import "../../../commons/components/app/hooks/useAppSitemap.js";
+import { useAppUser } from "../../../commons/components/app/hooks/useAppUser.js";
+import useMyApi from "../../hooks/useMyApi.js";
+import { useMyLocalStorageItem } from "../../hooks/useMyLocalStorage.js";
+import { has, omit } from "/home/runner/work/howler/howler/ui/node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/lodash.js";
+import { useLocation, useParams } from "/home/runner/work/howler/howler/ui/node_modules/.pnpm/react-router-dom@6.30.1_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/react-router-dom/dist/index.js";
+import { createContext, useContextSelector } from "/home/runner/work/howler/howler/ui/node_modules/.pnpm/use-context-selector@2.0.0_react@18.3.1_scheduler@0.23.2/node_modules/use-context-selector/dist/index.js";
+import { StorageKey } from "../../../utils/constants.js";
+const ViewContext = createContext(null);
+const ViewProvider = ({ children }) => {
+  var _a;
+  const { dispatchApi } = useMyApi();
+  const appUser = useAppUser();
+  const [defaultView, setDefaultView] = useMyLocalStorageItem(StorageKey.DEFAULT_VIEW);
+  const location = useLocation();
+  const routeParams = useParams();
+  const [views, setViews] = useState({});
+  const fetchViews = useCallback(
+    async (ids) => {
+      if (!ids) {
+        const newViews = await dispatchApi(api.view.get(), { throwError: false }) ?? [];
+        setViews((_views) => ({
+          ..._views,
+          ...Object.fromEntries(newViews.map((_view) => [_view.view_id, _view]))
+        }));
+        return newViews;
+      }
+      const missingIds = ids.filter((_id) => !has(views, _id));
+      if (missingIds.length < 1) {
+        return ids.map((id) => views[id]);
+      }
+      try {
+        const response = await dispatchApi(
+          api.search.view.post({
+            query: `view_id:(${missingIds.join(" OR ")})`,
+            rows: missingIds.length,
+            sort: "title asc"
+          })
+        );
+        const newViews = Object.fromEntries(response.items.map((_view) => [_view.view_id, _view]));
+        setViews((_views) => ({
+          ..._views,
+          ...Object.fromEntries(missingIds.map((_view_id) => [_view_id, null])),
+          ...newViews
+        }));
+        return ids.map((id) => views[id] ?? newViews[id]);
+      } catch (e) {
+        console.warn(e);
+        return [];
+      }
+    },
+    [dispatchApi, views]
+  );
+  useEffect(() => {
+    if (!defaultView || has(views, defaultView)) {
+      return;
+    }
+    (async () => {
+      const result = await fetchViews([defaultView]);
+      if (!result.length) {
+        setDefaultView(void 0);
+      }
+    })();
+  }, [defaultView, fetchViews, setDefaultView, views]);
+  const getCurrentView = useCallback(
+    async ({ viewId, lazy = false } = {}) => {
+      if (!viewId) {
+        viewId = location.pathname.startsWith("/views") ? routeParams.id : defaultView;
+      }
+      if (!viewId) {
+        return null;
+      }
+      if (!has(views, viewId) && !lazy) {
+        return (await fetchViews([viewId]))[0];
+      }
+      return views[viewId];
+    },
+    [defaultView, fetchViews, location.pathname, routeParams.id, views]
+  );
+  const editView = useCallback(
+    async (id, partialView) => {
+      const result = await dispatchApi(api.view.put(id, partialView));
+      setViews((_views) => ({
+        ..._views,
+        [id]: { ..._views[id] ?? {}, ...partialView }
+      }));
+      return result;
+    },
+    [dispatchApi]
+  );
+  const addFavourite = useCallback(
+    async (id) => {
+      await dispatchApi(api.view.favourite.post(id));
+      appUser.setUser({
+        ...appUser.user,
+        favourite_views: [...appUser.user.favourite_views, id]
+      });
+    },
+    [appUser, dispatchApi]
+  );
+  const addView = useCallback(
+    async (view) => {
+      const newView = await dispatchApi(api.view.post(view));
+      setViews((_views) => ({ ..._views, [newView.view_id]: newView }));
+      addFavourite(newView.view_id);
+      return newView;
+    },
+    [addFavourite, dispatchApi]
+  );
+  const removeFavourite = useCallback(
+    async (id) => {
+      await dispatchApi(api.view.favourite.del(id));
+      appUser.setUser({
+        ...appUser.user,
+        favourite_views: appUser.user.favourite_views.filter((v) => v !== id)
+      });
+    },
+    [appUser, dispatchApi]
+  );
+  const removeView = useCallback(
+    async (id) => {
+      var _a2;
+      const result = await dispatchApi(api.view.del(id));
+      setViews((_views) => omit(_views, id));
+      if ((_a2 = appUser.user) == null ? void 0 : _a2.favourite_views.includes(id)) {
+        removeFavourite(id);
+      }
+      return result;
+    },
+    [(_a = appUser.user) == null ? void 0 : _a.favourite_views, dispatchApi, removeFavourite]
+  );
+  return /* @__PURE__ */ jsx(
+    ViewContext.Provider,
+    {
+      value: {
+        views,
+        addFavourite,
+        removeFavourite,
+        fetchViews,
+        addView,
+        editView,
+        removeView,
+        defaultView,
+        setDefaultView,
+        getCurrentView
+      },
+      children
+    }
+  );
+};
+const useViewContextSelector = (selector) => {
+  return useContextSelector(ViewContext, selector);
+};
+export {
+  ViewContext,
+  ViewProvider as default,
+  useViewContextSelector
+};

package/components/elements/Comment.d.ts

@@ -0,0 +1,17 @@
+import { HowlerUser } from '@cccsaurora/howler-ui/models/entities/HowlerUser';
+import { Comment as AnalyticComment } from '@cccsaurora/howler-ui/models/entities/generated/Comment';
+import { HowlerComment } from '@cccsaurora/howler-ui/models/entities/generated/HowlerComment';
+import { ReactNode } from 'react';
+declare const _default: import('react').NamedExoticComponent<{
+    comment: HowlerComment | AnalyticComment;
+    handleDelete?: () => Promise<void>;
+    handleEdit?: (value: string) => Promise<void>;
+    handleReact?: (type: string) => Promise<void>;
+    handleQuote?: () => void;
+    onClick?: () => void;
+    users: {
+        [id: string]: HowlerUser;
+    };
+    extra?: ReactNode;
+}>;
+export default _default;