@blocklet/ui-react 3.2.16 → 3.2.18

package/lib/Dashboard/app-shell/app-badge.d.ts

@@ -0,0 +1,24 @@
+import { AppBadgeDefaultProps } from './badges/app-badge-default';
+import { AppBadgeSwitchProps } from './badges/app-badge-switch';
+import { AppBadgeVersionProps } from './badges/app-badge-version';
+import { AppBadgeStateProps } from './badges/app-badge-state';
+import { AppBadgeDIDProps } from './badges/app-badge-did';
+export declare const formatNumber: (num: unknown, round?: number) => string;
+export declare const formatTime: (value?: string | number | Date, locale?: string) => string;
+export type AppBadgeProps = (AppBadgeDefaultProps & {
+    variant?: 'default';
+}) | (AppBadgeDefaultProps & {
+    variant: 'number';
+}) | (Omit<AppBadgeDefaultProps, 'value'> & {
+    variant: 'time';
+    value?: string | number | Date;
+}) | (AppBadgeSwitchProps & {
+    variant: 'switch';
+}) | (AppBadgeVersionProps & {
+    variant: 'version';
+}) | (AppBadgeStateProps & {
+    variant: 'state';
+}) | (AppBadgeDIDProps & {
+    variant: 'did';
+});
+export default function AppBadge(props: AppBadgeProps): import("react/jsx-runtime").JSX.Element;

package/lib/Dashboard/app-shell/app-badge.js

@@ -0,0 +1,48 @@
+import { jsx as a } from "react/jsx-runtime";
+import f from "dayjs";
+import l from "dayjs/plugin/relativeTime";
+import s from "dayjs/plugin/localizedFormat";
+import "dayjs/locale/zh";
+import "dayjs/locale/zh-tw";
+import "dayjs/locale/ja";
+import { useLocaleContext as c } from "@arcblock/ux/lib/Locale/context";
+import { AppBadgeDefault as m } from "./badges/app-badge-default.js";
+import { AppBadgeSwitch as d } from "./badges/app-badge-switch.js";
+import { AppBadgeVersion as p } from "./badges/app-badge-version.js";
+import { AppBadgeState as u } from "./badges/app-badge-state.js";
+import { AppBadgeDID as v } from "./badges/app-badge-did.js";
+f.extend(l);
+f.extend(s);
+const g = (e, i = 0) => {
+  if (typeof e != "number") return "";
+  const r = Math.abs(e);
+  let t, o = "";
+  return r >= 1e12 ? (o = "T", t = `${(e / 1e12).toFixed(i)}`) : r >= 1e9 ? (o = "B", t = `${(e / 1e9).toFixed(i)}`) : r >= 1e6 ? (o = "M", t = `${(e / 1e6).toFixed(i)}`) : r >= 1e3 ? (o = "K", t = `${(e / 1e3).toFixed(i)}`) : t = e.toString(), i > 0 && (t = t.replace(/(\.\d*?)0+$/, "$1").replace(/\.$/, "")), `${t}${o}`;
+}, x = (e, i = "en") => e ? f(e).locale(i).fromNow() : "", B = {
+  switch: d,
+  version: p,
+  state: u,
+  did: v
+};
+function V(e) {
+  const { locale: i = "en" } = c() || {};
+  if (e.variant === "number") {
+    const { value: r, round: t = 0, ...o } = e, n = g(Number(r), t);
+    return /* @__PURE__ */ a(m, { value: n, ...o });
+  }
+  if (e.variant === "time") {
+    const { value: r, ...t } = e, o = x(r, i);
+    return /* @__PURE__ */ a(m, { value: o, ...t });
+  }
+  if (e.variant) {
+    const r = B[e.variant];
+    if (r)
+      return /* @__PURE__ */ a(r, { ...e });
+  }
+  return /* @__PURE__ */ a(m, { ...e });
+}
+export {
+  V as default,
+  g as formatNumber,
+  x as formatTime
+};

package/lib/Dashboard/app-shell/app-header.d.ts

