@selfcommunity/react-ui 0.8.0-embeds.17 → 0.8.0-live.41

package/lib/esm/components/CreateLiveStreamDialog/CreateLiveStreamDialog.js

@@ -0,0 +1,120 @@
+import { __rest } from "tslib";
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import React, { useCallback, useEffect, useMemo, useState } from 'react';
+import { styled } from '@mui/material/styles';
+import { useThemeProps } from '@mui/system';
+import { SCPreferences, UserUtils, useSCContext, useSCPreferences, useSCUser } from '@selfcommunity/react-core';
+import { SCFeatureName } from '@selfcommunity/types';
+import classNames from 'classnames';
+import { FormattedMessage } from 'react-intl';
+import BaseDialog from '../../shared/BaseDialog';
+import { PREFIX } from './constants';
+import EventForm from '../EventForm';
+import LiveStreamSelector from './LiveStreamSelector/LiveStreamSelector';
+import { CreateLiveStreamStep, LiveStreamType } from './types';
+import LiveStreamForm from '../LiveStreamForm';
+import Slide from '@mui/material/Slide';
+import { Box, Button, Icon } from '@mui/material';
+const classes = {
+    root: `${PREFIX}-root`,
+    title: `${PREFIX}-title`,
+    content: `${PREFIX}-content`
+};
+const Root = styled(BaseDialog, {
+    name: PREFIX,
+    slot: 'Root'
+})(({ theme }) => ({
+    paddingBottom: '0px !important',
+    [`& .${classes.title}`]: {
+        display: 'flex'
+    },
+    [`& .${classes.content}`]: {
+        paddingBottom: 0
+    }
+}));
+const Transition = React.forwardRef(function Transition(props, ref) {
+    return _jsx(Slide, Object.assign({ direction: "up", ref: ref }, props));
+});
+/**
+ *> API documentation for the Community-JS CreateLiveStreamDialog component. Learn about the available props and the CSS API.
+ *
+ #### Import
+ ```jsx
+ import {CreateLivestreamDialog} from '@selfcommunity/react-ui';
+ ```
+
+ #### Component Name
+ The name `SCCreateLivestreamDialog` can be used when providing style overrides in the theme.
+
+ #### CSS
+
+ |Rule Name|Global class|Description|
+ |---|---|---|
+ |root|.SCCreateLivestreamDialog-root|Styles applied to the root element.|
+ |content|.SCCreateLivestreamDialog-content|Styles applied to the content element.|
+
+
+
+ * @param inProps
+ */
+export default function CreateLiveStreamDialog(inProps) {
+    //PROPS
+    const props = useThemeProps({
+        props: inProps,
+        name: PREFIX
+    });
+    const { className, open = true, onClose, onSuccess } = props, rest = __rest(props, ["className", "open", "onClose", "onSuccess"]);
+    // CONTEXT
+    const scContext = useSCContext();
+    const scUserContext = useSCUser();
+    const { preferences, features } = useSCPreferences();
+    const liveStreamEnabled = useMemo(() => true, 
+    /* preferences &&
+            features &&
+            features.includes(SCFeatureName.LIVE_STREAM) &&
+            SCPreferences.CONFIGURATIONS_LIVE_STREAM_ENABLED in preferences &&
+            preferences[SCPreferences.CONFIGURATIONS_LIVE_STREAM_ENABLED].value*/ [preferences, features]);
+    const onlyStaffLiveStreamEnabled = useMemo(() => true /* preferences[SCPreferences.CONFIGURATIONS_LIVESTREAM_ONLY_STAFF_ENABLED].value */, [preferences]);
+    const canCreateLiveStream = useMemo(() => true /* liveStreamEnabled && (scUserContext?.user?.permission?.create_livestream || (onlyStaffLiveStreamEnabled && UserUtils.isStaff(scUserContext.user)))*/, [scUserContext === null || scUserContext === void 0 ? void 0 : scUserContext.user, onlyStaffLiveStreamEnabled]);
+    console.log(canCreateLiveStream);
+    const eventsEnabled = useMemo(() => preferences &&
+        features &&
+        features.includes(SCFeatureName.TAGGING) &&
+        SCPreferences.CONFIGURATIONS_EVENTS_ENABLED in preferences &&
+        preferences[SCPreferences.CONFIGURATIONS_EVENTS_ENABLED].value, [preferences, features]);
+    const onlyStaffEventEnabled = useMemo(() => preferences[SCPreferences.CONFIGURATIONS_EVENTS_ONLY_STAFF_ENABLED].value, [preferences]);
+    const canCreateEvent = useMemo(() => { var _a, _b; return eventsEnabled && (((_b = (_a = scUserContext === null || scUserContext === void 0 ? void 0 : scUserContext.user) === null || _a === void 0 ? void 0 : _a.permission) === null || _b === void 0 ? void 0 : _b.create_event) || true || (onlyStaffEventEnabled && UserUtils.isStaff(scUserContext.user))); }, [scUserContext === null || scUserContext === void 0 ? void 0 : scUserContext.user, eventsEnabled, onlyStaffEventEnabled]);
+    console.log(canCreateEvent);
+    const canCreateLiveStreamEvent = useMemo(() => Boolean(canCreateLiveStream && canCreateEvent), [canCreateEvent, canCreateLiveStream]);
+    console.log(canCreateLiveStreamEvent);
+    // STATE
+    const [step, setStep] = useState(canCreateLiveStreamEvent ? CreateLiveStreamStep.SELECT_TYPE : CreateLiveStreamStep.CREATE_LIVE);
+    const [liveType, setLiveType] = useState(canCreateLiveStreamEvent ? null : LiveStreamType.DIRECT_LIVE);
+    // HANDLER
+    const handleLiveTypeSelected = useCallback((l) => {
+        setLiveType(l);
+    }, []);
+    const handleLiveTypeSelectedNext = useCallback((l) => {
+        setLiveType(l);
+        setStep(CreateLiveStreamStep.CREATE_LIVE);
+    }, []);
+    const handleBack = useCallback((l) => {
+        setStep(CreateLiveStreamStep.SELECT_TYPE);
+    }, []);
+    const handleSubmit = useCallback((e) => {
+        onSuccess && onSuccess(e);
+    }, []);
+    useEffect(() => {
+        if (!canCreateLiveStreamEvent) {
+            setLiveType(LiveStreamType.DIRECT_LIVE);
+        }
+    }, [canCreateLiveStreamEvent]);
+    // user must be logged
+    if (!scUserContext.user) {
+        return null;
+    }
+    /**
+     * Renders root object
+     */
+    return (_jsx(Root, Object.assign({ DialogContentProps: { dividers: false }, maxWidth: 'md', title: _jsxs(Box, Object.assign({ className: classes.title, component: 'span' }, { children: [step === CreateLiveStreamStep.CREATE_LIVE && (_jsx(Button, Object.assign({ variant: "text", onClick: handleBack, startIcon: _jsx(Icon, { children: "arrow_back" }) }, { children: "Back" }))), _jsx(Box, Object.assign({ component: 'span' }, { children: _jsx(FormattedMessage, { id: "ui.createLivestreamDialog.title", defaultMessage: "ui.createLivestreamDialog.title" }) }))] })), fullWidth: true, open: open, onClose: onClose, className: classNames(classes.root, className), TransitionComponent: Transition, PaperProps: { elevation: 0 } }, rest, { children: _jsxs(Box, Object.assign({ className: classes.content }, { children: [step === CreateLiveStreamStep.SELECT_TYPE && (_jsx(LiveStreamSelector, { liveSelected: liveType, onLiveSelected: handleLiveTypeSelected, onNext: handleLiveTypeSelectedNext })), step === CreateLiveStreamStep.CREATE_LIVE && (_jsx(_Fragment, { children: liveType === LiveStreamType.EVENT_LIVE ? _jsx(EventForm, { onSuccess: handleSubmit }) : _jsx(LiveStreamForm, { onSuccess: handleSubmit }) }))] })) })));
+}

