@blocklet/discuss-kit 1.0.7 → 1.0.8

package/lib/es/components/rating/rating.js

@@ -1,91 +0,0 @@
-import { useEffect } from "react";
-import PropTypes from "prop-types";
-import useSetState from "react-use/lib/useSetState";
-function Rating({
-  ratingType,
-  values,
-  countPerValue,
-  selected,
-  render,
-  onRate,
-  onUnrate
-}) {
-  const [state, setState] = useSetState({
-    selected,
-    countPerValue
-  });
-  const hasSelected = !!state.selected || state.selected === 0;
-  const increaseCount = (value, inc) => {
-    setState((prevState) => ({
-      countPerValue: {
-        ...prevState.countPerValue,
-        [value]: (prevState.countPerValue[value] || 0) + inc
-      }
-    }));
-  };
-  useEffect(() => {
-    setState({
-      countPerValue,
-      selected
-    });
-  }, [countPerValue, selected]);
-  if (!render) {
-    return null;
-  }
-  const options = values.map((value) => {
-    var _a;
-    return {
-      value,
-      count: ((_a = state.countPerValue) == null ? void 0 : _a[value]) || 0,
-      selected: state.selected === value
-    };
-  });
-  const toggleRate = async (value) => {
-    try {
-      if (state.selected === value) {
-        await onUnrate({
-          ratingType,
-          value
-        });
-        increaseCount(value, -1);
-        setState({
-          selected: null
-        });
-      } else {
-        await onRate({
-          ratingType,
-          value
-        });
-        if (hasSelected) {
-          increaseCount(state.selected, -1);
-        }
-        increaseCount(value, 1);
-        setState({
-          selected: value
-        });
-      }
-    } catch (e) {
-      console.error("Failed to rate.", e);
-    }
-  };
-  return render({
-    options,
-    toggleRate
-  });
-}
-Rating.propTypes = {
-  ratingType: PropTypes.oneOf(["binary-thumb", "five-star", "emoji-based"]).isRequired,
-  values: PropTypes.arrayOf(PropTypes.number).isRequired,
-  countPerValue: PropTypes.object,
-  selected: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
-  render: PropTypes.func.isRequired,
-  onRate: PropTypes.func.isRequired,
-  onUnrate: PropTypes.func.isRequired
-};
-Rating.defaultProps = {
-  countPerValue: {},
-  selected: void 0
-};
-export {
-  Rating as default
-};

package/lib/es/context.js

@@ -1,74 +0,0 @@
-import { createContext, useContext, useEffect, useMemo } from "react";
-import PropTypes from "prop-types";
-import { SessionContext } from "@arcblock/did-connect/lib/Session";
-import { useComments } from "./hooks";
-import getWsClient from "./ws";
-import { jsx } from "react/jsx-runtime";
-const CommentsContext = createContext();
-function CommentsProvider({
-  prefix,
-  session,
-  object,
-  manageMode,
-  flatMode,
-  children
-}) {
-  var _a;
-  const sessionCtx = useContext(SessionContext);
-  const _session = session || (sessionCtx == null ? void 0 : sessionCtx.session);
-  const wsClient = getWsClient(prefix);
-  const commentsState = useComments({
-    objectId: object.id,
-    flatMode
-  }, [(_a = _session == null ? void 0 : _session.user) == null ? void 0 : _a.did]);
-  useEffect(() => {
-    wsClient.connect();
-    return () => {
-      if (wsClient.isConnected()) {
-        wsClient.disconnect();
-      }
-    };
-  }, []);
-  const value = useMemo(
-    () => ({
-      session: _session,
-      object,
-      prefix,
-      manageMode,
-      flatMode,
-      ...commentsState
-    }),
-    [_session, object, prefix, commentsState]
-  );
-  return /* @__PURE__ */ jsx(CommentsContext.Provider, {
-    value,
-    children
-  });
-}
-CommentsProvider.propTypes = {
-  prefix: PropTypes.string,
-  session: PropTypes.object,
-  object: PropTypes.PropTypes.shape({
-    id: PropTypes.string.isRequired,
-    title: PropTypes.string,
-    desc: PropTypes.string,
-    owner: PropTypes.string
-  }).isRequired,
-  manageMode: PropTypes.bool,
-  flatMode: PropTypes.bool,
-  children: PropTypes.any.isRequired
-};
-CommentsProvider.defaultProps = {
-  prefix: "",
-  session: void 0,
-  manageMode: false,
-  flatMode: false
-};
-const useCommentsContext = () => {
-  return useContext(CommentsContext);
-};
-export {
-  CommentsContext,
-  CommentsProvider,
-  useCommentsContext
-};

