@blocklet/discuss-kit-ux-lite 2.6.0

package/dist/components/rating/rating.mjs

@@ -0,0 +1,50 @@
+import { useEffect } from "react";
+import { useSetState } from "ahooks";
+function Rating({ ratingType, values, countPerValue, selectedValue, render, onRate, onUnrate }) {
+  const [state, setState] = useSetState({
+    selectedValue,
+    countPerValue: countPerValue || {}
+  });
+  const hasSelected = !!state.selectedValue;
+  const increaseCount = (value, inc) => {
+    setState((prevState) => ({
+      countPerValue: { ...prevState.countPerValue, [value]: (prevState.countPerValue[value] || 0) + inc }
+    }));
+  };
+  useEffect(() => {
+    setState({
+      countPerValue: countPerValue || {},
+      selectedValue
+    });
+  }, [countPerValue, selectedValue]);
+  if (!render) {
+    return null;
+  }
+  const options = values.map((value) => {
+    return {
+      value,
+      count: state.countPerValue?.[value] || 0,
+      selected: state.selectedValue === value
+    };
+  });
+  const toggleRate = async (value) => {
+    try {
+      if (state.selectedValue === value) {
+        await onUnrate();
+        increaseCount(value, -1);
+        setState({ selectedValue: void 0 });
+      } else {
+        await onRate({ ratingType, value });
+        if (hasSelected) {
+          increaseCount(state.selectedValue, -1);
+        }
+        increaseCount(value, 1);
+        setState({ selectedValue: value });
+      }
+    } catch (e) {
+      console.error("Failed to rate.", e);
+    }
+  };
+  return render({ options, toggleRate });
+}
+export default Rating;

package/dist/components/segmented-control.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="react" />
+import { type SxProps } from '@mui/material';
+interface Option {
+    value: string;
+    label: React.ReactNode;
+}
+interface Props {
+    value: string;
+    options: Option[];
+    onChange?: (value: string) => void;
+    sx?: SxProps;
+}
+export declare function SegmentedControl({ value, options, onChange, sx, ...rest }: Props): import("react").JSX.Element;
+export {};

package/dist/components/segmented-control.mjs

@@ -0,0 +1,55 @@
+import { jsx } from "react/jsx-runtime";
+import { Box, ToggleButton, ToggleButtonGroup } from "@mui/material";
+import { mergeSx } from "./utils.mjs";
+export function SegmentedControl({ value, options, onChange, sx, ...rest }) {
+  const mergedSx = mergeSx(
+    {
+      display: "inline-flex",
+      borderRadius: "100vh"
+    },
+    sx
+  );
+  return /* @__PURE__ */ jsx(Box, { sx: mergedSx, ...rest, children: /* @__PURE__ */ jsx(
+    ToggleButtonGroup,
+    {
+      size: "small",
+      value,
+      exclusive: true,
+      onChange: (_, v) => onChange?.(v),
+      sx: {
+        ".MuiToggleButtonGroup-grouped": {
+          m: 0.5,
+          px: 1.5,
+          border: 0,
+          borderRadius: "100vh",
+          lineHeight: 1.3,
+          textTransform: "none",
+          color: "text.primary"
+        },
+        ".MuiToggleButtonGroup-grouped.Mui-selected": {
+          border: 1,
+          borderColor: "divider"
+        },
+        ".MuiToggleButtonGroup-middleButton, .MuiToggleButtonGroup-lastButton": {
+          marginLeft: "-1px",
+          borderLeft: "1px solid transparent"
+        }
+      },
+      children: options.map((x) => {
+        return /* @__PURE__ */ jsx(
+          ToggleButton,
+          {
+            value: x.value,
+            sx: {
+              "&.Mui-selected": {
+                backgroundColor: "action.hover"
+              }
+            },
+            children: x.label
+          },
+          x.value
+        );
+      })
+    }
+  ) });
+}

package/dist/components/shared/relative-time.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+interface Props {
+    value: string | number | Date;
+    [key: string]: any;
+    autoUpdate?: boolean;
+}
+export default function RelativeTime({ value, autoUpdate, ...rest }: Props): import("react").JSX.Element;
+export {};

package/dist/components/shared/relative-time.mjs

