@blocklet/ui-react 3.0.7 → 3.0.9

package/lib/@types/index.d.ts

@@ -1,3 +1,204 @@
-declare var o: any;
-declare var r: any;
-export { o as DurationEnum, r as StatusEnum };
+import { Axios } from 'axios';
+import { UserPublicInfo } from '@blocklet/js-sdk';
+import { OAUTH_PROVIDER } from '@arcblock/ux/lib/Util/constant';
+import { CloseConnect, OpenConnect } from '@arcblock/did-connect/lib/types';
+export type SessionContext = {
+    session: Session;
+    api: Axios;
+    connectApi: {
+        open: OpenConnect;
+        close: CloseConnect;
+    };
+};
+export type OAuthAccount = {
+    provider: keyof typeof OAUTH_PROVIDER;
+    id: string;
+    did: string;
+    pk: string;
+    lastLoginAt: string;
+    firstLoginAt: string;
+    order?: number;
+    userInfo?: {
+        email: string;
+        emailVerified: boolean;
+        name: string;
+        picture: string;
+        sub: string;
+        extraData: Object;
+    };
+};
+export type WalletAccount = {
+    provider: 'wallet';
+    did: string;
+    pk: string;
+    lastLoginAt: string;
+    firstLoginAt: string;
+};
+export type NFTAccount = {
+    provider: 'nft';
+    did: string;
+    pk: string;
+    owner: string;
+    lastLoginAt: string;
+    firstLoginAt: string;
+};
+export type ConnectedAccount = OAuthAccount | WalletAccount | NFTAccount;
+export type UserMetadataLink = {
+    url: string;
+    favicon?: string;
+};
+export declare enum DurationEnum {
+    NoClear = "no_clear",
+    ThirtyMinutes = "30_minutes",
+    OneHour = "1_hour",
+    FourHours = "4_hours",
+    Today = "today",
+    ThisWeek = "this_week",
+    Custom = "custom"
+}
+export declare enum StatusEnum {
+    Meeting = "meeting",
+    Community = "community",
+    Holiday = "holiday",
+    OffSick = "off_sick",
+    WorkingRemotely = "working_remotely"
+}
+export type UserPhoneProps = {
+    country: string;
+    phoneNumber?: string;
+};
+export type UserMetadata = {
+    bio?: string;
+    location?: string;
+    timezone?: string;
+    joinedAt?: string;
+    status?: {
+        value: string;
+        duration?: DurationEnum;
+        dateRange?: Date[];
+    };
+    links?: UserMetadataLink[];
+    cover?: string;
+    email?: string;
+    phone?: UserPhoneProps;
+};
+export type UserAddress = {
+    country?: string;
+    province?: string;
+    city?: string;
+    line1?: string;
+    line2?: string;
+    postalCode?: string;
+};
+export type User = UserPublicInfo & {
+    role: string;
+    email?: string;
+    phone?: string;
+    sourceProvider?: string;
+    sourceAppPid?: string;
+    lastLoginAt?: string;
+    lastLoginIp?: string;
+    createdAt?: string;
+    passports?: any[];
+    didSpace?: Record<string, any>;
+    connectedAccounts?: any[];
+    locale?: string;
+    url: string;
+    inviter?: string;
+    emailVerified?: boolean;
+    phoneVerified?: boolean;
+    metadata?: UserMetadata;
+    address?: UserAddress;
+};
+export type UserCenterTab = {
+    value: string;
+    label: string;
+    url: string;
+    protected: boolean;
+    icon?: string;
+    isPrivate?: boolean;
+};
+export type Session = {
+    loading: boolean;
+    initialized: boolean;
+    user?: User;
+    login: any;
+    logout: any;
+    switch: any;
+    switchDid: any;
+    refreshProfile: () => Promise<void>;
+    switchProfile: any;
+    switchPassport: any;
+    refresh: Function;
+    useOAuth: Function;
+    usePasskey: Function;
+};
+export type WebhookType = 'slack' | 'api';
+export type WebhookItemData = {
+    type: WebhookType;
+    url: string;
+};
+export type WebhookItemProps = {
+    onTest: (params: WebhookItemData) => void;
+    onSave: (params: WebhookItemData) => void;
+    onDelete?: (params: WebhookItemData) => void;
+    onCancel?: () => void;
+    edit: boolean;
+    type?: WebhookType;
+    url?: string;
+};
+export type CreatePassportProps = {
+    issuer: string;
+    title: string;
+    issuerDid: string;
+    issuerAvatarUrl: string;
+    ownerDid: string;
+    ownerName?: string;
+    ownerAvatarUrl: string;
+    preferredColor?: string;
+    revoked?: boolean;
+    isDataUrl?: boolean;
+    width?: string;
+    height?: string;
+    scope?: string;
+    role?: string;
+    display?: {
+        type: string;
+        content: string;
+    };
+};
+export type BlockletMetaProps = {
+    appLogo?: React.ReactNode;
+    appName?: string;
+    theme?: {
+        background?: string;
+    };
+    enableConnect?: boolean;
+    enableLocale?: boolean;
+    navigation?: Array<{
+        title?: string | object;
+        link?: string | object;
+        icon?: string;
+        items?: Array<{
+            title?: string | object;
+            link?: string | object;
+        }>;
+    }>;
+};
+export type SessionManagerProps = {
+    showText?: boolean;
+    showRole?: boolean;
+    switchDid?: boolean;
+    switchProfile?: boolean;
+    switchPassport?: boolean;
+    disableLogout?: boolean;
+    onLogin?: () => void;
+    onLogout?: () => void;
+    onSwitchDid?: () => void;
+    onSwitchProfile?: () => void;
+    onSwitchPassport?: () => void;
+    menu?: any[];
+    menuRender?: () => void;
+    dark?: boolean;
+    size?: number;
+};