package/lib/esm/components/CreateLiveStreamDialog/LiveStreamSelector/LiveStreamSelector.d.ts

@@ -0,0 +1,46 @@
+import { LiveStreamType } from '../types';
+export interface LiveStreamSelectorProps {
+    /**
+     * Overrides or extends the styles applied to the component.
+     * @default null
+     */
+    className?: string;
+    /**
+     * Option selected
+     */
+    liveSelected?: LiveStreamType;
+    /**
+     * Callback on selected option
+     * @param LiveStreamType
+     */
+    onLiveSelected?: (live: LiveStreamType) => void;
+    /**
+     * On success callback function
+     * @default null
+     */
+    onNext?: (live: LiveStreamType) => void;
+    /**
+     * Any other properties
+     */
+    [p: string]: any;
+}
+/**
+ *> API documentation for the Community-JS LiveStreamSelector component. Learn about the available props and the CSS API.
+ *
+ #### Import
+ ```jsx
+ import {LiveStreamSelector} from '@selfcommunity/react-ui';
+ ```
+
+ #### Component Name
+ The name `SCLiveStreamSelector` can be used when providing style overrides in the theme.
+
+ #### CSS
+
+ |Rule Name|Global class|Description|
+ |---|---|---|
+ |root|.SCCreateLivestreamDialog-root|Styles applied to the root element.|
+
+ * @param inProps
+ */
+export default function LiveStreamSelector(inProps: LiveStreamSelectorProps): JSX.Element;