@@ -0,0 +1,5 @@
+interface AppHeaderProps {
+    onTabChange?: (tab: string) => void;
+}
+declare function AppHeader({ onTabChange }: AppHeaderProps): import("react/jsx-runtime").JSX.Element | null;
+export default AppHeader;

package/lib/Dashboard/app-shell/app-header.js

@@ -0,0 +1,64 @@
+import { jsxs as s, jsx as e, Fragment as f } from "react/jsx-runtime";
+import { isValidElement as g } from "react";
+import { Box as t, Stack as y, Typography as p, useMediaQuery as v } from "@mui/material";
+import M from "@arcblock/ux/lib/Tabs";
+import B from "./app-badge.js";
+import { useAppInfo as I } from "./app-info-context.js";
+function h() {
+  return v((r) => r.breakpoints.down("md"));
+}
+function x({ sx: i = {} }) {
+  const r = h();
+  return /* @__PURE__ */ e(t, { sx: { mx: r ? -2 : -3, borderBottom: "1px solid", borderColor: "divider", mt: 1.5, mb: 1, ...i } });
+}
+function H({ onTabChange: i = void 0 }) {
+  const r = h(), {
+    icon: a = void 0,
+    name: d = "",
+    description: m = void 0,
+    actions: n = void 0,
+    badges: c = [],
+    tabs: l = [],
+    currentTab: u = ""
+  } = I();
+  return d ? /* @__PURE__ */ s(t, { className: "app-header", sx: { mt: 3, mb: 3 }, children: [
+    /* @__PURE__ */ s(
+      t,
+      {
+        sx: {
+          display: "flex",
+          alignItems: "center",
+          gap: 1
+        },
+        children: [
+          a && /* @__PURE__ */ e(t, { sx: { display: "flex", alignItems: "center", justifyContent: "center" }, children: a }),
+          /* @__PURE__ */ s(y, { sx: { flexGrow: 1 }, children: [
+            /* @__PURE__ */ e(p, { variant: "h1", sx: { mb: 0.5 }, children: d }),
+            m && /* @__PURE__ */ e(
+              p,
+              {
+                variant: "body2",
+                color: "text.secondary",
+                sx: { lineHeight: 1.6, "& a": { color: "primary.main" }, maxWidth: 980 },
+                children: m
+              }
+            )
+          ] }),
+          !r && n && /* @__PURE__ */ e(t, { sx: { ml: 1 }, children: n })
+        ]
+      }
+    ),
+    c.length > 0 && /* @__PURE__ */ e(t, { sx: { display: "flex", flexWrap: "wrap", gap: 1, alignItems: "center", mt: 2 }, children: c.map(
+      (o, b) => g(o) ? o : /* @__PURE__ */ e(B, { ...o }, o.label || b)
+    ) }),
+    r && n && /* @__PURE__ */ e(t, { sx: { mt: r ? 2 : 0 }, children: n }),
+    l.length <= 1 && /* @__PURE__ */ e(x, {}),
+    l.length > 1 && /* @__PURE__ */ s(f, { children: [
+      /* @__PURE__ */ e(M, { tabs: l, current: u, onChange: i, scrollButtons: "auto", sx: { mt: 2.5 } }),
+      /* @__PURE__ */ e(x, { sx: { mt: 0 } })
+    ] })
+  ] }) : null;
+}
+export {
+  H as default
+};

package/lib/Dashboard/app-shell/app-info-context.d.ts