package/lib/BlockletStudio/index.d.ts

@@ -1,26 +1,27 @@
-export { z as default };
-declare function z({ open: d, setOpen: s, onOpened: i, componentDid: e, tenantScope: r, resourcesParams: h, mode: w, title: E, logo: v, description: R, introduction: L, note: y, componentsTitle: D, resourcesTitle: S, onUploaded: b, onReleased: j, onConnected: x, components: B, resources: P, style: U, zIndex: _, dependentComponentsMode: k, ...C }: {
-    [x: string]: any;
-    open: any;
-    setOpen: any;
-    onOpened?: undefined;
-    componentDid: any;
-    tenantScope?: undefined;
-    resourcesParams?: {} | undefined;
-    mode?: string | undefined;
-    title?: undefined;
-    logo?: undefined;
-    description?: undefined;
-    introduction?: undefined;
-    note?: undefined;
-    componentsTitle?: undefined;
-    resourcesTitle?: undefined;
-    onUploaded?: undefined;
-    onReleased?: undefined;
-    onConnected?: undefined;
-    components?: any[] | undefined;
-    resources?: {} | undefined;
-    style?: {} | undefined;
-    zIndex?: number | undefined;
-    dependentComponentsMode?: undefined;
-}): import('react').ReactElement<unknown, string | import('react').JSXElementConstructor<any>> | null;
+interface BlockletStudioProps {
+    open: boolean;
+    setOpen: (open: boolean) => void;
+    onOpened?: () => void;
+    componentDid: string;
+    tenantScope?: string;
+    resourcesParams?: Record<string, any>;
+    mode?: string;
+    title?: string;
+    logo?: string;
+    description?: string;
+    introduction?: string;
+    note?: string;
+    onUploaded?: (data: unknown) => void;
+    onReleased?: (data: unknown) => void;
+    onConnected?: (data: unknown) => void;
+    components?: Record<string, unknown>[];
+    resources?: Record<string, unknown>;
+    componentsTitle?: string;
+    resourcesTitle?: string;
+    style?: React.CSSProperties;
+    zIndex?: number;
+    dependentComponentsMode?: 'auto' | 'readonly';
+    [key: string]: any;
+}
+declare function BlockletStudio({ open, setOpen, onOpened, componentDid, tenantScope, resourcesParams, mode, title, logo, description, introduction, note, componentsTitle, resourcesTitle, onUploaded, onReleased, onConnected, components, resources, style, zIndex, dependentComponentsMode, ...rest }: BlockletStudioProps): import("react/jsx-runtime").JSX.Element | null;
+export default BlockletStudio;

