@nlabs/gothamui 1.8.0

package/lib/components/Notify/Notify.js

@@ -0,0 +1,178 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Copyright (c) 2018-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { Transition } from '@headlessui/react';
+import { useFluxListener } from '@nlabs/arkhamjs-utils-react';
+import { cn } from '@nlabs/utils';
+import { Fragment, useEffect, useRef, useState } from 'react';
+import { GothamConstants } from '../../constants/GothamConstants.js';
+import { Svg } from '../Svg/Svg.js';
+// Custom Button component
+const Button = ({ children, onClick, className = '' })=>/*#__PURE__*/ _jsx("button", {
+        className: cn('inline-flex items-center px-4 py-2 border border-transparent text-sm font-medium rounded-md shadow-sm', 'text-white bg-indigo-600 hover:bg-indigo-700 focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-indigo-500', className),
+        onClick: onClick,
+        type: "button",
+        children: children
+    });
+// Custom IconButton component
+const IconButton = ({ children, onClick, className = '' })=>/*#__PURE__*/ _jsx("button", {
+        className: cn('p-1 rounded-full hover:bg-gray-200 focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-indigo-500', className),
+        onClick: onClick,
+        type: "button",
+        children: children
+    });
+// Custom Alert component
+const Alert = ({ children, severity, onClose })=>{
+    const bgColors = {
+        error: 'bg-red-500',
+        info: 'bg-blue-500',
+        success: 'bg-green-500',
+        warning: 'bg-yellow-500'
+    };
+    return /*#__PURE__*/ _jsxs("div", {
+        className: cn('rounded-md p-4 w-full flex items-start justify-between gap-3', bgColors[severity] || 'bg-gray-500', 'text-white'),
+        children: [
+            /*#__PURE__*/ _jsx("div", {
+                className: "min-w-0 whitespace-normal break-words leading-relaxed [overflow-wrap:anywhere]",
+                children: children
+            }),
+            onClose && /*#__PURE__*/ _jsx("button", {
+                "aria-label": "Dismiss",
+                className: "-mx-1.5 -my-1.5 inline-flex shrink-0 rounded-md p-1.5 text-white hover:bg-black/20 focus:outline-none focus:ring-2 focus:ring-white",
+                onClick: onClose,
+                type: "button",
+                children: /*#__PURE__*/ _jsx("svg", {
+                    className: "h-5 w-5",
+                    fill: "currentColor",
+                    viewBox: "0 0 20 20",
+                    xmlns: "http://www.w3.org/2000/svg",
+                    children: /*#__PURE__*/ _jsx("path", {
+                        clipRule: "evenodd",
+                        d: "M4.293 4.293a1 1 0 011.414 0L10 8.586l4.293-4.293a1 1 0 111.414 1.414L11.414 10l4.293 4.293a1 1 0 01-1.414 1.414L10 11.414l-4.293 4.293a1 1 0 01-1.414-1.414L8.586 10 4.293 5.707a1 1 0 010-1.414z",
+                        fillRule: "evenodd"
+                    })
+                })
+            })
+        ]
+    });
+};
+export const Notify = ()=>{
+    const [isOpen, setOpen] = useState(false);
+    const [isHovered, setHovered] = useState(false);
+    const [notification, setNotification] = useState({});
+    const remainingDurationRef = useRef(undefined);
+    const timerStartedAtRef = useRef(0);
+    const notifyClose = ()=>{
+        remainingDurationRef.current = undefined;
+        timerStartedAtRef.current = 0;
+        setOpen(false);
+    };
+    useEffect(()=>{
+        if (isOpen && notification.autoHideDuration && !isHovered) {
+            const duration = remainingDurationRef.current ?? notification.autoHideDuration;
+            timerStartedAtRef.current = Date.now();
+            const id = setTimeout(()=>{
+                notifyClose();
+            }, duration);
+            return ()=>{
+                clearTimeout(id);
+                remainingDurationRef.current = Math.max(0, duration - (Date.now() - timerStartedAtRef.current));
+            };
+        }
+        return undefined;
+    }, [
+        isHovered,
+        isOpen,
+        notification.autoHideDuration
+    ]);
+    const notifyOpen = ({ actions = [], autoHideDuration = 15000, message, severity, anchorOrigin = {
+        horizontal: 'left',
+        vertical: 'bottom'
+    }, ...restProps })=>{
+        remainingDurationRef.current = autoHideDuration;
+        setHovered(false);
+        setNotification({
+            ...restProps,
+            actions,
+            anchorOrigin,
+            autoHideDuration,
+            message: severity ? /*#__PURE__*/ _jsx(Alert, {
+                onClose: notifyClose,
+                severity: severity,
+                children: message
+            }) : message,
+            severity
+        });
+        setOpen(true);
+    };
+    useFluxListener(GothamConstants.NOTIFY_OPEN, notifyOpen);
+    useFluxListener(GothamConstants.NOTIFY_CLOSE, notifyClose);
+    const positionClasses = (()=>{
+        const { horizontal = 'left', vertical = 'bottom' } = notification.anchorOrigin || {};
+        const positions = {
+            bottom: {
+                center: 'bottom-4 left-1/2 transform -translate-x-1/2',
+                left: 'bottom-4 left-4',
+                right: 'bottom-4 right-4'
+            },
+            top: {
+                center: 'top-4 left-1/2 transform -translate-x-1/2',
+                left: 'top-4 left-4',
+                right: 'top-4 right-4'
+            }
+        };
+        return positions[vertical][horizontal];
+    })();
+    return /*#__PURE__*/ _jsx(Transition, {
+        as: Fragment,
+        enter: "transform ease-out duration-300 transition",
+        enterFrom: "translate-y-2 opacity-0 sm:translate-y-0 sm:translate-x-2",
+        enterTo: "translate-y-0 opacity-100 sm:translate-x-0",
+        leave: "transition ease-in duration-100",
+        leaveFrom: "opacity-100",
+        leaveTo: "opacity-0",
+        show: isOpen,
+        children: /*#__PURE__*/ _jsx("div", {
+            className: cn('fixed z-50 w-[min(960px,calc(100vw-2rem))] max-w-[min(960px,calc(100vw-2rem))] shadow-lg rounded-lg pointer-events-auto overflow-hidden', positionClasses),
+            onMouseEnter: ()=>setHovered(true),
+            onMouseLeave: ()=>setHovered(false),
+            children: /*#__PURE__*/ _jsx("div", {
+                className: "ring-1 ring-black ring-opacity-5 bg-white",
+                children: !notification.severity ? /*#__PURE__*/ _jsx("div", {
+                    className: "p-4",
+                    children: /*#__PURE__*/ _jsxs("div", {
+                        className: "flex items-start",
+                        children: [
+                            /*#__PURE__*/ _jsx("div", {
+                                className: "flex-1",
+                                children: notification.message
+                            }),
+                            notification.actions?.length && /*#__PURE__*/ _jsx("div", {
+                                className: "ml-4 shrink-0 flex",
+                                children: notification.actions.map(({ icon, label, onClick }, index)=>/*#__PURE__*/ _jsx(Fragment, {
+                                        children: icon ? /*#__PURE__*/ _jsx(IconButton, {
+                                            onClick: ()=>onClick('notification'),
+                                            children: /*#__PURE__*/ _jsx(Svg, {
+                                                color: "inherit",
+                                                height: 24,
+                                                name: icon,
+                                                width: 24
+                                            })
+                                        }) : /*#__PURE__*/ _jsx(Button, {
+                                            onClick: ()=>onClick('notification'),
+                                            children: label
+                                        })
+                                    }, index))
+                            })
+                        ]
+                    })
+                }) : /*#__PURE__*/ _jsx("div", {
+                    children: notification.message
+                })
+            })
+        })
+    });
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/gothamjs/src/components/Notify/Notify.tsx"],"sourcesContent":["/**\n * Copyright (c) 2018-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nimport {Transition} from '@headlessui/react';\nimport {useFluxListener} from '@nlabs/arkhamjs-utils-react';\nimport {cn} from '@nlabs/utils';\nimport {Fragment, useEffect, useRef, useState} from 'react';\n\nimport {GothamConstants} from '../../constants/GothamConstants.js';\nimport {Svg} from '../Svg/Svg.js';\n\nimport type {ReactElement} from 'react';\n\nexport interface GothamNotifyAction {\n  readonly icon?: string;\n  readonly label?: string;\n  readonly onClick: (key: string) => void;\n}\n\nexport type GothamSeverity = 'error' | 'info' | 'success' | 'warning';\n\nexport interface GothamNotifyParams {\n  readonly actions?: GothamNotifyAction[];\n  readonly anchorOrigin?: {\n    vertical: 'top' | 'bottom';\n    horizontal: 'left' | 'center' | 'right';\n  };\n  readonly autoHideDuration?: number;\n  readonly message?: ReactElement | string;\n  readonly severity?: GothamSeverity;\n}\n\n// Custom Button component\nconst Button = ({children, onClick, className = ''}) => (\n  <button\n    className={cn(\n      'inline-flex items-center px-4 py-2 border border-transparent text-sm font-medium rounded-md shadow-sm',\n      'text-white bg-indigo-600 hover:bg-indigo-700 focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-indigo-500',\n      className\n    )}\n    onClick={onClick}\n    type=\"button\"\n  >\n    {children}\n  </button>\n);\n\n// Custom IconButton component\nconst IconButton = ({children, onClick, className = ''}) => (\n  <button\n    className={cn(\n      'p-1 rounded-full hover:bg-gray-200 focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-indigo-500',\n      className\n    )}\n    onClick={onClick}\n    type=\"button\"\n  >\n    {children}\n  </button>\n);\n\n// Custom Alert component\nconst Alert = ({children, severity, onClose}) => {\n  const bgColors = {\n    error: 'bg-red-500',\n    info: 'bg-blue-500',\n    success: 'bg-green-500',\n    warning: 'bg-yellow-500'\n  };\n\n  return (\n    <div className={cn(\n      'rounded-md p-4 w-full flex items-start justify-between gap-3',\n      bgColors[severity] || 'bg-gray-500',\n      'text-white'\n    )}>\n      <div className=\"min-w-0 whitespace-normal break-words leading-relaxed [overflow-wrap:anywhere]\">{children}</div>\n      {onClose && (\n        <button\n          aria-label=\"Dismiss\"\n          className=\"-mx-1.5 -my-1.5 inline-flex shrink-0 rounded-md p-1.5 text-white hover:bg-black/20 focus:outline-none focus:ring-2 focus:ring-white\"\n          onClick={onClose}\n          type=\"button\"\n        >\n          <svg className=\"h-5 w-5\" fill=\"currentColor\" viewBox=\"0 0 20 20\" xmlns=\"http://www.w3.org/2000/svg\">\n            <path clipRule=\"evenodd\" d=\"M4.293 4.293a1 1 0 011.414 0L10 8.586l4.293-4.293a1 1 0 111.414 1.414L11.414 10l4.293 4.293a1 1 0 01-1.414 1.414L10 11.414l-4.293 4.293a1 1 0 01-1.414-1.414L8.586 10 4.293 5.707a1 1 0 010-1.414z\" fillRule=\"evenodd\" />\n          </svg>\n        </button>\n      )}\n    </div>\n  );\n};\n\nexport const Notify = () => {\n  const [isOpen, setOpen] = useState(false);\n  const [isHovered, setHovered] = useState(false);\n  const [notification, setNotification] = useState<GothamNotifyParams>({});\n  const remainingDurationRef = useRef<number | undefined>(undefined);\n  const timerStartedAtRef = useRef(0);\n\n  const notifyClose = () => {\n    remainingDurationRef.current = undefined;\n    timerStartedAtRef.current = 0;\n    setOpen(false);\n  };\n\n  useEffect(() => {\n    if(isOpen && notification.autoHideDuration && !isHovered) {\n      const duration = remainingDurationRef.current ?? notification.autoHideDuration;\n      timerStartedAtRef.current = Date.now();\n      const id = setTimeout(() => {\n        notifyClose();\n      }, duration);\n\n      return () => {\n        clearTimeout(id);\n        remainingDurationRef.current = Math.max(0, duration - (Date.now() - timerStartedAtRef.current));\n      };\n    }\n\n    return undefined;\n  }, [isHovered, isOpen, notification.autoHideDuration]);\n\n  const notifyOpen = ({\n    actions = [],\n    autoHideDuration = 15000,\n    message,\n    severity,\n    anchorOrigin = {horizontal: 'left', vertical: 'bottom'},\n    ...restProps\n  }: GothamNotifyParams) => {\n    remainingDurationRef.current = autoHideDuration;\n    setHovered(false);\n    setNotification({\n      ...restProps,\n      actions,\n      anchorOrigin,\n      autoHideDuration,\n      message: severity ? (\n        <Alert\n          onClose={notifyClose}\n          severity={severity}\n        >\n          {message}\n        </Alert>\n      ) : message,\n      severity\n    });\n    setOpen(true);\n  };\n\n  useFluxListener(GothamConstants.NOTIFY_OPEN, notifyOpen);\n  useFluxListener(GothamConstants.NOTIFY_CLOSE, notifyClose);\n\n  const positionClasses = (() => {\n    const {horizontal = 'left', vertical = 'bottom'} = notification.anchorOrigin || {};\n\n    const positions = {\n      bottom: {\n        center: 'bottom-4 left-1/2 transform -translate-x-1/2',\n        left: 'bottom-4 left-4',\n        right: 'bottom-4 right-4'\n      },\n      top: {\n        center: 'top-4 left-1/2 transform -translate-x-1/2',\n        left: 'top-4 left-4',\n        right: 'top-4 right-4'\n      }\n    };\n\n    return positions[vertical][horizontal];\n  })();\n\n  return (\n    <Transition\n      as={Fragment}\n      enter=\"transform ease-out duration-300 transition\"\n      enterFrom=\"translate-y-2 opacity-0 sm:translate-y-0 sm:translate-x-2\"\n      enterTo=\"translate-y-0 opacity-100 sm:translate-x-0\"\n      leave=\"transition ease-in duration-100\"\n      leaveFrom=\"opacity-100\"\n      leaveTo=\"opacity-0\"\n      show={isOpen}\n    >\n      <div className={cn(\n        'fixed z-50 w-[min(960px,calc(100vw-2rem))] max-w-[min(960px,calc(100vw-2rem))] shadow-lg rounded-lg pointer-events-auto overflow-hidden',\n        positionClasses\n      )}\n      onMouseEnter={() => setHovered(true)}\n      onMouseLeave={() => setHovered(false)}\n      >\n        <div className=\"ring-1 ring-black ring-opacity-5 bg-white\">\n          {!notification.severity ? (\n            <div className=\"p-4\">\n              <div className=\"flex items-start\">\n                <div className=\"flex-1\">\n                  {notification.message}\n                </div>\n                {notification.actions?.length && (\n                  <div className=\"ml-4 shrink-0 flex\">\n                    {notification.actions.map(({icon, label, onClick}, index) => (\n                      <Fragment key={index}>\n                        {icon ? (\n                          <IconButton onClick={() => onClick('notification')}>\n                            <Svg color=\"inherit\" height={24} name={icon} width={24} />\n                          </IconButton>\n                        ) : (\n                          <Button onClick={() => onClick('notification')}>{label}</Button>\n                        )}\n                      </Fragment>\n                    ))}\n                  </div>\n                )}\n              </div>\n            </div>\n          ) : (\n            <div>\n              {notification.message as ReactElement}\n            </div>\n          )}\n        </div>\n      </div>\n    </Transition>\n  );\n};\n"],"names":["Transition","useFluxListener","cn","Fragment","useEffect","useRef","useState","GothamConstants","Svg","Button","children","onClick","className","button","type","IconButton","Alert","severity","onClose","bgColors","error","info","success","warning","div","aria-label","svg","fill","viewBox","xmlns","path","clipRule","d","fillRule","Notify","isOpen","setOpen","isHovered","setHovered","notification","setNotification","remainingDurationRef","undefined","timerStartedAtRef","notifyClose","current","autoHideDuration","duration","Date","now","id","setTimeout","clearTimeout","Math","max","notifyOpen","actions","message","anchorOrigin","horizontal","vertical","restProps","NOTIFY_OPEN","NOTIFY_CLOSE","positionClasses","positions","bottom","center","left","right","top","as","enter","enterFrom","enterTo","leave","leaveFrom","leaveTo","show","onMouseEnter","onMouseLeave","length","map","icon","label","index","color","height","name","width"],"mappings":"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"}

package/lib/components/Notify/Notify.stories.js

@@ -0,0 +1,148 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect } from 'react';
+import { Flux } from '@nlabs/arkhamjs';
+import { FluxProvider } from '@nlabs/arkhamjs-utils-react';
+import { GothamActions } from '../../actions/GothamActions.js';
+import { interactWithCanvas } from '../../utils/storyInteractions.js';
+import { Notify } from './Notify.js';
+import { NotifyExample } from './NotifyExample.js';
+if (!Flux.isInit) {
+    void Flux.init({
+        name: 'gothamui-storybook'
+    });
+}
+const NotifyTrigger = ({ notification })=>{
+    useEffect(()=>()=>{
+            GothamActions.notifyClose();
+        }, []);
+    return /*#__PURE__*/ _jsx("div", {
+        className: "flex min-h-64 items-center justify-center p-8",
+        children: /*#__PURE__*/ _jsx("button", {
+            className: "cursor-pointer rounded-md bg-primary px-4 py-2 text-sm font-semibold text-white shadow-sm hover:bg-primary-700 focus:outline-none focus:ring-2 focus:ring-primary focus:ring-offset-2",
+            onClick: ()=>GothamActions.notify(notification),
+            type: "button",
+            children: "Open"
+        })
+    });
+};
+const meta = {
+    argTypes: {
+        anchorOrigin: {
+            control: 'object'
+        },
+        message: {
+            control: 'text'
+        },
+        severity: {
+            control: 'select',
+            options: [
+                'error',
+                'info',
+                'success',
+                'warning'
+            ]
+        }
+    },
+    component: Notify,
+    decorators: [
+        (Story)=>/*#__PURE__*/ _jsxs(FluxProvider, {
+                flux: Flux,
+                children: [
+                    /*#__PURE__*/ _jsx(Story, {}),
+                    /*#__PURE__*/ _jsx(Notify, {})
+                ]
+            })
+    ],
+    parameters: {
+        layout: 'fullscreen'
+    },
+    title: 'Components/Notify'
+};
+export default meta;
+export const Basic = {
+    play: interactWithCanvas,
+    render: ()=>/*#__PURE__*/ _jsx(NotifyTrigger, {
+            notification: {
+                autoHideDuration: 5000,
+                message: 'This is a basic notification'
+            }
+        })
+};
+export const Success = {
+    play: interactWithCanvas,
+    render: ()=>/*#__PURE__*/ _jsx(NotifyTrigger, {
+            notification: {
+                message: 'Operation completed successfully',
+                severity: 'success'
+            }
+        })
+};
+export const Error = {
+    play: interactWithCanvas,
+    render: ()=>/*#__PURE__*/ _jsx(NotifyTrigger, {
+            notification: {
+                message: 'An error occurred',
+                severity: 'error'
+            }
+        })
+};
+export const Warning = {
+    play: interactWithCanvas,
+    render: ()=>/*#__PURE__*/ _jsx(NotifyTrigger, {
+            notification: {
+                message: 'This is a warning message',
+                severity: 'warning'
+            }
+        })
+};
+export const Info = {
+    play: interactWithCanvas,
+    render: ()=>/*#__PURE__*/ _jsx(NotifyTrigger, {
+            notification: {
+                message: 'This is an informational message',
+                severity: 'info'
+            }
+        })
+};
+export const TopRight = {
+    play: interactWithCanvas,
+    render: ()=>/*#__PURE__*/ _jsx(NotifyTrigger, {
+            notification: {
+                anchorOrigin: {
+                    horizontal: 'right',
+                    vertical: 'top'
+                },
+                message: 'This appears in the top right'
+            }
+        })
+};
+export const WithActions = {
+    play: interactWithCanvas,
+    render: ()=>/*#__PURE__*/ _jsx(NotifyTrigger, {
+            notification: {
+                actions: [
+                    {
+                        label: 'Undo',
+                        onClick: (key)=>{
+                            console.log('Undo clicked', key);
+                        // Perform undo action
+                        }
+                    },
+                    {
+                        icon: 'close',
+                        onClick: (key)=>{
+                            console.log('Close clicked', key);
+                            GothamActions.notifyClose();
+                        }
+                    }
+                ],
+                message: 'Would you like to undo?'
+            }
+        })
+};
+export const Examples = {
+    play: interactWithCanvas,
+    render: ()=>/*#__PURE__*/ _jsx(NotifyExample, {})
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/gothamjs/src/components/Notify/Notify.stories.tsx"],"sourcesContent":["import {useEffect} from 'react';\nimport {Flux} from '@nlabs/arkhamjs';\nimport {FluxProvider} from '@nlabs/arkhamjs-utils-react';\n\nimport {GothamActions} from '../../actions/GothamActions.js';\nimport {interactWithCanvas} from '../../utils/storyInteractions.js';\nimport {Notify} from './Notify.js';\nimport {NotifyExample} from './NotifyExample.js';\n\nimport type {Meta, StoryObj} from '@nlabs/lex/storybook';\nimport type {GothamNotifyParams} from './Notify.js';\n\nif (!(Flux as any).isInit) {\n  void Flux.init({name: 'gothamui-storybook'});\n}\n\nconst NotifyTrigger = ({notification}: {readonly notification: GothamNotifyParams}) => {\n  useEffect(() => () => {\n    GothamActions.notifyClose();\n  }, []);\n\n  return (\n    <div className=\"flex min-h-64 items-center justify-center p-8\">\n      <button\n        className=\"cursor-pointer rounded-md bg-primary px-4 py-2 text-sm font-semibold text-white shadow-sm hover:bg-primary-700 focus:outline-none focus:ring-2 focus:ring-primary focus:ring-offset-2\"\n        onClick={() => GothamActions.notify(notification)}\n        type=\"button\"\n      >\n        Open\n      </button>\n    </div>\n  );\n};\n\nconst meta: Meta<typeof Notify> = {\n  argTypes: {\n    anchorOrigin: {\n      control: 'object'\n    },\n    message: {\n      control: 'text'\n    },\n    severity: {\n      control: 'select',\n      options: ['error', 'info', 'success', 'warning']\n    }\n  },\n  component: Notify,\n  decorators: [\n    (Story) => (\n      <FluxProvider flux={Flux}>\n        <Story />\n        <Notify />\n      </FluxProvider>\n    )\n  ],\n  parameters: {\n    layout: 'fullscreen'\n  },\n  title: 'Components/Notify'\n};\n\nexport default meta;\ntype Story = StoryObj<typeof Notify>;\n\nexport const Basic: Story = {\n  play: interactWithCanvas,\n  render: () => (\n    <NotifyTrigger\n      notification={{\n        autoHideDuration: 5000,\n        message: 'This is a basic notification'\n      }}\n    />\n  )\n};\n\nexport const Success: Story = {\n  play: interactWithCanvas,\n  render: () => (\n    <NotifyTrigger\n      notification={{\n        message: 'Operation completed successfully',\n        severity: 'success'\n      }}\n    />\n  )\n};\n\nexport const Error: Story = {\n  play: interactWithCanvas,\n  render: () => (\n    <NotifyTrigger\n      notification={{\n        message: 'An error occurred',\n        severity: 'error'\n      }}\n    />\n  )\n};\n\nexport const Warning: Story = {\n  play: interactWithCanvas,\n  render: () => (\n    <NotifyTrigger\n      notification={{\n        message: 'This is a warning message',\n        severity: 'warning'\n      }}\n    />\n  )\n};\n\nexport const Info: Story = {\n  play: interactWithCanvas,\n  render: () => (\n    <NotifyTrigger\n      notification={{\n        message: 'This is an informational message',\n        severity: 'info'\n      }}\n    />\n  )\n};\n\nexport const TopRight: Story = {\n  play: interactWithCanvas,\n  render: () => (\n    <NotifyTrigger\n      notification={{\n        anchorOrigin: {\n          horizontal: 'right',\n          vertical: 'top'\n        },\n        message: 'This appears in the top right'\n      }}\n    />\n  )\n};\n\nexport const WithActions: Story = {\n  play: interactWithCanvas,\n  render: () => (\n    <NotifyTrigger\n      notification={{\n        actions: [\n          {\n            label: 'Undo',\n            onClick: (key) => {\n              console.log('Undo clicked', key);\n              // Perform undo action\n            }\n          },\n          {\n            icon: 'close',\n            onClick: (key) => {\n              console.log('Close clicked', key);\n              GothamActions.notifyClose();\n            }\n          }\n        ],\n        message: 'Would you like to undo?'\n      }}\n    />\n  )\n};\n\nexport const Examples: Story = {\n  play: interactWithCanvas,\n  render: () => <NotifyExample />\n};\n"],"names":["useEffect","Flux","FluxProvider","GothamActions","interactWithCanvas","Notify","NotifyExample","isInit","init","name","NotifyTrigger","notification","notifyClose","div","className","button","onClick","notify","type","meta","argTypes","anchorOrigin","control","message","severity","options","component","decorators","Story","flux","parameters","layout","title","Basic","play","render","autoHideDuration","Success","Error","Warning","Info","TopRight","horizontal","vertical","WithActions","actions","label","key","console","log","icon","Examples"],"mappings":";AAAA,SAAQA,SAAS,QAAO,QAAQ;AAChC,SAAQC,IAAI,QAAO,kBAAkB;AACrC,SAAQC,YAAY,QAAO,8BAA8B;AAEzD,SAAQC,aAAa,QAAO,iCAAiC;AAC7D,SAAQC,kBAAkB,QAAO,mCAAmC;AACpE,SAAQC,MAAM,QAAO,cAAc;AACnC,SAAQC,aAAa,QAAO,qBAAqB;AAKjD,IAAI,CAAC,AAACL,KAAaM,MAAM,EAAE;IACzB,KAAKN,KAAKO,IAAI,CAAC;QAACC,MAAM;IAAoB;AAC5C;AAEA,MAAMC,gBAAgB,CAAC,EAACC,YAAY,EAA8C;IAChFX,UAAU,IAAM;YACdG,cAAcS,WAAW;QAC3B,GAAG,EAAE;IAEL,qBACE,KAACC;QAAIC,WAAU;kBACb,cAAA,KAACC;YACCD,WAAU;YACVE,SAAS,IAAMb,cAAcc,MAAM,CAACN;YACpCO,MAAK;sBACN;;;AAKP;AAEA,MAAMC,OAA4B;IAChCC,UAAU;QACRC,cAAc;YACZC,SAAS;QACX;QACAC,SAAS;YACPD,SAAS;QACX;QACAE,UAAU;YACRF,SAAS;YACTG,SAAS;gBAAC;gBAAS;gBAAQ;gBAAW;aAAU;QAClD;IACF;IACAC,WAAWrB;IACXsB,YAAY;QACV,CAACC,sBACC,MAAC1B;gBAAa2B,MAAM5B;;kCAClB,KAAC2B;kCACD,KAACvB;;;KAGN;IACDyB,YAAY;QACVC,QAAQ;IACV;IACAC,OAAO;AACT;AAEA,eAAeb,KAAK;AAGpB,OAAO,MAAMc,QAAe;IAC1BC,MAAM9B;IACN+B,QAAQ,kBACN,KAACzB;YACCC,cAAc;gBACZyB,kBAAkB;gBAClBb,SAAS;YACX;;AAGN,EAAE;AAEF,OAAO,MAAMc,UAAiB;IAC5BH,MAAM9B;IACN+B,QAAQ,kBACN,KAACzB;YACCC,cAAc;gBACZY,SAAS;gBACTC,UAAU;YACZ;;AAGN,EAAE;AAEF,OAAO,MAAMc,QAAe;IAC1BJ,MAAM9B;IACN+B,QAAQ,kBACN,KAACzB;YACCC,cAAc;gBACZY,SAAS;gBACTC,UAAU;YACZ;;AAGN,EAAE;AAEF,OAAO,MAAMe,UAAiB;IAC5BL,MAAM9B;IACN+B,QAAQ,kBACN,KAACzB;YACCC,cAAc;gBACZY,SAAS;gBACTC,UAAU;YACZ;;AAGN,EAAE;AAEF,OAAO,MAAMgB,OAAc;IACzBN,MAAM9B;IACN+B,QAAQ,kBACN,KAACzB;YACCC,cAAc;gBACZY,SAAS;gBACTC,UAAU;YACZ;;AAGN,EAAE;AAEF,OAAO,MAAMiB,WAAkB;IAC7BP,MAAM9B;IACN+B,QAAQ,kBACN,KAACzB;YACCC,cAAc;gBACZU,cAAc;oBACZqB,YAAY;oBACZC,UAAU;gBACZ;gBACApB,SAAS;YACX;;AAGN,EAAE;AAEF,OAAO,MAAMqB,cAAqB;IAChCV,MAAM9B;IACN+B,QAAQ,kBACN,KAACzB;YACCC,cAAc;gBACZkC,SAAS;oBACP;wBACEC,OAAO;wBACP9B,SAAS,CAAC+B;4BACRC,QAAQC,GAAG,CAAC,gBAAgBF;wBAC5B,sBAAsB;wBACxB;oBACF;oBACA;wBACEG,MAAM;wBACNlC,SAAS,CAAC+B;4BACRC,QAAQC,GAAG,CAAC,iBAAiBF;4BAC7B5C,cAAcS,WAAW;wBAC3B;oBACF;iBACD;gBACDW,SAAS;YACX;;AAGN,EAAE;AAEF,OAAO,MAAM4B,WAAkB;IAC7BjB,MAAM9B;IACN+B,QAAQ,kBAAM,KAAC7B;AACjB,EAAE"}

package/lib/components/Notify/NotifyExample.d.ts

@@ -0,0 +1 @@
+export declare const NotifyExample: () => import("react").JSX.Element;

package/lib/components/Notify/NotifyExample.js

@@ -0,0 +1,174 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { GothamActions } from '../../actions/GothamActions.js';
+export const NotifyExample = ()=>{
+    // Basic notification
+    const showBasicNotification = ()=>{
+        GothamActions.notify({
+            autoHideDuration: 5000,
+            message: 'This is a basic notification'
+        });
+    };
+    // Success notification
+    const showSuccessNotification = ()=>{
+        GothamActions.notify({
+            message: 'Operation completed successfully',
+            severity: 'success'
+        });
+    };
+    // Error notification
+    const showErrorNotification = ()=>{
+        GothamActions.notify({
+            message: 'An error occurred',
+            severity: 'error'
+        });
+    };
+    // Warning notification
+    const showWarningNotification = ()=>{
+        GothamActions.notify({
+            message: 'This is a warning message',
+            severity: 'warning'
+        });
+    };
+    // Info notification
+    const showInfoNotification = ()=>{
+        GothamActions.notify({
+            message: 'This is an informational message',
+            severity: 'info'
+        });
+    };
+    // Notification with custom position
+    const showTopRightNotification = ()=>{
+        GothamActions.notify({
+            anchorOrigin: {
+                horizontal: 'right',
+                vertical: 'top'
+            },
+            message: 'This appears in the top right'
+        });
+    };
+    // Notification with actions
+    const showActionNotification = ()=>{
+        GothamActions.notify({
+            actions: [
+                {
+                    label: 'Undo',
+                    onClick: (key)=>{
+                        console.log('Undo clicked', key);
+                    // Perform undo action
+                    }
+                },
+                {
+                    icon: 'close',
+                    onClick: (key)=>{
+                        console.log('Close clicked', key);
+                        GothamActions.notifyClose();
+                    }
+                }
+            ],
+            message: 'Would you like to undo?'
+        });
+    };
+    return /*#__PURE__*/ _jsxs("div", {
+        className: "p-6 max-w-4xl mx-auto",
+        children: [
+            /*#__PURE__*/ _jsx("h1", {
+                className: "text-3xl font-bold mb-6",
+                children: "Notify Component Examples"
+            }),
+            /*#__PURE__*/ _jsxs("div", {
+                className: "grid grid-cols-1 md:grid-cols-2 gap-4",
+                children: [
+                    /*#__PURE__*/ _jsxs("div", {
+                        className: "p-4 border rounded-lg shadow-sm",
+                        children: [
+                            /*#__PURE__*/ _jsx("h2", {
+                                className: "text-xl font-semibold mb-4",
+                                children: "Basic Notifications"
+                            }),
+                            /*#__PURE__*/ _jsxs("div", {
+                                className: "space-y-2",
+                                children: [
+                                    /*#__PURE__*/ _jsx("button", {
+                                        onClick: showBasicNotification,
+                                        className: "w-full px-4 py-2 bg-gray-200 hover:bg-gray-300 rounded-md",
+                                        children: "Basic Notification"
+                                    }),
+                                    /*#__PURE__*/ _jsx("button", {
+                                        onClick: showSuccessNotification,
+                                        className: "w-full px-4 py-2 bg-green-100 hover:bg-green-200 text-green-800 rounded-md",
+                                        children: "Success Notification"
+                                    }),
+                                    /*#__PURE__*/ _jsx("button", {
+                                        onClick: showErrorNotification,
+                                        className: "w-full px-4 py-2 bg-red-100 hover:bg-red-200 text-red-800 rounded-md",
+                                        children: "Error Notification"
+                                    }),
+                                    /*#__PURE__*/ _jsx("button", {
+                                        onClick: showWarningNotification,
+                                        className: "w-full px-4 py-2 bg-yellow-100 hover:bg-yellow-200 text-yellow-800 rounded-md",
+                                        children: "Warning Notification"
+                                    }),
+                                    /*#__PURE__*/ _jsx("button", {
+                                        onClick: showInfoNotification,
+                                        className: "w-full px-4 py-2 bg-blue-100 hover:bg-blue-200 text-blue-800 rounded-md",
+                                        children: "Info Notification"
+                                    })
+                                ]
+                            })
+                        ]
+                    }),
+                    /*#__PURE__*/ _jsxs("div", {
+                        className: "p-4 border rounded-lg shadow-sm",
+                        children: [
+                            /*#__PURE__*/ _jsx("h2", {
+                                className: "text-xl font-semibold mb-4",
+                                children: "Advanced Options"
+                            }),
+                            /*#__PURE__*/ _jsxs("div", {
+                                className: "space-y-2",
+                                children: [
+                                    /*#__PURE__*/ _jsx("button", {
+                                        onClick: showTopRightNotification,
+                                        className: "w-full px-4 py-2 bg-purple-100 hover:bg-purple-200 text-purple-800 rounded-md",
+                                        children: "Top Right Position"
+                                    }),
+                                    /*#__PURE__*/ _jsx("button", {
+                                        onClick: showActionNotification,
+                                        className: "w-full px-4 py-2 bg-indigo-100 hover:bg-indigo-200 text-indigo-800 rounded-md",
+                                        children: "With Action Buttons"
+                                    })
+                                ]
+                            })
+                        ]
+                    })
+                ]
+            }),
+            /*#__PURE__*/ _jsxs("div", {
+                className: "mt-8 p-4 bg-gray-50 rounded-lg",
+                children: [
+                    /*#__PURE__*/ _jsx("h2", {
+                        className: "text-xl font-semibold mb-2",
+                        children: "Implementation Example"
+                    }),
+                    /*#__PURE__*/ _jsx("pre", {
+                        className: "bg-gray-800 text-gray-100 p-4 rounded-md overflow-x-auto",
+                        children: `// Import the GothamActions
+import {GothamActions} from '@actions/GothamActions';
+
+// Show a notification
+GothamActions.notify({
+  message: 'Hello World',
+  severity: 'success',
+  autoHideDuration: 5000
+});
+
+// Close all notifications
+GothamActions.notifyClose();`
+                    })
+                ]
+            })
+        ]
+    });
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/gothamjs/src/components/Notify/NotifyExample.tsx"],"sourcesContent":["import {GothamActions} from '../../actions/GothamActions.js';\n\nexport const NotifyExample = () => {\n  // Basic notification\n  const showBasicNotification = () => {\n    GothamActions.notify({\n      autoHideDuration: 5000,\n      message: 'This is a basic notification'\n    });\n  };\n\n  // Success notification\n  const showSuccessNotification = () => {\n    GothamActions.notify({\n      message: 'Operation completed successfully',\n      severity: 'success'\n    });\n  };\n\n  // Error notification\n  const showErrorNotification = () => {\n    GothamActions.notify({\n      message: 'An error occurred',\n      severity: 'error'\n    });\n  };\n\n  // Warning notification\n  const showWarningNotification = () => {\n    GothamActions.notify({\n      message: 'This is a warning message',\n      severity: 'warning'\n    });\n  };\n\n  // Info notification\n  const showInfoNotification = () => {\n    GothamActions.notify({\n      message: 'This is an informational message',\n      severity: 'info'\n    });\n  };\n\n  // Notification with custom position\n  const showTopRightNotification = () => {\n    GothamActions.notify({\n      anchorOrigin: {\n        horizontal: 'right',\n        vertical: 'top'\n      },\n      message: 'This appears in the top right'\n    });\n  };\n\n  // Notification with actions\n  const showActionNotification = () => {\n    GothamActions.notify({\n      actions: [\n        {\n          label: 'Undo',\n          onClick: (key) => {\n            console.log('Undo clicked', key);\n            // Perform undo action\n          }\n        },\n        {\n          icon: 'close',\n          onClick: (key) => {\n            console.log('Close clicked', key);\n            GothamActions.notifyClose();\n          }\n        }\n      ],\n      message: 'Would you like to undo?'\n    });\n  };\n\n  return (\n    <div className=\"p-6 max-w-4xl mx-auto\">\n      <h1 className=\"text-3xl font-bold mb-6\">Notify Component Examples</h1>\n\n      <div className=\"grid grid-cols-1 md:grid-cols-2 gap-4\">\n        <div className=\"p-4 border rounded-lg shadow-sm\">\n          <h2 className=\"text-xl font-semibold mb-4\">Basic Notifications</h2>\n          <div className=\"space-y-2\">\n            <button\n              onClick={showBasicNotification}\n              className=\"w-full px-4 py-2 bg-gray-200 hover:bg-gray-300 rounded-md\"\n            >\n              Basic Notification\n            </button>\n            <button\n              onClick={showSuccessNotification}\n              className=\"w-full px-4 py-2 bg-green-100 hover:bg-green-200 text-green-800 rounded-md\"\n            >\n              Success Notification\n            </button>\n            <button\n              onClick={showErrorNotification}\n              className=\"w-full px-4 py-2 bg-red-100 hover:bg-red-200 text-red-800 rounded-md\"\n            >\n              Error Notification\n            </button>\n            <button\n              onClick={showWarningNotification}\n              className=\"w-full px-4 py-2 bg-yellow-100 hover:bg-yellow-200 text-yellow-800 rounded-md\"\n            >\n              Warning Notification\n            </button>\n            <button\n              onClick={showInfoNotification}\n              className=\"w-full px-4 py-2 bg-blue-100 hover:bg-blue-200 text-blue-800 rounded-md\"\n            >\n              Info Notification\n            </button>\n          </div>\n        </div>\n\n        <div className=\"p-4 border rounded-lg shadow-sm\">\n          <h2 className=\"text-xl font-semibold mb-4\">Advanced Options</h2>\n          <div className=\"space-y-2\">\n            <button\n              onClick={showTopRightNotification}\n              className=\"w-full px-4 py-2 bg-purple-100 hover:bg-purple-200 text-purple-800 rounded-md\"\n            >\n              Top Right Position\n            </button>\n            <button\n              onClick={showActionNotification}\n              className=\"w-full px-4 py-2 bg-indigo-100 hover:bg-indigo-200 text-indigo-800 rounded-md\"\n            >\n              With Action Buttons\n            </button>\n          </div>\n        </div>\n      </div>\n\n      <div className=\"mt-8 p-4 bg-gray-50 rounded-lg\">\n        <h2 className=\"text-xl font-semibold mb-2\">Implementation Example</h2>\n        <pre className=\"bg-gray-800 text-gray-100 p-4 rounded-md overflow-x-auto\">\n          {`// Import the GothamActions\nimport {GothamActions} from '@actions/GothamActions';\n\n// Show a notification\nGothamActions.notify({\n  message: 'Hello World',\n  severity: 'success',\n  autoHideDuration: 5000\n});\n\n// Close all notifications\nGothamActions.notifyClose();`}\n        </pre>\n      </div>\n    </div>\n  );\n};"],"names":["GothamActions","NotifyExample","showBasicNotification","notify","autoHideDuration","message","showSuccessNotification","severity","showErrorNotification","showWarningNotification","showInfoNotification","showTopRightNotification","anchorOrigin","horizontal","vertical","showActionNotification","actions","label","onClick","key","console","log","icon","notifyClose","div","className","h1","h2","button","pre"],"mappings":";AAAA,SAAQA,aAAa,QAAO,iCAAiC;AAE7D,OAAO,MAAMC,gBAAgB;IAC3B,qBAAqB;IACrB,MAAMC,wBAAwB;QAC5BF,cAAcG,MAAM,CAAC;YACnBC,kBAAkB;YAClBC,SAAS;QACX;IACF;IAEA,uBAAuB;IACvB,MAAMC,0BAA0B;QAC9BN,cAAcG,MAAM,CAAC;YACnBE,SAAS;YACTE,UAAU;QACZ;IACF;IAEA,qBAAqB;IACrB,MAAMC,wBAAwB;QAC5BR,cAAcG,MAAM,CAAC;YACnBE,SAAS;YACTE,UAAU;QACZ;IACF;IAEA,uBAAuB;IACvB,MAAME,0BAA0B;QAC9BT,cAAcG,MAAM,CAAC;YACnBE,SAAS;YACTE,UAAU;QACZ;IACF;IAEA,oBAAoB;IACpB,MAAMG,uBAAuB;QAC3BV,cAAcG,MAAM,CAAC;YACnBE,SAAS;YACTE,UAAU;QACZ;IACF;IAEA,oCAAoC;IACpC,MAAMI,2BAA2B;QAC/BX,cAAcG,MAAM,CAAC;YACnBS,cAAc;gBACZC,YAAY;gBACZC,UAAU;YACZ;YACAT,SAAS;QACX;IACF;IAEA,4BAA4B;IAC5B,MAAMU,yBAAyB;QAC7Bf,cAAcG,MAAM,CAAC;YACnBa,SAAS;gBACP;oBACEC,OAAO;oBACPC,SAAS,CAACC;wBACRC,QAAQC,GAAG,CAAC,gBAAgBF;oBAC5B,sBAAsB;oBACxB;gBACF;gBACA;oBACEG,MAAM;oBACNJ,SAAS,CAACC;wBACRC,QAAQC,GAAG,CAAC,iBAAiBF;wBAC7BnB,cAAcuB,WAAW;oBAC3B;gBACF;aACD;YACDlB,SAAS;QACX;IACF;IAEA,qBACE,MAACmB;QAAIC,WAAU;;0BACb,KAACC;gBAAGD,WAAU;0BAA0B;;0BAExC,MAACD;gBAAIC,WAAU;;kCACb,MAACD;wBAAIC,WAAU;;0CACb,KAACE;gCAAGF,WAAU;0CAA6B;;0CAC3C,MAACD;gCAAIC,WAAU;;kDACb,KAACG;wCACCV,SAAShB;wCACTuB,WAAU;kDACX;;kDAGD,KAACG;wCACCV,SAASZ;wCACTmB,WAAU;kDACX;;kDAGD,KAACG;wCACCV,SAASV;wCACTiB,WAAU;kDACX;;kDAGD,KAACG;wCACCV,SAAST;wCACTgB,WAAU;kDACX;;kDAGD,KAACG;wCACCV,SAASR;wCACTe,WAAU;kDACX;;;;;;kCAML,MAACD;wBAAIC,WAAU;;0CACb,KAACE;gCAAGF,WAAU;0CAA6B;;0CAC3C,MAACD;gCAAIC,WAAU;;kDACb,KAACG;wCACCV,SAASP;wCACTc,WAAU;kDACX;;kDAGD,KAACG;wCACCV,SAASH;wCACTU,WAAU;kDACX;;;;;;;;0BAOP,MAACD;gBAAIC,WAAU;;kCACb,KAACE;wBAAGF,WAAU;kCAA6B;;kCAC3C,KAACI;wBAAIJ,WAAU;kCACZ,CAAC;;;;;;;;;;;4BAWgB,CAAC;;;;;;AAK7B,EAAE"}