package/lib/esm/components/CreateLiveStreamDialog/LiveStreamSelector/LiveStreamSelector.js

@@ -0,0 +1,163 @@
+import { __rest } from "tslib";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from 'react';
+import { styled } from '@mui/material/styles';
+import { Box, Typography, Button, Paper, Container, Radio } from '@mui/material';
+import Icon from '@mui/material/Icon';
+import { PREFIX } from '../constants';
+import { useThemeProps } from '@mui/system';
+import classNames from 'classnames';
+import { LiveStreamType } from '../types';
+import { useSnackbar } from 'notistack';
+import { FormattedMessage } from 'react-intl';
+const classes = {
+    root: `${PREFIX}-root`,
+    options: `${PREFIX}-options`,
+    actions: `${PREFIX}-actions`
+};
+const Root = styled(Container, {
+    name: PREFIX,
+    slot: 'Root'
+})(({ theme }) => ({
+    [`& .${classes.options}`]: {
+        display: 'flex',
+        justifyContent: 'center',
+        alignItems: 'center'
+    },
+    [`& .${classes.actions}`]: {
+        display: 'flex',
+        justifyContent: 'flex-end',
+        alignItems: 'flex-end',
+        marginTop: theme.spacing(4)
+    }
+}));
+// Styled components
+const OptionCard = styled(Paper, {
+    shouldForwardProp: (prop) => prop !== 'selected'
+})(({ theme, selected }) => ({
+    maxWidth: '300px',
+    padding: theme.spacing(3),
+    margin: theme.spacing(0, 3),
+    cursor: 'pointer',
+    transition: theme.transitions.create(['background-color', 'box-shadow'], {
+        duration: theme.transitions.duration.short
+    }),
+    backgroundColor: selected ? theme.palette.grey[100] : theme.palette.background.paper,
+    '&:hover': {
+        backgroundColor: theme.palette.grey[50],
+        boxShadow: theme.shadows[2]
+    },
+    border: `1px solid ${theme.palette.divider}`,
+    [`& > div`]: {
+        display: 'flex',
+        justifyContent: 'space-between',
+        alignItems: 'center',
+        marginBottom: 2,
+        maxWidth: '300px'
+    },
+    [`& ul`]: {
+        marginTop: theme.spacing(2),
+        padding: 0,
+        listStyle: 'none'
+    }
+}));
+const RadioIndicator = styled(Radio, {
+    shouldForwardProp: (prop) => prop !== 'selected'
+})(({ theme, selected }) => ({
+    width: 16,
+    height: 16,
+    borderRadius: '50%',
+    border: `2px solid ${selected ? theme.palette.secondary.main : theme.palette.grey[300]}`,
+    backgroundColor: selected ? theme.palette.secondary.main : 'transparent',
+    transition: theme.transitions.create(['border-color', 'background-color'], {
+        duration: theme.transitions.duration.shortest
+    })
+}));
+const FeatureItem = styled(Box)(({ theme }) => ({
+    display: 'flex',
+    alignItems: 'flex-start',
+    gap: theme.spacing(1.5),
+    marginBottom: theme.spacing(2),
+    '&:last-child': {
+        marginBottom: 0
+    }
+}));
+/**
+ *> API documentation for the Community-JS LiveStreamSelector component. Learn about the available props and the CSS API.
+ *
+ #### Import
+ ```jsx
+ import {LiveStreamSelector} from '@selfcommunity/react-ui';
+ ```
+
+ #### Component Name
+ The name `SCLiveStreamSelector` can be used when providing style overrides in the theme.
+
+ #### CSS
+
+ |Rule Name|Global class|Description|
+ |---|---|---|
+ |root|.SCCreateLivestreamDialog-root|Styles applied to the root element.|
+
+ * @param inProps
+ */
+export default function LiveStreamSelector(inProps) {
+    //PROPS
+    const props = useThemeProps({
+        props: inProps,
+        name: PREFIX
+    });
+    const { className, liveSelected, onLiveSelected, onNext } = props, rest = __rest(props, ["className", "liveSelected", "onLiveSelected", "onNext"]);
+    // CONTEXT
+    const { enqueueSnackbar } = useSnackbar();
+    // STATE
+    const [selectedOption, setSelectedOption] = useState(liveSelected);
+    const options = [
+        {
+            title: 'Schedule a live event',
+            type: LiveStreamType.EVENT_LIVE,
+            features: [
+                'Schedule a live room or stream in your event space',
+                'Allow your members to RSVP, add to calendar, and receive event reminders',
+                'Automatically post the event recording to your space',
+                'Allow your members to host the event'
+            ],
+            icons: [_jsx(Icon, { children: "chevron_right" }), _jsx(Icon, { children: "chevron_right" }), _jsx(Icon, { children: "chevron_right" }), _jsx(Icon, { children: "chevron_right" })]
+        },
+        {
+            title: 'Start a live stream',
+            type: LiveStreamType.DIRECT_LIVE,
+            features: [
+                'Best for webinars, Q&As, AMAs, and for presentations',
+                'Up to 100 people',
+                'Only co-hosts can talk to each other with audio/video',
+                'View-only participants can only chat or be promoted to the stage'
+            ],
+            icons: [_jsx(Icon, { children: "chevron_right" }), _jsx(Icon, { children: "chevron_right" }), _jsx(Icon, { children: "chevron_right" }), _jsx(Icon, { children: "chevron_right" })]
+        }
+    ];
+    const handleOptionSelect = (type) => {
+        setSelectedOption(type);
+        onLiveSelected(type);
+    };
+    const handleNext = () => {
+        if (!selectedOption) {
+            enqueueSnackbar(_jsx(FormattedMessage, { id: "ui.common.error", defaultMessage: "ui.common.error" }), {
+                variant: 'error',
+                autoHideDuration: 3000
+            });
+        }
+        else {
+            onNext && onNext(selectedOption);
+        }
+    };
+    return (_jsxs(Root, Object.assign({ className: classNames(classes.root, className), maxWidth: "lg", sx: { py: 4 } }, { children: [_jsx(Typography, Object.assign({ variant: "h4", component: "h1", align: "center", gutterBottom: true, sx: { mb: 4, fontWeight: 500 } }, { children: "How do you want to go live?" })), _jsx(Box, Object.assign({ className: classes.options }, { children: options.map((option, index) => (_jsxs(OptionCard, Object.assign({ selected: selectedOption === option.type, onClick: () => handleOptionSelect(option.type), elevation: 0, role: "button", tabIndex: 0, onKeyDown: (e) => {
+                        if (e.key === 'Enter' || e.key === ' ') {
+                            handleOptionSelect(index);
+                            e.preventDefault();
+                        }
+                    }, theme: undefined }, { children: [_jsxs(Box, { children: [_jsx(Typography, Object.assign({ variant: "h6", component: "h2", sx: { fontWeight: 500 } }, { children: option.title })), _jsx(RadioIndicator, { selected: selectedOption === option.type, theme: undefined })] }), _jsx(Box, Object.assign({ component: "ul" }, { children: option.features.map((feature, featureIndex) => {
+                                const _Icon = option.icons[featureIndex];
+                                return (_jsxs(FeatureItem, Object.assign({ component: "li" }, { children: [_Icon, _jsx(Typography, Object.assign({ variant: "body2", color: "text.secondary", sx: { flex: 1 } }, { children: feature }))] }), featureIndex));
+                            }) }))] }), index))) })), _jsx(Box, Object.assign({ className: classes.actions }, { children: _jsx(Button, Object.assign({ disabled: !selectedOption, variant: "contained", onClick: handleNext, color: "secondary" }, { children: "Next" })) }))] })));
+}