package/lib/ComponentInstaller/index.d.ts

@@ -1,18 +1,18 @@
-import { default as t } from 'prop-types';
-export { G as default };
-declare function G(l: any): any;
-declare namespace G {
+import { default as PropTypes } from 'prop-types';
+declare function WrapComponentInstaller(props: any): any;
+declare namespace WrapComponentInstaller {
     namespace propTypes {
-        let children: t.Validator<any>;
-        let disabled: t.Requireable<boolean>;
-        let warnIcon: t.Requireable<t.ReactNodeLike>;
-        let did: t.Validator<NonNullable<NonNullable<string | (string | null | undefined)[] | null | undefined>>>;
-        let noPermissionMute: t.Requireable<boolean>;
-        let onInstalled: t.Requireable<(...args: any[]) => any>;
-        let onError: t.Requireable<(...args: any[]) => any>;
-        let closeByOutSize: t.Requireable<boolean>;
-        let onClose: t.Requireable<(...args: any[]) => any>;
-        let fallback: t.Requireable<t.ReactNodeLike>;
-        let roles: t.Requireable<any[]>;
+        let children: PropTypes.Validator<any>;
+        let disabled: PropTypes.Requireable<boolean>;
+        let warnIcon: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        let did: PropTypes.Validator<NonNullable<NonNullable<string | (string | null | undefined)[] | null | undefined>>>;
+        let noPermissionMute: PropTypes.Requireable<boolean>;
+        let onInstalled: PropTypes.Requireable<(...args: any[]) => any>;
+        let onError: PropTypes.Requireable<(...args: any[]) => any>;
+        let closeByOutSize: PropTypes.Requireable<boolean>;
+        let onClose: PropTypes.Requireable<(...args: any[]) => any>;
+        let fallback: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        let roles: PropTypes.Requireable<any[]>;
     }
 }
+export default WrapComponentInstaller;

package/lib/ComponentInstaller/installer-item.d.ts

@@ -1,18 +1,18 @@
-import { default as s } from 'prop-types';
-export { I as default };
-declare function I({ optionalComponent: e, index: h, installStatus: l, hasPermission: f, t: c }: {
+import { default as PropTypes } from 'prop-types';
+declare function InstallerItem({ optionalComponent, index, installStatus, hasPermission, t }: {
     optionalComponent: any;
     index: any;
     installStatus?: string | undefined;
     hasPermission: any;
     t: any;
-}): import('react').ReactElement<unknown, string | import('react').JSXElementConstructor<any>>;
-declare namespace I {
+}): import("react/jsx-runtime").JSX.Element;
+declare namespace InstallerItem {
     namespace propTypes {
-        let t: s.Validator<(...args: any[]) => any>;
-        let optionalComponent: s.Validator<object>;
-        let index: s.Validator<number>;
-        let installStatus: s.Requireable<string>;
-        let hasPermission: s.Validator<boolean>;
+        let t: PropTypes.Validator<(...args: any[]) => any>;
+        let optionalComponent: PropTypes.Validator<object>;
+        let index: PropTypes.Validator<number>;
+        let installStatus: PropTypes.Requireable<string>;
+        let hasPermission: PropTypes.Validator<boolean>;
     }
 }
+export default InstallerItem;

package/lib/ComponentInstaller/locales.d.ts

@@ -1,5 +1,5 @@
-export { e as default };
-declare namespace e {
+export default translations;
+declare namespace translations {
     namespace zh {
         let componentInstallerTitle: string;
         let componentInstallerInstall: string;

package/lib/ComponentInstaller/use-component-installed.d.ts

@@ -1,5 +1,5 @@
-export { B as default };
-declare function B({ did: e, onInstalled: f, onError: p }: {
+export default useComponentInstalled;
+declare function useComponentInstalled({ did, onInstalled, onError }: {
     did: any;
     onInstalled: any;
     onError: any;

package/lib/ComponentManager/components/add-component.d.ts

@@ -1,13 +1,16 @@
-export { $ as default };
-declare function $({ componentDid: a, resourceType: w, resourceDid: p, grantedRoles: L, autoClose: R, selectedMeta: D, storeUrl: E, onComplete: n, onClose: t, render: d }: {
-    componentDid: any;
-    resourceType?: undefined;
-    resourceDid?: undefined;
-    grantedRoles?: string[] | undefined;
-    autoClose?: boolean | undefined;
-    selectedMeta?: undefined;
-    storeUrl?: undefined;
-    onComplete: any;
-    onClose: any;
-    render?: undefined;
-}): import('react').ReactElement<unknown, string | import('react').JSXElementConstructor<any>>;
+import { ReactElement } from 'react';
+export default function AddComponent({ componentDid, resourceType, resourceDid, grantedRoles, autoClose, selectedMeta, storeUrl, onComplete, onClose, render, }: {
+    componentDid: string;
+    resourceType?: string;
+    resourceDid?: string;
+    autoClose?: boolean;
+    selectedMeta?: any;
+    storeUrl?: string;
+    grantedRoles?: string[];
+    onComplete: () => void;
+    onClose: () => void;
+    render?: ({ onClick, loading }: {
+        onClick: () => void;
+        loading: boolean;
+    }) => ReactElement<any>;
+}): import("react/jsx-runtime").JSX.Element;

package/lib/ComponentManager/components/check-component.d.ts

@@ -1,2 +1,2 @@
-import { default as r } from '../../ComponentInstaller/index.js';
-export { r as default };
+import { default as CheckComponent } from '../../ComponentInstaller';
+export default CheckComponent;

package/lib/ComponentManager/components/publish-component.d.ts

@@ -1,7 +1,10 @@
-export { H as default };
-declare function H({ componentDid: s, grantedRoles: i, onClose: n, render: a }: {
-    componentDid: any;
-    grantedRoles?: undefined;
-    onClose: any;
-    render?: undefined;
-}): import('react').ReactElement<unknown, string | import('react').JSXElementConstructor<any>>;
+import { ReactElement } from 'react';
+export default function PublishComponent({ componentDid, grantedRoles, onClose, render, }: {
+    componentDid: string;
+    grantedRoles?: string[];
+    onClose: () => void;
+    render?: ({ onClick, loading }: {
+        onClick: () => void;
+        loading: boolean;
+    }) => ReactElement<any>;
+}): import("react/jsx-runtime").JSX.Element;

package/lib/ComponentManager/components/resource-dialog.d.ts

@@ -1,11 +1,13 @@
-export { I as default };
-declare const I: import('react').ForwardRefExoticComponent<{
-    src: any;
-    open?: boolean | undefined;
-    componentDid: any;
-    loading?: boolean | undefined;
-    storeUrl?: string | undefined;
-    onClose?: (() => void) | undefined;
-    onComplete?: (() => void) | undefined;
-    onLoad?: (() => void) | undefined;
-} & import('react').RefAttributes<any>>;
+declare const _default: import('react').ForwardRefExoticComponent<{
+    src: string;
+    componentDid: string;
+    open?: boolean;
+    loading?: boolean;
+    storeUrl?: string;
+    onLoad?: () => void;
+    onClose?: () => void;
+    onComplete?: () => void;
+} & import('react').RefAttributes<{
+    selectBlocklet: (blockletMeta: any) => void;
+}>>;
+export default _default;

package/lib/ComponentManager/index.d.ts

@@ -1,4 +1,3 @@
-import { default as f } from './components/add-component.js';
-import { default as n } from '../ComponentInstaller/index.js';
-import { default as t } from './components/publish-component.js';
-export { f as AddComponent, n as CheckComponent, t as PublishComponent };
+export { default as PublishComponent } from './components/publish-component';
+export { default as AddComponent } from './components/add-component';
+export { default as CheckComponent } from './components/check-component';

package/lib/ComponentManager/libs/locales.d.ts

@@ -1,19 +1,14 @@
-export { o as translations };
-declare namespace o {
-    namespace zh {
-        let importResource: string;
-        let exportResource: string;
-        let noPermission: string;
-        let needLogin: string;
-    }
-    namespace en {
-        let importResource_1: string;
-        export { importResource_1 as importResource };
-        let exportResource_1: string;
-        export { exportResource_1 as exportResource };
-        let noPermission_1: string;
-        export { noPermission_1 as noPermission };
-        let needLogin_1: string;
-        export { needLogin_1 as needLogin };
-    }
-}
+export declare const translations: {
+    zh: {
+        importResource: string;
+        exportResource: string;
+        noPermission: string;
+        needLogin: string;
+    };
+    en: {
+        importResource: string;
+        exportResource: string;
+        noPermission: string;
+        needLogin: string;
+    };
+};

package/lib/Dashboard/index.d.ts

@@ -1,7 +1,10 @@
-import { BlockletMetaProps as S, SessionManagerProps as H } from '../types.js';
-import { default as t } from 'prop-types';
-export { K as default };
-declare function K({ meta: l, fallbackUrl: c, invalidPathFallback: d, headerAddons: k, sessionManagerProps: W, links: f, showDomainWarningDialog: I, ...g }: {
+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 }: {
     [x: string]: any;
     meta?: {} | undefined;
     fallbackUrl?: any;
@@ -13,15 +16,15 @@ declare function K({ meta: l, fallbackUrl: c, invalidPathFallback: d, headerAddo
     } | undefined;
     links?: any[] | undefined;
     showDomainWarningDialog?: boolean | undefined;
-}): import('react').ReactElement<unknown, string | import('react').JSXElementConstructor<any>> | null;
-declare namespace K {
+}): import("react/jsx-runtime").JSX.Element | null;
+declare namespace Dashboard {
     namespace propTypes {
-        export { S as meta };
-        export let fallbackUrl: t.Requireable<string>;
-        export let invalidPathFallback: t.Requireable<(...args: any[]) => any>;
-        export let headerAddons: t.Requireable<NonNullable<((...args: any[]) => any) | t.ReactNodeLike>>;
-        export { H as sessionManagerProps };
-        export let links: t.Requireable<NonNullable<any[] | ((...args: any[]) => any) | null | undefined>>;
-        export let showDomainWarningDialog: t.Requireable<boolean>;
+        export { BlockletMetaProps as meta };
+        export let fallbackUrl: PropTypes.Requireable<string>;
+        export let invalidPathFallback: PropTypes.Requireable<(...args: any[]) => any>;
+        export let headerAddons: PropTypes.Requireable<NonNullable<PropTypes.ReactNodeLike | ((...args: any[]) => any)>>;
+        export { SessionManagerProps as sessionManagerProps };
+        export let links: PropTypes.Requireable<NonNullable<any[] | ((...args: any[]) => any) | null | undefined>>;
+        export let showDomainWarningDialog: PropTypes.Requireable<boolean>;
     }
 }

package/lib/Footer/brand.d.ts

@@ -1,15 +1,15 @@
-import { default as i } from 'prop-types';
-export { p as default };
-declare function p({ name: e, logo: t, description: r, ...a }: {
+import { default as PropTypes } from 'prop-types';
+declare function Brand({ name, logo, description, ...rest }: {
     [x: string]: any;
     name?: string | undefined;
     logo?: string | undefined;
     description?: string | undefined;
-}): import('react').ReactElement<unknown, string | import('react').JSXElementConstructor<any>> | null;
-declare namespace p {
+}): import("react/jsx-runtime").JSX.Element | null;
+declare namespace Brand {
     namespace propTypes {
-        let name: i.Requireable<i.ReactNodeLike>;
-        let logo: i.Requireable<i.ReactNodeLike>;
-        let description: i.Requireable<string>;
+        let name: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        let logo: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        let description: PropTypes.Requireable<string>;
     }
 }
+export default Brand;

package/lib/Footer/copyright.d.ts

@@ -1,13 +1,13 @@
-import { default as r } from 'prop-types';
-export { n as default };
-declare function n({ owner: t, year: e, ...o }: {
+import { default as PropTypes } from 'prop-types';
+declare function Copyright({ owner, year, ...rest }: {
     [x: string]: any;
     owner?: string | undefined;
     year?: string | undefined;
-}): import('react').ReactElement<unknown, string | import('react').JSXElementConstructor<any>>;
-declare namespace n {
+}): import("react/jsx-runtime").JSX.Element;
+declare namespace Copyright {
     namespace propTypes {
-        let owner: r.Requireable<string>;
-        let year: r.Requireable<string>;
+        let owner: PropTypes.Requireable<string>;
+        let year: PropTypes.Requireable<string>;
     }
 }
+export default Copyright;

package/lib/Footer/index.d.ts

@@ -1,6 +1,6 @@
-export { oo as default };
-declare const oo: import('react').ComponentType<{
+declare const _default: import('react').ComponentType<{
     [x: string]: any;
     meta?: {} | undefined;
     theme?: null | undefined;
 }>;
+export default _default;

package/lib/Footer/internal-footer.d.ts

@@ -1,31 +1,34 @@
-import { default as n } from 'prop-types';
-export { _ as default };
-declare function _({ ...a }: {
+import { default as PropTypes } from 'prop-types';
+export default InternalFooter;
+/**
+ * 通用的内部 footer 组件, 定义并渲染常见的几种 footer 元素: brand/navigation/social medial 等
+ */
+declare function InternalFooter({ ...props }: {
     [x: string]: any;
-}): import('react').ReactElement<unknown, string | import('react').JSXElementConstructor<any>>;
-declare namespace _ {
+}): import("react/jsx-runtime").JSX.Element;
+declare namespace InternalFooter {
     namespace propTypes {
-        let brand: n.Requireable<n.InferProps<{
-            name: n.Requireable<n.ReactNodeLike>;
-            description: n.Requireable<string>;
-            logo: n.Requireable<n.ReactNodeLike>;
+        let brand: PropTypes.Requireable<PropTypes.InferProps<{
+            name: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+            description: PropTypes.Requireable<string>;
+            logo: PropTypes.Requireable<PropTypes.ReactNodeLike>;
         }>>;
-        let navigation: n.Requireable<(n.InferProps<{
-            label: n.Requireable<n.ReactNodeLike>;
-            link: n.Requireable<string>;
+        let navigation: PropTypes.Requireable<(PropTypes.InferProps<{
+            label: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+            link: PropTypes.Requireable<string>;
         }> | null | undefined)[]>;
-        let socialMedia: n.Requireable<(n.InferProps<{
-            icon: n.Requireable<n.ReactNodeLike>;
-            link: n.Requireable<string>;
+        let socialMedia: PropTypes.Requireable<(PropTypes.InferProps<{
+            icon: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+            link: PropTypes.Requireable<string>;
         }> | null | undefined)[]>;
-        let copyright: n.Requireable<n.InferProps<{
-            owner: n.Requireable<string>;
-            year: n.Requireable<NonNullable<string | number | null | undefined>>;
+        let copyright: PropTypes.Requireable<PropTypes.InferProps<{
+            owner: PropTypes.Requireable<string>;
+            year: PropTypes.Requireable<NonNullable<string | number | null | undefined>>;
         }>>;
-        let links: n.Requireable<(n.InferProps<{
-            label: n.Requireable<n.ReactNodeLike>;
-            link: n.Requireable<string>;
+        let links: PropTypes.Requireable<(PropTypes.InferProps<{
+            label: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+            link: PropTypes.Requireable<string>;
         }> | null | undefined)[]>;
-        let layout: n.Requireable<string>;
+        let layout: PropTypes.Requireable<string>;
     }
 }