@xyo-network/react-shared 4.1.9 → 4.1.11

package/dist/browser/index.d.ts

@@ -1,7 +1,319 @@
-export * from './components/index.ts';
-export * from './contexts/index.ts';
-export * from './hooks/index.ts';
-export * from './lib/index.ts';
-export * from './models/index.ts';
-export * from './SizeProp.ts';
-//# sourceMappingURL=index.d.ts.map
+import { TypographyProps, BoxProps, TypographyTypeMap, StackProps, ListItemButtonProps, AlertProps, TableCellProps, AvatarProps, AvatarGroupProps, PaperProps, CardHeaderProps, SvgIconProps } from '@mui/material';
+export { useMediaQuery } from '@mui/material';
+import * as React from 'react';
+import React__default, { ReactElement, PropsWithChildren, ReactNode, Dispatch, SetStateAction, Context, CSSProperties, ForwardedRef } from 'react';
+import * as _xylabs_react_flexbox from '@xylabs/react-flexbox';
+import { FlexBoxProps } from '@xylabs/react-flexbox';
+import { To, NavigateOptions } from 'react-router-dom';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { Hash } from '@xylabs/hex';
+import * as _mui_styles from '@mui/styles';
+import { Payload } from '@xyo-network/payload-model';
+
+declare const Ampersand: React__default.FC<TypographyProps>;
+
+interface BasicHeroProps extends FlexBoxProps {
+    backgroundColor?: string;
+    backgroundImage?: string;
+    button1Href?: string;
+    button1Text?: string;
+    button1To?: string;
+    button2Href?: string;
+    button2Text?: string;
+    button2To?: string;
+    desc: string;
+    gradientTitle?: string;
+    heroImage?: string;
+    subLinkIcon?: ReactElement;
+    subLinkPath?: string;
+    subLinkText1?: string;
+    subLinkText2?: string;
+    sx?: Record<string, string>;
+    textColor?: string;
+    title: string;
+    title2?: string;
+}
+declare const BasicHero: React__default.FC<BasicHeroProps>;
+
+interface EllipsizeRootProps extends BoxProps {
+    beforeLineHeight?: string | number;
+}
+type TypographyWithComponentProps<D extends React__default.ElementType = TypographyTypeMap['defaultComponent'], P = {}> = TypographyProps<D, P> & {
+    ellipsisPosition?: 'start' | 'end';
+};
+interface EllipsizeBoxProps extends BoxProps {
+    disableSharedRef?: boolean;
+    ellipsisPosition?: 'start' | 'end';
+    typographyProps?: TypographyWithComponentProps;
+}
+declare const EllipsizeBox: React__default.ForwardRefExoticComponent<Omit<PropsWithChildren<EllipsizeBoxProps>, "ref"> & React__default.RefAttributes<HTMLDivElement>>;
+
+interface LabeledTextFieldWrapperProps extends StackProps {
+    label: string;
+}
+declare const LabeledTextFieldWrapper: React__default.FC<LabeledTextFieldWrapperProps>;
+
+interface ListItemButtonExProps extends ListItemButtonProps {
+    target?: string;
+    to?: To;
+    toOptions?: NavigateOptions;
+}
+declare const ListItemButtonExTo: React__default.FC<ListItemButtonExProps>;
+declare const ListItemButtonEx: React__default.FC<ListItemButtonExProps>;
+
+interface LoadResultProps<T> {
+    apiError?: Error;
+    error?: boolean;
+    notFound: boolean;
+    searchResult: T | undefined;
+}
+declare function LoadResult<T>(props: PropsWithChildren<LoadResultProps<T>>): react_jsx_runtime.JSX.Element;
+
+declare const NotFound: React__default.FC<FlexBoxProps>;
+
+declare const Pipe: React__default.FC<TypographyProps>;
+
+interface PayloadDataMissingProps extends AlertProps {
+    alertBody?: string;
+}
+declare const PayloadDataMissing: React__default.FC<PayloadDataMissingProps>;
+
+declare const ScrollTableOnSm: React__default.FC<PropsWithChildren>;
+
+declare const SectionSpacingRow: React__default.ForwardRefExoticComponent<_xylabs_react_flexbox.BusyBoxProps & React__default.RefAttributes<HTMLDivElement>>;
+
+interface EllipsisTableCellProps extends Omit<TableCellProps, 'ref'> {
+    href?: string;
+    link?: boolean;
+    to?: To;
+    value?: string;
+    width?: string | number;
+}
+declare const EllipsisTableCellWithRef: React__default.ForwardRefExoticComponent<EllipsisTableCellProps & React__default.RefAttributes<HTMLElement>>;
+declare const EllipsisTableCell: React__default.ForwardRefExoticComponent<EllipsisTableCellProps & React__default.RefAttributes<HTMLElement>>;
+
+interface AddressTableCellProps extends Omit<EllipsisTableCellProps, 'ref'> {
+    archive?: string;
+    exploreDomain?: string;
+    link?: boolean;
+}
+declare const AddressTableCell: React__default.ForwardRefExoticComponent<AddressTableCellProps & React__default.RefAttributes<HTMLElement>>;
+
+interface HashTableCellProps extends EllipsisTableCellProps {
+    archive?: string;
+    dataType?: 'block' | 'payload';
+    exploreDomain?: string;
+    network?: string;
+    onHashClick?: (value: Hash) => void;
+}
+declare const HashTableCell: React__default.FC<HashTableCellProps>;
+
+declare const ThemeTokenAvatar: React__default.FC<AvatarProps>;
+
+interface ThemeTokenAvatarGroupProps extends AvatarGroupProps {
+    images?: string[];
+}
+declare const ThemeTokenAvatarGroup: React__default.FC<ThemeTokenAvatarGroupProps>;
+
+interface TokenBarProps extends PaperProps {
+    text1?: ReactNode;
+    text1Props?: TypographyProps;
+    text1Suffix?: ReactNode;
+    text2?: ReactNode;
+    text2Props?: TypographyProps;
+    text2Suffix?: ReactNode;
+}
+declare const TokenBar: React__default.FC<TokenBarProps>;
+
+interface TokenData {
+    coinmarketcapLink: string;
+    etherscanLink: string;
+    icon: string;
+    readableName: string;
+    tokenSymbol: string;
+    uniqueTokenId: string;
+}
+declare const TokenData: TokenData[];
+
+declare const useGetTokenData: (symbols: (string | undefined)[]) => TokenData[];
+
+interface TokenSummaryProps extends CardHeaderProps {
+    icon?: string;
+    imgBgProps?: AvatarProps;
+    symbol?: string;
+    symbolElement?: ReactNode;
+}
+declare const TokenSummary: React__default.FC<TokenSummaryProps>;
+
+interface TypographyExProps extends TypographyProps {
+    gradient?: 'text';
+}
+declare const TypographyEx: React__default.FC<TypographyExProps>;
+
+interface CollapsibleProviderProps extends PropsWithChildren {
+    defaultCollapse?: boolean;
+    defaultCollapseEnd?: boolean;
+}
+declare const CollapsibleProvider: React__default.FC<CollapsibleProviderProps>;
+
+interface ContextExState$1 {
+    provided: boolean;
+}
+
+interface CollapsibleState extends ContextExState$1 {
+    collapse?: boolean;
+    collapseEnd?: boolean;
+    setCollapse?: Dispatch<SetStateAction<boolean>>;
+    setCollapseEnd?: Dispatch<SetStateAction<boolean>>;
+}
+
+declare const useCollapsible: () => Omit<CollapsibleState & ContextExState$1, "provided">;
+
+type EmptyObject = {};
+type ContextExProviderProps<T extends EmptyObject = EmptyObject> = PropsWithChildren<{
+    required?: boolean;
+} & T>;
+
+interface ContextExState {
+    provided: boolean;
+}
+
+declare const createContextEx: <T>() => React.Context<T & ContextExState>;
+
+declare const useContextEx: <T extends ContextExState>(context: Context<T>, contextName: string, required?: boolean) => Omit<T, "provided">;
+declare const useProvided: <T extends ContextExState>(context: Context<T>) => boolean;
+
+declare const ResolvedDivinerContext: <T>() => React.Context<T & ContextExState>;
+
+interface ResolvedDivinerState<T> extends ContextExState {
+    diviner?: T;
+    setDiviner?: Dispatch<SetStateAction<T | undefined>>;
+}
+
+interface DivinerProviderProps<D> extends ContextExProviderProps, PropsWithChildren {
+    context: Context<ResolvedDivinerState<D>>;
+    diviner?: D;
+}
+declare const ResolvedDivinerProvider: <D>({ diviner: divinerProp, required, children, context, }: DivinerProviderProps<D>) => react_jsx_runtime.JSX.Element;
+
+type ListMode = 'table' | 'grid' | 'default';
+
+interface ListModeContextState extends ContextExState {
+    listMode: ListMode;
+    setListMode?: Dispatch<ListMode>;
+}
+
+declare const ListModeContext: React.Context<ListModeContextState & ContextExState>;
+
+interface ListModeProviderProps {
+    defaultListMode?: ListMode;
+}
+declare const ListModeProvider: React__default.FC<PropsWithChildren<ListModeProviderProps>>;
+
+declare const useListMode: (required?: boolean) => Omit<ListModeContextState & ContextExState, "provided">;
+
+interface GradientStyles {
+    background: CSSProperties;
+    border: CSSProperties;
+    heading: CSSProperties;
+}
+declare const colorfulGradientLightMode: () => {
+    background: {
+        backgroundImage: string;
+    };
+    border: {
+        borderImage: string;
+        borderImageSlice: number;
+        borderImageSource: string;
+        borderRadius: number;
+        borderStyle: string;
+        borderWidth: string;
+    };
+    heading: {
+        WebkitBackgroundClip: string;
+        WebkitTextFillColor: string;
+        background: string;
+        display: string;
+    };
+};
+declare const colorfulGradientDarkMode: () => {
+    background: {
+        backgroundImage: string;
+    };
+    border: {
+        borderImage: string;
+        borderImageSlice: number;
+        borderImageSource: string;
+        borderRadius: number;
+        borderStyle: string;
+        borderWidth: string;
+    };
+    heading: {
+        WebkitBackgroundClip: string;
+        WebkitTextFillColor: string;
+        background: string;
+        display: string;
+    };
+};
+declare const useGradientStyles: () => {
+    classes: (props?: any) => _mui_styles.ClassNameMap<"border" | "background" | "heading">;
+    styles: {
+        background: {
+            backgroundImage: string;
+        };
+        border: {
+            borderImage: string;
+            borderImageSlice: number;
+            borderImageSource: string;
+            borderRadius: number;
+            borderStyle: string;
+            borderWidth: string;
+        };
+        heading: {
+            WebkitBackgroundClip: string;
+            WebkitTextFillColor: string;
+            background: string;
+            display: string;
+        };
+    };
+};
+
+declare const useDataState: <T>(defaultValue: T | undefined) => [T | undefined, Dispatch<SetStateAction<T | undefined>>];
+
+declare const useIsMobile: () => boolean;
+declare const useIsSmall: () => boolean;
+
+declare const usePayloadHash: <TPayload extends Payload>(payload: TPayload | undefined | null) => Lowercase<string> | undefined;
+declare const usePayloadHashes: <TPayload extends Payload>(payloads: TPayload[] | undefined | null) => [TPayload, Lowercase<string>][] | undefined;
+
+declare const useShareForwardedRef: <T>(forwardedRef: ForwardedRef<T>, refresh?: number) => React.RefObject<T>;
+
+declare const assertDefinedEx: <T>(expr?: T | null, message?: string) => T;
+
+declare const parseMeausureString: (measure?: string, absolute?: number) => number | undefined;
+declare const parsePadding: (padding: string) => {
+    bottom: string;
+    left: string;
+    right: string;
+    top: string;
+} | {
+    bottom: string;
+    right: string;
+    top: string;
+    left?: undefined;
+} | undefined;
+declare const getActualPaddingX: (element: HTMLElement) => number;
+
+type NetworkComponentSlug = 'sentinel' | 'bridge' | 'archivist' | 'diviner' | 'node' | 'witness';
+interface NetworkComponentDetails {
+    icon: (props?: SvgIconProps) => ReactElement;
+    name: string;
+    slug: NetworkComponentSlug;
+}
+declare const networkComponents: NetworkComponentDetails[];
+declare const findNetworkComponentIndex: (slug: string) => number;
+declare const findNetworkComponent: (slug: string) => NetworkComponentDetails | undefined;
+
+type SizeProp = 'small' | 'medium' | 'large';
+
+export { AddressTableCell, type AddressTableCellProps, Ampersand, BasicHero, type BasicHeroProps, CollapsibleProvider, type CollapsibleProviderProps, type CollapsibleState, type ContextExProviderProps, type ContextExState, type DivinerProviderProps, EllipsisTableCell, type EllipsisTableCellProps, EllipsisTableCellWithRef, EllipsizeBox, type EllipsizeBoxProps, type EllipsizeRootProps, type EmptyObject, type GradientStyles, HashTableCell, type HashTableCellProps, LabeledTextFieldWrapper, type LabeledTextFieldWrapperProps, ListItemButtonEx, type ListItemButtonExProps, ListItemButtonExTo, type ListMode, ListModeContext, type ListModeContextState, ListModeProvider, type ListModeProviderProps, LoadResult, type LoadResultProps, type NetworkComponentDetails, type NetworkComponentSlug, NotFound, PayloadDataMissing, type PayloadDataMissingProps, Pipe, ResolvedDivinerContext, ResolvedDivinerProvider, type ResolvedDivinerState, ScrollTableOnSm, SectionSpacingRow, type SizeProp, ThemeTokenAvatar, ThemeTokenAvatarGroup, type ThemeTokenAvatarGroupProps, TokenBar, type TokenBarProps, TokenData, TokenSummary, type TokenSummaryProps, TypographyEx, type TypographyExProps, type TypographyWithComponentProps, assertDefinedEx, colorfulGradientDarkMode, colorfulGradientLightMode, createContextEx, findNetworkComponent, findNetworkComponentIndex, getActualPaddingX, networkComponents, parseMeausureString, parsePadding, useCollapsible, useContextEx, useDataState, useGetTokenData, useGradientStyles, useIsMobile, useIsSmall, useListMode, usePayloadHash, usePayloadHashes, useProvided, useShareForwardedRef };