package/lib/esm/components/CreateLiveStreamDialog/constants.d.ts

@@ -0,0 +1 @@
+export declare const PREFIX = "SCCreateLiveStreamDialog";

package/lib/esm/components/CreateLiveStreamDialog/constants.js

@@ -0,0 +1 @@
+export const PREFIX = 'SCCreateLiveStreamDialog';

package/lib/esm/components/CreateLiveStreamDialog/index.d.ts

@@ -0,0 +1,3 @@
+import CreateLiveStreamDialog, { CreateLiveStreamDialogProps } from './CreateLiveStreamDialog';
+export default CreateLiveStreamDialog;
+export { CreateLiveStreamDialogProps };

package/lib/esm/components/CreateLiveStreamDialog/index.js

@@ -0,0 +1,2 @@
+import CreateLiveStreamDialog from './CreateLiveStreamDialog';
+export default CreateLiveStreamDialog;

package/lib/esm/components/CreateLiveStreamDialog/types.d.ts

@@ -0,0 +1,8 @@
+export declare enum CreateLiveStreamStep {
+    SELECT_TYPE = "_select_type",
+    CREATE_LIVE = "_create_live"
+}
+export declare enum LiveStreamType {
+    EVENT_LIVE = "_event_live",
+    DIRECT_LIVE = "_direct_live"
+}

