Initial commit

node_modules/@fluentui/react-toolbar/lib-commonjs/components/Toolbar/Toolbar.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "Toolbar", {
+    enumerable: true,
+    get: function() {
+        return Toolbar;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _useToolbar = require("./useToolbar");
+const _renderToolbar = require("./renderToolbar");
+const _useToolbarStylesstyles = require("./useToolbarStyles.styles");
+const _useToolbarContextValues = require("./useToolbarContextValues");
+const _reactsharedcontexts = require("@fluentui/react-shared-contexts");
+const Toolbar = /*#__PURE__*/ _react.forwardRef((props, ref)=>{
+    const state = (0, _useToolbar.useToolbar_unstable)(props, ref);
+    const contextValues = (0, _useToolbarContextValues.useToolbarContextValues_unstable)(state);
+    (0, _useToolbarStylesstyles.useToolbarStyles_unstable)(state);
+    (0, _reactsharedcontexts.useCustomStyleHook_unstable)('useToolbarStyles_unstable')(state);
+    return (0, _renderToolbar.renderToolbar_unstable)(state, contextValues);
+});
+Toolbar.displayName = 'Toolbar';

node_modules/@fluentui/react-toolbar/lib-commonjs/components/Toolbar/Toolbar.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/Toolbar/Toolbar.tsx"],"sourcesContent":["import * as React from 'react';\nimport { useToolbar_unstable } from './useToolbar';\nimport { renderToolbar_unstable } from './renderToolbar';\nimport { useToolbarStyles_unstable } from './useToolbarStyles.styles';\nimport type { ToolbarProps } from './Toolbar.types';\nimport type { ForwardRefComponent } from '@fluentui/react-utilities';\nimport { useToolbarContextValues_unstable } from './useToolbarContextValues';\nimport { useCustomStyleHook_unstable } from '@fluentui/react-shared-contexts';\n\n/**\n * Toolbar component\n */\nexport const Toolbar: ForwardRefComponent<ToolbarProps> = React.forwardRef((props, ref) => {\n  const state = useToolbar_unstable(props, ref);\n  const contextValues = useToolbarContextValues_unstable(state);\n\n  useToolbarStyles_unstable(state);\n\n  useCustomStyleHook_unstable('useToolbarStyles_unstable')(state);\n\n  return renderToolbar_unstable(state, contextValues);\n});\n\nToolbar.displayName = 'Toolbar';\n"],"names":["Toolbar","React","forwardRef","props","ref","state","useToolbar_unstable","contextValues","useToolbarContextValues_unstable","useToolbarStyles_unstable","useCustomStyleHook_unstable","renderToolbar_unstable","displayName"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAYaA;;;eAAAA;;;;iEAZU;4BACa;+BACG;wCACG;yCAGO;qCACL;AAKrC,MAAMA,UAAAA,WAAAA,GAA6CC,OAAMC,UAAU,CAAC,CAACC,OAAOC;IACjF,MAAMC,QAAQC,IAAAA,+BAAAA,EAAoBH,OAAOC;IACzC,MAAMG,gBAAgBC,IAAAA,yDAAAA,EAAiCH;IAEvDI,IAAAA,iDAAAA,EAA0BJ;IAE1BK,IAAAA,gDAAAA,EAA4B,6BAA6BL;IAEzD,OAAOM,IAAAA,qCAAAA,EAAuBN,OAAOE;AACvC;AAEAP,QAAQY,WAAW,GAAG"}

node_modules/@fluentui/react-toolbar/lib-commonjs/components/Toolbar/Toolbar.types.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));

node_modules/@fluentui/react-toolbar/lib-commonjs/components/Toolbar/Toolbar.types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/Toolbar/Toolbar.types.ts"],"sourcesContent":["import * as React from 'react';\nimport type { ComponentProps, ComponentState, Slot } from '@fluentui/react-utilities';\n\nexport type ToolbarSlots = {\n  root: Slot<'div'>;\n};\n\nexport type ToolbarCheckedValueChangeData = {\n  /** The items for this value that are checked */\n  checkedItems: string[];\n  /** The name of the value */\n  name: string;\n};\n\nexport type ToolbarCheckedValueChangeEvent = React.MouseEvent | React.KeyboardEvent;\n\n/**\n * Toolbar Props\n */\nexport type ToolbarProps = ComponentProps<ToolbarSlots> & {\n  /**\n   * Toolbar can have small or medium size\n   *\n   * @default medium\n   */\n  size?: 'small' | 'medium' | 'large';\n\n  /**\n   * Toolbar can be vertical styled\n   * @default false\n   */\n  vertical?: boolean;\n\n  /**\n   * Map of all checked values\n   */\n  checkedValues?: Record<string, string[]>;\n\n  /**\n   * Default values to be checked on mount\n   */\n  defaultCheckedValues?: Record<string, string[]>;\n\n  /**\n   * Callback when checked items change for value with a name\n   *\n   * @param event - React's original SyntheticEvent\n   * @param data - A data object with relevant information\n   */\n  // eslint-disable-next-line @nx/workspace-consistent-callback-type -- can't change type of existing callback\n  onCheckedValueChange?: (e: ToolbarCheckedValueChangeEvent, data: ToolbarCheckedValueChangeData) => void;\n};\n\n/**\n * State used in rendering Toolbar\n */\nexport type ToolbarState = ComponentState<ToolbarSlots> &\n  Required<Pick<ToolbarProps, 'size' | 'checkedValues' | 'vertical'>> &\n  Pick<ToolbarProps, 'defaultCheckedValues' | 'onCheckedValueChange'> & {\n    /*\n     * Toggles the state of a ToggleButton item\n     */\n    handleToggleButton: ToggableHandler;\n    /*\n     * Toggles the state of a ToggleButton item\n     */\n    handleRadio: ToggableHandler;\n  };\n\nexport type ToolbarContextValue = Pick<ToolbarState, 'size' | 'vertical' | 'checkedValues'> & {\n  handleToggleButton?: ToggableHandler;\n  handleRadio?: ToggableHandler;\n};\n\nexport type ToolbarContextValues = {\n  toolbar: ToolbarContextValue;\n};\n\nexport type UninitializedToolbarState = Omit<ToolbarState, 'checkedValues' | 'handleToggleButton' | 'handleRadio'> &\n  Partial<Pick<ToolbarState, 'checkedValues'>>;\n\nexport type ToggableHandler = (\n  e: React.MouseEvent | React.KeyboardEvent,\n  name: string,\n  value: string,\n  checked?: boolean,\n) => void;\n"],"names":[],"rangeMappings":";;;;;","mappings":";;;;;iEAAuB"}

node_modules/@fluentui/react-toolbar/lib-commonjs/components/Toolbar/ToolbarContext.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    ToolbarContext: function() {
+        return ToolbarContext;
+    },
+    useToolbarContext_unstable: function() {
+        return useToolbarContext_unstable;
+    }
+});
+const _reactcontextselector = require("@fluentui/react-context-selector");
+const ToolbarContext = (0, _reactcontextselector.createContext)(undefined);
+const toolbarContextDefaultValue = {
+    size: 'medium',
+    handleToggleButton: ()=>null,
+    handleRadio: ()=>null,
+    vertical: false,
+    checkedValues: {}
+};
+const useToolbarContext_unstable = (selector)=>(0, _reactcontextselector.useContextSelector)(ToolbarContext, (ctx = toolbarContextDefaultValue)=>selector(ctx));

node_modules/@fluentui/react-toolbar/lib-commonjs/components/Toolbar/ToolbarContext.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/Toolbar/ToolbarContext.ts"],"sourcesContent":["import { ContextSelector, createContext, useContextSelector } from '@fluentui/react-context-selector';\nimport type { Context } from '@fluentui/react-context-selector';\nimport type { ToolbarContextValue } from './Toolbar.types';\n\nexport const ToolbarContext = createContext<ToolbarContextValue | undefined>(undefined) as Context<ToolbarContextValue>;\n\nconst toolbarContextDefaultValue: ToolbarContextValue = {\n  size: 'medium' as 'medium',\n  handleToggleButton: () => null,\n  handleRadio: () => null,\n  vertical: false,\n  checkedValues: {},\n};\n\nexport const useToolbarContext_unstable = <T>(selector: ContextSelector<ToolbarContextValue, T>): T =>\n  useContextSelector(ToolbarContext, (ctx = toolbarContextDefaultValue) => selector(ctx));\n"],"names":["ToolbarContext","useToolbarContext_unstable","createContext","undefined","toolbarContextDefaultValue","size","handleToggleButton","handleRadio","vertical","checkedValues","selector","useContextSelector","ctx"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAIaA,cAAAA;eAAAA;;IAUAC,0BAAAA;eAAAA;;;sCAdsD;AAI5D,MAAMD,iBAAiBE,IAAAA,mCAAAA,EAA+CC;AAE7E,MAAMC,6BAAkD;IACtDC,MAAM;IACNC,oBAAoB,IAAM;IAC1BC,aAAa,IAAM;IACnBC,UAAU;IACVC,eAAe,CAAC;AAClB;AAEO,MAAMR,6BAA6B,CAAIS,WAC5CC,IAAAA,wCAAAA,EAAmBX,gBAAgB,CAACY,MAAMR,0BAA0B,GAAKM,SAASE"}

node_modules/@fluentui/react-toolbar/lib-commonjs/components/Toolbar/index.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    Toolbar: function() {
+        return _Toolbar.Toolbar;
+    },
+    renderToolbar_unstable: function() {
+        return _renderToolbar.renderToolbar_unstable;
+    },
+    toolbarClassNames: function() {
+        return _useToolbarStylesstyles.toolbarClassNames;
+    },
+    useToolbarStyles_unstable: function() {
+        return _useToolbarStylesstyles.useToolbarStyles_unstable;
+    },
+    useToolbar_unstable: function() {
+        return _useToolbar.useToolbar_unstable;
+    }
+});
+const _Toolbar = require("./Toolbar");
+const _renderToolbar = require("./renderToolbar");
+const _useToolbar = require("./useToolbar");
+const _useToolbarStylesstyles = require("./useToolbarStyles.styles");

node_modules/@fluentui/react-toolbar/lib-commonjs/components/Toolbar/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/Toolbar/index.ts"],"sourcesContent":["export { Toolbar } from './Toolbar';\nexport type {\n  ToggableHandler,\n  ToolbarCheckedValueChangeData,\n  ToolbarCheckedValueChangeEvent,\n  ToolbarContextValue,\n  ToolbarContextValues,\n  ToolbarProps,\n  ToolbarSlots,\n  ToolbarState,\n  UninitializedToolbarState,\n} from './Toolbar.types';\nexport { renderToolbar_unstable } from './renderToolbar';\nexport { useToolbar_unstable } from './useToolbar';\nexport { toolbarClassNames, useToolbarStyles_unstable } from './useToolbarStyles.styles';\n"],"names":["Toolbar","renderToolbar_unstable","toolbarClassNames","useToolbarStyles_unstable","useToolbar_unstable"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAASA,OAAO;eAAPA,gBAAO;;IAYPC,sBAAsB;eAAtBA,qCAAsB;;IAEtBC,iBAAiB;eAAjBA,yCAAiB;;IAAEC,yBAAyB;eAAzBA,iDAAyB;;IAD5CC,mBAAmB;eAAnBA,+BAAmB;;;yBAbJ;+BAYe;4BACH;wCACyB"}

node_modules/@fluentui/react-toolbar/lib-commonjs/components/Toolbar/renderToolbar.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "renderToolbar_unstable", {
+    enumerable: true,
+    get: function() {
+        return renderToolbar_unstable;
+    }
+});
+const _jsxruntime = require("@fluentui/react-jsx-runtime/jsx-runtime");
+const _reactutilities = require("@fluentui/react-utilities");
+const _ToolbarContext = require("./ToolbarContext");
+const renderToolbar_unstable = (state, contextValues)=>{
+    (0, _reactutilities.assertSlots)(state);
+    return /*#__PURE__*/ (0, _jsxruntime.jsx)(_ToolbarContext.ToolbarContext.Provider, {
+        value: contextValues.toolbar,
+        children: /*#__PURE__*/ (0, _jsxruntime.jsx)(state.root, {
+            children: state.root.children
+        })
+    });
+};