@@ -0,0 +1,21 @@
+import { jsx } from "react/jsx-runtime";
+import UxRelativeTime from "@arcblock/ux/lib/RelativeTime";
+import { useUpdate } from "ahooks";
+import { useEffect, useMemo } from "react";
+export default function RelativeTime({ value, autoUpdate, ...rest }) {
+  const v = value instanceof Date ? value.getTime() : value;
+  const update = useUpdate();
+  const timestamp = useMemo(() => new Date(v).getTime(), [v]);
+  useEffect(() => {
+    if (autoUpdate) {
+      const diff = Math.abs(Date.now() - timestamp);
+      const isLessThan45Minutes = diff < 45 * 6e4;
+      if (isLessThan45Minutes) {
+        const timer = setInterval(update, 6e4);
+        return () => clearInterval(timer);
+      }
+    }
+    return void 0;
+  }, [autoUpdate, timestamp, update]);
+  return /* @__PURE__ */ jsx(UxRelativeTime, { value: v, ...rest });
+}

package/dist/components/toast.d.ts

@@ -0,0 +1,8 @@
+import hotToast from 'react-hot-toast';
+type Message = Parameters<typeof hotToast>[0];
+export type ToastOptions = Parameters<typeof hotToast>[1];
+type Toast = typeof hotToast & {
+    warning: (message: Message, options?: ToastOptions) => string;
+};
+declare let toast: Toast;
+export { toast };

package/dist/components/toast.mjs

@@ -0,0 +1,44 @@
+import hotToast from "react-hot-toast";
+import bridge from "@arcblock/bridge";
+let toast = Object.assign(hotToast, {
+  warning: (message, options) => {
+    return hotToast.error(message, { ...options, icon: "\u26A0\uFE0F" });
+  }
+});
+const isInArcSphere = window?.navigator?.userAgent.indexOf("ArcSphere") > -1;
+if (isInArcSphere) {
+  toast = Object.assign(
+    (message) => {
+      try {
+        return bridge.call("arc__toast", { text: message });
+      } catch (e) {
+        return hotToast(message);
+      }
+    },
+    hotToast,
+    {
+      error: (message) => {
+        try {
+          return bridge.call("arc__toast", { text: message, level: "error" });
+        } catch (e) {
+          return hotToast.error(message);
+        }
+      },
+      success: (message) => {
+        try {
+          return bridge.call("arc__toast", { text: message, level: "success" });
+        } catch (e) {
+          return hotToast.success(message);
+        }
+      },
+      warning: (message, options) => {
+        try {
+          return bridge.call("arc__toast", { text: message, level: "warning" });
+        } catch (e) {
+          return hotToast.error(message, { ...options, icon: "\u26A0\uFE0F" });
+        }
+      }
+    }
+  );
+}
+export { toast };

package/dist/components/uploader/index.d.ts

@@ -0,0 +1,13 @@
+import { ReactNode } from 'react';
+export * from './utils';
+interface UploaderProviderProps {
+    children: ReactNode;
+}
+export declare const UploaderContext: import("react").Context<null>;
+export declare function useUploader(): never;
+export declare function UploaderTrigger({ onChange, children }: {
+    onChange?: Function;
+    children?: ReactNode;
+}): import("react").JSX.Element;
+export declare function UploaderProvider({ children }: UploaderProviderProps): import("react").JSX.Element;
+export default UploaderProvider;

package/dist/components/uploader/index.mjs