package/lib/esm/components/CreateLiveStreamDialog/types.js

@@ -0,0 +1,10 @@
+export var CreateLiveStreamStep;
+(function (CreateLiveStreamStep) {
+    CreateLiveStreamStep["SELECT_TYPE"] = "_select_type";
+    CreateLiveStreamStep["CREATE_LIVE"] = "_create_live";
+})(CreateLiveStreamStep || (CreateLiveStreamStep = {}));
+export var LiveStreamType;
+(function (LiveStreamType) {
+    LiveStreamType["EVENT_LIVE"] = "_event_live";
+    LiveStreamType["DIRECT_LIVE"] = "_direct_live";
+})(LiveStreamType || (LiveStreamType = {}));

package/lib/esm/components/EditEventButton/EditEventButton.js

@@ -53,5 +53,5 @@ export default function EditEventButton(inProps) {
     /**
      * Renders root object
      */
-    return (_jsx(Root, Object.assign({ variant: "outlined", className: classNames(classes.root, className), EventFormProps: { event: scEvent, onSuccess: handleSuccess } }, rest, { children: _jsx(FormattedMessage, { id: "ui.editEventButton", defaultMessage: "ui.editEventButton" }) })));
+    return (_jsx(Root, Object.assign({ variant: "outlined", className: classNames(classes.root, className), EventFormDialogComponentProps: { EventFormComponentProps: { event: scEvent, onSuccess: handleSuccess } } }, rest, { children: _jsx(FormattedMessage, { id: "ui.editEventButton", defaultMessage: "ui.editEventButton" }) })));
 }