node_modules/@fluentui/react-toolbar/lib-commonjs/components/Toolbar/renderToolbar.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/Toolbar/renderToolbar.tsx"],"sourcesContent":["/** @jsxRuntime automatic */\n/** @jsxImportSource @fluentui/react-jsx-runtime */\nimport { assertSlots } from '@fluentui/react-utilities';\nimport type { ToolbarState, ToolbarSlots, ToolbarContextValues } from './Toolbar.types';\nimport { ToolbarContext } from './ToolbarContext';\n\n/**\n * Render the final JSX of Toolbar\n */\nexport const renderToolbar_unstable = (state: ToolbarState, contextValues: ToolbarContextValues) => {\n  assertSlots<ToolbarSlots>(state);\n\n  return (\n    <ToolbarContext.Provider value={contextValues.toolbar}>\n      <state.root>{state.root.children}</state.root>\n    </ToolbarContext.Provider>\n  );\n};\n"],"names":["renderToolbar_unstable","state","contextValues","assertSlots","_jsx","ToolbarContext","Provider","value","toolbar","root","children"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BASaA;;;eAAAA;;;4BARb;gCAC4B;gCAEG;AAKxB,MAAMA,yBAAyB,CAACC,OAAqBC;IAC1DC,IAAAA,2BAAAA,EAA0BF;IAE1B,OAAA,WAAA,GACEG,IAAAA,eAAA,EAACC,8BAAAA,CAAeC,QAAQ,EAAA;QAACC,OAAOL,cAAcM,OAAO;kBACnD,WAAA,GAAAJ,IAAAA,eAAA,EAACH,MAAMQ,IAAI,EAAA;sBAAER,MAAMQ,IAAI,CAACC,QAAQ;;;AAGtC"}

node_modules/@fluentui/react-toolbar/lib-commonjs/components/Toolbar/useToolbar.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useToolbar_unstable", {
+    enumerable: true,
+    get: function() {
+        return useToolbar_unstable;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _reactutilities = require("@fluentui/react-utilities");
+const _reacttabster = require("@fluentui/react-tabster");
+const useToolbar_unstable = (props, ref)=>{
+    const { size = 'medium', vertical = false } = props;
+    const arrowNavigationProps = (0, _reacttabster.useArrowNavigationGroup)({
+        circular: true,
+        axis: 'both'
+    });
+    const initialState = {
+        size,
+        vertical,
+        // TODO add appropriate props/defaults
+        components: {
+            // TODO add each slot's element type or component
+            root: 'div'
+        },
+        // TODO add appropriate slots, for example:
+        // mySlot: resolveShorthand(props.mySlot),
+        root: _reactutilities.slot.always((0, _reactutilities.getIntrinsicElementProps)('div', {
+            role: 'toolbar',
+            // FIXME:
+            // `ref` is wrongly assigned to be `HTMLElement` instead of `HTMLDivElement`
+            // but since it would be a breaking change to fix it, we are casting ref to it's proper type
+            ref: ref,
+            ...vertical && {
+                'aria-orientation': 'vertical'
+            },
+            ...arrowNavigationProps,
+            ...props
+        }), {
+            elementType: 'div'
+        })
+    };
+    const [checkedValues, onCheckedValueChange] = useToolbarSelectableState({
+        checkedValues: props.checkedValues,
+        defaultCheckedValues: props.defaultCheckedValues,
+        onCheckedValueChange: props.onCheckedValueChange
+    });
+    const handleToggleButton = (0, _reactutilities.useEventCallback)((e, name, value, checked)=>{
+        if (name && value) {
+            const checkedItems = (checkedValues === null || checkedValues === void 0 ? void 0 : checkedValues[name]) || [];
+            const newCheckedItems = [
+                ...checkedItems
+            ];
+            if (checked) {
+                newCheckedItems.splice(newCheckedItems.indexOf(value), 1);
+            } else {
+                newCheckedItems.push(value);
+            }
+            onCheckedValueChange === null || onCheckedValueChange === void 0 ? void 0 : onCheckedValueChange(e, {
+                name,
+                checkedItems: newCheckedItems
+            });
+        }
+    });
+    const handleRadio = (0, _reactutilities.useEventCallback)((e, name, value, checked)=>{
+        if (name && value) {
+            onCheckedValueChange === null || onCheckedValueChange === void 0 ? void 0 : onCheckedValueChange(e, {
+                name,
+                checkedItems: [
+                    value
+                ]
+            });
+        }
+    });
+    return {
+        ...initialState,
+        handleToggleButton,
+        handleRadio,
+        checkedValues: checkedValues !== null && checkedValues !== void 0 ? checkedValues : {}
+    };
+};
+/**
+ * Adds appropriate state values and handlers for selectable items
+ * i.e checkboxes and radios
+ */ const useToolbarSelectableState = (state)=>{
+    const [checkedValues, setCheckedValues] = (0, _reactutilities.useControllableState)({
+        state: state.checkedValues,
+        defaultState: state.defaultCheckedValues,
+        initialState: {}
+    });
+    const { onCheckedValueChange: onCheckedValueChangeOriginal } = state;
+    const onCheckedValueChange = (0, _reactutilities.useEventCallback)((e, { name, checkedItems })=>{
+        if (onCheckedValueChangeOriginal) {
+            onCheckedValueChangeOriginal(e, {
+                name,
+                checkedItems
+            });
+        }
+        setCheckedValues((s)=>{
+            return s ? {
+                ...s,
+                [name]: checkedItems
+            } : {
+                [name]: checkedItems
+            };
+        });
+    });
+    return [
+        checkedValues,
+        onCheckedValueChange
+    ];
+};

node_modules/@fluentui/react-toolbar/lib-commonjs/components/Toolbar/useToolbarContextValues.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useToolbarContextValues_unstable", {
+    enumerable: true,
+    get: function() {
+        return useToolbarContextValues_unstable;
+    }
+});
+function useToolbarContextValues_unstable(state) {
+    const { size, handleToggleButton, vertical, checkedValues, handleRadio } = state;
+    // This context is created with "@fluentui/react-context-selector", these is no sense to memoize it
+    const toolbar = {
+        size,
+        vertical,
+        handleToggleButton,
+        handleRadio,
+        checkedValues
+    };
+    return {
+        toolbar
+    };
+}

node_modules/@fluentui/react-toolbar/lib-commonjs/components/Toolbar/useToolbarContextValues.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/Toolbar/useToolbarContextValues.tsx"],"sourcesContent":["import type { ToolbarContextValue, ToolbarContextValues, ToolbarState } from './Toolbar.types';\n\nexport function useToolbarContextValues_unstable(state: ToolbarState): ToolbarContextValues {\n  const { size, handleToggleButton, vertical, checkedValues, handleRadio } = state;\n  // This context is created with \"@fluentui/react-context-selector\", these is no sense to memoize it\n  const toolbar: ToolbarContextValue = {\n    size,\n    vertical,\n    handleToggleButton,\n    handleRadio,\n    checkedValues,\n  };\n\n  return { toolbar };\n}\n"],"names":["useToolbarContextValues_unstable","state","size","handleToggleButton","vertical","checkedValues","handleRadio","toolbar"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAEgBA;;;eAAAA;;;AAAT,SAASA,iCAAiCC,KAAmB;IAClE,MAAM,EAAEC,IAAI,EAAEC,kBAAkB,EAAEC,QAAQ,EAAEC,aAAa,EAAEC,WAAW,EAAE,GAAGL;IAC3E,mGAAmG;IACnG,MAAMM,UAA+B;QACnCL;QACAE;QACAD;QACAG;QACAD;IACF;IAEA,OAAO;QAAEE;IAAQ;AACnB"}

node_modules/@fluentui/react-toolbar/lib-commonjs/components/Toolbar/useToolbarStyles.styles.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    toolbarClassNames: function() {
+        return toolbarClassNames;
+    },
+    useToolbarStyles_unstable: function() {
+        return useToolbarStyles_unstable;
+    }
+});
+const _react = require("@griffel/react");
+const toolbarClassNames = {
+    root: 'fui-Toolbar'
+};
+/**
+ * Styles for the root slot
+ */ const useStyles = /*#__PURE__*/ (0, _react.__styles)({
+    root: {
+        mc9l5x: "f22iagw",
+        Bt984gj: "f122n59",
+        Byoj8tv: 0,
+        uwmqm3: 0,
+        z189sj: 0,
+        z8tnut: 0,
+        B0ocmuz: "f1yqiaad"
+    },
+    vertical: {
+        Beiy3e4: "f1vx9l62",
+        a9b677: "f1acs6jw"
+    },
+    small: {
+        Byoj8tv: 0,
+        uwmqm3: 0,
+        z189sj: 0,
+        z8tnut: 0,
+        B0ocmuz: "fvz760z"
+    },
+    medium: {
+        Byoj8tv: 0,
+        uwmqm3: 0,
+        z189sj: 0,
+        z8tnut: 0,
+        B0ocmuz: "f1yqiaad"
+    },
+    large: {
+        Byoj8tv: 0,
+        uwmqm3: 0,
+        z189sj: 0,
+        z8tnut: 0,
+        B0ocmuz: "f1ms6bdn"
+    }
+}, {
+    d: [
+        ".f22iagw{display:flex;}",
+        ".f122n59{align-items:center;}",
+        [
+            ".f1yqiaad{padding:4px 8px;}",
+            {
+                p: -1
+            }
+        ],
+        ".f1vx9l62{flex-direction:column;}",
+        ".f1acs6jw{width:fit-content;}",
+        [
+            ".fvz760z{padding:0px 4px;}",
+            {
+                p: -1
+            }
+        ],
+        [
+            ".f1yqiaad{padding:4px 8px;}",
+            {
+                p: -1
+            }
+        ],
+        [
+            ".f1ms6bdn{padding:4px 20px;}",
+            {
+                p: -1
+            }
+        ]
+    ]
+});
+const useToolbarStyles_unstable = (state)=>{
+    'use no memo';
+    const styles = useStyles();
+    const { vertical, size } = state;
+    state.root.className = (0, _react.mergeClasses)(toolbarClassNames.root, styles.root, vertical && styles.vertical, size === 'small' && !vertical && styles.small, size === 'medium' && !vertical && styles.medium, size === 'large' && !vertical && styles.large, state.root.className);
+    return state;
+};