@@ -0,0 +1,70 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { Box } from "@mui/material";
+import { createContext, useContext, useRef, Suspense } from "react";
+import { lazyRetry as lazy } from "@arcblock/ux/lib/Util";
+import { createPortal } from "react-dom";
+import { useLocaleContext } from "@arcblock/ux/lib/Locale/context";
+export * from "./utils.mjs";
+const UploaderComponent = lazy(() => import("@blocklet/uploader").then((res) => ({ default: res.Uploader })));
+export const UploaderContext = createContext(null);
+export function useUploader() {
+  const uploaderRef = useContext(UploaderContext);
+  if (!uploaderRef) {
+    throw new Error("useUploader must be used within an UploaderProvider");
+  }
+  return uploaderRef;
+}
+export function UploaderTrigger({ onChange, children }) {
+  const uploaderRef = useUploader();
+  const handleOpen = () => {
+    const uploader = uploaderRef?.current?.getUploader();
+    const setMaxNumberOfFiles = (maxNumberOfFiles) => {
+      uploader?.setOptions({
+        // @ts-ignore
+        restrictions: {
+          maxNumberOfFiles
+        }
+      });
+    };
+    uploader?.open();
+    setMaxNumberOfFiles(1);
+    uploader?.onClose(() => {
+      setMaxNumberOfFiles(void 0);
+    });
+    if (onChange) {
+      uploader.onceUploadSuccess((...args) => {
+        onChange(...args);
+      });
+    }
+  };
+  return /* @__PURE__ */ jsx(Box, { onClick: handleOpen, children });
+}
+export function UploaderProvider({ children }) {
+  const uploaderRef = useRef(null);
+  const { locale } = useLocaleContext();
+  window.uploaderRef = uploaderRef;
+  return /* @__PURE__ */ jsxs(UploaderContext.Provider, { value: uploaderRef, children: [
+    children,
+    /* @__PURE__ */ jsx(Suspense, { children: createPortal(
+      /* @__PURE__ */ jsx(
+        UploaderComponent,
+        {
+          locale,
+          ref: uploaderRef,
+          popup: true,
+          coreProps: {
+            // 不做代码限制，默认使用 Media Kit 配置
+            // // 上传限制，参考 https://uppy.io/docs/uppy/#restrictions
+            // restrictions: {
+            //   allowedFileExts: ['.png', '.jpg', '.jpeg', '.gif', '.webp', '.svg', '.mp4', '.webm', '.pdf'],
+            //   maxNumberOfFiles: undefined, // default is unlimited
+            // },
+          }
+        },
+        "uploader"
+      ),
+      document.body
+    ) })
+  ] });
+}
+export default UploaderProvider;

package/dist/components/uploader/utils.d.ts

@@ -0,0 +1 @@
+export declare const getUploadedImageUrl: (imageUrl: string, width?: number) => string;

package/dist/components/uploader/utils.mjs

@@ -0,0 +1,16 @@
+import { joinURL } from "ufo";
+export const getUploadedImageUrl = (imageUrl, width = 320) => {
+  const prefix = joinURL(window.blocklet?.prefix || "/", "uploads");
+  let result = imageUrl;
+  if (imageUrl && imageUrl.startsWith("/") && !imageUrl.startsWith(prefix)) {
+    result = joinURL(prefix, imageUrl);
+    const tmp = new URL(result, window.location.origin);
+    if (!imageUrl.endsWith(".gif")) {
+      tmp.searchParams.set("imageFilter", "resize");
+      tmp.searchParams.set("w", width.toString());
+      tmp.searchParams.set("f", "webp");
+    }
+    return tmp.href;
+  }
+  return result;
+};

package/dist/components/utils.d.ts

@@ -0,0 +1,22 @@
+import type { SxProps, Theme } from '@mui/material';
+import type { SystemStyleObject } from '@mui/system';
+export declare const repairBase64Avatar: (avatar?: string) => string | undefined;
+export declare const getResizedAvatar: (avatar: string, size?: number) => string;
+export declare const sleep: (ms: number) => Promise<unknown>;
+export declare const minDelay: <T>(promise: Promise<T>, ms: number) => Promise<T>;
+export declare const protectLogin: (session: any, action: () => Promise<any> | void) => void | Promise<unknown>;
+export declare const copy: (text: string) => void;
+export declare const getLastItem: <T>(arr: T[]) => T | null;
+export declare function tryParseJSONObject(str: string): boolean;
+export declare const getPreference: (key: string) => any;
+export declare const getBlockletMountPointInfo: (name: string) => any;
+export declare const blockletExists: (name: string) => boolean;
+export declare const mergeSx: (initial: SystemStyleObject<Theme>, sx?: SxProps<Theme>) => any[];
+export declare const discussKitMountPoint: string | undefined;
+export declare const discussKitApiBaseUrl: string;
+export declare const discussKitUploadsUrl: string;
+export declare const isInDiscussKitApp: boolean | "" | undefined;
+export declare const openProfile: (did: string, newTab?: boolean) => void;
+export declare const randomId: () => string;
+export declare const getDiscussKitClientId: () => any;
+export declare const getPaymentKitMountPoint: () => string | undefined;