package/lib/esm/components/Editor/Editor.d.ts

@@ -1,5 +1,5 @@
 import React from 'react';
-export declare type EditorRef = {
+export type EditorRef = {
     focus: () => void;
 };
 export interface EditorProps {

package/lib/esm/components/Editor/nodes/HashtagNode.d.ts

@@ -1,7 +1,7 @@
 import { DOMExportOutput, EditorConfig, LexicalNode, NodeKey, SerializedTextNode, Spread, TextNode } from 'lexical';
 import { SCCategoryType } from '@selfcommunity/types';
 import { DOMConversionMap } from 'lexical/LexicalNode';
-export declare type SerializedHashtagNode = Spread<{
+export type SerializedHashtagNode = Spread<{
     category: SCCategoryType;
     type: 'hashtag';
     version: 1;

package/lib/esm/components/Editor/nodes/HashtagNode.js

@@ -9,16 +9,16 @@ function convertHashtagElement(domNode) {
     };
 }
 export class HashtagNode extends TextNode {
-    constructor(category, text, key) {
-        super(text !== null && text !== void 0 ? text : `#${category.name}`, key);
-        this.__category = category;
-    }
     static getType() {
         return 'hashtag';
     }
     static clone(node) {
         return new HashtagNode(node.__category, node.__text, node.__key);
     }
+    constructor(category, text, key) {
+        super(text !== null && text !== void 0 ? text : `#${category.name}`, key);
+        this.__category = category;
+    }
     createDOM(config) {
         const tag = 'hashtag';
         const dom = document.createElement(tag);

package/lib/esm/components/Editor/nodes/ImageNode.d.ts

@@ -12,7 +12,7 @@ export interface ImagePayload {
 declare function convertImageElement(domNode: any): {
     node: ImageNode;
 };
-export declare type SerializedImageNode = Spread<{
+export type SerializedImageNode = Spread<{
     altText: string;
     maxWidth: number | string;
     src: string;

package/lib/esm/components/Editor/nodes/ImageNode.js

@@ -104,18 +104,18 @@ function convertImageElement(domNode) {
 // eslint-disable-next-line @typescript-eslint/ban-ts-ignore
 // @ts-ignore
 export class ImageNode extends DecoratorNode {
-    constructor(src, altText, maxWidth, key) {
-        super(key);
-        this.__src = src;
-        this.__altText = altText;
-        this.__maxWidth = maxWidth;
-    }
     static getType() {
         return 'image';
     }
     static clone(node) {
         return new ImageNode(node.__src, node.__altText, node.__maxWidth, node.__key);
     }
+    constructor(src, altText, maxWidth, key) {
+        super(key);
+        this.__src = src;
+        this.__altText = altText;
+        this.__maxWidth = maxWidth;
+    }
     setWidthAndHeight(width, height) {
         const writable = this.getWritable();
         // eslint-disable-next-line @typescript-eslint/ban-ts-ignore

package/lib/esm/components/Editor/nodes/MentionNode.d.ts

@@ -1,7 +1,7 @@
 import { DOMExportOutput, EditorConfig, LexicalNode, NodeKey, SerializedTextNode, Spread, TextNode } from 'lexical';
 import { SCUserType } from '@selfcommunity/types';
 import { DOMConversionMap } from 'lexical/LexicalNode';
-export declare type SerializedMentionNode = Spread<{
+export type SerializedMentionNode = Spread<{
     user: SCUserType;
     type: 'mention';
     version: 1;

package/lib/esm/components/Editor/nodes/MentionNode.js

@@ -22,16 +22,16 @@ function convertMentionElement(domNode) {
     };
 }
 export class MentionNode extends TextNode {
-    constructor(user, text, key) {
-        super(text !== null && text !== void 0 ? text : `@${user.username}`, key);
-        this.__user = user;
-    }
     static getType() {
         return 'mention';
     }
     static clone(node) {
         return new MentionNode(node.__user, node.__text, node.__key);
     }
+    constructor(user, text, key) {
+        super(text !== null && text !== void 0 ? text : `@${user.username}`, key);
+        this.__user = user;
+    }
     createDOM(config) {
         const tag = 'mention';
         const dom = document.createElement(tag);

package/lib/esm/components/Editor/plugins/ApiPlugin.d.ts

@@ -1,5 +1,5 @@
 import React from 'react';
-export declare type ApiRef = {
+export type ApiRef = {
     focus: () => void;
 };
 declare const _default: React.ForwardRefExoticComponent<Pick<any, string | number | symbol> & React.RefAttributes<ApiRef>>;

package/lib/esm/components/Editor/plugins/MentionsPlugin.d.ts

@@ -1,9 +1,9 @@
-declare type MentionMatch = {
+type MentionMatch = {
     leadOffset: number;
     matchingString: string;
     replaceableString: string;
 };
-declare type Resolution = {
+type Resolution = {
     match: MentionMatch;
     range: Range;
 };

package/lib/esm/components/Editor/shared/useDecorators.d.ts

@@ -7,10 +7,10 @@
  */
 import type { LexicalEditor } from 'lexical';
 import * as React from 'react';
-declare type ErrorBoundaryProps = {
+type ErrorBoundaryProps = {
     children: JSX.Element;
     onError: (error: Error) => void;
 };
-export declare type ErrorBoundaryType = React.ComponentClass<ErrorBoundaryProps> | React.FC<ErrorBoundaryProps>;
+export type ErrorBoundaryType = React.ComponentClass<ErrorBoundaryProps> | React.FC<ErrorBoundaryProps>;
 export declare function useDecorators(editor: LexicalEditor, ErrorBoundary: ErrorBoundaryType): Array<JSX.Element>;
 export {};

package/lib/esm/components/Event/Event.js

@@ -106,7 +106,7 @@ export default function Event(inProps) {
     });
     const { id = `event_object_${props.eventId ? props.eventId : props.event ? props.event.id : ''}`, eventId = null, event = null, className = null, template = SCEventTemplateType.SNIPPET, hideInProgress = false, hideEventParticipants = false, hideEventPlanner = false, actions, EventParticipantsButtonComponentProps = {}, EventSkeletonComponentProps = {} } = props, rest = __rest(props, ["id", "eventId", "event", "className", "template", "hideInProgress", "hideEventParticipants", "hideEventPlanner", "actions", "EventParticipantsButtonComponentProps", "EventSkeletonComponentProps"]);
     // STATE
-    const { scEvent } = useSCFetchEvent({ id: eventId, event });
+    const { scEvent } = useSCFetchEvent({ id: eventId, event, autoSubscribe: false });
     const inProgress = useMemo(() => scEvent && scEvent.active && scEvent.running, [scEvent]);
     // CONTEXT
     const scRoutingContext = useSCRouting();

package/lib/esm/components/EventForm/EventForm.d.ts

@@ -1,21 +1,11 @@
+import { BoxProps } from '@mui/material';
 import { SCEventType } from '@selfcommunity/types';
-import { BaseDialogProps } from '../../shared/BaseDialog';
-export interface EventFormProps extends BaseDialogProps {
+export interface EventFormProps extends BoxProps {
     /**
      * Overrides or extends the styles applied to the component.
      * @default null
      */
     className?: string;
-    /**
-     * Open dialog
-     * @default true
-     */
-    open?: boolean;
-    /**
-     * On dialog close callback function
-     * @default null
-     */
-    onClose?: () => void;
     /**
      * Event Object
      * @default null
@@ -26,6 +16,11 @@ export interface EventFormProps extends BaseDialogProps {
      * @default null
      */
     onSuccess?: (data: SCEventType) => void;
+    /**
+     * On error callback function
+     * @default null
+     */
+    onError?: (error: any) => void;
     /**
      * Any other properties
      */