node_modules/@fluentui/react-toolbar/lib-commonjs/components/Toolbar/useToolbarStyles.styles.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["useToolbarStyles.styles.js"],"sourcesContent":["import { makeStyles, mergeClasses } from '@griffel/react';\nexport const toolbarClassNames = {\n    root: 'fui-Toolbar'\n};\n/**\n * Styles for the root slot\n */ const useStyles = makeStyles({\n    root: {\n        display: 'flex',\n        alignItems: 'center',\n        padding: '4px 8px'\n    },\n    vertical: {\n        flexDirection: 'column',\n        width: 'fit-content'\n    },\n    small: {\n        padding: '0px 4px'\n    },\n    medium: {\n        padding: '4px 8px'\n    },\n    large: {\n        padding: '4px 20px'\n    }\n});\n/**\n * Apply styling to the Toolbar slots based on the state\n */ export const useToolbarStyles_unstable = (state)=>{\n    'use no memo';\n    const styles = useStyles();\n    const { vertical, size } = state;\n    state.root.className = mergeClasses(toolbarClassNames.root, styles.root, vertical && styles.vertical, size === 'small' && !vertical && styles.small, size === 'medium' && !vertical && styles.medium, size === 'large' && !vertical && styles.large, state.root.className);\n    return state;\n};\n"],"names":["toolbarClassNames","useToolbarStyles_unstable","root","useStyles","__styles","mc9l5x","Bt984gj","Byoj8tv","uwmqm3","z189sj","z8tnut","B0ocmuz","vertical","Beiy3e4","a9b677","small","medium","large","d","p","state","styles","size","className","mergeClasses"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IACaA,iBAAiB;eAAjBA;;IA2BIC,yBAAyB;eAAzBA;;;uBA5BwB;AAClC,MAAMD,oBAAoB;IAC7BE,MAAM;AACV;AACA;;CAEA,GAAI,MAAMC,YAAS,WAAA,GAAGC,IAAAA,eAAA,EAAA;IAAAF,MAAA;QAAAG,QAAA;QAAAC,SAAA;QAAAC,SAAA;QAAAC,QAAA;QAAAC,QAAA;QAAAC,QAAA;QAAAC,SAAA;IAAA;IAAAC,UAAA;QAAAC,SAAA;QAAAC,QAAA;IAAA;IAAAC,OAAA;QAAAR,SAAA;QAAAC,QAAA;QAAAC,QAAA;QAAAC,QAAA;QAAAC,SAAA;IAAA;IAAAK,QAAA;QAAAT,SAAA;QAAAC,QAAA;QAAAC,QAAA;QAAAC,QAAA;QAAAC,SAAA;IAAA;IAAAM,OAAA;QAAAV,SAAA;QAAAC,QAAA;QAAAC,QAAA;QAAAC,QAAA;QAAAC,SAAA;IAAA;AAAA,GAAA;IAAAO,GAAA;QAAA;QAAA;QAAA;YAAA;YAAA;gBAAAC,GAAA,CAAA;YAAA;SAAA;QAAA;QAAA;QAAA;YAAA;YAAA;gBAAAA,GAAA,CAAA;YAAA;SAAA;QAAA;YAAA;YAAA;gBAAAA,GAAA,CAAA;YAAA;SAAA;QAAA;YAAA;YAAA;gBAAAA,GAAA,CAAA;YAAA;SAAA;KAAA;AAAA;AAsBX,MAAMlB,4BAA6BmB,CAAAA;IAC1C;IACA,MAAMC,SAASlB;IACf,MAAM,EAAES,QAAQ,EAAEU,IAAAA,EAAM,GAAGF;IAC3BA,MAAMlB,IAAI,CAACqB,SAAS,GAAGC,IAAAA,mBAAY,EAACxB,kBAAkBE,IAAI,EAAEmB,OAAOnB,IAAI,EAAEU,YAAYS,OAAOT,QAAQ,EAAEU,SAAS,WAAW,CAACV,YAAYS,OAAON,KAAK,EAAEO,SAAS,YAAY,CAACV,YAAYS,OAAOL,MAAM,EAAEM,SAAS,WAAW,CAACV,YAAYS,OAAOJ,KAAK,EAAEG,MAAMlB,IAAI,CAACqB,SAAS;IACzQ,OAAOH;AACX"}

node_modules/@fluentui/react-toolbar/lib-commonjs/components/ToolbarButton/ToolbarButton.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ToolbarButton", {
+    enumerable: true,
+    get: function() {
+        return ToolbarButton;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _reactbutton = require("@fluentui/react-button");
+const _useToolbarButtonStylesstyles = require("./useToolbarButtonStyles.styles");
+const _useToolbarButton = require("./useToolbarButton");
+const _reactsharedcontexts = require("@fluentui/react-shared-contexts");
+const ToolbarButton = /*#__PURE__*/ _react.forwardRef((props, ref)=>{
+    const state = (0, _useToolbarButton.useToolbarButton_unstable)(props, ref);
+    (0, _useToolbarButtonStylesstyles.useToolbarButtonStyles_unstable)(state);
+    (0, _reactsharedcontexts.useCustomStyleHook_unstable)('useToolbarButtonStyles_unstable')(state);
+    return (0, _reactbutton.renderButton_unstable)(state);
+// Casting is required due to lack of distributive union to support unions on @types/react
+});
+ToolbarButton.displayName = 'ToolbarButton';

node_modules/@fluentui/react-toolbar/lib-commonjs/components/ToolbarButton/ToolbarButton.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/ToolbarButton/ToolbarButton.tsx"],"sourcesContent":["import * as React from 'react';\nimport type { ToolbarButtonProps } from './ToolbarButton.types';\nimport type { ForwardRefComponent } from '@fluentui/react-utilities';\nimport { renderButton_unstable } from '@fluentui/react-button';\nimport { useToolbarButtonStyles_unstable } from './useToolbarButtonStyles.styles';\nimport { useToolbarButton_unstable } from './useToolbarButton';\nimport { useCustomStyleHook_unstable } from '@fluentui/react-shared-contexts';\n\n/**\n * ToolbarButton component is a Button to be used inside Toolbar\n * which will respect toolbar props such as `size`\n */\nexport const ToolbarButton: ForwardRefComponent<ToolbarButtonProps> = React.forwardRef((props, ref) => {\n  const state = useToolbarButton_unstable(props, ref);\n\n  useToolbarButtonStyles_unstable(state);\n\n  useCustomStyleHook_unstable('useToolbarButtonStyles_unstable')(state);\n\n  return renderButton_unstable(state);\n  // Casting is required due to lack of distributive union to support unions on @types/react\n}) as ForwardRefComponent<ToolbarButtonProps>;\n\nToolbarButton.displayName = 'ToolbarButton';\n"],"names":["ToolbarButton","React","forwardRef","props","ref","state","useToolbarButton_unstable","useToolbarButtonStyles_unstable","useCustomStyleHook_unstable","renderButton_unstable","displayName"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAYaA;;;eAAAA;;;;iEAZU;6BAGe;8CACU;kCACN;qCACE;AAMrC,MAAMA,gBAAAA,WAAAA,GAAyDC,OAAMC,UAAU,CAAC,CAACC,OAAOC;IAC7F,MAAMC,QAAQC,IAAAA,2CAAAA,EAA0BH,OAAOC;IAE/CG,IAAAA,6DAAAA,EAAgCF;IAEhCG,IAAAA,gDAAAA,EAA4B,mCAAmCH;IAE/D,OAAOI,IAAAA,kCAAAA,EAAsBJ;AAC7B,0FAA0F;AAC5F;AAEAL,cAAcU,WAAW,GAAG"}

node_modules/@fluentui/react-toolbar/lib-commonjs/components/ToolbarButton/ToolbarButton.types.js

@@ -0,0 +1,6 @@
+/**
+ * State used in rendering ToolbarButton
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});

node_modules/@fluentui/react-toolbar/lib-commonjs/components/ToolbarButton/ToolbarButton.types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/ToolbarButton/ToolbarButton.types.ts"],"sourcesContent":["import type { ComponentProps, ComponentState } from '@fluentui/react-utilities';\nimport { ButtonProps, ButtonSlots, ButtonState } from '@fluentui/react-button';\n\n/**\n * ToolbarButton Props\n */\nexport type ToolbarButtonProps = ComponentProps<ButtonSlots> &\n  Partial<Pick<ButtonProps, 'disabled' | 'disabledFocusable'>> & {\n    appearance?: 'primary' | 'subtle' | 'transparent';\n  } & {\n    vertical?: boolean;\n  };\n\n/**\n * State used in rendering ToolbarButton\n */\nexport type ToolbarButtonState = ComponentState<Partial<ButtonSlots>> &\n  ButtonState &\n  Required<Pick<ToolbarButtonProps, 'vertical'>>;\n"],"names":[],"rangeMappings":";;","mappings":"AAaA;;CAEC"}

node_modules/@fluentui/react-toolbar/lib-commonjs/components/ToolbarButton/index.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    ToolbarButton: function() {
+        return _ToolbarButton.ToolbarButton;
+    },
+    useToolbarButtonStyles_unstable: function() {
+        return _useToolbarButtonStylesstyles.useToolbarButtonStyles_unstable;
+    },
+    useToolbarButton_unstable: function() {
+        return _useToolbarButton.useToolbarButton_unstable;
+    }
+});
+const _ToolbarButton = require("./ToolbarButton");
+const _useToolbarButton = require("./useToolbarButton");
+const _useToolbarButtonStylesstyles = require("./useToolbarButtonStyles.styles");

node_modules/@fluentui/react-toolbar/lib-commonjs/components/ToolbarButton/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/ToolbarButton/index.ts"],"sourcesContent":["export { ToolbarButton } from './ToolbarButton';\nexport type { ToolbarButtonProps, ToolbarButtonState } from './ToolbarButton.types';\nexport { useToolbarButton_unstable } from './useToolbarButton';\nexport { useToolbarButtonStyles_unstable } from './useToolbarButtonStyles.styles';\n"],"names":["ToolbarButton","useToolbarButtonStyles_unstable","useToolbarButton_unstable"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAASA,aAAa;eAAbA,4BAAa;;IAGbC,+BAA+B;eAA/BA,6DAA+B;;IAD/BC,yBAAyB;eAAzBA,2CAAyB;;;+BAFJ;kCAEY;8CACM"}

node_modules/@fluentui/react-toolbar/lib-commonjs/components/ToolbarButton/useToolbarButton.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useToolbarButton_unstable", {
+    enumerable: true,
+    get: function() {
+        return useToolbarButton_unstable;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _reactbutton = require("@fluentui/react-button");
+const useToolbarButton_unstable = (props, ref)=>{
+    const { vertical = false, ...buttonProps } = props;
+    const state = (0, _reactbutton.useButton_unstable)({
+        appearance: 'subtle',
+        ...buttonProps,
+        size: 'medium'
+    }, ref);
+    return {
+        vertical,
+        ...state
+    };
+};

node_modules/@fluentui/react-toolbar/lib-commonjs/components/ToolbarButton/useToolbarButton.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/ToolbarButton/useToolbarButton.ts"],"sourcesContent":["import * as React from 'react';\nimport { useButton_unstable } from '@fluentui/react-button';\nimport { ToolbarButtonProps, ToolbarButtonState } from './ToolbarButton.types';\n\n/**\n * Given user props, defines default props for the Button, calls useButtonState and useChecked, and returns\n * processed state.\n * @param props - User provided props to the Button component.\n * @param ref - User provided ref to be passed to the Button component.\n */\nexport const useToolbarButton_unstable = (\n  props: ToolbarButtonProps,\n  ref: React.Ref<HTMLButtonElement | HTMLAnchorElement>,\n): ToolbarButtonState => {\n  const { vertical = false, ...buttonProps } = props;\n  const state = useButton_unstable(\n    {\n      appearance: 'subtle',\n      ...buttonProps,\n      size: 'medium',\n    },\n    ref,\n  );\n\n  return {\n    vertical,\n    ...state,\n  };\n};\n"],"names":["useToolbarButton_unstable","props","ref","vertical","buttonProps","state","useButton_unstable","appearance","size"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAUaA;;;eAAAA;;;;iEAVU;6BACY;AAS5B,MAAMA,4BAA4B,CACvCC,OACAC;IAEA,MAAM,EAAEC,WAAW,KAAK,EAAE,GAAGC,aAAa,GAAGH;IAC7C,MAAMI,QAAQC,IAAAA,+BAAAA,EACZ;QACEC,YAAY;QACZ,GAAGH,WAAW;QACdI,MAAM;IACR,GACAN;IAGF,OAAO;QACLC;QACA,GAAGE,KAAK;IACV;AACF"}

node_modules/@fluentui/react-toolbar/lib-commonjs/components/ToolbarButton/useToolbarButtonStyles.styles.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useToolbarButtonStyles_unstable", {
+    enumerable: true,
+    get: function() {
+        return useToolbarButtonStyles_unstable;
+    }
+});
+const _react = require("@griffel/react");
+const _reactbutton = require("@fluentui/react-button");
+const useBaseStyles = /*#__PURE__*/ (0, _react.__styles)({
+    vertical: {
+        Beiy3e4: "f1vx9l62"
+    },
+    verticalIcon: {
+        Be2twd7: "f1rt2boy",
+        jrapky: 0,
+        Frg6f3: 0,
+        t21cq0: 0,
+        B6of3ja: 0,
+        B74szlk: "f1s184ao"
+    }
+}, {
+    d: [
+        ".f1vx9l62{flex-direction:column;}",
+        ".f1rt2boy{font-size:24px;}",
+        [
+            ".f1s184ao{margin:0;}",
+            {
+                p: -1
+            }
+        ]
+    ]
+});
+const useToolbarButtonStyles_unstable = (state)=>{
+    'use no memo';
+    (0, _reactbutton.useButtonStyles_unstable)(state);
+    const buttonStyles = useBaseStyles();
+    state.root.className = (0, _react.mergeClasses)(state.root.className, state.vertical && buttonStyles.vertical);
+    if (state.icon) {
+        state.icon.className = (0, _react.mergeClasses)(state.icon.className, state.vertical && buttonStyles.verticalIcon);
+    }
+};