package/dist/components/utils.mjs

@@ -0,0 +1,103 @@
+import { joinURL, withQuery, withTrailingSlash } from "ufo";
+export const repairBase64Avatar = (avatar) => {
+  if (avatar && avatar.startsWith("data:")) {
+    return avatar.replace(/\s/g, encodeURIComponent(" "));
+  }
+  return avatar;
+};
+export const getResizedAvatar = (avatar, size = 72) => {
+  if (!avatar) {
+    return avatar;
+  }
+  if (avatar.indexOf("/.well-known/service") >= 0) {
+    const tmp = new URL(avatar, window.location.origin);
+    tmp.searchParams.set("imageFilter", "resize");
+    tmp.searchParams.set("w", size.toString());
+    tmp.searchParams.set("h", size.toString());
+    tmp.searchParams.set("f", "webp");
+    return tmp.href;
+  }
+  return avatar;
+};
+export const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+export const minDelay = (promise, ms) => {
+  return Promise.all([promise, sleep(ms)]).then(([result]) => result);
+};
+export const protectLogin = (session, action) => {
+  if (session?.user) {
+    return action();
+  }
+  return new Promise((resolve) => {
+    session.login(() => resolve(action()));
+  });
+};
+const copyWithExecCommand = (text) => {
+  const tmp = document.createElement("TEXTAREA");
+  const active = document.activeElement;
+  tmp.style.position = "fixed";
+  tmp.style.opacity = "0";
+  tmp.style.left = "-9999px";
+  tmp.style.top = "0";
+  tmp.value = text;
+  document.body.appendChild(tmp);
+  tmp.select();
+  document.execCommand("copy");
+  document.body.removeChild(tmp);
+  active?.focus();
+};
+export const copy = (text) => {
+  if (navigator?.clipboard) {
+    try {
+      navigator.clipboard.writeText(text).catch(() => {
+        copyWithExecCommand(text);
+      });
+      return;
+    } catch (e) {
+    }
+  }
+  copyWithExecCommand(text);
+};
+export const getLastItem = (arr) => arr?.length ? arr[arr.length - 1] : null;
+export function tryParseJSONObject(str) {
+  try {
+    const parsed = JSON.parse(str);
+    if (parsed && typeof parsed === "object") {
+      return true;
+    }
+  } catch (e) {
+    return false;
+  }
+  return false;
+}
+export const getPreference = (key) => window.blocklet?.preferences?.[key];
+export const getBlockletMountPointInfo = (name) => {
+  return window.blocklet?.componentMountPoints?.find((x) => x.name === name);
+};
+export const blockletExists = (name) => {
+  const info = getBlockletMountPointInfo(name);
+  return info?.status === "running";
+};
+export const mergeSx = (initial, sx) => {
+  const mergedSx = [initial, ...Array.isArray(sx) ? sx : [sx]];
+  return mergedSx;
+};
+export const discussKitMountPoint = getBlockletMountPointInfo("did-comments")?.mountPoint;
+export const discussKitApiBaseUrl = joinURL(window.location.origin, discussKitMountPoint || "", "api");
+export const discussKitUploadsUrl = joinURL(discussKitMountPoint || "", "/uploads");
+export const isInDiscussKitApp = discussKitMountPoint && withTrailingSlash(window.blocklet.prefix) === withTrailingSlash(discussKitMountPoint);
+export const openProfile = (did, newTab) => {
+  if (did) {
+    window.open(withQuery(joinURL(discussKitMountPoint || "/", "profile"), { did }), newTab ? "_blank" : "_self");
+  }
+};
+export const randomId = () => crypto?.randomUUID?.() || Math.random().toString(36).substring(2);
+export const getDiscussKitClientId = () => {
+  if (!window.__discuss_kit_client_id__) {
+    window.__discuss_kit_client_id__ = randomId();
+  }
+  return window.__discuss_kit_client_id__;
+};
+export const getPaymentKitMountPoint = () => {
+  const info = window.blocklet?.componentMountPoints?.find((x) => x.did === "z2qaCNvKMv5GjouKdcDWexv6WqtHbpNPQDnAk");
+  return info?.mountPoint;
+};