@@ -0,0 +1,38 @@
+import { default as React } from 'react';
+import { AppBadgeProps } from './app-badge';
+export type NavItem = {
+    id: string;
+    parent: string;
+    title: string;
+    link: string;
+    description?: string;
+};
+export interface TabConfig {
+    value: string;
+    label?: string;
+    render?: React.ComponentType | React.ReactNode;
+}
+export interface AppInfo {
+    icon?: React.ReactNode;
+    name?: React.ReactNode;
+    description?: React.ReactNode;
+    badges?: Array<AppBadgeProps | React.ReactElement>;
+    actions?: React.ReactNode;
+    tabs?: TabConfig[];
+    currentTab?: string;
+}
+export interface AppInfoContextValue extends AppInfo {
+    currentTab: string;
+    TabComponent: React.ComponentType | React.ReactNode;
+    navItem?: NavItem;
+    updateAppInfo: (patch: Partial<AppInfo>) => void;
+}
+interface AppInfoProviderProps {
+    path?: string;
+    currentTab?: string;
+    meta?: object;
+    children?: React.ReactNode;
+}
+export declare function AppInfoProvider({ path, currentTab, meta, children, }: AppInfoProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function useAppInfo(): AppInfoContextValue;
+export {};

package/lib/Dashboard/app-shell/app-info-context.js

@@ -0,0 +1,69 @@
+import { jsx as x } from "react/jsx-runtime";
+import { createContext as h, useState as L, useMemo as T, useEffect as w, useContext as M } from "react";
+import { useCreation as A, useMemoizedFn as O } from "ahooks";
+import { withoutTrailingSlash as P } from "ufo";
+import W from "lodash/isPlainObject";
+import { WELLKNOWN_BLOCKLET_ADMIN_PATH as j } from "@abtnode/constant";
+import { useLocaleContext as E } from "@arcblock/ux/lib/Locale/context";
+const C = h({
+  currentTab: "",
+  TabComponent: null,
+  navItem: void 0,
+  updateAppInfo: () => {
+  }
+}), u = (s, a, d = "en") => {
+  const o = s?.[a];
+  return W(o) ? o[d] || o.en : o;
+};
+function D({
+  path: s = window?.location?.pathname || "",
+  currentTab: a = "",
+  meta: d = void 0,
+  children: o = null
+}) {
+  const { locale: i = "en" } = E() || {}, I = P(s), f = I.startsWith(j), b = A(() => Object.assign({}, window.blocklet, d), [d]), r = A(() => {
+    const n = b.navigation?.filter(
+      (e) => Array.isArray(e.section) ? e.section.includes("dashboard") : e.section === "dashboard"
+    ), t = n?.flatMap((e) => e.items || [])?.find((e) => (u(e, "link", i) || "").startsWith(I));
+    if (!t)
+      return;
+    const l = n.find((e) => e.id === t.parent);
+    let p = u(t, "title", i) || "";
+    return f || (p = `${u(l, "title", i) || ""} - ${p}`), {
+      id: t.id,
+      parent: t.parent,
+      title: p,
+      link: u(t, "link", i) || "",
+      description: u(t, "description", i) || ""
+    };
+  }, [s, f, i, b]), [v, g] = L({}), m = O((n) => {
+    g((c) => ({ ...c, ...n }));
+  }), k = T(
+    () => {
+      const { tabs: n = [] } = v, c = n.find((p) => p.value === a);
+      let t = a, l = null;
+      return !c && n.length > 0 ? (t = n[0].value, l = n[0].render || null) : l = c?.render || null, {
+        ...v,
+        navItem: r,
+        currentTab: t,
+        TabComponent: l,
+        updateAppInfo: m
+      };
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [v, r, a, m]
+  );
+  return w(() => {
+    f || m({
+      name: r?.title || "",
+      description: r?.description || ""
+    });
+  }, [r?.title, r?.description, f, m]), /* @__PURE__ */ x(C.Provider, { value: k, children: o });
+}
+function F() {
+  return M(C);
+}
+export {
+  D as AppInfoProvider,
+  F as useAppInfo
+};

package/lib/Dashboard/app-shell/badges/app-badge-default.d.ts

@@ -0,0 +1,20 @@
+import { TBox } from '@arcblock/ux/lib/MuiWrap';
+import { BoxProps } from '@mui/material/Box';
+export declare const isExternal: (to?: string) => boolean;
+export declare const isSameOrigin: (to: string) => boolean;
+export declare const StateIcon: import('@emotion/styled').StyledComponent<import('@mui/system').MUIStyledCommonProps<import('@mui/material').Theme> & {
+    color: string;
+}, import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, {}>;
+export declare const StyledBadge: typeof TBox;
+export interface BadgeContainerProps extends Omit<BoxProps, 'to'> {
+    loading?: boolean;
+    to?: string;
+}
+export declare function BadgeContainer({ loading, children, to, ...rest }: BadgeContainerProps): import("react/jsx-runtime").JSX.Element;
+export interface AppBadgeDefaultProps extends BadgeContainerProps {
+    icon?: string;
+    label?: string;
+    value?: string | number;
+    round?: number;
+}
+export declare function AppBadgeDefault({ icon, label, value, loading, ...rest }: AppBadgeDefaultProps): import("react/jsx-runtime").JSX.Element;

package/lib/Dashboard/app-shell/badges/app-badge-default.js

@@ -0,0 +1,84 @@
+import { jsxs as p, jsx as i } from "react/jsx-runtime";
+import { styled as l, Box as g, Typography as s, Skeleton as c } from "@mui/material";
+import { Icon as f } from "@iconify/react";
+import { Link as u } from "react-router-dom";
+const b = (a = "") => a.startsWith("http:") || a.startsWith("https:"), y = (a) => {
+  try {
+    return new URL(a).origin === window.location.origin;
+  } catch {
+    return !1;
+  }
+}, S = l("span")(({ theme: a, color: n }) => ({
+  position: "relative",
+  display: "inline-block",
+  width: a.spacing(1),
+  height: a.spacing(1),
+  borderRadius: "50%",
+  backgroundColor: n,
+  marginRight: a.spacing(1)
+})), o = l(g)(({ theme: a }) => ({
+  position: "relative",
+  display: "inline-flex",
+  alignItems: "center",
+  height: a.spacing(3),
+  paddingLeft: a.spacing(1.5),
+  paddingRight: a.spacing(1.5),
+  border: "1px solid",
+  borderColor: a.palette.divider,
+  borderRadius: a.shape.borderRadius * 0.5,
+  fontSize: 12,
+  overflow: "hidden",
+  "& .app-badge-label": {
+    display: "inline-flex",
+    gap: a.spacing(1),
+    alignItems: "center",
+    lineHeight: a.spacing(3),
+    marginLeft: a.spacing(-1.5),
+    paddingLeft: a.spacing(1.5),
+    marginRight: a.spacing(1),
+    fontSize: 12,
+    backgroundColor: a.palette.grey[100],
+    color: a.palette.text.secondary,
+    "&::after": {
+      content: '""',
+      height: a.spacing(3),
+      borderRight: "1px solid",
+      borderColor: a.palette.divider,
+      backgroundColor: a.palette.grey[100]
+    }
+  },
+  "& .app-badge-value": {
+    color: a.palette.text.primary,
+    fontSize: 12
+  }
+}));
+function x({ loading: a = !1, children: n = null, to: r = "", ...e }) {
+  const t = /* @__PURE__ */ i(o, { className: "app-badge", component: r ? "a" : "div", href: r, ...e, children: n });
+  if (a)
+    return /* @__PURE__ */ i(c, { variant: "rounded", children: t });
+  if (r) {
+    if (b(r)) {
+      const d = y(r) ? "_self" : "_blank";
+      return /* @__PURE__ */ i(o, { className: "app-badge", component: "a", href: r, target: d, rel: "noreferrer noopener", ...e, children: n });
+    }
+    return /* @__PURE__ */ i(o, { className: "app-badge", component: u, to: r, ...e, children: n });
+  }
+  return /* @__PURE__ */ i(o, { className: "app-badge", component: "div", ...e, children: n });
+}
+function h({ icon: a = "", label: n = "", value: r = "", loading: e = !1, ...t }) {
+  return /* @__PURE__ */ p(x, { loading: e, ...t, children: [
+    n && /* @__PURE__ */ p(s, { className: "app-badge-label", children: [
+      a && /* @__PURE__ */ i(f, { icon: a }),
+      n
+    ] }),
+    /* @__PURE__ */ i(s, { className: "app-badge-value", children: r })
+  ] });
+}
+export {
+  h as AppBadgeDefault,
+  x as BadgeContainer,
+  S as StateIcon,
+  o as StyledBadge,
+  b as isExternal,
+  y as isSameOrigin
+};

package/lib/Dashboard/app-shell/badges/app-badge-did.d.ts

@@ -0,0 +1,5 @@
+import { AppBadgeDefaultProps } from './app-badge-default';
+export interface AppBadgeDIDProps extends Omit<AppBadgeDefaultProps, 'value'> {
+    value?: string;
+}
+export declare function AppBadgeDID({ value, loading, ...rest }: AppBadgeDIDProps): import("react/jsx-runtime").JSX.Element;

package/lib/Dashboard/app-shell/badges/app-badge-did.js

@@ -0,0 +1,16 @@
+import { jsxs as a, jsx as e } from "react/jsx-runtime";
+import { useCreation as p } from "ahooks";
+import { Typography as i } from "@mui/material";
+import { isEthereumDid as m } from "@arcblock/ux/lib/Util";
+import n from "@arcblock/ux/lib/Address";
+import { BadgeContainer as d } from "./app-badge-default.js";
+function b({ value: r = "", loading: o = !1, ...s }) {
+  const t = p(() => `DID:${m(r) ? "ETH" : "ABT"}`, [r]);
+  return /* @__PURE__ */ a(d, { loading: o, ...s, children: [
+    /* @__PURE__ */ e(i, { className: "app-badge-label", children: t }),
+    /* @__PURE__ */ e(i, { className: "app-badge-value", children: /* @__PURE__ */ e(n, { inline: !0, size: 14, compact: !0, responsive: !1, children: r }) })
+  ] });
+}
+export {
+  b as AppBadgeDID
+};

package/lib/Dashboard/app-shell/badges/app-badge-state.d.ts

@@ -0,0 +1,6 @@
+import { AppBadgeDefaultProps } from './app-badge-default';
+import { BadgeColor } from './app-badge-version';
+export interface AppBadgeStateProps extends AppBadgeDefaultProps {
+    color?: BadgeColor;
+}
+export declare function AppBadgeState({ value, color, loading, ...rest }: AppBadgeStateProps): import("react/jsx-runtime").JSX.Element;

package/lib/Dashboard/app-shell/badges/app-badge-state.js

@@ -0,0 +1,34 @@
+import { jsxs as l, jsx as a } from "react/jsx-runtime";
+import { styled as c, useTheme as g, alpha as d, Typography as m } from "@mui/material";
+import { BadgeContainer as h } from "./app-badge-default.js";
+import { getTextColor as i, getBgColor as u } from "./app-badge-version.js";
+const b = c("span")(({ theme: o, color: r }) => ({
+  position: "relative",
+  display: "inline-block",
+  width: o.spacing(1),
+  height: o.spacing(1),
+  borderRadius: "50%",
+  backgroundColor: r,
+  marginRight: o.spacing(1)
+}));
+function B({ value: o = "", color: r = "primary", loading: n = !1, ...s }) {
+  const t = g(), e = i(t, r), p = u(t, r);
+  return /* @__PURE__ */ l(
+    h,
+    {
+      loading: n,
+      sx: {
+        borderColor: d(e, 0.2),
+        bgcolor: p
+      },
+      ...s,
+      children: [
+        /* @__PURE__ */ a(b, { color: i(t, r) }),
+        /* @__PURE__ */ a(m, { className: "app-badge-value", style: { color: e }, children: o })
+      ]
+    }
+  );
+}
+export {
+  B as AppBadgeState
+};

package/lib/Dashboard/app-shell/badges/app-badge-switch.d.ts

@@ -0,0 +1,8 @@
+import { AppBadgeDefaultProps } from './app-badge-default';
+export interface AppBadgeSwitchProps extends Omit<AppBadgeDefaultProps, 'value' | 'onChange'> {
+    value?: unknown;
+    trueValue?: unknown;
+    falseValue?: unknown;
+    onChange?: (checked: boolean) => void;
+}
+export declare function AppBadgeSwitch({ label, value, trueValue, falseValue, loading, onChange, ...rest }: AppBadgeSwitchProps): import("react/jsx-runtime").JSX.Element;

package/lib/Dashboard/app-shell/badges/app-badge-switch.js

@@ -0,0 +1,66 @@
+import { jsxs as l, jsx as i } from "react/jsx-runtime";
+import { useTheme as m, Typography as g, Box as h } from "@mui/material";
+import { useMemoizedFn as f } from "ahooks";
+import { BadgeContainer as u } from "./app-badge-default.js";
+function C({
+  label: n = "",
+  value: r = void 0,
+  trueValue: s = !0,
+  falseValue: t = !1,
+  loading: a = !1,
+  onChange: c = void 0,
+  ...d
+}) {
+  const e = m();
+  let o = !1;
+  const p = f(() => c?.(!o));
+  return r === s ? o = !0 : r === t ? o = !1 : o = !!r, /* @__PURE__ */ l(
+    u,
+    {
+      loading: a,
+      sx: {
+        cursor: "pointer",
+        backgroundColor: o ? "primary.main" : "grey.100",
+        borderColor: o ? "primary.main" : "divider",
+        transition: "background-color 0.3s ease"
+      },
+      onClick: p,
+      ...d,
+      children: [
+        /* @__PURE__ */ i(
+          g,
+          {
+            sx: {
+              fontWeight: 400,
+              paddingLeft: o ? 0 : e.spacing(2.5),
+              paddingRight: o ? e.spacing(2.5) : 0,
+              color: o ? "common.white" : "text.secondary",
+              transition: "color 0.3s ease"
+            },
+            children: n
+          }
+        ),
+        /* @__PURE__ */ i(
+          h,
+          {
+            sx: {
+              width: e.spacing(2.5),
+              height: e.spacing(2.5),
+              borderRadius: `${e.shape.borderRadius * 0.5}px`,
+              backgroundColor: "common.white",
+              position: "absolute",
+              top: "50%",
+              left: o ? `calc(100% - ${e.spacing(3)})` : e.spacing(0.5),
+              transform: "translateY(-50%)",
+              transition: "left 0.3s ease",
+              boxShadow: 1
+            }
+          }
+        )
+      ]
+    }
+  );
+}
+export {
+  C as AppBadgeSwitch
+};

package/lib/Dashboard/app-shell/badges/app-badge-version.d.ts

@@ -0,0 +1,14 @@
+import { LiteralUnion } from 'type-fest';
+import { Theme } from '@mui/material';
+import { AppBadgeDefaultProps } from './app-badge-default';
+export type ColorKey = 'primary' | 'info' | 'success' | 'error' | 'warning';
+export type BadgeColor = LiteralUnion<ColorKey, string>;
+export declare const colorMap: Record<ColorKey, (theme: Theme) => {
+    main: string;
+}>;
+export declare const getBgColor: (theme: Theme, color: BadgeColor) => string;
+export declare const getTextColor: (theme: Theme, color: BadgeColor) => string;
+export interface AppBadgeVersionProps extends AppBadgeDefaultProps {
+    color?: string | ColorKey;
+}
+export declare function AppBadgeVersion({ icon, value, color, loading, ...rest }: AppBadgeVersionProps): import("react/jsx-runtime").JSX.Element;

package/lib/Dashboard/app-shell/badges/app-badge-version.js

@@ -0,0 +1,50 @@
+import { jsxs as s, jsx as m } from "react/jsx-runtime";
+import { useTheme as g, alpha as n, Typography as f } from "@mui/material";
+import { Icon as u } from "@iconify/react";
+import { BadgeContainer as d } from "./app-badge-default.js";
+const o = {
+  primary: (e) => e.palette.primary,
+  info: (e) => e.palette.info,
+  success: (e) => e.palette.success,
+  error: (e) => e.palette.error,
+  warning: (e) => e.palette.warning
+}, h = (e, r) => {
+  if (o[r]) {
+    const t = o[r](e).main;
+    return n(t, 0.1);
+  }
+  return n(r, 0.1);
+}, x = (e, r) => o[r] ? o[r](e).main : r;
+function T({
+  icon: e = "",
+  value: r = "",
+  color: t = "info",
+  loading: p = !1,
+  ...c
+}) {
+  const a = g(), i = x(a, t), l = h(a, t);
+  return /* @__PURE__ */ s(
+    d,
+    {
+      loading: p,
+      sx: {
+        borderColor: n(i, 0.2),
+        bgcolor: l
+      },
+      ...c,
+      children: [
+        /* @__PURE__ */ m(u, { icon: e || "lucide:orbit", style: { marginRight: 6 } }),
+        /* @__PURE__ */ s(f, { className: "app-badge-value", style: { color: i }, children: [
+          "v ",
+          r
+        ] })
+      ]
+    }
+  );
+}
+export {
+  T as AppBadgeVersion,
+  o as colorMap,
+  h as getBgColor,
+  x as getTextColor
+};

package/lib/Dashboard/app-shell/index.d.ts

@@ -0,0 +1,4 @@
+import { default as AppHeader } from './app-header';
+import { default as AppBadge } from './app-badge';
+import { AppInfoProvider, useAppInfo } from './app-info-context';
+export { AppHeader, AppBadge, AppInfoProvider, useAppInfo };

package/lib/Dashboard/app-shell/index.js

@@ -0,0 +1,9 @@
+import { default as o } from "./app-header.js";
+import { default as f } from "./app-badge.js";
+import { AppInfoProvider as d, useAppInfo as t } from "./app-info-context.js";
+export {
+  f as AppBadge,
+  o as AppHeader,
+  d as AppInfoProvider,
+  t as useAppInfo
+};

package/lib/Dashboard/index.d.ts

@@ -1,10 +1,11 @@
+import { AppHeader, AppBadge, AppInfoProvider, useAppInfo } from './app-shell';
 import { BlockletMetaProps, SessionManagerProps } from '../types';
 import { default as PropTypes } from 'prop-types';
 export default Dashboard;
 /**
  * 专门用于 (composable) blocklet 的 Dashboard 组件, 解析 blocklet meta 中 section 为 dashboard 的 navigation 数据, 渲染一个 UX Dashboard
  */
-declare function Dashboard({ meta, fallbackUrl, invalidPathFallback, headerAddons, sessionManagerProps, links, showDomainWarningDialog, ...rest }: {
+declare function Dashboard({ meta, fallbackUrl, invalidPathFallback, headerAddons, sessionManagerProps, links, showDomainWarningDialog, appPath, appTab, onAppTabChange, children, ...rest }: {
     [x: string]: any;
     meta?: {} | undefined;
     fallbackUrl?: any;
@@ -16,6 +17,10 @@ declare function Dashboard({ meta, fallbackUrl, invalidPathFallback, headerAddon
     } | undefined;
     links?: never[] | undefined;
     showDomainWarningDialog?: boolean | undefined;
+    appPath?: undefined;
+    appTab?: undefined;
+    onAppTabChange?: undefined;
+    children?: undefined;
 }): import("react/jsx-runtime").JSX.Element | null;
 declare namespace Dashboard {
     namespace propTypes {
@@ -26,5 +31,10 @@ declare namespace Dashboard {
         export { SessionManagerProps as sessionManagerProps };
         export let links: PropTypes.Requireable<NonNullable<any[] | ((...args: any[]) => any) | null | undefined>>;
         export let showDomainWarningDialog: PropTypes.Requireable<boolean>;
+        export let appPath: PropTypes.Requireable<string>;
+        export let appTab: PropTypes.Requireable<string>;
+        export let onAppTabChange: PropTypes.Requireable<(...args: any[]) => any>;
+        export let children: PropTypes.Requireable<PropTypes.ReactNodeLike>;
     }
 }
+export { AppHeader, AppBadge, AppInfoProvider, useAppInfo };