node_modules/@fluentui/react-toolbar/lib-commonjs/components/ToolbarButton/useToolbarButtonStyles.styles.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["useToolbarButtonStyles.styles.js"],"sourcesContent":["import { makeStyles, mergeClasses } from '@griffel/react';\nimport { useButtonStyles_unstable } from '@fluentui/react-button';\nconst useBaseStyles = makeStyles({\n    vertical: {\n        flexDirection: 'column'\n    },\n    verticalIcon: {\n        fontSize: '24px',\n        margin: '0'\n    }\n});\n/**\n * Apply styling to the ToolbarButton slots based on the state\n */ export const useToolbarButtonStyles_unstable = (state)=>{\n    'use no memo';\n    useButtonStyles_unstable(state);\n    const buttonStyles = useBaseStyles();\n    state.root.className = mergeClasses(state.root.className, state.vertical && buttonStyles.vertical);\n    if (state.icon) {\n        state.icon.className = mergeClasses(state.icon.className, state.vertical && buttonStyles.verticalIcon);\n    }\n};\n"],"names":["useToolbarButtonStyles_unstable","useBaseStyles","__styles","vertical","Beiy3e4","verticalIcon","Be2twd7","jrapky","Frg6f3","t21cq0","B6of3ja","B74szlk","d","p","state","useButtonStyles_unstable","buttonStyles","root","className","mergeClasses","icon"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAaiBA;;;eAAAA;;;uBAbwB;6BACA;AACzC,MAAMC,gBAAa,WAAA,GAAGC,IAAAA,eAAA,EAAA;IAAAC,UAAA;QAAAC,SAAA;IAAA;IAAAC,cAAA;QAAAC,SAAA;QAAAC,QAAA;QAAAC,QAAA;QAAAC,QAAA;QAAAC,SAAA;QAAAC,SAAA;IAAA;AAAA,GAAA;IAAAC,GAAA;QAAA;QAAA;QAAA;YAAA;YAAA;gBAAAC,GAAA,CAAA;YAAA;SAAA;KAAA;AAAA;AAWX,MAAMb,kCAAmCc,CAAAA;IAChD;IACAC,IAAAA,qCAAwB,EAACD;IACzB,MAAME,eAAef;IACrBa,MAAMG,IAAI,CAACC,SAAS,GAAGC,IAAAA,mBAAY,EAACL,MAAMG,IAAI,CAACC,SAAS,EAAEJ,MAAMX,QAAQ,IAAIa,aAAab,QAAQ;IACjG,IAAIW,MAAMM,IAAI,EAAE;QACZN,MAAMM,IAAI,CAACF,SAAS,GAAGC,IAAAA,mBAAY,EAACL,MAAMM,IAAI,CAACF,SAAS,EAAEJ,MAAMX,QAAQ,IAAIa,aAAaX,YAAY;IACzG;AACJ"}

node_modules/@fluentui/react-toolbar/lib-commonjs/components/ToolbarDivider/ToolbarDivider.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ToolbarDivider", {
+    enumerable: true,
+    get: function() {
+        return ToolbarDivider;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _useToolbarDividerStylesstyles = require("./useToolbarDividerStyles.styles");
+const _reactdivider = require("@fluentui/react-divider");
+const _useToolbarDivider = require("./useToolbarDivider");
+const _reactsharedcontexts = require("@fluentui/react-shared-contexts");
+const ToolbarDivider = /*#__PURE__*/ _react.forwardRef((props, ref)=>{
+    const state = (0, _useToolbarDivider.useToolbarDivider_unstable)(props, ref);
+    (0, _useToolbarDividerStylesstyles.useToolbarDividerStyles_unstable)(state);
+    (0, _reactsharedcontexts.useCustomStyleHook_unstable)('useToolbarDividerStyles_unstable')(state);
+    return (0, _reactdivider.renderDivider_unstable)(state);
+});
+ToolbarDivider.displayName = 'ToolbarDivider';

node_modules/@fluentui/react-toolbar/lib-commonjs/components/ToolbarDivider/ToolbarDivider.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/ToolbarDivider/ToolbarDivider.tsx"],"sourcesContent":["import * as React from 'react';\nimport { useToolbarDividerStyles_unstable } from './useToolbarDividerStyles.styles';\nimport type { ToolbarDividerProps } from './ToolbarDivider.types';\nimport type { ForwardRefComponent } from '@fluentui/react-utilities';\nimport { renderDivider_unstable } from '@fluentui/react-divider';\nimport { useToolbarDivider_unstable } from './useToolbarDivider';\nimport { useCustomStyleHook_unstable } from '@fluentui/react-shared-contexts';\n\n/**\n * ToolbarDivider component\n */\nexport const ToolbarDivider: ForwardRefComponent<ToolbarDividerProps> = React.forwardRef((props, ref) => {\n  const state = useToolbarDivider_unstable(props, ref);\n\n  useToolbarDividerStyles_unstable(state);\n\n  useCustomStyleHook_unstable('useToolbarDividerStyles_unstable')(state);\n\n  return renderDivider_unstable(state);\n});\n\nToolbarDivider.displayName = 'ToolbarDivider';\n"],"names":["ToolbarDivider","React","forwardRef","props","ref","state","useToolbarDivider_unstable","useToolbarDividerStyles_unstable","useCustomStyleHook_unstable","renderDivider_unstable","displayName"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAWaA;;;eAAAA;;;;iEAXU;+CAC0B;8BAGV;mCACI;qCACC;AAKrC,MAAMA,iBAAAA,WAAAA,GAA2DC,OAAMC,UAAU,CAAC,CAACC,OAAOC;IAC/F,MAAMC,QAAQC,IAAAA,6CAAAA,EAA2BH,OAAOC;IAEhDG,IAAAA,+DAAAA,EAAiCF;IAEjCG,IAAAA,gDAAAA,EAA4B,oCAAoCH;IAEhE,OAAOI,IAAAA,oCAAAA,EAAuBJ;AAChC;AAEAL,eAAeU,WAAW,GAAG"}

node_modules/@fluentui/react-toolbar/lib-commonjs/components/ToolbarDivider/ToolbarDivider.types.js

@@ -0,0 +1,6 @@
+/**
+ * State used in rendering ToolbarDivider
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});

node_modules/@fluentui/react-toolbar/lib-commonjs/components/ToolbarDivider/ToolbarDivider.types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/ToolbarDivider/ToolbarDivider.types.ts"],"sourcesContent":["import type { ComponentProps, ComponentState } from '@fluentui/react-utilities';\nimport { DividerSlots, DividerState } from '@fluentui/react-divider';\n\n/**\n * ToolbarDivider Props\n */\nexport type ToolbarDividerProps = ComponentProps<Partial<DividerSlots>> & {\n  /**\n   * A divider can be horizontal or vertical (default).\n   *\n   * @default true\n   */\n  vertical?: boolean;\n};\n\n/**\n * State used in rendering ToolbarDivider\n */\nexport type ToolbarDividerState = ComponentState<Partial<DividerSlots>> & DividerState;\n"],"names":[],"rangeMappings":";;","mappings":"AAeA;;CAEC"}

node_modules/@fluentui/react-toolbar/lib-commonjs/components/ToolbarDivider/index.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    ToolbarDivider: function() {
+        return _ToolbarDivider.ToolbarDivider;
+    },
+    useToolbarDividerStyles_unstable: function() {
+        return _useToolbarDividerStylesstyles.useToolbarDividerStyles_unstable;
+    },
+    useToolbarDivider_unstable: function() {
+        return _useToolbarDivider.useToolbarDivider_unstable;
+    }
+});
+const _ToolbarDivider = require("./ToolbarDivider");
+const _useToolbarDividerStylesstyles = require("./useToolbarDividerStyles.styles");
+const _useToolbarDivider = require("./useToolbarDivider");

node_modules/@fluentui/react-toolbar/lib-commonjs/components/ToolbarDivider/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/ToolbarDivider/index.ts"],"sourcesContent":["export { ToolbarDivider } from './ToolbarDivider';\nexport type { ToolbarDividerProps, ToolbarDividerState } from './ToolbarDivider.types';\nexport { useToolbarDividerStyles_unstable } from './useToolbarDividerStyles.styles';\nexport { useToolbarDivider_unstable } from './useToolbarDivider';\n"],"names":["ToolbarDivider","useToolbarDividerStyles_unstable","useToolbarDivider_unstable"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAASA,cAAc;eAAdA,8BAAc;;IAEdC,gCAAgC;eAAhCA,+DAAgC;;IAChCC,0BAA0B;eAA1BA,6CAA0B;;;gCAHJ;+CAEkB;mCACN"}

node_modules/@fluentui/react-toolbar/lib-commonjs/components/ToolbarDivider/useToolbarDivider.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useToolbarDivider_unstable", {
+    enumerable: true,
+    get: function() {
+        return useToolbarDivider_unstable;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _reactdivider = require("@fluentui/react-divider");
+const _ToolbarContext = require("../Toolbar/ToolbarContext");
+const useToolbarDivider_unstable = (props, ref)=>{
+    const vertical = (0, _ToolbarContext.useToolbarContext_unstable)((ctx)=>ctx.vertical);
+    return (0, _reactdivider.useDivider_unstable)({
+        vertical: !vertical,
+        ...props
+    }, ref);
+};

node_modules/@fluentui/react-toolbar/lib-commonjs/components/ToolbarDivider/useToolbarDivider.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/ToolbarDivider/useToolbarDivider.ts"],"sourcesContent":["import * as React from 'react';\nimport { ToolbarDividerProps, ToolbarDividerState } from './ToolbarDivider.types';\nimport { useDivider_unstable } from '@fluentui/react-divider';\nimport { useToolbarContext_unstable } from '../Toolbar/ToolbarContext';\n\n/**\n * Create the state required to render ToolbarDivider.\n *\n * The returned state can be modified with hooks such as useToolbarDividerStyles_unstable,\n * before being passed to renderToolbar_unstable.\n *\n * @param props - props from this instance of ToolbarDivider\n * @param ref - reference to root HTMLElement of ToolbarDivider\n */\nexport const useToolbarDivider_unstable = (\n  props: ToolbarDividerProps,\n  ref: React.Ref<HTMLElement>,\n): ToolbarDividerState => {\n  const vertical = useToolbarContext_unstable(ctx => ctx.vertical);\n  return useDivider_unstable({ vertical: !vertical, ...props }, ref);\n};\n"],"names":["useToolbarDivider_unstable","props","ref","vertical","useToolbarContext_unstable","ctx","useDivider_unstable"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAcaA;;;eAAAA;;;;iEAdU;8BAEa;gCACO;AAWpC,MAAMA,6BAA6B,CACxCC,OACAC;IAEA,MAAMC,WAAWC,IAAAA,0CAAAA,EAA2BC,CAAAA,MAAOA,IAAIF,QAAQ;IAC/D,OAAOG,IAAAA,iCAAAA,EAAoB;QAAEH,UAAU,CAACA;QAAU,GAAGF,KAAK;IAAC,GAAGC;AAChE"}

node_modules/@fluentui/react-toolbar/lib-commonjs/components/ToolbarDivider/useToolbarDividerStyles.styles.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useToolbarDividerStyles_unstable", {
+    enumerable: true,
+    get: function() {
+        return useToolbarDividerStyles_unstable;
+    }
+});
+const _react = require("@griffel/react");
+const _reactdivider = require("@fluentui/react-divider");
+const useBaseStyles = /*#__PURE__*/ (0, _react.__styles)({
+    root: {
+        mc9l5x: "ftuwxu6",
+        B2u0y6b: "f1lwjmbk",
+        Byoj8tv: 0,
+        uwmqm3: 0,
+        z189sj: 0,
+        z8tnut: 0,
+        B0ocmuz: "f1oic3e7"
+    },
+    vertical: {
+        B2u0y6b: "fe668z"
+    }
+}, {
+    d: [
+        ".ftuwxu6{display:inline-flex;}",
+        ".f1lwjmbk{max-width:1px;}",
+        [
+            ".f1oic3e7{padding:0 12px;}",
+            {
+                p: -1
+            }
+        ],
+        ".fe668z{max-width:initial;}"
+    ]
+});
+const useToolbarDividerStyles_unstable = (state)=>{
+    'use no memo';
+    (0, _reactdivider.useDividerStyles_unstable)(state);
+    const { vertical } = state;
+    const toolbarDividerStyles = useBaseStyles();
+    state.root.className = (0, _react.mergeClasses)(toolbarDividerStyles.root, !vertical && toolbarDividerStyles.vertical, state.root.className);
+    return state;
+};