package/dist/components/view-more.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+export declare function ViewMore({ children, ...rest }: {
+    children: any;
+} & React.HTMLAttributes<HTMLDivElement>): import("react").JSX.Element;

package/dist/components/view-more.mjs

@@ -0,0 +1,50 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useState } from "react";
+import Box from "@mui/material/Box";
+import { styled } from "@arcblock/ux/lib/Theme";
+import { useLocaleContext } from "@arcblock/ux/lib/Locale/context";
+import useMeasure from "./hooks/measure.mjs";
+const MAX_HEIGHT = 200;
+const Root = styled("div")`
+  &.markdown-viewer-collapsed .markdown-viewer-md-wrapper {
+    position: relative;
+    max-height: ${MAX_HEIGHT}px;
+    overflow: hidden;
+
+    .markdown-viewer-shadow {
+      position: absolute;
+      left: 0;
+      bottom: 0;
+      width: 100%;
+      height: 80px;
+      background-image: ${({ theme }) => `linear-gradient(to bottom, transparent, ${theme.palette.background.paper})`};
+    }
+  }
+`;
+export function ViewMore({ children, ...rest }) {
+  const { t } = useLocaleContext();
+  const [collapsed, setCollapsed] = useState(true);
+  const [ref, { height }] = useMeasure();
+  const _collapsed = collapsed && height > MAX_HEIGHT;
+  return /* @__PURE__ */ jsxs(Root, { ...rest, className: `${rest.className || ""} ${_collapsed ? "markdown-viewer-collapsed" : ""}`, children: [
+    /* @__PURE__ */ jsxs("div", { className: "markdown-viewer-md-wrapper", children: [
+      /* @__PURE__ */ jsx("div", { ref, "data-color-mode": "light", children }),
+      /* @__PURE__ */ jsx("div", { className: "markdown-viewer-shadow" })
+    ] }),
+    _collapsed && /* @__PURE__ */ jsx(
+      Box,
+      {
+        onClick: () => setCollapsed(false),
+        sx: {
+          display: "inline-block",
+          fontSize: 13,
+          fontWeight: "bold",
+          mt: 1,
+          color: "primary.light",
+          "&:hover": { color: "primary.dark", cursor: "pointer" }
+        },
+        children: t("readMore")
+      }
+    )
+  ] });
+}

package/dist/constants.d.ts

@@ -0,0 +1,5 @@
+export declare const AIGNE_RUNTIME_DID = "z2qaBP9SahqU2L2YA3ip7NecwKACMByTFuiJ2";
+export declare const AIGNE_STUDIO_DID = "z8iZpog7mcgcgBZzTiXJCWESvmnRrQmnd3XBB";
+export declare const DISCUSS_KIT_DID = "z8ia1WEiBZ7hxURf6LwH21Wpg99vophFwSJdu";
+export declare const MAX_DISCUSSION_LENGTH: number;
+export declare const MAX_COMMENT_LENGTH: number;

package/dist/constants.mjs

@@ -0,0 +1,14 @@
+export const AIGNE_RUNTIME_DID = "z2qaBP9SahqU2L2YA3ip7NecwKACMByTFuiJ2";
+export const AIGNE_STUDIO_DID = "z8iZpog7mcgcgBZzTiXJCWESvmnRrQmnd3XBB";
+export const DISCUSS_KIT_DID = "z8ia1WEiBZ7hxURf6LwH21Wpg99vophFwSJdu";
+const DEFAULT_MAX_DISCUSSION_LENGTH = 25e3;
+const DEFAULT_MAX_COMMENT_LENGTH = 1e4;
+const MAX_POST_LENGTH = 5e4;
+export const MAX_DISCUSSION_LENGTH = Math.min(
+  Number(window.blocklet.DISCUSS_KIT_MAX_DISCUSSION_LENGTH || DEFAULT_MAX_DISCUSSION_LENGTH),
+  MAX_POST_LENGTH
+);
+export const MAX_COMMENT_LENGTH = Math.min(
+  Number(window.blocklet.DISCUSS_KIT_MAX_COMMENT_LENGTH || DEFAULT_MAX_COMMENT_LENGTH),
+  MAX_POST_LENGTH
+);