package/dist/browser/index.mjs

@@ -838,13 +838,16 @@ var TypographyEx = /* @__PURE__ */ __name(({ gradient, ...props }) => {
   });
 }, "TypographyEx");
 
-// src/contexts/contextEx/create.ts
+// ../../../../../../xylabs/sdk-react/packages/shared/src/Collapsible/provider.tsx
+import React20, { useState as useState3 } from "react";
+
+// ../../../../../../xylabs/sdk-react/packages/shared/src/contextEx/create.ts
 import { createContext } from "react";
 var createContextEx = /* @__PURE__ */ __name(() => createContext({
   provided: false
 }), "createContextEx");
 
-// src/contexts/contextEx/use.ts
+// ../../../../../../xylabs/sdk-react/packages/shared/src/contextEx/use.ts
 import { useContext } from "react";
 var useContextEx = /* @__PURE__ */ __name((context, contextName, required = true) => {
   const { provided, ...props } = useContext(context);
@@ -853,17 +856,57 @@ var useContextEx = /* @__PURE__ */ __name((context, contextName, required = true
   }
   return props;
 }, "useContextEx");
+
+// ../../../../../../xylabs/sdk-react/packages/shared/src/Collapsible/context.ts
+var CollapsibleContext = createContextEx();
+
+// ../../../../../../xylabs/sdk-react/packages/shared/src/Collapsible/provider.tsx
+var CollapsibleProvider = /* @__PURE__ */ __name(({ defaultCollapse = false, defaultCollapseEnd = false, children }) => {
+  const [collapse, setCollapse] = useState3(() => defaultCollapse);
+  const [collapseEnd, setCollapseEnd] = useState3(() => defaultCollapseEnd);
+  return (
+    // eslint-disable-next-line @eslint-react/no-unstable-context-value
+    /* @__PURE__ */ React20.createElement(CollapsibleContext.Provider, {
+      value: {
+        collapse,
+        collapseEnd,
+        provided: true,
+        setCollapse,
+        setCollapseEnd
+      }
+    }, children)
+  );
+}, "CollapsibleProvider");
+
+// ../../../../../../xylabs/sdk-react/packages/shared/src/Collapsible/use.ts
+var useCollapsible = /* @__PURE__ */ __name(() => useContextEx(CollapsibleContext, "Collapsible", false), "useCollapsible");
+
+// src/contexts/contextEx/create.ts
+import { createContext as createContext2 } from "react";
+var createContextEx2 = /* @__PURE__ */ __name(() => createContext2({
+  provided: false
+}), "createContextEx");
+
+// src/contexts/contextEx/use.ts
+import { useContext as useContext2 } from "react";
+var useContextEx2 = /* @__PURE__ */ __name((context, contextName, required = true) => {
+  const { provided, ...props } = useContext2(context);
+  if (!provided && required) {
+    throw new Error(`use${contextName} can not be used outside of a ${contextName}Context when required=true`);
+  }
+  return props;
+}, "useContextEx");
 var useProvided = /* @__PURE__ */ __name((context) => {
-  const { provided } = useContext(context);
+  const { provided } = useContext2(context);
   return provided;
 }, "useProvided");
 
 // src/contexts/diviner/Context.ts
-var ResolvedDivinerContext = /* @__PURE__ */ __name(() => createContextEx(), "ResolvedDivinerContext");
+var ResolvedDivinerContext = /* @__PURE__ */ __name(() => createContextEx2(), "ResolvedDivinerContext");
 
 // src/contexts/diviner/Provider.tsx
 import { useResetState } from "@xylabs/react-hooks";
-import React20, { useMemo as useMemo2 } from "react";
+import React21, { useMemo as useMemo2 } from "react";
 var ResolvedDivinerProvider = /* @__PURE__ */ __name(({ diviner: divinerProp, required = false, children, context }) => {
   const [diviner, setDiviner] = useResetState(divinerProp);
   const value = useMemo2(() => {
@@ -883,18 +926,18 @@ var ResolvedDivinerProvider = /* @__PURE__ */ __name(({ diviner: divinerProp, re
     setDiviner,
     divinerProp
   ]);
-  return /* @__PURE__ */ React20.createElement(context.Provider, {
+  return /* @__PURE__ */ React21.createElement(context.Provider, {
     value
   }, diviner ? children : required ? null : children);
 }, "ResolvedDivinerProvider");
 
 // src/contexts/ListMode/Context.ts
-var ListModeContext = createContextEx();
+var ListModeContext = createContextEx2();
 
 // src/contexts/ListMode/Provider.tsx
-import React21, { useMemo as useMemo3, useState as useState3 } from "react";
+import React22, { useMemo as useMemo3, useState as useState4 } from "react";
 var ListModeProvider = /* @__PURE__ */ __name(({ children, defaultListMode }) => {
-  const [listMode, setListMode] = useState3(defaultListMode ?? "default");
+  const [listMode, setListMode] = useState4(defaultListMode ?? "default");
   const value = useMemo3(() => ({
     listMode,
     provided: true,
@@ -903,14 +946,14 @@ var ListModeProvider = /* @__PURE__ */ __name(({ children, defaultListMode }) =>
     listMode,
     setListMode
   ]);
-  return /* @__PURE__ */ React21.createElement(ListModeContext.Provider, {
+  return /* @__PURE__ */ React22.createElement(ListModeContext.Provider, {
     value
   }, children);
 }, "ListModeProvider");
 
 // src/contexts/ListMode/use.ts
 var useListMode = /* @__PURE__ */ __name((required = false) => {
-  return useContextEx(ListModeContext, "ListMode", required);
+  return useContextEx2(ListModeContext, "ListMode", required);
 }, "useListMode");
 
 // src/lib/assertDefinedEx.ts
@@ -982,35 +1025,35 @@ var getActualPaddingX = /* @__PURE__ */ __name((element) => {
 
 // src/lib/networkComponents.tsx
 import { BubbleChartRounded as BubbleChartRoundedIcon, HubRounded as HubRoundedIcon, InsertLinkRounded as InsertLinkRoundedIcon, Inventory2Rounded as Inventory2RoundedIcon, TimerRounded as TimerRoundedIcon, VisibilityRounded as VisibilityRoundedIcon } from "@mui/icons-material";
-import React22 from "react";
+import React23 from "react";
 var networkComponents = [
   {
-    icon: /* @__PURE__ */ __name((props) => /* @__PURE__ */ React22.createElement(HubRoundedIcon, props), "icon"),
+    icon: /* @__PURE__ */ __name((props) => /* @__PURE__ */ React23.createElement(HubRoundedIcon, props), "icon"),
     name: "Node",
     slug: "node"
   },
   {
-    icon: /* @__PURE__ */ __name((props) => /* @__PURE__ */ React22.createElement(TimerRoundedIcon, props), "icon"),
+    icon: /* @__PURE__ */ __name((props) => /* @__PURE__ */ React23.createElement(TimerRoundedIcon, props), "icon"),
     name: "Sentinel",
     slug: "sentinel"
   },
   {
-    icon: /* @__PURE__ */ __name((props) => /* @__PURE__ */ React22.createElement(InsertLinkRoundedIcon, props), "icon"),
+    icon: /* @__PURE__ */ __name((props) => /* @__PURE__ */ React23.createElement(InsertLinkRoundedIcon, props), "icon"),
     name: "Bridge",
     slug: "bridge"
   },
   {
-    icon: /* @__PURE__ */ __name((props) => /* @__PURE__ */ React22.createElement(Inventory2RoundedIcon, props), "icon"),
+    icon: /* @__PURE__ */ __name((props) => /* @__PURE__ */ React23.createElement(Inventory2RoundedIcon, props), "icon"),
     name: "Archivist",
     slug: "archivist"
   },
   {
-    icon: /* @__PURE__ */ __name((props) => /* @__PURE__ */ React22.createElement(BubbleChartRoundedIcon, props), "icon"),
+    icon: /* @__PURE__ */ __name((props) => /* @__PURE__ */ React23.createElement(BubbleChartRoundedIcon, props), "icon"),
     name: "Diviner",
     slug: "diviner"
   },
   {
-    icon: /* @__PURE__ */ __name((props) => /* @__PURE__ */ React22.createElement(VisibilityRoundedIcon, props), "icon"),
+    icon: /* @__PURE__ */ __name((props) => /* @__PURE__ */ React23.createElement(VisibilityRoundedIcon, props), "icon"),
     name: "Witness",
     slug: "witness"
   }
@@ -1025,6 +1068,7 @@ export {
   AddressTableCell,
   Ampersand,
   BasicHero,
+  CollapsibleProvider,
   EllipsisTableCell,
   EllipsisTableCellWithRef,
   EllipsizeBox,
@@ -1051,14 +1095,15 @@ export {
   assertDefinedEx,
   colorfulGradientDarkMode,
   colorfulGradientLightMode,
-  createContextEx,
+  createContextEx2 as createContextEx,
   findNetworkComponent,
   findNetworkComponentIndex,
   getActualPaddingX,
   networkComponents,
   parseMeausureString,
   parsePadding,
-  useContextEx,
+  useCollapsible,
+  useContextEx2 as useContextEx,
   useDataState,
   useGetTokenData,
   useGradientStyles,