node_modules/@fluentui/react-toolbar/lib-commonjs/components/ToolbarDivider/useToolbarDividerStyles.styles.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["useToolbarDividerStyles.styles.js"],"sourcesContent":["import { makeStyles, mergeClasses } from '@griffel/react';\nimport { useDividerStyles_unstable } from '@fluentui/react-divider';\nconst useBaseStyles = makeStyles({\n    // Base styles\n    root: {\n        display: 'inline-flex',\n        maxWidth: '1px',\n        padding: '0 12px'\n    },\n    vertical: {\n        maxWidth: 'initial'\n    }\n});\n/**\n * Apply styling to the ToolbarDivider slots based on the state\n */ export const useToolbarDividerStyles_unstable = (state)=>{\n    'use no memo';\n    useDividerStyles_unstable(state);\n    const { vertical } = state;\n    const toolbarDividerStyles = useBaseStyles();\n    state.root.className = mergeClasses(toolbarDividerStyles.root, !vertical && toolbarDividerStyles.vertical, state.root.className);\n    return state;\n};\n"],"names":["useToolbarDividerStyles_unstable","useBaseStyles","__styles","root","mc9l5x","B2u0y6b","Byoj8tv","uwmqm3","z189sj","z8tnut","B0ocmuz","vertical","d","p","state","useDividerStyles_unstable","toolbarDividerStyles","className","mergeClasses"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAeiBA;;;eAAAA;;;uBAfwB;8BACC;AAC1C,MAAMC,gBAAa,WAAA,GAAGC,IAAAA,eAAA,EAAA;IAAAC,MAAA;QAAAC,QAAA;QAAAC,SAAA;QAAAC,SAAA;QAAAC,QAAA;QAAAC,QAAA;QAAAC,QAAA;QAAAC,SAAA;IAAA;IAAAC,UAAA;QAAAN,SAAA;IAAA;AAAA,GAAA;IAAAO,GAAA;QAAA;QAAA;QAAA;YAAA;YAAA;gBAAAC,GAAA,CAAA;YAAA;SAAA;QAAA;KAAA;AAAA;AAaX,MAAMb,mCAAoCc,CAAAA;IACjD;IACAC,IAAAA,uCAAyB,EAACD;IAC1B,MAAM,EAAEH,QAAAA,EAAU,GAAGG;IACrB,MAAME,uBAAuBf;IAC7Ba,MAAMX,IAAI,CAACc,SAAS,GAAGC,IAAAA,mBAAY,EAACF,qBAAqBb,IAAI,EAAE,CAACQ,YAAYK,qBAAqBL,QAAQ,EAAEG,MAAMX,IAAI,CAACc,SAAS;IAC/H,OAAOH;AACX"}

node_modules/@fluentui/react-toolbar/lib-commonjs/components/ToolbarGroup/ToolbarGroup.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ToolbarGroup", {
+    enumerable: true,
+    get: function() {
+        return ToolbarGroup;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _useToolbarGroup = require("./useToolbarGroup");
+const _useToolbarGroupStylesstyles = require("./useToolbarGroupStyles.styles");
+const _renderToolbarGroup = require("./renderToolbarGroup");
+const _reactsharedcontexts = require("@fluentui/react-shared-contexts");
+const ToolbarGroup = /*#__PURE__*/ _react.forwardRef((props, ref)=>{
+    const state = (0, _useToolbarGroup.useToolbarGroup_unstable)(props, ref);
+    (0, _useToolbarGroupStylesstyles.useToolbarGroupStyles_unstable)(state);
+    (0, _reactsharedcontexts.useCustomStyleHook_unstable)('useToolbarGroupStyles_unstable')(state);
+    return (0, _renderToolbarGroup.renderToolbarGroup_unstable)(state);
+// Casting is required due to lack of distributive union to support unions on @types/react
+});
+ToolbarGroup.displayName = 'ToolbarGroup';

node_modules/@fluentui/react-toolbar/lib-commonjs/components/ToolbarGroup/ToolbarGroup.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/ToolbarGroup/ToolbarGroup.tsx"],"sourcesContent":["import * as React from 'react';\nimport type { ToolbarGroupProps } from './ToolbarGroup.types';\nimport type { ForwardRefComponent } from '@fluentui/react-utilities';\nimport { useToolbarGroup_unstable } from './useToolbarGroup';\nimport { useToolbarGroupStyles_unstable } from './useToolbarGroupStyles.styles';\nimport { renderToolbarGroup_unstable } from './renderToolbarGroup';\nimport { useCustomStyleHook_unstable } from '@fluentui/react-shared-contexts';\n\n/**\n * ToolbarGroup component is a Button to be used inside Toolbar\n * which will respect toolbar props such as `size`\n */\nexport const ToolbarGroup: ForwardRefComponent<ToolbarGroupProps> = React.forwardRef((props, ref) => {\n  const state = useToolbarGroup_unstable(props, ref);\n\n  useToolbarGroupStyles_unstable(state);\n\n  useCustomStyleHook_unstable('useToolbarGroupStyles_unstable')(state);\n\n  return renderToolbarGroup_unstable(state);\n  // Casting is required due to lack of distributive union to support unions on @types/react\n}) as ForwardRefComponent<ToolbarGroupProps>;\n\nToolbarGroup.displayName = 'ToolbarGroup';\n"],"names":["ToolbarGroup","React","forwardRef","props","ref","state","useToolbarGroup_unstable","useToolbarGroupStyles_unstable","useCustomStyleHook_unstable","renderToolbarGroup_unstable","displayName"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAYaA;;;eAAAA;;;;iEAZU;iCAGkB;6CACM;oCACH;qCACA;AAMrC,MAAMA,eAAAA,WAAAA,GAAuDC,OAAMC,UAAU,CAAC,CAACC,OAAOC;IAC3F,MAAMC,QAAQC,IAAAA,yCAAAA,EAAyBH,OAAOC;IAE9CG,IAAAA,2DAAAA,EAA+BF;IAE/BG,IAAAA,gDAAAA,EAA4B,kCAAkCH;IAE9D,OAAOI,IAAAA,+CAAAA,EAA4BJ;AACnC,0FAA0F;AAC5F;AAEAL,aAAaU,WAAW,GAAG"}

node_modules/@fluentui/react-toolbar/lib-commonjs/components/ToolbarGroup/ToolbarGroup.types.js

@@ -0,0 +1,6 @@
+/**
+ * State used in rendering ToolbarButton
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});

node_modules/@fluentui/react-toolbar/lib-commonjs/components/ToolbarGroup/ToolbarGroup.types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/ToolbarGroup/ToolbarGroup.types.ts"],"sourcesContent":["import type { ComponentProps, ComponentState, Slot } from '@fluentui/react-utilities';\n\nexport type ToolbarGroupSlots = {\n  root: Slot<'div'>;\n};\n\n/**\n * ToolbarButton Props\n */\nexport type ToolbarGroupProps = ComponentProps<ToolbarGroupSlots>;\n\n/**\n * State used in rendering ToolbarButton\n */\nexport type ToolbarGroupState = ComponentState<ToolbarGroupSlots>;\n"],"names":[],"rangeMappings":";;","mappings":"AAWA;;CAEC"}

node_modules/@fluentui/react-toolbar/lib-commonjs/components/ToolbarGroup/index.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    ToolbarGroup: function() {
+        return _ToolbarGroup.ToolbarGroup;
+    },
+    renderToolbarGroup_unstable: function() {
+        return _renderToolbarGroup.renderToolbarGroup_unstable;
+    },
+    toolbarGroupClassNames: function() {
+        return _useToolbarGroupStylesstyles.toolbarGroupClassNames;
+    },
+    useToolbarGroupStyles_unstable: function() {
+        return _useToolbarGroupStylesstyles.useToolbarGroupStyles_unstable;
+    },
+    useToolbarGroup_unstable: function() {
+        return _useToolbarGroup.useToolbarGroup_unstable;
+    }
+});
+const _ToolbarGroup = require("./ToolbarGroup");
+const _useToolbarGroup = require("./useToolbarGroup");
+const _useToolbarGroupStylesstyles = require("./useToolbarGroupStyles.styles");
+const _renderToolbarGroup = require("./renderToolbarGroup");

node_modules/@fluentui/react-toolbar/lib-commonjs/components/ToolbarGroup/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/ToolbarGroup/index.ts"],"sourcesContent":["export { ToolbarGroup } from './ToolbarGroup';\nexport type { ToolbarGroupProps, ToolbarGroupSlots, ToolbarGroupState } from './ToolbarGroup.types';\nexport { useToolbarGroup_unstable } from './useToolbarGroup';\nexport { toolbarGroupClassNames, useToolbarGroupStyles_unstable } from './useToolbarGroupStyles.styles';\nexport { renderToolbarGroup_unstable } from './renderToolbarGroup';\n"],"names":["ToolbarGroup","renderToolbarGroup_unstable","toolbarGroupClassNames","useToolbarGroupStyles_unstable","useToolbarGroup_unstable"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAASA,YAAY;eAAZA,0BAAY;;IAIZC,2BAA2B;eAA3BA,+CAA2B;;IAD3BC,sBAAsB;eAAtBA,mDAAsB;;IAAEC,8BAA8B;eAA9BA,2DAA8B;;IADtDC,wBAAwB;eAAxBA,yCAAwB;;;8BAFJ;iCAEY;6CAC8B;oCAC3B"}

node_modules/@fluentui/react-toolbar/lib-commonjs/components/ToolbarGroup/renderToolbarGroup.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "renderToolbarGroup_unstable", {
+    enumerable: true,
+    get: function() {
+        return renderToolbarGroup_unstable;
+    }
+});
+const _jsxruntime = require("@fluentui/react-jsx-runtime/jsx-runtime");
+const _reactutilities = require("@fluentui/react-utilities");
+const renderToolbarGroup_unstable = (state)=>{
+    (0, _reactutilities.assertSlots)(state);
+    return /*#__PURE__*/ (0, _jsxruntime.jsx)(state.root, {
+        children: state.root.children
+    });
+};

node_modules/@fluentui/react-toolbar/lib-commonjs/components/ToolbarGroup/renderToolbarGroup.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/ToolbarGroup/renderToolbarGroup.tsx"],"sourcesContent":["/** @jsxRuntime automatic */\n/** @jsxImportSource @fluentui/react-jsx-runtime */\nimport { assertSlots } from '@fluentui/react-utilities';\nimport type { ToolbarGroupState, ToolbarGroupSlots } from './ToolbarGroup.types';\n\n/**\n * Render the final JSX of ToolbarGroup\n */\nexport const renderToolbarGroup_unstable = (state: ToolbarGroupState) => {\n  assertSlots<ToolbarGroupSlots>(state);\n\n  return <state.root>{state.root.children}</state.root>;\n};\n"],"names":["renderToolbarGroup_unstable","state","assertSlots","_jsx","root","children"],"rangeMappings":";;;;;;;;;;;;;;;;;","mappings":";;;;+BAQaA;;;eAAAA;;;4BAPb;gCAC4B;AAMrB,MAAMA,8BAA8B,CAACC;IAC1CC,IAAAA,2BAAAA,EAA+BD;IAE/B,OAAA,WAAA,GAAOE,IAAAA,eAAA,EAACF,MAAMG,IAAI,EAAA;kBAAEH,MAAMG,IAAI,CAACC,QAAQ;;AACzC"}

node_modules/@fluentui/react-toolbar/lib-commonjs/components/ToolbarGroup/useToolbarGroup.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useToolbarGroup_unstable", {
+    enumerable: true,
+    get: function() {
+        return useToolbarGroup_unstable;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _reactutilities = require("@fluentui/react-utilities");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const useToolbarGroup_unstable = (props, ref)=>{
+    return {
+        components: {
+            root: 'div'
+        },
+        root: _reactutilities.slot.always((0, _reactutilities.getIntrinsicElementProps)('div', {
+            ref,
+            role: 'presentation',
+            ...props
+        }), {
+            elementType: 'div'
+        })
+    };
+};

node_modules/@fluentui/react-toolbar/lib-commonjs/components/ToolbarGroup/useToolbarGroup.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/ToolbarGroup/useToolbarGroup.ts"],"sourcesContent":["import { getIntrinsicElementProps, slot } from '@fluentui/react-utilities';\nimport * as React from 'react';\nimport { ToolbarGroupProps, ToolbarGroupState } from './ToolbarGroup.types';\n\n/**\n * Given user props, defines default props for the Group\n * @param props - User provided props to the Group component.\n * @param ref - User provided ref to be passed to the Group component.\n */\nexport const useToolbarGroup_unstable = (\n  props: ToolbarGroupProps,\n  ref: React.Ref<HTMLDivElement>,\n): ToolbarGroupState => {\n  return {\n    components: {\n      root: 'div',\n    },\n    root: slot.always(\n      getIntrinsicElementProps<React.HTMLAttributes<HTMLDivElement>>('div', {\n        ref,\n        role: 'presentation',\n        ...props,\n      }),\n      { elementType: 'div' },\n    ),\n  };\n};\n"],"names":["useToolbarGroup_unstable","props","ref","components","root","slot","always","getIntrinsicElementProps","role","elementType"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BASaA;;;eAAAA;;;;gCATkC;iEACxB;AAQhB,MAAMA,2BAA2B,CACtCC,OACAC;IAEA,OAAO;QACLC,YAAY;YACVC,MAAM;QACR;QACAA,MAAMC,oBAAAA,CAAKC,MAAM,CACfC,IAAAA,wCAAAA,EAA+D,OAAO;YACpEL;YACAM,MAAM;YACN,GAAGP,KAAK;QACV,IACA;YAAEQ,aAAa;QAAM;IAEzB;AACF"}

node_modules/@fluentui/react-toolbar/lib-commonjs/components/ToolbarGroup/useToolbarGroupStyles.styles.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    toolbarGroupClassNames: function() {
+        return toolbarGroupClassNames;
+    },
+    useToolbarGroupStyles_unstable: function() {
+        return useToolbarGroupStyles_unstable;
+    }
+});
+const _react = require("@griffel/react");
+const toolbarGroupClassNames = {
+    root: 'fui-ToolbarGroup'
+};
+const useToolbarGroupStyles_unstable = (state)=>{
+    'use no memo';
+    state.root.className = (0, _react.mergeClasses)(toolbarGroupClassNames.root, state.root.className);
+    return state;
+};