package/lib/es/hooks.js

@@ -1,197 +0,0 @@
-import { useMemo, useRef, useEffect } from "react";
-import useSetState from "react-use/lib/useSetState";
-import uniqBy from "lodash/uniqBy";
-import orderBy from "lodash/orderBy";
-import Toast from "@arcblock/ux/lib/Toast";
-import { fetchRatingStats, fetchMoreReplies, fetchComments } from "./api";
-import { useSubscription } from "./ws";
-const lastItem = (arr) => (arr == null ? void 0 : arr.length) ? arr[arr.length - 1] : null;
-const getInitialState = () => ({
-  comments: [],
-  cursor: null,
-  total: 0,
-  initialized: false,
-  loading: true,
-  error: null,
-  rating: {},
-  sortType: localStorage.getItem("sortType") || "asc"
-});
-const useComments = ({ objectId, flatMode }, deps = []) => {
-  const [state, setState] = useSetState(getInitialState());
-  const commentsKeyById = useMemo(() => {
-    return state.comments.reduce((acc, cur) => {
-      var _a;
-      acc[cur.id] = cur;
-      if ((_a = cur.replies) == null ? void 0 : _a.length) {
-        cur.replies.forEach((item) => {
-          acc[item.id] = item;
-        });
-      }
-      return acc;
-    }, {});
-  }, [state]);
-  const hasMore = useMemo(() => !!state.cursor, [state]);
-  const fetchParamsRef = useRef({
-    objectId,
-    size: 12,
-    embed: "replies,rating",
-    ...flatMode && { includeReplies: 1 }
-  });
-  const updateCommentList = () => {
-    setState({ comments: [...state.comments] });
-  };
-  const updateComment = (commentId, mapper) => {
-    const commentOrReply = commentsKeyById[commentId];
-    if (commentOrReply) {
-      const rootComment = commentsKeyById[commentOrReply.commentId];
-      if (!rootComment || flatMode) {
-        const index = state.comments.findIndex((item) => item.id === commentId);
-        if (index !== -1) {
-          state.comments[index] = mapper(state.comments[index]);
-          updateCommentList();
-        }
-      } else {
-        const index = rootComment.replies.findIndex((item) => item.id === commentId);
-        if (index !== -1) {
-          rootComment.replies[index] = mapper(rootComment.replies[index]);
-          updateComment(rootComment.id, (current) => ({
-            ...current,
-            replies: [...rootComment.replies]
-          }));
-        }
-      }
-    }
-  };
-  const addComment = (commentOrReply) => {
-    if (commentsKeyById[commentOrReply.id]) {
-      return;
-    }
-    const rootComment = commentsKeyById[commentOrReply.commentId];
-    if (!rootComment || flatMode) {
-      const comments = uniqBy([...state.comments, commentOrReply], "id");
-      setState({ comments: orderBy(comments, ["createdAt"], [state.sortType]), total: state.total + 1 });
-    } else {
-      updateComment(rootComment.id, (current) => {
-        var _a;
-        const replies = uniqBy([...rootComment.replies || [], commentOrReply], "id");
-        const newComment = {
-          ...current,
-          replies: orderBy(replies, ["createdAt"], ["asc"]),
-          totalReplies: (current.totalReplies || 0) + 1
-        };
-        if (!current.repliesCursor) {
-          newComment.repliesCursor = (_a = lastItem(current.replies)) == null ? void 0 : _a.createdAt;
-        }
-        return newComment;
-      });
-    }
-  };
-  const removeComment = (comment) => {
-    const isReply = comment.commentId;
-    if (isReply && !flatMode) {
-      updateComment(comment.commentId, (current) => {
-        return {
-          ...current,
-          replies: (current.replies || []).map((item) => {
-            if (item.id === comment.id) {
-              return { ...item, deletedAt: new Date() };
-            }
-            return item;
-          })
-        };
-      });
-    } else {
-      updateComment(comment.id, (current) => {
-        return { ...current, deletedAt: new Date() };
-      });
-    }
-  };
-  const handlers = {
-    ADD_COMMENT: (data) => addComment(data),
-    RATING: async () => {
-      const rating = await fetchRatingStats(objectId);
-      setState({ rating });
-    },
-    RATING_COMMENT: async ({ commentId }) => {
-      const rating = await fetchRatingStats(commentId);
-      updateComment(commentId, (current) => ({
-        ...current,
-        rating
-      }));
-    }
-  };
-  useSubscription(
-    objectId,
-    ({ event, data }) => {
-      var _a;
-      (_a = handlers[event]) == null ? void 0 : _a.call(handlers, data);
-    },
-    [objectId, state]
-  );
-  const fetch = async () => {
-    try {
-      setState({ loading: true });
-      return fetchComments({ ...fetchParamsRef.current, order: state.sortType, cursor: state.cursor });
-    } catch (e) {
-      Toast.warning("Failed to load comments data.");
-      setState({ error: e });
-      return { comments: [], total: 0, cursor: null };
-    } finally {
-      setState({ loading: false });
-    }
-  };
-  const loadMore = async () => {
-    if (hasMore) {
-      const { data: comments, total, nextCursor } = await fetch();
-      const sorted = orderBy([...state.comments, ...comments], ["createdAt"], [state.sortType]);
-      setState({ comments: sorted, total, cursor: nextCursor });
-    }
-  };
-  const loadMoreReplies = async (commentId) => {
-    var _a;
-    const rootComment = commentsKeyById[commentId];
-    const cursor = rootComment.repliesCursor || ((_a = lastItem(rootComment.replies)) == null ? void 0 : _a.createdAt);
-    const data = await fetchMoreReplies({
-      commentId,
-      cursor,
-      embed: "rating"
-    });
-    const loadedReplies = data.data;
-    let replies = uniqBy([...rootComment.replies || [], ...loadedReplies || []], "id");
-    replies = orderBy(replies, ["createdAt"], ["asc"]);
-    updateComment(commentId, (current) => {
-      var _a2;
-      return {
-        ...current,
-        replies,
-        totalReplies: data.total,
-        repliesCursor: (_a2 = lastItem(loadedReplies)) == null ? void 0 : _a2.createdAt
-      };
-    });
-  };
-  const sort = (sortType) => {
-    setState({ sortType, cursor: null });
-    localStorage.setItem("sortType", sortType);
-  };
-  useEffect(() => {
-    const init = async () => {
-      setState({ ...getInitialState(), initialized: false });
-      const [{ data: comments, total, nextCursor }, rating] = await Promise.all([fetch(), fetchRatingStats(objectId)]);
-      setState({ comments, total, cursor: nextCursor, rating, initialized: true });
-    };
-    init();
-  }, [objectId, state.sortType, ...deps || []]);
-  return {
-    ...state,
-    hasMore,
-    loadMore,
-    sort,
-    addComment,
-    updateComment,
-    loadMoreReplies,
-    removeComment
-  };
-};
-export {
-  useComments
-};