react-share

  • Version 5.2.0
  • Published
  • 349 kB
  • 2 dependencies
  • MIT license

Install

npm i react-share
yarn add react-share
pnpm add react-share

Overview

Social media share buttons and share counts for React.

Index

Variables

variable BlueskyIcon

const BlueskyIcon: FC<
Omit<SVGProps<SVGSVGElement>, 'width' | 'height'> & {
bgStyle?: React.CSSProperties;
borderRadius?: number;
iconFillColor?: string;
round?: boolean;
size?: number | string;
}
>;

    variable BlueskyShareButton

    const BlueskyShareButton: ForwardRefExoticComponent<any>;

      variable EmailIcon

      const EmailIcon: FC<
      Omit<SVGProps<SVGSVGElement>, 'width' | 'height'> & {
      bgStyle?: React.CSSProperties;
      borderRadius?: number;
      iconFillColor?: string;
      round?: boolean;
      size?: number | string;
      }
      >;

        variable EmailShareButton

        const EmailShareButton: default_2.ForwardRefExoticComponent<any>;

          variable FacebookIcon

          const FacebookIcon: FC<
          Omit<SVGProps<SVGSVGElement>, 'width' | 'height'> & {
          bgStyle?: React.CSSProperties;
          borderRadius?: number;
          iconFillColor?: string;
          round?: boolean;
          size?: number | string;
          }
          >;

            variable FacebookMessengerIcon

            const FacebookMessengerIcon: FC<
            Omit<SVGProps<SVGSVGElement>, 'width' | 'height'> & {
            bgStyle?: React.CSSProperties;
            borderRadius?: number;
            iconFillColor?: string;
            round?: boolean;
            size?: number | string;
            }
            >;

              variable FacebookMessengerShareButton

              const FacebookMessengerShareButton: ForwardRefExoticComponent<any>;

                variable FacebookShareButton

                const FacebookShareButton: ForwardRefExoticComponent<any>;

                  variable FacebookShareCount

                  const FacebookShareCount: {
                  (
                  props: Omit<
                  Omit<HTMLAttributes<HTMLSpanElement>, 'children'> & {
                  children?: (shareCount: number) => React.ReactNode;
                  getCount: (
                  url: string,
                  callback: (shareCount?: number) => void
                  ) => void;
                  url: string;
                  },
                  'getCount'
                  >
                  ): JSX_2.Element;
                  displayName: string;
                  };

                    variable GabIcon

                    const GabIcon: FC<
                    Omit<SVGProps<SVGSVGElement>, 'width' | 'height'> & {
                    bgStyle?: React.CSSProperties;
                    borderRadius?: number;
                    iconFillColor?: string;
                    round?: boolean;
                    size?: number | string;
                    }
                    >;

                      variable GabShareButton

                      const GabShareButton: ForwardRefExoticComponent<any>;

                        variable HatenaIcon

                        const HatenaIcon: FC<
                        Omit<SVGProps<SVGSVGElement>, 'width' | 'height'> & {
                        bgStyle?: React.CSSProperties;
                        borderRadius?: number;
                        iconFillColor?: string;
                        round?: boolean;
                        size?: number | string;
                        }
                        >;

                          variable HatenaShareButton

                          const HatenaShareButton: ForwardRefExoticComponent<any>;

                            variable HatenaShareCount

                            const HatenaShareCount: {
                            (
                            props: Omit<
                            Omit<HTMLAttributes<HTMLSpanElement>, 'children'> & {
                            children?: (shareCount: number) => React.ReactNode;
                            getCount: (
                            url: string,
                            callback: (shareCount?: number) => void
                            ) => void;
                            url: string;
                            },
                            'getCount'
                            >
                            ): JSX_2.Element;
                            displayName: string;
                            };

                              variable InstapaperIcon

                              const InstapaperIcon: FC<
                              Omit<SVGProps<SVGSVGElement>, 'width' | 'height'> & {
                              bgStyle?: React.CSSProperties;
                              borderRadius?: number;
                              iconFillColor?: string;
                              round?: boolean;
                              size?: number | string;
                              }
                              >;

                                variable InstapaperShareButton

                                const InstapaperShareButton: ForwardRefExoticComponent<any>;

                                  variable LineIcon

                                  const LineIcon: FC<
                                  Omit<SVGProps<SVGSVGElement>, 'width' | 'height'> & {
                                  bgStyle?: React.CSSProperties;
                                  borderRadius?: number;
                                  iconFillColor?: string;
                                  round?: boolean;
                                  size?: number | string;
                                  }
                                  >;

                                    variable LineShareButton

                                    const LineShareButton: ForwardRefExoticComponent<any>;

                                      variable LinkedinIcon

                                      const LinkedinIcon: FC<
                                      Omit<SVGProps<SVGSVGElement>, 'width' | 'height'> & {
                                      bgStyle?: React.CSSProperties;
                                      borderRadius?: number;
                                      iconFillColor?: string;
                                      round?: boolean;
                                      size?: number | string;
                                      }
                                      >;

                                        variable LinkedinShareButton

                                        const LinkedinShareButton: ForwardRefExoticComponent<any>;

                                          variable LivejournalIcon

                                          const LivejournalIcon: FC<
                                          Omit<SVGProps<SVGSVGElement>, 'width' | 'height'> & {
                                          bgStyle?: React.CSSProperties;
                                          borderRadius?: number;
                                          iconFillColor?: string;
                                          round?: boolean;
                                          size?: number | string;
                                          }
                                          >;

                                            variable LivejournalShareButton

                                            const LivejournalShareButton: ForwardRefExoticComponent<any>;

                                              variable MailruIcon

                                              const MailruIcon: FC<
                                              Omit<SVGProps<SVGSVGElement>, 'width' | 'height'> & {
                                              bgStyle?: React.CSSProperties;
                                              borderRadius?: number;
                                              iconFillColor?: string;
                                              round?: boolean;
                                              size?: number | string;
                                              }
                                              >;

                                                variable MailruShareButton

                                                const MailruShareButton: ForwardRefExoticComponent<any>;

                                                  variable OKIcon

                                                  const OKIcon: FC<
                                                  Omit<SVGProps<SVGSVGElement>, 'width' | 'height'> & {
                                                  bgStyle?: React.CSSProperties;
                                                  borderRadius?: number;
                                                  iconFillColor?: string;
                                                  round?: boolean;
                                                  size?: number | string;
                                                  }
                                                  >;

                                                    variable OKShareButton

                                                    const OKShareButton: ForwardRefExoticComponent<any>;

                                                      variable OKShareCount

                                                      const OKShareCount: {
                                                      (
                                                      props: Omit<
                                                      Omit<HTMLAttributes<HTMLSpanElement>, 'children'> & {
                                                      children?: (shareCount: number) => React.ReactNode;
                                                      getCount: (
                                                      url: string,
                                                      callback: (shareCount?: number) => void
                                                      ) => void;
                                                      url: string;
                                                      },
                                                      'getCount'
                                                      >
                                                      ): JSX_2.Element;
                                                      displayName: string;
                                                      };

                                                        variable PinterestIcon

                                                        const PinterestIcon: FC<
                                                        Omit<SVGProps<SVGSVGElement>, 'width' | 'height'> & {
                                                        bgStyle?: React.CSSProperties;
                                                        borderRadius?: number;
                                                        iconFillColor?: string;
                                                        round?: boolean;
                                                        size?: number | string;
                                                        }
                                                        >;

                                                          variable PinterestShareButton

                                                          const PinterestShareButton: ForwardRefExoticComponent<any>;

                                                            variable PinterestShareCount

                                                            const PinterestShareCount: {
                                                            (
                                                            props: Omit<
                                                            Omit<HTMLAttributes<HTMLSpanElement>, 'children'> & {
                                                            children?: (shareCount: number) => React.ReactNode;
                                                            getCount: (
                                                            url: string,
                                                            callback: (shareCount?: number) => void
                                                            ) => void;
                                                            url: string;
                                                            },
                                                            'getCount'
                                                            >
                                                            ): JSX_2.Element;
                                                            displayName: string;
                                                            };

                                                              variable PocketIcon

                                                              const PocketIcon: FC<
                                                              Omit<SVGProps<SVGSVGElement>, 'width' | 'height'> & {
                                                              bgStyle?: React.CSSProperties;
                                                              borderRadius?: number;
                                                              iconFillColor?: string;
                                                              round?: boolean;
                                                              size?: number | string;
                                                              }
                                                              >;

                                                                variable PocketShareButton

                                                                const PocketShareButton: ForwardRefExoticComponent<any>;

                                                                  variable RedditIcon

                                                                  const RedditIcon: FC<
                                                                  Omit<SVGProps<SVGSVGElement>, 'width' | 'height'> & {
                                                                  bgStyle?: React.CSSProperties;
                                                                  borderRadius?: number;
                                                                  iconFillColor?: string;
                                                                  round?: boolean;
                                                                  size?: number | string;
                                                                  }
                                                                  >;

                                                                    variable RedditShareButton

                                                                    const RedditShareButton: ForwardRefExoticComponent<any>;

                                                                      variable RedditShareCount

                                                                      const RedditShareCount: {
                                                                      (
                                                                      props: Omit<
                                                                      Omit<HTMLAttributes<HTMLSpanElement>, 'children'> & {
                                                                      children?: (shareCount: number) => React.ReactNode;
                                                                      getCount: (
                                                                      url: string,
                                                                      callback: (shareCount?: number) => void
                                                                      ) => void;
                                                                      url: string;
                                                                      },
                                                                      'getCount'
                                                                      >
                                                                      ): JSX_2.Element;
                                                                      displayName: string;
                                                                      };

                                                                        variable TelegramIcon

                                                                        const TelegramIcon: FC<
                                                                        Omit<SVGProps<SVGSVGElement>, 'width' | 'height'> & {
                                                                        bgStyle?: React.CSSProperties;
                                                                        borderRadius?: number;
                                                                        iconFillColor?: string;
                                                                        round?: boolean;
                                                                        size?: number | string;
                                                                        }
                                                                        >;

                                                                          variable TelegramShareButton

                                                                          const TelegramShareButton: ForwardRefExoticComponent<any>;

                                                                            variable ThreadsIcon

                                                                            const ThreadsIcon: FC<
                                                                            Omit<SVGProps<SVGSVGElement>, 'width' | 'height'> & {
                                                                            bgStyle?: React.CSSProperties;
                                                                            borderRadius?: number;
                                                                            iconFillColor?: string;
                                                                            round?: boolean;
                                                                            size?: number | string;
                                                                            }
                                                                            >;

                                                                              variable ThreadsShareButton

                                                                              const ThreadsShareButton: ForwardRefExoticComponent<any>;

                                                                                variable TumblrIcon

                                                                                const TumblrIcon: FC<
                                                                                Omit<SVGProps<SVGSVGElement>, 'width' | 'height'> & {
                                                                                bgStyle?: React.CSSProperties;
                                                                                borderRadius?: number;
                                                                                iconFillColor?: string;
                                                                                round?: boolean;
                                                                                size?: number | string;
                                                                                }
                                                                                >;

                                                                                  variable TumblrShareButton

                                                                                  const TumblrShareButton: ForwardRefExoticComponent<any>;

                                                                                    variable TumblrShareCount

                                                                                    const TumblrShareCount: {
                                                                                    (
                                                                                    props: Omit<
                                                                                    Omit<HTMLAttributes<HTMLSpanElement>, 'children'> & {
                                                                                    children?: (shareCount: number) => React.ReactNode;
                                                                                    getCount: (
                                                                                    url: string,
                                                                                    callback: (shareCount?: number) => void
                                                                                    ) => void;
                                                                                    url: string;
                                                                                    },
                                                                                    'getCount'
                                                                                    >
                                                                                    ): JSX_2.Element;
                                                                                    displayName: string;
                                                                                    };

                                                                                      variable TwitterIcon

                                                                                      const TwitterIcon: FC<
                                                                                      Omit<SVGProps<SVGSVGElement>, 'width' | 'height'> & {
                                                                                      bgStyle?: React.CSSProperties;
                                                                                      borderRadius?: number;
                                                                                      iconFillColor?: string;
                                                                                      round?: boolean;
                                                                                      size?: number | string;
                                                                                      }
                                                                                      >;

                                                                                        variable TwitterShareButton

                                                                                        const TwitterShareButton: ForwardRefExoticComponent<any>;

                                                                                          variable ViberIcon

                                                                                          const ViberIcon: FC<
                                                                                          Omit<SVGProps<SVGSVGElement>, 'width' | 'height'> & {
                                                                                          bgStyle?: React.CSSProperties;
                                                                                          borderRadius?: number;
                                                                                          iconFillColor?: string;
                                                                                          round?: boolean;
                                                                                          size?: number | string;
                                                                                          }
                                                                                          >;

                                                                                            variable ViberShareButton

                                                                                            const ViberShareButton: ForwardRefExoticComponent<any>;

                                                                                              variable VKIcon

                                                                                              const VKIcon: FC<
                                                                                              Omit<SVGProps<SVGSVGElement>, 'width' | 'height'> & {
                                                                                              bgStyle?: React.CSSProperties;
                                                                                              borderRadius?: number;
                                                                                              iconFillColor?: string;
                                                                                              round?: boolean;
                                                                                              size?: number | string;
                                                                                              }
                                                                                              >;

                                                                                                variable VKShareButton

                                                                                                const VKShareButton: ForwardRefExoticComponent<any>;

                                                                                                  variable VKShareCount

                                                                                                  const VKShareCount: {
                                                                                                  (
                                                                                                  props: Omit<
                                                                                                  Omit<HTMLAttributes<HTMLSpanElement>, 'children'> & {
                                                                                                  children?: (shareCount: number) => React.ReactNode;
                                                                                                  getCount: (
                                                                                                  url: string,
                                                                                                  callback: (shareCount?: number) => void
                                                                                                  ) => void;
                                                                                                  url: string;
                                                                                                  },
                                                                                                  'getCount'
                                                                                                  >
                                                                                                  ): JSX_2.Element;
                                                                                                  displayName: string;
                                                                                                  };

                                                                                                    variable WeiboIcon

                                                                                                    const WeiboIcon: FC<
                                                                                                    Omit<SVGProps<SVGSVGElement>, 'width' | 'height'> & {
                                                                                                    bgStyle?: React.CSSProperties;
                                                                                                    borderRadius?: number;
                                                                                                    iconFillColor?: string;
                                                                                                    round?: boolean;
                                                                                                    size?: number | string;
                                                                                                    }
                                                                                                    >;

                                                                                                      variable WeiboShareButton

                                                                                                      const WeiboShareButton: ForwardRefExoticComponent<any>;

                                                                                                        variable WhatsappIcon

                                                                                                        const WhatsappIcon: FC<
                                                                                                        Omit<SVGProps<SVGSVGElement>, 'width' | 'height'> & {
                                                                                                        bgStyle?: React.CSSProperties;
                                                                                                        borderRadius?: number;
                                                                                                        iconFillColor?: string;
                                                                                                        round?: boolean;
                                                                                                        size?: number | string;
                                                                                                        }
                                                                                                        >;

                                                                                                          variable WhatsappShareButton

                                                                                                          const WhatsappShareButton: ForwardRefExoticComponent<any>;

                                                                                                            variable WorkplaceIcon

                                                                                                            const WorkplaceIcon: FC<
                                                                                                            Omit<SVGProps<SVGSVGElement>, 'width' | 'height'> & {
                                                                                                            bgStyle?: React.CSSProperties;
                                                                                                            borderRadius?: number;
                                                                                                            iconFillColor?: string;
                                                                                                            round?: boolean;
                                                                                                            size?: number | string;
                                                                                                            }
                                                                                                            >;

                                                                                                              variable WorkplaceShareButton

                                                                                                              const WorkplaceShareButton: ForwardRefExoticComponent<any>;

                                                                                                                variable XIcon

                                                                                                                const XIcon: FC<
                                                                                                                Omit<SVGProps<SVGSVGElement>, 'width' | 'height'> & {
                                                                                                                bgStyle?: React.CSSProperties;
                                                                                                                borderRadius?: number;
                                                                                                                iconFillColor?: string;
                                                                                                                round?: boolean;
                                                                                                                size?: number | string;
                                                                                                                }
                                                                                                                >;

                                                                                                                  Namespaces

                                                                                                                  namespace global

                                                                                                                  namespace global {}

                                                                                                                    interface Window

                                                                                                                    interface Window {}

                                                                                                                      property ODKL

                                                                                                                      ODKL: {
                                                                                                                      updateCount: (index: string, count: string) => void;
                                                                                                                      };

                                                                                                                        property OK

                                                                                                                        OK: {
                                                                                                                        Share: {
                                                                                                                        count: (index: number, _count: number) => void;
                                                                                                                        };
                                                                                                                        callbacks: ((count?: number) => void)[];
                                                                                                                        };

                                                                                                                          interface Window

                                                                                                                          interface Window {}

                                                                                                                            property VK

                                                                                                                            VK: {
                                                                                                                            Share?: {
                                                                                                                            count: (index: number, count: number) => void;
                                                                                                                            };
                                                                                                                            callbacks?: ((count?: number) => void)[];
                                                                                                                            };

                                                                                                                              Package Files (1)

                                                                                                                              Dependencies (2)

                                                                                                                              Dev Dependencies (23)

                                                                                                                              Peer Dependencies (1)

                                                                                                                              Badge

                                                                                                                              To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                              You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/react-share.

                                                                                                                              • Markdown
                                                                                                                                [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/react-share)
                                                                                                                              • HTML
                                                                                                                                <a href="https://www.jsdocs.io/package/react-share"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>