node_modules/@fluentui/react-toolbar/lib-commonjs/components/ToolbarGroup/useToolbarGroupStyles.styles.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["useToolbarGroupStyles.styles.js"],"sourcesContent":["import { mergeClasses } from '@griffel/react';\nexport const toolbarGroupClassNames = {\n    root: 'fui-ToolbarGroup'\n};\n/**\n * Apply styling to the Toolbar slots based on the state\n */ export const useToolbarGroupStyles_unstable = (state)=>{\n    'use no memo';\n    state.root.className = mergeClasses(toolbarGroupClassNames.root, state.root.className);\n    return state;\n};\n"],"names":["toolbarGroupClassNames","useToolbarGroupStyles_unstable","root","state","className","mergeClasses"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IACaA,sBAAsB;eAAtBA;;IAKIC,8BAA8B;eAA9BA;;;uBANY;AACtB,MAAMD,yBAAyB;IAClCE,MAAM;AACV;AAGW,MAAMD,iCAAkCE,CAAAA;IAC/C;IACAA,MAAMD,IAAI,CAACE,SAAS,GAAGC,IAAAA,mBAAY,EAACL,uBAAuBE,IAAI,EAAEC,MAAMD,IAAI,CAACE,SAAS;IACrF,OAAOD;AACX"}

node_modules/@fluentui/react-toolbar/lib-commonjs/components/ToolbarRadioButton/ToolbarRadioButton.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ToolbarRadioButton", {
+    enumerable: true,
+    get: function() {
+        return ToolbarRadioButton;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _reactbutton = require("@fluentui/react-button");
+const _useToolbarRadioButton = require("./useToolbarRadioButton");
+const _useToolbarRadioButtonStylesstyles = require("./useToolbarRadioButtonStyles.styles");
+const _reactsharedcontexts = require("@fluentui/react-shared-contexts");
+const ToolbarRadioButton = /*#__PURE__*/ _react.forwardRef((props, ref)=>{
+    const state = (0, _useToolbarRadioButton.useToolbarRadioButton_unstable)(props, ref);
+    (0, _useToolbarRadioButtonStylesstyles.useToolbarRadioButtonStyles_unstable)(state);
+    (0, _reactsharedcontexts.useCustomStyleHook_unstable)('useToolbarRadioButtonStyles_unstable')(state);
+    return (0, _reactbutton.renderToggleButton_unstable)(state);
+});
+ToolbarRadioButton.displayName = 'ToolbarRadioButton';

node_modules/@fluentui/react-toolbar/lib-commonjs/components/ToolbarRadioButton/ToolbarRadioButton.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/ToolbarRadioButton/ToolbarRadioButton.tsx"],"sourcesContent":["import * as React from 'react';\nimport type { ToolbarRadioButtonProps } from './ToolbarRadioButton.types';\nimport type { ForwardRefComponent } from '@fluentui/react-utilities';\nimport { renderToggleButton_unstable } from '@fluentui/react-button';\nimport { useToolbarRadioButton_unstable } from './useToolbarRadioButton';\nimport { useToolbarRadioButtonStyles_unstable } from './useToolbarRadioButtonStyles.styles';\nimport { useCustomStyleHook_unstable } from '@fluentui/react-shared-contexts';\n\n/**\n * ToolbarRadioButton component\n */\nexport const ToolbarRadioButton: ForwardRefComponent<ToolbarRadioButtonProps> = React.forwardRef((props, ref) => {\n  const state = useToolbarRadioButton_unstable(props, ref);\n\n  useToolbarRadioButtonStyles_unstable(state);\n\n  useCustomStyleHook_unstable('useToolbarRadioButtonStyles_unstable')(state);\n\n  return renderToggleButton_unstable(state);\n}) as ForwardRefComponent<ToolbarRadioButtonProps>;\n\nToolbarRadioButton.displayName = 'ToolbarRadioButton';\n"],"names":["ToolbarRadioButton","React","forwardRef","props","ref","state","useToolbarRadioButton_unstable","useToolbarRadioButtonStyles_unstable","useCustomStyleHook_unstable","renderToggleButton_unstable","displayName"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAWaA;;;eAAAA;;;;iEAXU;6BAGqB;uCACG;mDACM;qCACT;AAKrC,MAAMA,qBAAAA,WAAAA,GAAmEC,OAAMC,UAAU,CAAC,CAACC,OAAOC;IACvG,MAAMC,QAAQC,IAAAA,qDAAAA,EAA+BH,OAAOC;IAEpDG,IAAAA,uEAAAA,EAAqCF;IAErCG,IAAAA,gDAAAA,EAA4B,wCAAwCH;IAEpE,OAAOI,IAAAA,wCAAAA,EAA4BJ;AACrC;AAEAL,mBAAmBU,WAAW,GAAG"}

node_modules/@fluentui/react-toolbar/lib-commonjs/components/ToolbarRadioButton/ToolbarRadioButton.types.js

@@ -0,0 +1,6 @@
+/**
+ * State used in rendering ToolbarRadioButton
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});

node_modules/@fluentui/react-toolbar/lib-commonjs/components/ToolbarRadioButton/ToolbarRadioButton.types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/ToolbarRadioButton/ToolbarRadioButton.types.ts"],"sourcesContent":["import type { ComponentProps, ComponentState } from '@fluentui/react-utilities';\nimport { ToggleButtonProps, ButtonSlots, ToggleButtonState } from '@fluentui/react-button';\n\n/**\n * ToolbarRadioButton Props\n */\nexport type ToolbarRadioButtonProps = ComponentProps<ButtonSlots> &\n  Partial<Pick<ToggleButtonProps, 'disabled' | 'disabledFocusable' | 'size'>> & {\n    appearance?: 'primary' | 'subtle' | 'transparent';\n    name: string;\n    value: string;\n  };\n\n/**\n * State used in rendering ToolbarRadioButton\n */\nexport type ToolbarRadioButtonState = ComponentState<Partial<ButtonSlots>> &\n  ToggleButtonState &\n  Required<Pick<ToggleButtonProps, 'checked'>> &\n  Pick<ToolbarRadioButtonProps, 'name' | 'value'>;\n"],"names":[],"rangeMappings":";;","mappings":"AAaA;;CAEC"}

node_modules/@fluentui/react-toolbar/lib-commonjs/components/ToolbarRadioButton/index.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    ToolbarRadioButton: function() {
+        return _ToolbarRadioButton.ToolbarRadioButton;
+    },
+    useToolbarRadioButtonStyles_unstable: function() {
+        return _useToolbarRadioButtonStylesstyles.useToolbarRadioButtonStyles_unstable;
+    },
+    useToolbarRadioButton_unstable: function() {
+        return _useToolbarRadioButton.useToolbarRadioButton_unstable;
+    }
+});
+const _ToolbarRadioButton = require("./ToolbarRadioButton");
+const _useToolbarRadioButton = require("./useToolbarRadioButton");
+const _useToolbarRadioButtonStylesstyles = require("./useToolbarRadioButtonStyles.styles");

node_modules/@fluentui/react-toolbar/lib-commonjs/components/ToolbarRadioButton/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/ToolbarRadioButton/index.ts"],"sourcesContent":["export { ToolbarRadioButton } from './ToolbarRadioButton';\nexport type { ToolbarRadioButtonProps, ToolbarRadioButtonState } from './ToolbarRadioButton.types';\nexport { useToolbarRadioButton_unstable } from './useToolbarRadioButton';\nexport { useToolbarRadioButtonStyles_unstable } from './useToolbarRadioButtonStyles.styles';\n"],"names":["ToolbarRadioButton","useToolbarRadioButtonStyles_unstable","useToolbarRadioButton_unstable"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAASA,kBAAkB;eAAlBA,sCAAkB;;IAGlBC,oCAAoC;eAApCA,uEAAoC;;IADpCC,8BAA8B;eAA9BA,qDAA8B;;;oCAFJ;uCAEY;mDACM"}

node_modules/@fluentui/react-toolbar/lib-commonjs/components/ToolbarRadioButton/useToolbarRadioButton.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useToolbarRadioButton_unstable", {
+    enumerable: true,
+    get: function() {
+        return useToolbarRadioButton_unstable;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _reactutilities = require("@fluentui/react-utilities");
+const _reactbutton = require("@fluentui/react-button");
+const _ToolbarContext = require("../Toolbar/ToolbarContext");
+const useToolbarRadioButton_unstable = (props, ref)=>{
+    const handleRadio = (0, _ToolbarContext.useToolbarContext_unstable)((ctx)=>ctx.handleRadio);
+    const checked = (0, _ToolbarContext.useToolbarContext_unstable)((ctx)=>{
+        var _ctx_checkedValues_props_name;
+        return !!((_ctx_checkedValues_props_name = ctx.checkedValues[props.name]) === null || _ctx_checkedValues_props_name === void 0 ? void 0 : _ctx_checkedValues_props_name.includes(props.value));
+    });
+    const size = (0, _ToolbarContext.useToolbarContext_unstable)((ctx)=>ctx.size);
+    const { onClick: onClickOriginal } = props;
+    const toggleButtonState = (0, _reactbutton.useToggleButton_unstable)({
+        size,
+        checked,
+        role: 'radio',
+        'aria-checked': checked,
+        ...props
+    }, ref);
+    const state = {
+        ...toggleButtonState,
+        name: props.name,
+        value: props.value
+    };
+    const handleOnClick = (0, _reactutilities.useEventCallback)((e)=>{
+        handleRadio === null || handleRadio === void 0 ? void 0 : handleRadio(e, state.name, state.value, state.checked);
+        onClickOriginal === null || onClickOriginal === void 0 ? void 0 : onClickOriginal(e);
+    });
+    state.root['aria-pressed'] = undefined;
+    state.root.onClick = handleOnClick;
+    return state;
+};

node_modules/@fluentui/react-toolbar/lib-commonjs/components/ToolbarRadioButton/useToolbarRadioButton.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/ToolbarRadioButton/useToolbarRadioButton.ts"],"sourcesContent":["import * as React from 'react';\nimport { useEventCallback } from '@fluentui/react-utilities';\nimport { useToggleButton_unstable } from '@fluentui/react-button';\nimport { useToolbarContext_unstable } from '../Toolbar/ToolbarContext';\nimport { ToolbarRadioButtonProps, ToolbarRadioButtonState } from './ToolbarRadioButton.types';\n\n/**\n * Given user props, defines default props for the RadioButton, calls useButtonState and useChecked, and returns\n * processed state.\n * @param props - User provided props to the RadioButton component.\n * @param ref - User provided ref to be passed to the RadioButton component.\n */\nexport const useToolbarRadioButton_unstable = (\n  props: ToolbarRadioButtonProps,\n  ref: React.Ref<HTMLButtonElement | HTMLAnchorElement>,\n): ToolbarRadioButtonState => {\n  const handleRadio = useToolbarContext_unstable(ctx => ctx.handleRadio);\n  const checked = useToolbarContext_unstable(ctx => !!ctx.checkedValues[props.name]?.includes(props.value));\n  const size = useToolbarContext_unstable(ctx => ctx.size);\n\n  const { onClick: onClickOriginal } = props;\n  const toggleButtonState = useToggleButton_unstable(\n    { size, checked, role: 'radio', 'aria-checked': checked, ...props },\n    ref,\n  );\n  const state: ToolbarRadioButtonState = {\n    ...toggleButtonState,\n    name: props.name,\n    value: props.value,\n  };\n\n  const handleOnClick = useEventCallback(\n    (e: React.MouseEvent<HTMLButtonElement, MouseEvent> & React.MouseEvent<HTMLAnchorElement, MouseEvent>) => {\n      handleRadio?.(e, state.name, state.value, state.checked);\n      onClickOriginal?.(e);\n    },\n  );\n  state.root['aria-pressed'] = undefined;\n  state.root.onClick = handleOnClick;\n  return state;\n};\n"],"names":["useToolbarRadioButton_unstable","props","ref","handleRadio","useToolbarContext_unstable","ctx","checked","checkedValues","name","includes","value","size","onClick","onClickOriginal","toggleButtonState","useToggleButton_unstable","role","state","handleOnClick","useEventCallback","e","root","undefined"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAYaA;;;eAAAA;;;;iEAZU;gCACU;6BACQ;gCACE;AASpC,MAAMA,iCAAiC,CAC5CC,OACAC;IAEA,MAAMC,cAAcC,IAAAA,0CAAAA,EAA2BC,CAAAA,MAAOA,IAAIF,WAAW;IACrE,MAAMG,UAAUF,IAAAA,0CAAAA,EAA2BC,CAAAA;YAASA;eAAF,CAAC,CAAA,CAAA,AAACA,CAAAA,gCAAAA,IAAIE,aAAa,CAACN,MAAMO,IAAI,CAAC,AAAD,MAAC,QAA7BH,kCAAAA,KAAAA,IAAAA,KAAAA,IAAAA,8BAA+BI,QAAQ,CAACR,MAAMS,KAAK,CAAA;;IACvG,MAAMC,OAAOP,IAAAA,0CAAAA,EAA2BC,CAAAA,MAAOA,IAAIM,IAAI;IAEvD,MAAM,EAAEC,SAASC,eAAe,EAAE,GAAGZ;IACrC,MAAMa,oBAAoBC,IAAAA,qCAAAA,EACxB;QAAEJ;QAAML;QAASU,MAAM;QAAS,gBAAgBV;QAAS,GAAGL,KAAK;IAAC,GAClEC;IAEF,MAAMe,QAAiC;QACrC,GAAGH,iBAAiB;QACpBN,MAAMP,MAAMO,IAAI;QAChBE,OAAOT,MAAMS,KAAK;IACpB;IAEA,MAAMQ,gBAAgBC,IAAAA,gCAAAA,EACpB,CAACC;QACCjB,gBAAAA,QAAAA,gBAAAA,KAAAA,IAAAA,KAAAA,IAAAA,YAAciB,GAAGH,MAAMT,IAAI,EAAES,MAAMP,KAAK,EAAEO,MAAMX,OAAO;QACvDO,oBAAAA,QAAAA,oBAAAA,KAAAA,IAAAA,KAAAA,IAAAA,gBAAkBO;IACpB;IAEFH,MAAMI,IAAI,CAAC,eAAe,GAAGC;IAC7BL,MAAMI,IAAI,CAACT,OAAO,GAAGM;IACrB,OAAOD;AACT"}