package/dist/global.d.ts

@@ -0,0 +1 @@
+/// <reference path="../../../global.d.ts" />

package/dist/index.d.ts

@@ -0,0 +1,29 @@
+export * from './theme';
+export { Input, CommentInput, ScrollableEditorWrapper } from './components/input';
+export * from './components/avatars';
+export * from './components/posts';
+export * from './components/rating';
+export * from './components/empty-status';
+export * from './components/authz';
+export * from './components/confirm';
+export * from './components/api-error-handler';
+export { default as DefaultEditorConfigProvider } from './components/default-editor-config-provider';
+export { default as Pagination } from './components/pagination';
+export * from './components/editor';
+export * as lexicalUtils from './components/lexical';
+export * from './components/dirty-prompt';
+export { translations } from './components/locale';
+export { useNow, useChanged, useSessionContext, useEventCallback } from './components/hooks';
+export * as utils from './components/utils';
+export { default as preferences } from './preferences';
+export * from './components/uploader';
+export * from './components/button-group';
+export * from './components/segmented-control';
+export * from './ws';
+export * from './components/toast';
+export * from './components/arcsphere';
+export { default as RelativeTime } from './components/shared/relative-time';
+export * from './components/profile-card';
+export * from './components/icon-button';
+export * from './blocklets';
+export * from './components/auto-translate';

package/dist/index.mjs

@@ -0,0 +1,29 @@
+export * from "./theme/index.mjs";
+export { Input, CommentInput, ScrollableEditorWrapper } from "./components/input/index.mjs";
+export * from "./components/avatars/index.mjs";
+export * from "./components/posts/index.mjs";
+export * from "./components/rating/index.mjs";
+export * from "./components/empty-status/index.mjs";
+export * from "./components/authz/index.mjs";
+export * from "./components/confirm.mjs";
+export * from "./components/api-error-handler/index.mjs";
+export { default as DefaultEditorConfigProvider } from "./components/default-editor-config-provider.mjs";
+export { default as Pagination } from "./components/pagination.mjs";
+export * from "./components/editor/index.mjs";
+export * as lexicalUtils from "./components/lexical.mjs";
+export * from "./components/dirty-prompt.mjs";
+export { translations } from "./components/locale/index.mjs";
+export { useNow, useChanged, useSessionContext, useEventCallback } from "./components/hooks/index.mjs";
+export * as utils from "./components/utils.mjs";
+export { default as preferences } from "./preferences.mjs";
+export * from "./components/uploader/index.mjs";
+export * from "./components/button-group/index.mjs";
+export * from "./components/segmented-control.mjs";
+export * from "./ws.mjs";
+export * from "./components/toast.mjs";
+export * from "./components/arcsphere/index.mjs";
+export { default as RelativeTime } from "./components/shared/relative-time.mjs";
+export * from "./components/profile-card/index.mjs";
+export * from "./components/icon-button.mjs";
+export * from "./blocklets.mjs";
+export * from "./components/auto-translate/index.mjs";

package/dist/preferences.d.ts

@@ -0,0 +1,2 @@
+declare const preferences: typeof window.blocklet.preferences;
+export default preferences;

package/dist/preferences.mjs

@@ -0,0 +1,9 @@
+const prefs = window.blocklet.preferences;
+const preferences = {
+  ...prefs,
+  // 对 preferences 做一些格式化处理
+  maxPinLimit: parseInt(`${prefs.maxPinLimit}`, 10),
+  maxFeaturedLimit: parseInt(`${prefs.maxFeaturedLimit}`, 10),
+  assignmentAuthorizedPassports: prefs.assignmentAuthorizedPassports?.split(",").map((x) => x.trim())
+};
+export default preferences;

package/dist/theme/index.d.ts

@@ -0,0 +1,8 @@
+import { type ThemeOptions } from '@mui/material/styles';
+import React from 'react';
+import { typography } from './typography';
+export { typography };
+export declare const themeOverrides: Partial<ThemeOptions>;
+export declare function InternalThemeProvider({ children }: {
+    children: React.ReactNode;
+}): JSX.Element;