node_modules/@fluentui/react-toolbar/lib-commonjs/components/ToolbarRadioButton/useToolbarRadioButtonStyles.styles.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useToolbarRadioButtonStyles_unstable", {
+    enumerable: true,
+    get: function() {
+        return useToolbarRadioButtonStyles_unstable;
+    }
+});
+const _react = require("@griffel/react");
+const _reactbutton = require("@fluentui/react-button");
+const useBaseStyles = /*#__PURE__*/ (0, _react.__styles)({
+    selected: {
+        sj55zd: "f16muhyy"
+    }
+}, {
+    d: [
+        ".f16muhyy{color:var(--colorBrandForeground1);}"
+    ]
+});
+const useToolbarRadioButtonStyles_unstable = (state)=>{
+    'use no memo';
+    (0, _reactbutton.useToggleButtonStyles_unstable)(state);
+    const toggleButtonStyles = useBaseStyles();
+    state.root.className = (0, _react.mergeClasses)(state.root.className, state.checked && toggleButtonStyles.selected);
+    return state;
+};

node_modules/@fluentui/react-toolbar/lib-commonjs/components/ToolbarRadioButton/useToolbarRadioButtonStyles.styles.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["useToolbarRadioButtonStyles.styles.js"],"sourcesContent":["import { tokens } from '@fluentui/react-theme';\nimport { makeStyles, mergeClasses } from '@griffel/react';\nimport { useToggleButtonStyles_unstable } from '@fluentui/react-button';\nconst useBaseStyles = makeStyles({\n    selected: {\n        color: tokens.colorBrandForeground1\n    }\n});\n/**\n * Apply styling to the ToolbarRadioButton slots based on the state\n */ export const useToolbarRadioButtonStyles_unstable = (state)=>{\n    'use no memo';\n    useToggleButtonStyles_unstable(state);\n    const toggleButtonStyles = useBaseStyles();\n    state.root.className = mergeClasses(state.root.className, state.checked && toggleButtonStyles.selected);\n    return state;\n};\n"],"names":["useToolbarRadioButtonStyles_unstable","useBaseStyles","__styles","selected","sj55zd","d","state","useToggleButtonStyles_unstable","toggleButtonStyles","root","className","mergeClasses","checked"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAUiBA;;;eAAAA;;;uBATwB;6BACM;AAC/C,MAAMC,gBAAa,WAAA,GAAGC,IAAAA,eAAA,EAAA;IAAAC,UAAA;QAAAC,QAAA;IAAA;AAAA,GAAA;IAAAC,GAAA;QAAA;KAAA;AAAA;AAOX,MAAML,uCAAwCM,CAAAA;IACrD;IACAC,IAAAA,2CAA8B,EAACD;IAC/B,MAAME,qBAAqBP;IAC3BK,MAAMG,IAAI,CAACC,SAAS,GAAGC,IAAAA,mBAAY,EAACL,MAAMG,IAAI,CAACC,SAAS,EAAEJ,MAAMM,OAAO,IAAIJ,mBAAmBL,QAAQ;IACtG,OAAOG;AACX"}

node_modules/@fluentui/react-toolbar/lib-commonjs/components/ToolbarRadioGroup/ToolbarRadioGroup.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ToolbarRadioGroup", {
+    enumerable: true,
+    get: function() {
+        return ToolbarRadioGroup;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _ToolbarGroup = require("../../ToolbarGroup");
+const _reactsharedcontexts = require("@fluentui/react-shared-contexts");
+const ToolbarRadioGroup = /*#__PURE__*/ _react.forwardRef((props, ref)=>{
+    const state = (0, _ToolbarGroup.useToolbarGroup_unstable)({
+        role: 'radiogroup',
+        ...props
+    }, ref);
+    (0, _ToolbarGroup.useToolbarGroupStyles_unstable)(state);
+    (0, _reactsharedcontexts.useCustomStyleHook_unstable)('useToolbarGroupStyles_unstable')(state);
+    return (0, _ToolbarGroup.renderToolbarGroup_unstable)(state);
+// Casting is required due to lack of distributive union to support unions on @types/react
+});
+ToolbarRadioGroup.displayName = 'ToolbarRadioGroup';

node_modules/@fluentui/react-toolbar/lib-commonjs/components/ToolbarRadioGroup/ToolbarRadioGroup.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/ToolbarRadioGroup/ToolbarRadioGroup.tsx"],"sourcesContent":["import * as React from 'react';\nimport type { ToolbarRadioGroupProps } from './ToolbarRadioGroup.types';\nimport type { ForwardRefComponent } from '@fluentui/react-utilities';\nimport {\n  renderToolbarGroup_unstable,\n  useToolbarGroupStyles_unstable,\n  useToolbarGroup_unstable,\n} from '../../ToolbarGroup';\nimport { useCustomStyleHook_unstable } from '@fluentui/react-shared-contexts';\n\n/**\n * ToolbarRadioGroup component is a Button to be used inside Toolbar\n * which will respect toolbar props such as `size`\n */\nexport const ToolbarRadioGroup: ForwardRefComponent<ToolbarRadioGroupProps> = React.forwardRef((props, ref) => {\n  const state = useToolbarGroup_unstable({ role: 'radiogroup', ...props }, ref);\n\n  useToolbarGroupStyles_unstable(state);\n\n  useCustomStyleHook_unstable('useToolbarGroupStyles_unstable')(state);\n\n  return renderToolbarGroup_unstable(state);\n  // Casting is required due to lack of distributive union to support unions on @types/react\n}) as ForwardRefComponent<ToolbarRadioGroupProps>;\n\nToolbarRadioGroup.displayName = 'ToolbarRadioGroup';\n"],"names":["ToolbarRadioGroup","React","forwardRef","props","ref","state","useToolbarGroup_unstable","role","useToolbarGroupStyles_unstable","useCustomStyleHook_unstable","renderToolbarGroup_unstable","displayName"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAcaA;;;eAAAA;;;;iEAdU;8BAOhB;qCACqC;AAMrC,MAAMA,oBAAAA,WAAAA,GAAiEC,OAAMC,UAAU,CAAC,CAACC,OAAOC;IACrG,MAAMC,QAAQC,IAAAA,sCAAAA,EAAyB;QAAEC,MAAM;QAAc,GAAGJ,KAAK;IAAC,GAAGC;IAEzEI,IAAAA,4CAAAA,EAA+BH;IAE/BI,IAAAA,gDAAAA,EAA4B,kCAAkCJ;IAE9D,OAAOK,IAAAA,yCAAAA,EAA4BL;AACnC,0FAA0F;AAC5F;AAEAL,kBAAkBW,WAAW,GAAG"}

node_modules/@fluentui/react-toolbar/lib-commonjs/components/ToolbarRadioGroup/ToolbarRadioGroup.types.js

@@ -0,0 +1,6 @@
+/**
+ * State used in rendering ToolbarButton
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});

node_modules/@fluentui/react-toolbar/lib-commonjs/components/ToolbarRadioGroup/ToolbarRadioGroup.types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/ToolbarRadioGroup/ToolbarRadioGroup.types.ts"],"sourcesContent":["import type { ComponentProps, ComponentState, Slot } from '@fluentui/react-utilities';\n\nexport type ToolbarRadioGroupSlots = {\n  root: Slot<'div'>;\n};\n\n/**\n * ToolbarButton Props\n */\nexport type ToolbarRadioGroupProps = ComponentProps<ToolbarRadioGroupSlots>;\n\n/**\n * State used in rendering ToolbarButton\n */\nexport type ToolbarRadioGroupState = ComponentState<ToolbarRadioGroupSlots>;\n"],"names":[],"rangeMappings":";;","mappings":"AAWA;;CAEC"}

node_modules/@fluentui/react-toolbar/lib-commonjs/components/ToolbarRadioGroup/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ToolbarRadioGroup", {
+    enumerable: true,
+    get: function() {
+        return _ToolbarRadioGroup.ToolbarRadioGroup;
+    }
+});
+const _ToolbarRadioGroup = require("./ToolbarRadioGroup");

node_modules/@fluentui/react-toolbar/lib-commonjs/components/ToolbarRadioGroup/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/ToolbarRadioGroup/index.ts"],"sourcesContent":["export { ToolbarRadioGroup } from './ToolbarRadioGroup';\nexport type { ToolbarRadioGroupProps, ToolbarRadioGroupSlots, ToolbarRadioGroupState } from './ToolbarRadioGroup.types';\n"],"names":["ToolbarRadioGroup"],"rangeMappings":";;;;;;;;;;","mappings":";;;;+BAASA;;;eAAAA,oCAAiB;;;mCAAQ"}

node_modules/@fluentui/react-toolbar/lib-commonjs/components/ToolbarToggleButton/ToolbarToggleButton.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ToolbarToggleButton", {
+    enumerable: true,
+    get: function() {
+        return ToolbarToggleButton;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _reactbutton = require("@fluentui/react-button");
+const _useToolbarToggleButton = require("./useToolbarToggleButton");
+const _useToolbarToggleButtonStylesstyles = require("./useToolbarToggleButtonStyles.styles");
+const _reactsharedcontexts = require("@fluentui/react-shared-contexts");
+const ToolbarToggleButton = /*#__PURE__*/ _react.forwardRef((props, ref)=>{
+    const state = (0, _useToolbarToggleButton.useToolbarToggleButton_unstable)(props, ref);
+    (0, _useToolbarToggleButtonStylesstyles.useToolbarToggleButtonStyles_unstable)(state);
+    (0, _reactsharedcontexts.useCustomStyleHook_unstable)('useToolbarToggleButtonStyles_unstable')(state);
+    return (0, _reactbutton.renderToggleButton_unstable)(state);
+});
+ToolbarToggleButton.displayName = 'ToolbarToggleButton';

node_modules/@fluentui/react-toolbar/lib-commonjs/components/ToolbarToggleButton/ToolbarToggleButton.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/ToolbarToggleButton/ToolbarToggleButton.tsx"],"sourcesContent":["import * as React from 'react';\nimport type { ToolbarToggleButtonProps } from './ToolbarToggleButton.types';\nimport type { ForwardRefComponent } from '@fluentui/react-utilities';\nimport { renderToggleButton_unstable } from '@fluentui/react-button';\nimport { useToolbarToggleButton_unstable } from './useToolbarToggleButton';\nimport { useToolbarToggleButtonStyles_unstable } from './useToolbarToggleButtonStyles.styles';\nimport { useCustomStyleHook_unstable } from '@fluentui/react-shared-contexts';\n\n/**\n * ToolbarToggleButton component\n */\nexport const ToolbarToggleButton: ForwardRefComponent<ToolbarToggleButtonProps> = React.forwardRef((props, ref) => {\n  const state = useToolbarToggleButton_unstable(props, ref);\n\n  useToolbarToggleButtonStyles_unstable(state);\n\n  useCustomStyleHook_unstable('useToolbarToggleButtonStyles_unstable')(state);\n\n  return renderToggleButton_unstable(state);\n}) as ForwardRefComponent<ToolbarToggleButtonProps>;\n\nToolbarToggleButton.displayName = 'ToolbarToggleButton';\n"],"names":["ToolbarToggleButton","React","forwardRef","props","ref","state","useToolbarToggleButton_unstable","useToolbarToggleButtonStyles_unstable","useCustomStyleHook_unstable","renderToggleButton_unstable","displayName"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAWaA;;;eAAAA;;;;iEAXU;6BAGqB;wCACI;oDACM;qCACV;AAKrC,MAAMA,sBAAAA,WAAAA,GAAqEC,OAAMC,UAAU,CAAC,CAACC,OAAOC;IACzG,MAAMC,QAAQC,IAAAA,uDAAAA,EAAgCH,OAAOC;IAErDG,IAAAA,yEAAAA,EAAsCF;IAEtCG,IAAAA,gDAAAA,EAA4B,yCAAyCH;IAErE,OAAOI,IAAAA,wCAAAA,EAA4BJ;AACrC;AAEAL,oBAAoBU,WAAW,GAAG"}

node_modules/@fluentui/react-toolbar/lib-commonjs/components/ToolbarToggleButton/ToolbarToggleButton.types.js

@@ -0,0 +1,6 @@
+/**
+ * State used in rendering ToolbarToggleButton
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});

node_modules/@fluentui/react-toolbar/lib-commonjs/components/ToolbarToggleButton/ToolbarToggleButton.types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/ToolbarToggleButton/ToolbarToggleButton.types.ts"],"sourcesContent":["import type { ComponentProps, ComponentState } from '@fluentui/react-utilities';\nimport { ToggleButtonProps, ButtonSlots, ToggleButtonState } from '@fluentui/react-button';\n\n/**\n * ToolbarToggleButton Props\n */\nexport type ToolbarToggleButtonProps = ComponentProps<ButtonSlots> &\n  Partial<Pick<ToggleButtonProps, 'disabled' | 'disabledFocusable' | 'size'>> & {\n    appearance?: 'primary' | 'subtle' | 'transparent';\n    name: string;\n    value: string;\n  };\n\n/**\n * State used in rendering ToolbarToggleButton\n */\nexport type ToolbarToggleButtonState = ComponentState<Partial<ButtonSlots>> &\n  ToggleButtonState &\n  Required<Pick<ToggleButtonProps, 'checked'>> &\n  Pick<ToolbarToggleButtonProps, 'name' | 'value'>;\n"],"names":[],"rangeMappings":";;","mappings":"AAaA;;CAEC"}

node_modules/@fluentui/react-toolbar/lib-commonjs/components/ToolbarToggleButton/index.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    ToolbarToggleButton: function() {
+        return _ToolbarToggleButton.ToolbarToggleButton;
+    },
+    useToolbarToggleButtonStyles_unstable: function() {
+        return _useToolbarToggleButtonStylesstyles.useToolbarToggleButtonStyles_unstable;
+    },
+    useToolbarToggleButton_unstable: function() {
+        return _useToolbarToggleButton.useToolbarToggleButton_unstable;
+    }
+});
+const _ToolbarToggleButton = require("./ToolbarToggleButton");
+const _useToolbarToggleButton = require("./useToolbarToggleButton");
+const _useToolbarToggleButtonStylesstyles = require("./useToolbarToggleButtonStyles.styles");

node_modules/@fluentui/react-toolbar/lib-commonjs/components/ToolbarToggleButton/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/ToolbarToggleButton/index.ts"],"sourcesContent":["export { ToolbarToggleButton } from './ToolbarToggleButton';\nexport type { ToolbarToggleButtonProps, ToolbarToggleButtonState } from './ToolbarToggleButton.types';\nexport { useToolbarToggleButton_unstable } from './useToolbarToggleButton';\nexport { useToolbarToggleButtonStyles_unstable } from './useToolbarToggleButtonStyles.styles';\n"],"names":["ToolbarToggleButton","useToolbarToggleButtonStyles_unstable","useToolbarToggleButton_unstable"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAASA,mBAAmB;eAAnBA,wCAAmB;;IAGnBC,qCAAqC;eAArCA,yEAAqC;;IADrCC,+BAA+B;eAA/BA,uDAA+B;;;qCAFJ;wCAEY;oDACM"}

node_modules/@fluentui/react-toolbar/lib-commonjs/components/ToolbarToggleButton/useToolbarToggleButton.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useToolbarToggleButton_unstable", {
+    enumerable: true,
+    get: function() {
+        return useToolbarToggleButton_unstable;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _reactbutton = require("@fluentui/react-button");
+const _ToolbarContext = require("../Toolbar/ToolbarContext");
+const useToolbarToggleButton_unstable = (props, ref)=>{
+    const handleToggleButton = (0, _ToolbarContext.useToolbarContext_unstable)((ctx)=>ctx.handleToggleButton);
+    const checked = (0, _ToolbarContext.useToolbarContext_unstable)((ctx)=>{
+        var _ctx_checkedValues_props_name;
+        return !!((_ctx_checkedValues_props_name = ctx.checkedValues[props.name]) === null || _ctx_checkedValues_props_name === void 0 ? void 0 : _ctx_checkedValues_props_name.includes(props.value));
+    });
+    const { onClick: onClickOriginal } = props;
+    const toggleButtonState = (0, _reactbutton.useToggleButton_unstable)({
+        checked,
+        ...props
+    }, ref);
+    const state = {
+        ...toggleButtonState,
+        name: props.name,
+        value: props.value
+    };
+    const handleOnClick = (e)=>{
+        if (state.disabled) {
+            e.preventDefault();
+            e.stopPropagation();
+            return;
+        }
+        handleToggleButton === null || handleToggleButton === void 0 ? void 0 : handleToggleButton(e, state.name, state.value, state.checked);
+        onClickOriginal === null || onClickOriginal === void 0 ? void 0 : onClickOriginal(e);
+    };
+    state.root.onClick = handleOnClick;
+    return state;
+};

node_modules/@fluentui/react-toolbar/lib-commonjs/components/ToolbarToggleButton/useToolbarToggleButton.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/ToolbarToggleButton/useToolbarToggleButton.ts"],"sourcesContent":["import * as React from 'react';\nimport { useToggleButton_unstable } from '@fluentui/react-button';\nimport { useToolbarContext_unstable } from '../Toolbar/ToolbarContext';\nimport { ToolbarToggleButtonProps, ToolbarToggleButtonState } from './ToolbarToggleButton.types';\n\n/**\n * Given user props, defines default props for the ToggleButton, calls useButtonState and useChecked, and returns\n * processed state.\n * @param props - User provided props to the ToggleButton component.\n * @param ref - User provided ref to be passed to the ToggleButton component.\n */\nexport const useToolbarToggleButton_unstable = (\n  props: ToolbarToggleButtonProps,\n  ref: React.Ref<HTMLButtonElement | HTMLAnchorElement>,\n): ToolbarToggleButtonState => {\n  const handleToggleButton = useToolbarContext_unstable(ctx => ctx.handleToggleButton);\n  const checked = useToolbarContext_unstable(ctx => !!ctx.checkedValues[props.name]?.includes(props.value));\n\n  const { onClick: onClickOriginal } = props;\n  const toggleButtonState = useToggleButton_unstable({ checked, ...props }, ref);\n  const state: ToolbarToggleButtonState = {\n    ...toggleButtonState,\n    name: props.name,\n    value: props.value,\n  };\n\n  const handleOnClick = (\n    e: React.MouseEvent<HTMLButtonElement, MouseEvent> & React.MouseEvent<HTMLAnchorElement, MouseEvent>,\n  ) => {\n    if (state.disabled) {\n      e.preventDefault();\n      e.stopPropagation();\n      return;\n    }\n\n    handleToggleButton?.(e, state.name, state.value, state.checked);\n    onClickOriginal?.(e);\n  };\n\n  state.root.onClick = handleOnClick;\n  return state;\n};\n"],"names":["useToolbarToggleButton_unstable","props","ref","handleToggleButton","useToolbarContext_unstable","ctx","checked","checkedValues","name","includes","value","onClick","onClickOriginal","toggleButtonState","useToggleButton_unstable","state","handleOnClick","e","disabled","preventDefault","stopPropagation","root"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAWaA;;;eAAAA;;;;iEAXU;6BACkB;gCACE;AASpC,MAAMA,kCAAkC,CAC7CC,OACAC;IAEA,MAAMC,qBAAqBC,IAAAA,0CAAAA,EAA2BC,CAAAA,MAAOA,IAAIF,kBAAkB;IACnF,MAAMG,UAAUF,IAAAA,0CAAAA,EAA2BC,CAAAA;YAASA;eAAF,CAAC,CAAA,CAAA,AAACA,CAAAA,gCAAAA,IAAIE,aAAa,CAACN,MAAMO,IAAI,CAAC,AAAD,MAAC,QAA7BH,kCAAAA,KAAAA,IAAAA,KAAAA,IAAAA,8BAA+BI,QAAQ,CAACR,MAAMS,KAAK,CAAA;;IAEvG,MAAM,EAAEC,SAASC,eAAe,EAAE,GAAGX;IACrC,MAAMY,oBAAoBC,IAAAA,qCAAAA,EAAyB;QAAER;QAAS,GAAGL,KAAK;IAAC,GAAGC;IAC1E,MAAMa,QAAkC;QACtC,GAAGF,iBAAiB;QACpBL,MAAMP,MAAMO,IAAI;QAChBE,OAAOT,MAAMS,KAAK;IACpB;IAEA,MAAMM,gBAAgB,CACpBC;QAEA,IAAIF,MAAMG,QAAQ,EAAE;YAClBD,EAAEE,cAAc;YAChBF,EAAEG,eAAe;YACjB;QACF;QAEAjB,uBAAAA,QAAAA,uBAAAA,KAAAA,IAAAA,KAAAA,IAAAA,mBAAqBc,GAAGF,MAAMP,IAAI,EAAEO,MAAML,KAAK,EAAEK,MAAMT,OAAO;QAC9DM,oBAAAA,QAAAA,oBAAAA,KAAAA,IAAAA,KAAAA,IAAAA,gBAAkBK;IACpB;IAEAF,MAAMM,IAAI,CAACV,OAAO,GAAGK;IACrB,OAAOD;AACT"}

node_modules/@fluentui/react-toolbar/lib-commonjs/components/ToolbarToggleButton/useToolbarToggleButtonStyles.styles.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useToolbarToggleButtonStyles_unstable", {
+    enumerable: true,
+    get: function() {
+        return useToolbarToggleButtonStyles_unstable;
+    }
+});
+const _react = require("@griffel/react");
+const _reactbutton = require("@fluentui/react-button");
+const useBaseStyles = /*#__PURE__*/ (0, _react.__styles)({
+    selected: {
+        sj55zd: "f16muhyy"
+    }
+}, {
+    d: [
+        ".f16muhyy{color:var(--colorBrandForeground1);}"
+    ]
+});
+const useToolbarToggleButtonStyles_unstable = (state)=>{
+    'use no memo';
+    (0, _reactbutton.useToggleButtonStyles_unstable)(state);
+    const toggleButtonStyles = useBaseStyles();
+    state.root.className = (0, _react.mergeClasses)(state.root.className, state.checked && toggleButtonStyles.selected);
+    return state;
+};

node_modules/@fluentui/react-toolbar/lib-commonjs/components/ToolbarToggleButton/useToolbarToggleButtonStyles.styles.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["useToolbarToggleButtonStyles.styles.js"],"sourcesContent":["import { tokens } from '@fluentui/react-theme';\nimport { makeStyles, mergeClasses } from '@griffel/react';\nimport { useToggleButtonStyles_unstable } from '@fluentui/react-button';\nconst useBaseStyles = makeStyles({\n    selected: {\n        color: tokens.colorBrandForeground1\n    }\n});\n/**\n * Apply styling to the ToolbarToggleButton slots based on the state\n */ export const useToolbarToggleButtonStyles_unstable = (state)=>{\n    'use no memo';\n    useToggleButtonStyles_unstable(state);\n    const toggleButtonStyles = useBaseStyles();\n    state.root.className = mergeClasses(state.root.className, state.checked && toggleButtonStyles.selected);\n    return state;\n};\n"],"names":["useToolbarToggleButtonStyles_unstable","useBaseStyles","__styles","selected","sj55zd","d","state","useToggleButtonStyles_unstable","toggleButtonStyles","root","className","mergeClasses","checked"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAUiBA;;;eAAAA;;;uBATwB;6BACM;AAC/C,MAAMC,gBAAa,WAAA,GAAGC,IAAAA,eAAA,EAAA;IAAAC,UAAA;QAAAC,QAAA;IAAA;AAAA,GAAA;IAAAC,GAAA;QAAA;KAAA;AAAA;AAOX,MAAML,wCAAyCM,CAAAA;IACtD;IACAC,IAAAA,2CAA8B,EAACD;IAC/B,MAAME,qBAAqBP;IAC3BK,MAAMG,IAAI,CAACC,SAAS,GAAGC,IAAAA,mBAAY,EAACL,MAAMG,IAAI,CAACC,SAAS,EAAEJ,MAAMM,OAAO,IAAIJ,mBAAmBL,QAAQ;IACtG,OAAOG;AACX"}