idanoo/GoScrobble
1
0
Fork 0
mirror of https://github.com/idanoo/GoScrobble synced 2025-07-01 05:32:18 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

0.2.0 - Mid migration

Browse source
This commit is contained in:
Daniel Mason 2022-04-25 14:47:15 +12:00
parent 139e6a915e
commit 7e38fdbd7d
42393 changed files with 5358157 additions and 62 deletions
Download patch file Download diff file Expand all files Collapse all files

10
web/node_modules/react-bootstrap/esm/AbstractModalHeader.d.ts generated vendored Normal file
View file

@ -0,0 +1,10 @@
import * as React from 'react';
import { CloseButtonVariant } from './CloseButton';
export interface AbstractModalHeaderProps extends React.HTMLAttributes<HTMLDivElement> {
closeLabel?: string;
closeVariant?: CloseButtonVariant;
closeButton?: boolean;
onHide?: () => void;
}
declare const AbstractModalHeader: React.ForwardRefExoticComponent<AbstractModalHeaderProps & React.RefAttributes<HTMLDivElement>>;
export default AbstractModalHeader;

15
web/node_modules/react-bootstrap/esm/AbstractNav.d.ts generated vendored Normal file
View file

@ -0,0 +1,15 @@
import React from 'react';
import { BsPrefixRefForwardingComponent } from './helpers';
interface AbstractNavProps {
activeKey?: any;
as?: React.ElementType;
getControlledId?: any;
getControllerId?: any;
onKeyDown?: any;
onSelect?: any;
parentOnSelect?: any;
role?: string;
}
declare type AbstractNav = BsPrefixRefForwardingComponent<'ul', AbstractNavProps>;
declare const AbstractNav: AbstractNav;
export default AbstractNav;

112
web/node_modules/react-bootstrap/esm/AbstractNav.js generated vendored Normal file
View file

@ -0,0 +1,112 @@
import _extends from "@babel/runtime/helpers/esm/extends";
import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
var _excluded = ["as", "onSelect", "activeKey", "role", "onKeyDown"];
import qsa from 'dom-helpers/querySelectorAll';
import React, { useContext, useEffect, useRef } from 'react';
import useForceUpdate from '@restart/hooks/useForceUpdate';
import useMergedRefs from '@restart/hooks/useMergedRefs';
import NavContext from './NavContext';
import SelectableContext, { makeEventKey } from './SelectableContext';
import TabContext from './TabContext';
// eslint-disable-next-line @typescript-eslint/no-empty-function
var noop = function noop() {};
var AbstractNav = /*#__PURE__*/React.forwardRef(function (_ref, ref) {
var _ref$as = _ref.as,
Component = _ref$as === void 0 ? 'ul' : _ref$as,
onSelect = _ref.onSelect,
activeKey = _ref.activeKey,
role = _ref.role,
onKeyDown = _ref.onKeyDown,
props = _objectWithoutPropertiesLoose(_ref, _excluded);
// A ref and forceUpdate for refocus, b/c we only want to trigger when needed
// and don't want to reset the set in the effect
var forceUpdate = useForceUpdate();
var needsRefocusRef = useRef(false);
var parentOnSelect = useContext(SelectableContext);
var tabContext = useContext(TabContext);
var getControlledId, getControllerId;
if (tabContext) {
role = role || 'tablist';
activeKey = tabContext.activeKey;
getControlledId = tabContext.getControlledId;
getControllerId = tabContext.getControllerId;
}
var listNode = useRef(null);
var getNextActiveChild = function getNextActiveChild(offset) {
var currentListNode = listNode.current;
if (!currentListNode) return null;
var items = qsa(currentListNode, '[data-rb-event-key]:not(.disabled)');
var activeChild = currentListNode.querySelector('.active');
if (!activeChild) return null;
var index = items.indexOf(activeChild);
if (index === -1) return null;
var nextIndex = index + offset;
if (nextIndex >= items.length) nextIndex = 0;
if (nextIndex < 0) nextIndex = items.length - 1;
return items[nextIndex];
};
var handleSelect = function handleSelect(key, event) {
if (key == null) return;
if (onSelect) onSelect(key, event);
if (parentOnSelect) parentOnSelect(key, event);
};
var handleKeyDown = function handleKeyDown(event) {
if (onKeyDown) onKeyDown(event);
var nextActiveChild;
switch (event.key) {
case 'ArrowLeft':
case 'ArrowUp':
nextActiveChild = getNextActiveChild(-1);
break;
case 'ArrowRight':
case 'ArrowDown':
nextActiveChild = getNextActiveChild(1);
break;
default:
return;
}
if (!nextActiveChild) return;
event.preventDefault();
handleSelect(nextActiveChild.dataset.rbEventKey, event);
needsRefocusRef.current = true;
forceUpdate();
};
useEffect(function () {
if (listNode.current && needsRefocusRef.current) {
var activeChild = listNode.current.querySelector('[data-rb-event-key].active');
if (activeChild) activeChild.focus();
}
needsRefocusRef.current = false;
});
var mergedRef = useMergedRefs(ref, listNode);
return /*#__PURE__*/React.createElement(SelectableContext.Provider, {
value: handleSelect
}, /*#__PURE__*/React.createElement(NavContext.Provider, {
value: {
role: role,
// used by NavLink to determine it's role
activeKey: makeEventKey(activeKey),
getControlledId: getControlledId || noop,
getControllerId: getControllerId || noop
}
}, /*#__PURE__*/React.createElement(Component, _extends({}, props, {
onKeyDown: handleKeyDown,
ref: mergedRef,
role: role
}))));
});
export default AbstractNav;

19
web/node_modules/react-bootstrap/esm/AbstractNavItem.d.ts generated vendored Normal file
View file

@ -0,0 +1,19 @@
import React from 'react';
import { BsPrefixRefForwardingComponent } from './helpers';
import { EventKey } from './types';
interface AbstractNavItemProps {
active?: boolean;
as: React.ElementType;
className?: string;
disabled?: boolean;
eventKey?: EventKey;
href?: string;
role?: string;
id?: string;
tabIndex?: number;
onClick?: (e: any) => void;
onSelect?: (navKey: string, e: any) => void;
}
declare type AbstractNavItem = BsPrefixRefForwardingComponent<'div', AbstractNavItemProps>;
declare const AbstractNavItem: AbstractNavItem;
export default AbstractNavItem;

61
web/node_modules/react-bootstrap/esm/AbstractNavItem.js generated vendored Normal file
View file

@ -0,0 +1,61 @@
import _extends from "@babel/runtime/helpers/esm/extends";
import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
var _excluded = ["active", "className", "eventKey", "onSelect", "onClick", "as"];
import classNames from 'classnames';
import React, { useContext } from 'react';
import useEventCallback from '@restart/hooks/useEventCallback';
import warning from 'warning';
import NavContext from './NavContext';
import SelectableContext, { makeEventKey } from './SelectableContext';
var defaultProps = {
disabled: false
};
var AbstractNavItem = /*#__PURE__*/React.forwardRef(function (_ref, ref) {
var active = _ref.active,
className = _ref.className,
eventKey = _ref.eventKey,
onSelect = _ref.onSelect,
onClick = _ref.onClick,
Component = _ref.as,
props = _objectWithoutPropertiesLoose(_ref, _excluded);
var navKey = makeEventKey(eventKey, props.href);
var parentOnSelect = useContext(SelectableContext);
var navContext = useContext(NavContext);
var isActive = active;
if (navContext) {
if (!props.role && navContext.role === 'tablist') props.role = 'tab';
var contextControllerId = navContext.getControllerId(navKey);
var contextControlledId = navContext.getControlledId(navKey);
process.env.NODE_ENV !== "production" ? warning(!contextControllerId || !props.id, "[react-bootstrap] The provided id '" + props.id + "' was overwritten by the current navContext with '" + contextControllerId + "'.") : void 0;
process.env.NODE_ENV !== "production" ? warning(!contextControlledId || !props['aria-controls'], "[react-bootstrap] The provided aria-controls value '" + props['aria-controls'] + "' was overwritten by the current navContext with '" + contextControlledId + "'.") : void 0;
props['data-rb-event-key'] = navKey;
props.id = contextControllerId || props.id;
props['aria-controls'] = contextControlledId || props['aria-controls'];
isActive = active == null && navKey != null ? navContext.activeKey === navKey : active;
}
if (props.role === 'tab') {
if (props.disabled) {
props.tabIndex = -1;
props['aria-disabled'] = true;
}
props['aria-selected'] = isActive;
}
var handleOnclick = useEventCallback(function (e) {
if (onClick) onClick(e);
if (navKey == null) return;
if (onSelect) onSelect(navKey, e);
if (parentOnSelect) parentOnSelect(navKey, e);
});
return /*#__PURE__*/React.createElement(Component, _extends({}, props, {
ref: ref,
onClick: handleOnclick,
className: classNames(className, isActive && 'active')
}));
});
AbstractNavItem.defaultProps = defaultProps;
export default AbstractNavItem;

15
web/node_modules/react-bootstrap/esm/Accordion.d.ts generated vendored Normal file
View file

@ -0,0 +1,15 @@
import React from 'react';
import AccordionToggle from './AccordionToggle';
import AccordionCollapse from './AccordionCollapse';
import { BsPrefixPropsWithChildren, BsPrefixRefForwardingComponent, SelectCallback } from './helpers';
export interface AccordionProps extends Omit<React.HTMLAttributes<HTMLElement>, 'onSelect'>, BsPrefixPropsWithChildren {
activeKey?: string;
defaultActiveKey?: string;
onSelect?: SelectCallback;
}
declare type Accordion = BsPrefixRefForwardingComponent<'div', AccordionProps> & {
Toggle: typeof AccordionToggle;
Collapse: typeof AccordionCollapse;
};
declare const Accordion: Accordion;
export default Accordion;

39
web/node_modules/react-bootstrap/esm/Accordion.js generated vendored Normal file
View file

@ -0,0 +1,39 @@
import _extends from "@babel/runtime/helpers/esm/extends";
import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
var _excluded = ["as", "activeKey", "bsPrefix", "children", "className", "onSelect"];
import classNames from 'classnames';
import React from 'react';
import { useUncontrolled } from 'uncontrollable';
import { useBootstrapPrefix } from './ThemeProvider';
import AccordionToggle from './AccordionToggle';
import SelectableContext from './SelectableContext';
import AccordionCollapse from './AccordionCollapse';
import AccordionContext from './AccordionContext';
var Accordion = /*#__PURE__*/React.forwardRef(function (props, ref) {
var _useUncontrolled = useUncontrolled(props, {
activeKey: 'onSelect'
}),
_useUncontrolled$as = _useUncontrolled.as,
Component = _useUncontrolled$as === void 0 ? 'div' : _useUncontrolled$as,
activeKey = _useUncontrolled.activeKey,
bsPrefix = _useUncontrolled.bsPrefix,
children = _useUncontrolled.children,
className = _useUncontrolled.className,
onSelect = _useUncontrolled.onSelect,
controlledProps = _objectWithoutPropertiesLoose(_useUncontrolled, _excluded);
var finalClassName = classNames(className, useBootstrapPrefix(bsPrefix, 'accordion'));
return /*#__PURE__*/React.createElement(AccordionContext.Provider, {
value: activeKey || null
}, /*#__PURE__*/React.createElement(SelectableContext.Provider, {
value: onSelect || null
}, /*#__PURE__*/React.createElement(Component, _extends({
ref: ref
}, controlledProps, {
className: finalClassName
}), children)));
});
Accordion.displayName = 'Accordion';
Accordion.Toggle = AccordionToggle;
Accordion.Collapse = AccordionCollapse;
export default Accordion;

6
web/node_modules/react-bootstrap/esm/AccordionBody.d.ts generated vendored Normal file
View file

@ -0,0 +1,6 @@
import * as React from 'react';
import { BsPrefixRefForwardingComponent, BsPrefixProps } from './helpers';
export interface AccordionBodyProps extends BsPrefixProps, React.HTMLAttributes<HTMLElement> {
}
declare const AccordionBody: BsPrefixRefForwardingComponent<'div', AccordionBodyProps>;
export default AccordionBody;

8
web/node_modules/react-bootstrap/esm/AccordionButton.d.ts generated vendored Normal file
View file

@ -0,0 +1,8 @@
import * as React from 'react';
import { BsPrefixProps, BsPrefixRefForwardingComponent } from './helpers';
declare type EventHandler = React.EventHandler<React.SyntheticEvent>;
export interface AccordionButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, BsPrefixProps {
}
export declare function useAccordionButton(eventKey: string, onClick?: EventHandler): EventHandler;
declare const AccordionButton: BsPrefixRefForwardingComponent<'div', AccordionButtonProps>;
export default AccordionButton;

9
web/node_modules/react-bootstrap/esm/AccordionCollapse.d.ts generated vendored Normal file
View file

@ -0,0 +1,9 @@
import React from 'react';
import { CollapseProps } from './Collapse';
import { BsPrefixRefForwardingComponent } from './helpers';
export interface AccordionCollapseProps extends React.PropsWithChildren<CollapseProps> {
eventKey: string;
}
declare type AccordionCollapse = BsPrefixRefForwardingComponent<'div', AccordionCollapseProps>;
declare const AccordionCollapse: AccordionCollapse;
export default AccordionCollapse;

24
web/node_modules/react-bootstrap/esm/AccordionCollapse.js generated vendored Normal file
View file

@ -0,0 +1,24 @@
import _extends from "@babel/runtime/helpers/esm/extends";
import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
var _excluded = ["children", "eventKey"];
import React, { useContext } from 'react';
import Collapse from './Collapse';
import AccordionContext from './AccordionContext';
import SelectableContext from './SelectableContext';
var AccordionCollapse = /*#__PURE__*/React.forwardRef(function (_ref, ref) {
var children = _ref.children,
eventKey = _ref.eventKey,
props = _objectWithoutPropertiesLoose(_ref, _excluded);
var contextEventKey = useContext(AccordionContext); // Empty SelectableContext is to prevent elements in the collapse
// from collapsing the accordion when clicked.
return /*#__PURE__*/React.createElement(SelectableContext.Provider, {
value: null
}, /*#__PURE__*/React.createElement(Collapse, _extends({
ref: ref,
in: contextEventKey === eventKey
}, props), /*#__PURE__*/React.createElement("div", null, React.Children.only(children))));
});
AccordionCollapse.displayName = 'AccordionCollapse';
export default AccordionCollapse;

3
web/node_modules/react-bootstrap/esm/AccordionContext.d.ts generated vendored Normal file
View file

@ -0,0 +1,3 @@
import React from 'react';
declare const context: React.Context<string | null>;
export default context;

4
web/node_modules/react-bootstrap/esm/AccordionContext.js generated vendored Normal file
View file

@ -0,0 +1,4 @@
import React from 'react';
var context = /*#__PURE__*/React.createContext(null);
context.displayName = 'AccordionContext';
export default context;

6
web/node_modules/react-bootstrap/esm/AccordionHeader.d.ts generated vendored Normal file
View file

@ -0,0 +1,6 @@
import * as React from 'react';
import { BsPrefixRefForwardingComponent, BsPrefixProps } from './helpers';
export interface AccordionHeaderProps extends BsPrefixProps, React.HTMLAttributes<HTMLElement> {
}
declare const AccordionHeader: BsPrefixRefForwardingComponent<'h2', AccordionHeaderProps>;
export default AccordionHeader;

7
web/node_modules/react-bootstrap/esm/AccordionItem.d.ts generated vendored Normal file
View file

@ -0,0 +1,7 @@
import * as React from 'react';
import { BsPrefixRefForwardingComponent, BsPrefixProps } from './helpers';
export interface AccordionItemProps extends BsPrefixProps, React.HTMLAttributes<HTMLElement> {
eventKey: string;
}
declare const AccordionItem: BsPrefixRefForwardingComponent<'div', AccordionItemProps>;
export default AccordionItem;

6
web/node_modules/react-bootstrap/esm/AccordionItemContext.d.ts generated vendored Normal file
View file

@ -0,0 +1,6 @@
import * as React from 'react';
export interface AccordionItemContextValue {
eventKey: string;
}
declare const context: React.Context<AccordionItemContextValue>;
export default context;

11
web/node_modules/react-bootstrap/esm/AccordionToggle.d.ts generated vendored Normal file
View file

@ -0,0 +1,11 @@
import React from 'react';
import { BsPrefixPropsWithChildren, BsPrefixRefForwardingComponent } from './helpers';
declare type EventHandler = React.EventHandler<React.SyntheticEvent>;
export interface AccordionToggleProps extends BsPrefixPropsWithChildren {
eventKey: string;
onClick?: EventHandler;
}
declare type AccordionToggle = BsPrefixRefForwardingComponent<'div', AccordionToggleProps>;
export declare function useAccordionToggle(eventKey: string, onClick?: EventHandler): EventHandler;
declare const AccordionToggle: AccordionToggle;
export default AccordionToggle;

39
web/node_modules/react-bootstrap/esm/AccordionToggle.js generated vendored Normal file
View file

@ -0,0 +1,39 @@
import _extends from "@babel/runtime/helpers/esm/extends";
import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
var _excluded = ["as", "children", "eventKey", "onClick"];
import React, { useContext } from 'react';
import SelectableContext from './SelectableContext';
import AccordionContext from './AccordionContext';
export function useAccordionToggle(eventKey, onClick) {
var contextEventKey = useContext(AccordionContext);
var onSelect = useContext(SelectableContext);
return function (e) {
/*
Compare the event key in context with the given event key.
If they are the same, then collapse the component.
*/
var eventKeyPassed = eventKey === contextEventKey ? null : eventKey;
if (onSelect) onSelect(eventKeyPassed, e);
if (onClick) onClick(e);
};
}
var AccordionToggle = /*#__PURE__*/React.forwardRef(function (_ref, ref) {
var _ref$as = _ref.as,
Component = _ref$as === void 0 ? 'button' : _ref$as,
children = _ref.children,
eventKey = _ref.eventKey,
onClick = _ref.onClick,
props = _objectWithoutPropertiesLoose(_ref, _excluded);
var accordionOnClick = useAccordionToggle(eventKey, onClick);
if (Component === 'button') {
props.type = 'button';
}
return /*#__PURE__*/React.createElement(Component, _extends({
ref: ref,
onClick: accordionOnClick
}, props), children);
});
export default AccordionToggle;

21
web/node_modules/react-bootstrap/esm/Alert.d.ts generated vendored Normal file
View file

@ -0,0 +1,21 @@
import React from 'react';
import { Variant } from './types';
import SafeAnchor from './SafeAnchor';
import { TransitionType } from './helpers';
export interface AlertProps extends React.HTMLProps<HTMLDivElement> {
bsPrefix?: string;
variant?: Variant;
dismissible?: boolean;
show?: boolean;
onClose?: (a: any, b: any) => void;
closeLabel?: string;
transition?: TransitionType;
}
declare const AlertHeading: import("./helpers").BsPrefixRefForwardingComponent<React.ForwardRefExoticComponent<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & React.RefAttributes<HTMLDivElement>>, unknown>;
declare const AlertLink: import("./helpers").BsPrefixRefForwardingComponent<SafeAnchor, unknown>;
declare type Alert = React.ForwardRefExoticComponent<AlertProps> & {
Link: typeof AlertLink;
Heading: typeof AlertHeading;
};
declare const Alert: Alert;
export default Alert;

70
web/node_modules/react-bootstrap/esm/Alert.js generated vendored Normal file
View file

@ -0,0 +1,70 @@
import _extends from "@babel/runtime/helpers/esm/extends";
import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
var _excluded = ["bsPrefix", "show", "closeLabel", "className", "children", "variant", "onClose", "dismissible", "transition"];
import classNames from 'classnames';
import React from 'react';
import { useUncontrolled } from 'uncontrollable';
import useEventCallback from '@restart/hooks/useEventCallback';
import { useBootstrapPrefix } from './ThemeProvider';
import Fade from './Fade';
import CloseButton from './CloseButton';
import divWithClassName from './divWithClassName';
import createWithBsPrefix from './createWithBsPrefix';
import SafeAnchor from './SafeAnchor';
var DivStyledAsH4 = divWithClassName('h4');
DivStyledAsH4.displayName = 'DivStyledAsH4';
var AlertHeading = createWithBsPrefix('alert-heading', {
Component: DivStyledAsH4
});
var AlertLink = createWithBsPrefix('alert-link', {
Component: SafeAnchor
});
var defaultProps = {
show: true,
transition: Fade,
closeLabel: 'Close alert'
};
var Alert = /*#__PURE__*/React.forwardRef(function (uncontrolledProps, ref) {
var _useUncontrolled = useUncontrolled(uncontrolledProps, {
show: 'onClose'
}),
bsPrefix = _useUncontrolled.bsPrefix,
show = _useUncontrolled.show,
closeLabel = _useUncontrolled.closeLabel,
className = _useUncontrolled.className,
children = _useUncontrolled.children,
variant = _useUncontrolled.variant,
onClose = _useUncontrolled.onClose,
dismissible = _useUncontrolled.dismissible,
transition = _useUncontrolled.transition,
props = _objectWithoutPropertiesLoose(_useUncontrolled, _excluded);
var prefix = useBootstrapPrefix(bsPrefix, 'alert');
var handleClose = useEventCallback(function (e) {
if (onClose) {
onClose(false, e);
}
});
var Transition = transition === true ? Fade : transition;
var alert = /*#__PURE__*/React.createElement("div", _extends({
role: "alert"
}, !Transition ? props : undefined, {
ref: ref,
className: classNames(className, prefix, variant && prefix + "-" + variant, dismissible && prefix + "-dismissible")
}), dismissible && /*#__PURE__*/React.createElement(CloseButton, {
onClick: handleClose,
label: closeLabel
}), children);
if (!Transition) return show ? alert : null;
return /*#__PURE__*/React.createElement(Transition, _extends({
unmountOnExit: true
}, props, {
ref: undefined,
in: show
}), alert);
});
Alert.displayName = 'Alert';
Alert.defaultProps = defaultProps;
Alert.Link = AlertLink;
Alert.Heading = AlertHeading;
export default Alert;

9
web/node_modules/react-bootstrap/esm/Badge.d.ts generated vendored Normal file
View file

@ -0,0 +1,9 @@
import { BsPrefixProps, BsPrefixRefForwardingComponent } from './helpers';
import { Variant } from './types';
export interface BadgeProps extends BsPrefixProps {
variant?: Variant;
pill?: boolean;
}
declare type Badge = BsPrefixRefForwardingComponent<'span', BadgeProps>;
declare const Badge: Badge;
export default Badge;

28
web/node_modules/react-bootstrap/esm/Badge.js generated vendored Normal file
View file

@ -0,0 +1,28 @@
import _extends from "@babel/runtime/helpers/esm/extends";
import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
var _excluded = ["bsPrefix", "variant", "pill", "className", "as"];
import classNames from 'classnames';
import React from 'react';
import { useBootstrapPrefix } from './ThemeProvider';
var defaultProps = {
pill: false
};
var Badge = /*#__PURE__*/React.forwardRef(function (_ref, ref) {
var bsPrefix = _ref.bsPrefix,
variant = _ref.variant,
pill = _ref.pill,
className = _ref.className,
_ref$as = _ref.as,
Component = _ref$as === void 0 ? 'span' : _ref$as,
props = _objectWithoutPropertiesLoose(_ref, _excluded);
var prefix = useBootstrapPrefix(bsPrefix, 'badge');
return /*#__PURE__*/React.createElement(Component, _extends({
ref: ref
}, props, {
className: classNames(className, prefix, pill && prefix + "-pill", variant && prefix + "-" + variant)
}));
});
Badge.displayName = 'Badge';
Badge.defaultProps = defaultProps;
export default Badge;

7
web/node_modules/react-bootstrap/esm/BootstrapModalManager.d.ts generated vendored Normal file
View file

@ -0,0 +1,7 @@
import ModalManager from 'react-overlays/ModalManager';
export default class BootstrapModalManager extends ModalManager {
private adjustAndStore;
private restore;
setContainerStyle(containerState: any, container: any): void;
removeContainerStyle(containerState: any, container: any): void;
}

79
web/node_modules/react-bootstrap/esm/BootstrapModalManager.js generated vendored Normal file
View file

@ -0,0 +1,79 @@
import _inheritsLoose from "@babel/runtime/helpers/esm/inheritsLoose";
import css from 'dom-helpers/css';
import qsa from 'dom-helpers/querySelectorAll';
import getScrollbarSize from 'dom-helpers/scrollbarSize';
import ModalManager from 'react-overlays/ModalManager';
var Selector = {
FIXED_CONTENT: '.fixed-top, .fixed-bottom, .is-fixed, .sticky-top',
STICKY_CONTENT: '.sticky-top',
NAVBAR_TOGGLER: '.navbar-toggler'
};
var BootstrapModalManager = /*#__PURE__*/function (_ModalManager) {
_inheritsLoose(BootstrapModalManager, _ModalManager);
function BootstrapModalManager() {
return _ModalManager.apply(this, arguments) || this;
}
var _proto = BootstrapModalManager.prototype;
_proto.adjustAndStore = function adjustAndStore(prop, element, adjust) {
var _css;
var actual = element.style[prop]; // TODO: DOMStringMap and CSSStyleDeclaration aren't strictly compatible
// @ts-ignore
element.dataset[prop] = actual;
css(element, (_css = {}, _css[prop] = parseFloat(css(element, prop)) + adjust + "px", _css));
};
_proto.restore = function restore(prop, element) {
var value = element.dataset[prop];
if (value !== undefined) {
var _css2;
delete element.dataset[prop];
css(element, (_css2 = {}, _css2[prop] = value, _css2));
}
};
_proto.setContainerStyle = function setContainerStyle(containerState, container) {
var _this = this;
_ModalManager.prototype.setContainerStyle.call(this, containerState, container);
if (!containerState.overflowing) return;
var size = getScrollbarSize();
qsa(container, Selector.FIXED_CONTENT).forEach(function (el) {
return _this.adjustAndStore('paddingRight', el, size);
});
qsa(container, Selector.STICKY_CONTENT).forEach(function (el) {
return _this.adjustAndStore('marginRight', el, -size);
});
qsa(container, Selector.NAVBAR_TOGGLER).forEach(function (el) {
return _this.adjustAndStore('marginRight', el, size);
});
};
_proto.removeContainerStyle = function removeContainerStyle(containerState, container) {
var _this2 = this;
_ModalManager.prototype.removeContainerStyle.call(this, containerState, container);
qsa(container, Selector.FIXED_CONTENT).forEach(function (el) {
return _this2.restore('paddingRight', el);
});
qsa(container, Selector.STICKY_CONTENT).forEach(function (el) {
return _this2.restore('marginRight', el);
});
qsa(container, Selector.NAVBAR_TOGGLER).forEach(function (el) {
return _this2.restore('marginRight', el);
});
};
return BootstrapModalManager;
}(ModalManager);
export { BootstrapModalManager as default };

13
web/node_modules/react-bootstrap/esm/Breadcrumb.d.ts generated vendored Normal file
View file

@ -0,0 +1,13 @@
import React from 'react';
import BreadcrumbItem from './BreadcrumbItem';
import { BsPrefixPropsWithChildren, BsPrefixRefForwardingComponent } from './helpers';
export interface BreadcrumbProps extends BsPrefixPropsWithChildren {
className?: string;
label?: string;
listProps?: React.OlHTMLAttributes<HTMLOListElement>;
}
declare type Breadcrumb = BsPrefixRefForwardingComponent<'nav', BreadcrumbProps> & {
Item: typeof BreadcrumbItem;
};
declare const Breadcrumb: Breadcrumb;
export default Breadcrumb;

34
web/node_modules/react-bootstrap/esm/Breadcrumb.js generated vendored Normal file
View file

@ -0,0 +1,34 @@
import _extends from "@babel/runtime/helpers/esm/extends";
import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
var _excluded = ["bsPrefix", "className", "listProps", "children", "label", "as"];
import classNames from 'classnames';
import React from 'react';
import { useBootstrapPrefix } from './ThemeProvider';
import BreadcrumbItem from './BreadcrumbItem';
var defaultProps = {
label: 'breadcrumb',
listProps: {}
};
var Breadcrumb = /*#__PURE__*/React.forwardRef(function (_ref, ref) {
var bsPrefix = _ref.bsPrefix,
className = _ref.className,
listProps = _ref.listProps,
children = _ref.children,
label = _ref.label,
_ref$as = _ref.as,
Component = _ref$as === void 0 ? 'nav' : _ref$as,
props = _objectWithoutPropertiesLoose(_ref, _excluded);
var prefix = useBootstrapPrefix(bsPrefix, 'breadcrumb');
return /*#__PURE__*/React.createElement(Component, _extends({
"aria-label": label,
className: className,
ref: ref
}, props), /*#__PURE__*/React.createElement("ol", _extends({}, listProps, {
className: classNames(prefix, listProps == null ? void 0 : listProps.className)
}), children));
});
Breadcrumb.displayName = 'Breadcrumb';
Breadcrumb.defaultProps = defaultProps;
Breadcrumb.Item = BreadcrumbItem;
export default Breadcrumb;

13
web/node_modules/react-bootstrap/esm/BreadcrumbItem.d.ts generated vendored Normal file
View file

@ -0,0 +1,13 @@
import React from 'react';
import { BsPrefixPropsWithChildren, BsPrefixRefForwardingComponent } from './helpers';
export interface BreadcrumbItemProps extends BsPrefixPropsWithChildren {
active?: boolean;
href?: string;
linkAs?: React.ElementType;
target?: string;
title?: React.ReactNode;
linkProps?: Record<string, any>;
}
declare type BreadcrumbItem = BsPrefixRefForwardingComponent<'li', BreadcrumbItemProps>;
declare const BreadcrumbItem: BreadcrumbItem;
export default BreadcrumbItem;

43
web/node_modules/react-bootstrap/esm/BreadcrumbItem.js generated vendored Normal file
View file

@ -0,0 +1,43 @@
import _extends from "@babel/runtime/helpers/esm/extends";
import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
var _excluded = ["bsPrefix", "active", "children", "className", "as", "linkAs", "linkProps", "href", "title", "target"];
import classNames from 'classnames';
import React from 'react';
import SafeAnchor from './SafeAnchor';
import { useBootstrapPrefix } from './ThemeProvider';
var defaultProps = {
active: false,
linkProps: {}
};
var BreadcrumbItem = /*#__PURE__*/React.forwardRef(function (_ref, ref) {
var bsPrefix = _ref.bsPrefix,
active = _ref.active,
children = _ref.children,
className = _ref.className,
_ref$as = _ref.as,
Component = _ref$as === void 0 ? 'li' : _ref$as,
_ref$linkAs = _ref.linkAs,
LinkComponent = _ref$linkAs === void 0 ? SafeAnchor : _ref$linkAs,
linkProps = _ref.linkProps,
href = _ref.href,
title = _ref.title,
target = _ref.target,
props = _objectWithoutPropertiesLoose(_ref, _excluded);
var prefix = useBootstrapPrefix(bsPrefix, 'breadcrumb-item');
return /*#__PURE__*/React.createElement(Component, _extends({
ref: ref
}, props, {
className: classNames(prefix, className, {
active: active
}),
"aria-current": active ? 'page' : undefined
}), active ? children : /*#__PURE__*/React.createElement(LinkComponent, _extends({}, linkProps, {
href: href,
title: title,
target: target
}), children));
});
BreadcrumbItem.displayName = 'BreadcrumbItem';
BreadcrumbItem.defaultProps = defaultProps;
export default BreadcrumbItem;

18
web/node_modules/react-bootstrap/esm/Button.d.ts generated vendored Normal file
View file

@ -0,0 +1,18 @@
import React from 'react';
import { BsPrefixPropsWithChildren, BsPrefixRefForwardingComponent } from './helpers';
import { ButtonVariant } from './types';
export declare type ButtonType = 'button' | 'reset' | 'submit' | string;
export interface ButtonProps extends React.HTMLAttributes<HTMLElement>, BsPrefixPropsWithChildren {
active?: boolean;
block?: boolean;
variant?: ButtonVariant;
size?: 'sm' | 'lg';
type?: ButtonType;
href?: string;
disabled?: boolean;
target?: any;
}
declare type Button = BsPrefixRefForwardingComponent<'button', ButtonProps>;
export declare type CommonButtonProps = 'href' | 'size' | 'variant' | 'disabled';
declare const Button: Button;
export default Button;

52
web/node_modules/react-bootstrap/esm/Button.js generated vendored Normal file
View file

@ -0,0 +1,52 @@
import _extends from "@babel/runtime/helpers/esm/extends";
import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
var _excluded = ["bsPrefix", "variant", "size", "active", "className", "block", "type", "as"];
import classNames from 'classnames';
import React from 'react';
import { useBootstrapPrefix } from './ThemeProvider';
import SafeAnchor from './SafeAnchor';
var defaultProps = {
variant: 'primary',
active: false,
disabled: false
};
var Button = /*#__PURE__*/React.forwardRef(function (_ref, ref) {
var bsPrefix = _ref.bsPrefix,
variant = _ref.variant,
size = _ref.size,
active = _ref.active,
className = _ref.className,
block = _ref.block,
type = _ref.type,
as = _ref.as,
props = _objectWithoutPropertiesLoose(_ref, _excluded);
var prefix = useBootstrapPrefix(bsPrefix, 'btn');
var classes = classNames(className, prefix, active && 'active', variant && prefix + "-" + variant, block && prefix + "-block", size && prefix + "-" + size);
if (props.href) {
return /*#__PURE__*/React.createElement(SafeAnchor, _extends({}, props, {
as: as,
ref: ref,
className: classNames(classes, props.disabled && 'disabled')
}));
}
if (ref) {
props.ref = ref;
}
if (type) {
props.type = type;
} else if (!as) {
props.type = 'button';
}
var Component = as || 'button';
return /*#__PURE__*/React.createElement(Component, _extends({}, props, {
className: classes
}));
});
Button.displayName = 'Button';
Button.defaultProps = defaultProps;
export default Button;

10
web/node_modules/react-bootstrap/esm/ButtonGroup.d.ts generated vendored Normal file
View file

@ -0,0 +1,10 @@
import { BsPrefixPropsWithChildren, BsPrefixRefForwardingComponent } from './helpers';
export interface ButtonGroupProps extends BsPrefixPropsWithChildren {
role?: string;
size?: 'sm' | 'lg';
toggle?: boolean;
vertical?: boolean;
}
declare type ButtonGroup = BsPrefixRefForwardingComponent<'div', ButtonGroupProps>;
declare const ButtonGroup: ButtonGroup;
export default ButtonGroup;

32
web/node_modules/react-bootstrap/esm/ButtonGroup.js generated vendored Normal file
View file

@ -0,0 +1,32 @@
import _extends from "@babel/runtime/helpers/esm/extends";
import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
var _excluded = ["bsPrefix", "size", "toggle", "vertical", "className", "as"];
import classNames from 'classnames';
import React from 'react';
import { useBootstrapPrefix } from './ThemeProvider';
var defaultProps = {
vertical: false,
toggle: false,
role: 'group'
};
var ButtonGroup = /*#__PURE__*/React.forwardRef(function (_ref, ref) {
var bsPrefix = _ref.bsPrefix,
size = _ref.size,
toggle = _ref.toggle,
vertical = _ref.vertical,
className = _ref.className,
_ref$as = _ref.as,
Component = _ref$as === void 0 ? 'div' : _ref$as,
rest = _objectWithoutPropertiesLoose(_ref, _excluded);
var prefix = useBootstrapPrefix(bsPrefix, 'btn-group');
var baseClass = prefix;
if (vertical) baseClass = prefix + "-vertical";
return /*#__PURE__*/React.createElement(Component, _extends({}, rest, {
ref: ref,
className: classNames(className, baseClass, size && prefix + "-" + size, toggle && prefix + "-toggle")
}));
});
ButtonGroup.displayName = 'ButtonGroup';
ButtonGroup.defaultProps = defaultProps;
export default ButtonGroup;

7
web/node_modules/react-bootstrap/esm/ButtonToolbar.d.ts generated vendored Normal file
View file

@ -0,0 +1,7 @@
import { BsPrefixPropsWithChildren, BsPrefixRefForwardingComponent } from './helpers';
export interface ButtonToolbarProps extends BsPrefixPropsWithChildren {
role?: string;
}
declare type ButtonToolbar = BsPrefixRefForwardingComponent<'div', ButtonToolbarProps>;
declare const ButtonToolbar: ButtonToolbar;
export default ButtonToolbar;

23
web/node_modules/react-bootstrap/esm/ButtonToolbar.js generated vendored Normal file
View file

@ -0,0 +1,23 @@
import _extends from "@babel/runtime/helpers/esm/extends";
import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
var _excluded = ["bsPrefix", "className"];
import classNames from 'classnames';
import React from 'react';
import { useBootstrapPrefix } from './ThemeProvider';
var defaultProps = {
role: 'toolbar'
};
var ButtonToolbar = /*#__PURE__*/React.forwardRef(function (_ref, ref) {
var bsPrefix = _ref.bsPrefix,
className = _ref.className,
props = _objectWithoutPropertiesLoose(_ref, _excluded);
var prefix = useBootstrapPrefix(bsPrefix, 'btn-toolbar');
return /*#__PURE__*/React.createElement("div", _extends({}, props, {
ref: ref,
className: classNames(className, prefix)
}));
});
ButtonToolbar.displayName = 'ButtonToolbar';
ButtonToolbar.defaultProps = defaultProps;
export default ButtonToolbar;

31
web/node_modules/react-bootstrap/esm/Card.d.ts generated vendored Normal file
View file

@ -0,0 +1,31 @@
import React from 'react';
import CardImg from './CardImg';
import { BsPrefixPropsWithChildren, BsPrefixRefForwardingComponent } from './helpers';
import { Color, Variant } from './types';
declare const CardBody: BsPrefixRefForwardingComponent<"div", unknown>;
declare const CardTitle: BsPrefixRefForwardingComponent<React.ForwardRefExoticComponent<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & React.RefAttributes<HTMLDivElement>>, unknown>;
declare const CardSubtitle: BsPrefixRefForwardingComponent<React.ForwardRefExoticComponent<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & React.RefAttributes<HTMLDivElement>>, unknown>;
declare const CardLink: BsPrefixRefForwardingComponent<"a", unknown>;
declare const CardText: BsPrefixRefForwardingComponent<"p", unknown>;
declare const CardHeader: BsPrefixRefForwardingComponent<"div", unknown>;
declare const CardFooter: BsPrefixRefForwardingComponent<"div", unknown>;
declare const CardImgOverlay: BsPrefixRefForwardingComponent<"div", unknown>;
export interface CardProps extends BsPrefixPropsWithChildren {
bg?: Variant;
text?: Color;
border?: Variant;
body?: boolean;
}
declare type Card = BsPrefixRefForwardingComponent<'div', CardProps> & {
Img: typeof CardImg;
Title: typeof CardTitle;
Subtitle: typeof CardSubtitle;
Body: typeof CardBody;
Link: typeof CardLink;
Text: typeof CardText;
Header: typeof CardHeader;
Footer: typeof CardFooter;
ImgOverlay: typeof CardImgOverlay;
};
declare const Card: Card;
export default Card;

72
web/node_modules/react-bootstrap/esm/Card.js generated vendored Normal file
View file

@ -0,0 +1,72 @@
import _extends from "@babel/runtime/helpers/esm/extends";
import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
var _excluded = ["bsPrefix", "className", "bg", "text", "border", "body", "children", "as"];
import classNames from 'classnames';
import React, { useMemo } from 'react';
import { useBootstrapPrefix } from './ThemeProvider';
import createWithBsPrefix from './createWithBsPrefix';
import divWithClassName from './divWithClassName';
import CardContext from './CardContext';
import CardImg from './CardImg';
var DivStyledAsH5 = divWithClassName('h5');
var DivStyledAsH6 = divWithClassName('h6');
var CardBody = createWithBsPrefix('card-body');
var CardTitle = createWithBsPrefix('card-title', {
Component: DivStyledAsH5
});
var CardSubtitle = createWithBsPrefix('card-subtitle', {
Component: DivStyledAsH6
});
var CardLink = createWithBsPrefix('card-link', {
Component: 'a'
});
var CardText = createWithBsPrefix('card-text', {
Component: 'p'
});
var CardHeader = createWithBsPrefix('card-header');
var CardFooter = createWithBsPrefix('card-footer');
var CardImgOverlay = createWithBsPrefix('card-img-overlay');
var defaultProps = {
body: false
};
var Card = /*#__PURE__*/React.forwardRef(function (_ref, ref) {
var bsPrefix = _ref.bsPrefix,
className = _ref.className,
bg = _ref.bg,
text = _ref.text,
border = _ref.border,
body = _ref.body,
children = _ref.children,
_ref$as = _ref.as,
Component = _ref$as === void 0 ? 'div' : _ref$as,
props = _objectWithoutPropertiesLoose(_ref, _excluded);
var prefix = useBootstrapPrefix(bsPrefix, 'card');
var cardContext = useMemo(function () {
return {
cardHeaderBsPrefix: prefix + "-header"
};
}, [prefix]);
return /*#__PURE__*/React.createElement(CardContext.Provider, {
value: cardContext
}, /*#__PURE__*/React.createElement(Component, _extends({
ref: ref
}, props, {
className: classNames(className, prefix, bg && "bg-" + bg, text && "text-" + text, border && "border-" + border)
}), body ?
/*#__PURE__*/
// @ts-ignore
React.createElement(CardBody, null, children) : children));
});
Card.displayName = 'Card';
Card.defaultProps = defaultProps;
Card.Img = CardImg;
Card.Title = CardTitle;
Card.Subtitle = CardSubtitle;
Card.Body = CardBody;
Card.Link = CardLink;
Card.Text = CardText;
Card.Header = CardHeader;
Card.Footer = CardFooter;
Card.ImgOverlay = CardImgOverlay;
export default Card;

2
web/node_modules/react-bootstrap/esm/CardColumns.d.ts generated vendored Normal file
View file

@ -0,0 +1,2 @@
declare const _default: import("./helpers").BsPrefixRefForwardingComponent<"div", unknown>;
export default _default;

2
web/node_modules/react-bootstrap/esm/CardColumns.js generated vendored Normal file
View file

@ -0,0 +1,2 @@
import createWithBsPrefix from './createWithBsPrefix';
export default createWithBsPrefix('card-columns');

6
web/node_modules/react-bootstrap/esm/CardContext.d.ts generated vendored Normal file
View file

@ -0,0 +1,6 @@
import React from 'react';
interface CardContextType {
cardHeaderBsPrefix: string;
}
declare const context: React.Context<CardContextType | null>;
export default context;

4
web/node_modules/react-bootstrap/esm/CardContext.js generated vendored Normal file
View file

@ -0,0 +1,4 @@
import React from 'react';
var context = /*#__PURE__*/React.createContext(null);
context.displayName = 'CardContext';
export default context;

2
web/node_modules/react-bootstrap/esm/CardDeck.d.ts generated vendored Normal file
View file

@ -0,0 +1,2 @@
declare const _default: import("./helpers").BsPrefixRefForwardingComponent<"div", unknown>;
export default _default;

2
web/node_modules/react-bootstrap/esm/CardDeck.js generated vendored Normal file
View file

@ -0,0 +1,2 @@
import createWithBsPrefix from './createWithBsPrefix';
export default createWithBsPrefix('card-deck');

2
web/node_modules/react-bootstrap/esm/CardGroup.d.ts generated vendored Normal file
View file

@ -0,0 +1,2 @@
declare const _default: import("./helpers").BsPrefixRefForwardingComponent<"div", unknown>;
export default _default;

2
web/node_modules/react-bootstrap/esm/CardGroup.js generated vendored Normal file
View file

@ -0,0 +1,2 @@
import createWithBsPrefix from './createWithBsPrefix';
export default createWithBsPrefix('card-group');

6
web/node_modules/react-bootstrap/esm/CardHeader.d.ts generated vendored Normal file
View file

@ -0,0 +1,6 @@
import * as React from 'react';
import { BsPrefixProps, BsPrefixRefForwardingComponent } from './helpers';
export interface CardHeaderProps extends BsPrefixProps, React.HTMLAttributes<HTMLElement> {
}
declare const CardHeader: BsPrefixRefForwardingComponent<'div', CardHeaderProps>;
export default CardHeader;

6
web/node_modules/react-bootstrap/esm/CardHeaderContext.d.ts generated vendored Normal file
View file

@ -0,0 +1,6 @@
import * as React from 'react';
interface CardHeaderContextValue {
cardHeaderBsPrefix: string;
}
declare const context: React.Context<CardHeaderContextValue | null>;
export default context;

7
web/node_modules/react-bootstrap/esm/CardImg.d.ts generated vendored Normal file
View file

@ -0,0 +1,7 @@
import { BsPrefixProps, BsPrefixRefForwardingComponent } from './helpers';
export interface CardImgProps extends BsPrefixProps {
variant?: 'top' | 'bottom' | null;
}
declare type CardImg = BsPrefixRefForwardingComponent<'img', CardImgProps>;
declare const CardImg: CardImg;
export default CardImg;

27
web/node_modules/react-bootstrap/esm/CardImg.js generated vendored Normal file
View file

@ -0,0 +1,27 @@
import _extends from "@babel/runtime/helpers/esm/extends";
import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
var _excluded = ["bsPrefix", "className", "variant", "as"];
import classNames from 'classnames';
import React from 'react';
import { useBootstrapPrefix } from './ThemeProvider';
var defaultProps = {
variant: null
};
var CardImg = /*#__PURE__*/React.forwardRef( // Need to define the default "as" during prop destructuring to be compatible with styled-components github.com/react-bootstrap/react-bootstrap/issues/3595
function (_ref, ref) {
var bsPrefix = _ref.bsPrefix,
className = _ref.className,
variant = _ref.variant,
_ref$as = _ref.as,
Component = _ref$as === void 0 ? 'img' : _ref$as,
props = _objectWithoutPropertiesLoose(_ref, _excluded);
var prefix = useBootstrapPrefix(bsPrefix, 'card-img');
return /*#__PURE__*/React.createElement(Component, _extends({
ref: ref,
className: classNames(variant ? prefix + "-" + variant : prefix, className)
}, props));
});
CardImg.displayName = 'CardImg';
CardImg.defaultProps = defaultProps;
export default CardImg;

36
web/node_modules/react-bootstrap/esm/Carousel.d.ts generated vendored Normal file
View file

@ -0,0 +1,36 @@
import React from 'react';
import CarouselCaption from './CarouselCaption';
import CarouselItem from './CarouselItem';
import { BsPrefixPropsWithChildren, BsPrefixRefForwardingComponent } from './helpers';
export interface CarouselRef {
element: HTMLElement;
prev: (e?: React.SyntheticEvent) => void;
next: (e?: React.SyntheticEvent) => void;
}
export interface CarouselProps extends BsPrefixPropsWithChildren, Pick<React.DOMAttributes<HTMLElement>, 'onKeyDown' | 'onMouseOver' | 'onMouseOut' | 'onTouchStart' | 'onTouchMove' | 'onTouchEnd'> {
slide?: boolean;
fade?: boolean;
controls?: boolean;
indicators?: boolean;
activeIndex?: number;
onSelect?: (eventKey: number, event: Record<string, unknown> | null) => void;
defaultActiveIndex?: number;
onSlide?: (eventKey: number, direction: 'left' | 'right') => void;
onSlid?: (eventKey: number, direction: 'left' | 'right') => void;
interval?: number | null;
keyboard?: boolean;
pause?: 'hover' | false;
wrap?: boolean;
touch?: boolean;
prevIcon?: React.ReactNode;
prevLabel?: React.ReactNode;
nextIcon?: React.ReactNode;
nextLabel?: React.ReactNode;
ref?: React.Ref<CarouselRef>;
}
declare type Carousel = BsPrefixRefForwardingComponent<'div', CarouselProps> & {
Caption: typeof CarouselCaption;
Item: typeof CarouselItem;
};
declare const Carousel: Carousel;
export default Carousel;

493
web/node_modules/react-bootstrap/esm/Carousel.js generated vendored Normal file
View file

@ -0,0 +1,493 @@
import _extends from "@babel/runtime/helpers/esm/extends";
import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
var _excluded = ["as", "bsPrefix", "slide", "fade", "controls", "indicators", "activeIndex", "onSelect", "onSlide", "onSlid", "interval", "keyboard", "onKeyDown", "pause", "onMouseOver", "onMouseOut", "wrap", "touch", "onTouchStart", "onTouchMove", "onTouchEnd", "prevIcon", "prevLabel", "nextIcon", "nextLabel", "className", "children"];
import useEventCallback from '@restart/hooks/useEventCallback';
import useUpdateEffect from '@restart/hooks/useUpdateEffect';
import useCommittedRef from '@restart/hooks/useCommittedRef';
import useTimeout from '@restart/hooks/useTimeout';
import classNames from 'classnames';
import Transition from 'react-transition-group/Transition';
import PropTypes from 'prop-types';
import React, { useCallback, useEffect, useImperativeHandle, useMemo, useRef, useState } from 'react';
import { useUncontrolled } from 'uncontrollable';
import CarouselCaption from './CarouselCaption';
import CarouselItem from './CarouselItem';
import { map, forEach } from './ElementChildren';
import SafeAnchor from './SafeAnchor';
import { useBootstrapPrefix } from './ThemeProvider';
import transitionEndListener from './transitionEndListener';
import triggerBrowserReflow from './triggerBrowserReflow';
var SWIPE_THRESHOLD = 40;
var propTypes = {
/**
* @default 'carousel'
*/
bsPrefix: PropTypes.string,
as: PropTypes.elementType,
/**
* Enables animation on the Carousel as it transitions between slides.
*/
slide: PropTypes.bool,
/** Animates slides with a crossfade animation instead of the default slide animation */
fade: PropTypes.bool,
/**
* Show the Carousel previous and next arrows for changing the current slide
*/
controls: PropTypes.bool,
/**
* Show a set of slide position indicators
*/
indicators: PropTypes.bool,
/**
* Controls the current visible slide
*
* @controllable onSelect
*/
activeIndex: PropTypes.number,
/**
* Callback fired when the active item changes.
*
* ```js
* (eventKey: number, event: Object | null) => void
* ```
*
* @controllable activeIndex
*/
onSelect: PropTypes.func,
/**
* Callback fired when a slide transition starts.
*
* ```js
* (eventKey: number, direction: 'left' | 'right') => void
*/
onSlide: PropTypes.func,
/**
* Callback fired when a slide transition ends.
*
* ```js
* (eventKey: number, direction: 'left' | 'right') => void
*/
onSlid: PropTypes.func,
/**
* The amount of time to delay between automatically cycling an item. If `null`, carousel will not automatically cycle.
*/
interval: PropTypes.number,
/** Whether the carousel should react to keyboard events. */
keyboard: PropTypes.bool,
/**
* If set to `"hover"`, pauses the cycling of the carousel on `mouseenter` and resumes the cycling of the carousel on `mouseleave`. If set to `false`, hovering over the carousel won't pause it.
*
* On touch-enabled devices, when set to `"hover"`, cycling will pause on `touchend` (once the user finished interacting with the carousel) for two intervals, before automatically resuming. Note that this is in addition to the above mouse behavior.
*/
pause: PropTypes.oneOf(['hover', false]),
/** Whether the carousel should cycle continuously or have hard stops. */
wrap: PropTypes.bool,
/**
* Whether the carousel should support left/right swipe interactions on touchscreen devices.
*/
touch: PropTypes.bool,
/** Override the default button icon for the "previous" control */
prevIcon: PropTypes.node,
/**
* Label shown to screen readers only, can be used to show the previous element
* in the carousel.
* Set to null to deactivate.
*/
prevLabel: PropTypes.string,
/** Override the default button icon for the "next" control */
nextIcon: PropTypes.node,
/**
* Label shown to screen readers only, can be used to show the next element
* in the carousel.
* Set to null to deactivate.
*/
nextLabel: PropTypes.string
};
var defaultProps = {
slide: true,
fade: false,
controls: true,
indicators: true,
defaultActiveIndex: 0,
interval: 5000,
keyboard: true,
pause: 'hover',
wrap: true,
touch: true,
prevIcon: /*#__PURE__*/React.createElement("span", {
"aria-hidden": "true",
className: "carousel-control-prev-icon"
}),
prevLabel: 'Previous',
nextIcon: /*#__PURE__*/React.createElement("span", {
"aria-hidden": "true",
className: "carousel-control-next-icon"
}),
nextLabel: 'Next'
};
function isVisible(element) {
if (!element || !element.style || !element.parentNode || !element.parentNode.style) {
return false;
}
var elementStyle = getComputedStyle(element);
return elementStyle.display !== 'none' && elementStyle.visibility !== 'hidden' && getComputedStyle(element.parentNode).display !== 'none';
}
function CarouselFunc(uncontrolledProps, ref) {
var _useUncontrolled = useUncontrolled(uncontrolledProps, {
activeIndex: 'onSelect'
}),
_useUncontrolled$as = _useUncontrolled.as,
Component = _useUncontrolled$as === void 0 ? 'div' : _useUncontrolled$as,
bsPrefix = _useUncontrolled.bsPrefix,
slide = _useUncontrolled.slide,
fade = _useUncontrolled.fade,
controls = _useUncontrolled.controls,
indicators = _useUncontrolled.indicators,
activeIndex = _useUncontrolled.activeIndex,
onSelect = _useUncontrolled.onSelect,
onSlide = _useUncontrolled.onSlide,
onSlid = _useUncontrolled.onSlid,
interval = _useUncontrolled.interval,
keyboard = _useUncontrolled.keyboard,
onKeyDown = _useUncontrolled.onKeyDown,
pause = _useUncontrolled.pause,
onMouseOver = _useUncontrolled.onMouseOver,
onMouseOut = _useUncontrolled.onMouseOut,
wrap = _useUncontrolled.wrap,
touch = _useUncontrolled.touch,
onTouchStart = _useUncontrolled.onTouchStart,
onTouchMove = _useUncontrolled.onTouchMove,
onTouchEnd = _useUncontrolled.onTouchEnd,
prevIcon = _useUncontrolled.prevIcon,
prevLabel = _useUncontrolled.prevLabel,
nextIcon = _useUncontrolled.nextIcon,
nextLabel = _useUncontrolled.nextLabel,
className = _useUncontrolled.className,
children = _useUncontrolled.children,
props = _objectWithoutPropertiesLoose(_useUncontrolled, _excluded);
var prefix = useBootstrapPrefix(bsPrefix, 'carousel');
var nextDirectionRef = useRef(null);
var _useState = useState('next'),
direction = _useState[0],
setDirection = _useState[1];
var _useState2 = useState(false),
paused = _useState2[0],
setPaused = _useState2[1];
var _useState3 = useState(false),
isSliding = _useState3[0],
setIsSliding = _useState3[1];
var _useState4 = useState(activeIndex || 0),
renderedActiveIndex = _useState4[0],
setRenderedActiveIndex = _useState4[1];
if (!isSliding && activeIndex !== renderedActiveIndex) {
if (nextDirectionRef.current) {
setDirection(nextDirectionRef.current);
} else {
setDirection((activeIndex || 0) > renderedActiveIndex ? 'next' : 'prev');
}
if (slide) {
setIsSliding(true);
}
setRenderedActiveIndex(activeIndex || 0);
}
useEffect(function () {
if (nextDirectionRef.current) {
nextDirectionRef.current = null;
}
});
var numChildren = 0;
var activeChildInterval; // Iterate to grab all of the children's interval values
// (and count them, too)
forEach(children, function (child, index) {
++numChildren;
if (index === activeIndex) {
activeChildInterval = child.props.interval;
}
});
var activeChildIntervalRef = useCommittedRef(activeChildInterval);
var prev = useCallback(function (event) {
if (isSliding) {
return;
}
var nextActiveIndex = renderedActiveIndex - 1;
if (nextActiveIndex < 0) {
if (!wrap) {
return;
}
nextActiveIndex = numChildren - 1;
}
nextDirectionRef.current = 'prev';
if (onSelect) {
onSelect(nextActiveIndex, event);
}
}, [isSliding, renderedActiveIndex, onSelect, wrap, numChildren]); // This is used in the setInterval, so it should not invalidate.
var next = useEventCallback(function (event) {
if (isSliding) {
return;
}
var nextActiveIndex = renderedActiveIndex + 1;
if (nextActiveIndex >= numChildren) {
if (!wrap) {
return;
}
nextActiveIndex = 0;
}
nextDirectionRef.current = 'next';
if (onSelect) {
onSelect(nextActiveIndex, event);
}
});
var elementRef = useRef();
useImperativeHandle(ref, function () {
return {
element: elementRef.current,
prev: prev,
next: next
};
}); // This is used in the setInterval, so it should not invalidate.
var nextWhenVisible = useEventCallback(function () {
if (!document.hidden && isVisible(elementRef.current)) {
next();
}
});
var slideDirection = direction === 'next' ? 'left' : 'right';
useUpdateEffect(function () {
if (slide) {
// These callbacks will be handled by the <Transition> callbacks.
return;
}
if (onSlide) {
onSlide(renderedActiveIndex, slideDirection);
}
if (onSlid) {
onSlid(renderedActiveIndex, slideDirection);
}
}, [renderedActiveIndex]);
var orderClassName = prefix + "-item-" + direction;
var directionalClassName = prefix + "-item-" + slideDirection;
var handleEnter = useCallback(function (node) {
triggerBrowserReflow(node);
if (onSlide) {
onSlide(renderedActiveIndex, slideDirection);
}
}, [onSlide, renderedActiveIndex, slideDirection]);
var handleEntered = useCallback(function () {
setIsSliding(false);
if (onSlid) {
onSlid(renderedActiveIndex, slideDirection);
}
}, [onSlid, renderedActiveIndex, slideDirection]);
var handleKeyDown = useCallback(function (event) {
if (keyboard && !/input|textarea/i.test(event.target.tagName)) {
switch (event.key) {
case 'ArrowLeft':
event.preventDefault();
prev(event);
return;
case 'ArrowRight':
event.preventDefault();
next(event);
return;
default:
}
}
if (onKeyDown) {
onKeyDown(event);
}
}, [keyboard, onKeyDown, prev, next]);
var handleMouseOver = useCallback(function (event) {
if (pause === 'hover') {
setPaused(true);
}
if (onMouseOver) {
onMouseOver(event);
}
}, [pause, onMouseOver]);
var handleMouseOut = useCallback(function (event) {
setPaused(false);
if (onMouseOut) {
onMouseOut(event);
}
}, [onMouseOut]);
var touchStartXRef = useRef(0);
var touchDeltaXRef = useRef(0);
var touchUnpauseTimeout = useTimeout();
var handleTouchStart = useCallback(function (event) {
touchStartXRef.current = event.touches[0].clientX;
touchDeltaXRef.current = 0;
if (pause === 'hover') {
setPaused(true);
}
if (onTouchStart) {
onTouchStart(event);
}
}, [pause, onTouchStart]);
var handleTouchMove = useCallback(function (event) {
if (event.touches && event.touches.length > 1) {
touchDeltaXRef.current = 0;
} else {
touchDeltaXRef.current = event.touches[0].clientX - touchStartXRef.current;
}
if (onTouchMove) {
onTouchMove(event);
}
}, [onTouchMove]);
var handleTouchEnd = useCallback(function (event) {
if (touch) {
var touchDeltaX = touchDeltaXRef.current;
if (Math.abs(touchDeltaX) > SWIPE_THRESHOLD) {
if (touchDeltaX > 0) {
prev(event);
} else {
next(event);
}
}
}
if (pause === 'hover') {
touchUnpauseTimeout.set(function () {
setPaused(false);
}, interval || undefined);
}
if (onTouchEnd) {
onTouchEnd(event);
}
}, [touch, pause, prev, next, touchUnpauseTimeout, interval, onTouchEnd]);
var shouldPlay = interval != null && !paused && !isSliding;
var intervalHandleRef = useRef();
useEffect(function () {
var _ref, _activeChildIntervalR;
if (!shouldPlay) {
return undefined;
}
intervalHandleRef.current = window.setInterval(document.visibilityState ? nextWhenVisible : next, (_ref = (_activeChildIntervalR = activeChildIntervalRef.current) != null ? _activeChildIntervalR : interval) != null ? _ref : undefined);
return function () {
if (intervalHandleRef.current !== null) {
clearInterval(intervalHandleRef.current);
}
};
}, [shouldPlay, next, activeChildIntervalRef, interval, nextWhenVisible]);
var indicatorOnClicks = useMemo(function () {
return indicators && Array.from({
length: numChildren
}, function (_, index) {
return function (event) {
if (onSelect) {
onSelect(index, event);
}
};
});
}, [indicators, numChildren, onSelect]);
return /*#__PURE__*/React.createElement(Component, _extends({
ref: elementRef
}, props, {
onKeyDown: handleKeyDown,
onMouseOver: handleMouseOver,
onMouseOut: handleMouseOut,
onTouchStart: handleTouchStart,
onTouchMove: handleTouchMove,
onTouchEnd: handleTouchEnd,
className: classNames(className, prefix, slide && 'slide', fade && prefix + "-fade")
}), indicators && /*#__PURE__*/React.createElement("ol", {
className: prefix + "-indicators"
}, map(children, function (_child, index) {
return /*#__PURE__*/React.createElement("li", {
key: index,
className: index === renderedActiveIndex ? 'active' : undefined,
onClick: indicatorOnClicks ? indicatorOnClicks[index] : undefined
});
})), /*#__PURE__*/React.createElement("div", {
className: prefix + "-inner"
}, map(children, function (child, index) {
var isActive = index === renderedActiveIndex;
return slide ? /*#__PURE__*/React.createElement(Transition, {
in: isActive,
onEnter: isActive ? handleEnter : undefined,
onEntered: isActive ? handleEntered : undefined,
addEndListener: transitionEndListener
}, function (status) {
return /*#__PURE__*/React.cloneElement(child, {
className: classNames(child.props.className, isActive && status !== 'entered' && orderClassName, (status === 'entered' || status === 'exiting') && 'active', (status === 'entering' || status === 'exiting') && directionalClassName)
});
}) : /*#__PURE__*/React.cloneElement(child, {
className: classNames(child.props.className, isActive && 'active')
});
})), controls && /*#__PURE__*/React.createElement(React.Fragment, null, (wrap || activeIndex !== 0) && /*#__PURE__*/React.createElement(SafeAnchor, {
className: prefix + "-control-prev",
onClick: prev
}, prevIcon, prevLabel && /*#__PURE__*/React.createElement("span", {
className: "sr-only"
}, prevLabel)), (wrap || activeIndex !== numChildren - 1) && /*#__PURE__*/React.createElement(SafeAnchor, {
className: prefix + "-control-next",
onClick: next
}, nextIcon, nextLabel && /*#__PURE__*/React.createElement("span", {
className: "sr-only"
}, nextLabel))));
}
var Carousel = /*#__PURE__*/React.forwardRef(CarouselFunc);
Carousel.displayName = 'Carousel';
Carousel.propTypes = propTypes;
Carousel.defaultProps = defaultProps;
Carousel.Caption = CarouselCaption;
Carousel.Item = CarouselItem;
export default Carousel;

2
web/node_modules/react-bootstrap/esm/CarouselCaption.d.ts generated vendored Normal file
View file

@ -0,0 +1,2 @@
declare const _default: import("./helpers").BsPrefixRefForwardingComponent<"div", unknown>;
export default _default;

2
web/node_modules/react-bootstrap/esm/CarouselCaption.js generated vendored Normal file
View file

@ -0,0 +1,2 @@
import createWithBsPrefix from './createWithBsPrefix';
export default createWithBsPrefix('carousel-caption');

7
web/node_modules/react-bootstrap/esm/CarouselItem.d.ts generated vendored Normal file
View file

@ -0,0 +1,7 @@
import { BsPrefixPropsWithChildren, BsPrefixRefForwardingComponent } from './helpers';
export interface CarouselItemProps extends BsPrefixPropsWithChildren {
interval?: number;
}
declare type CarouselItem = BsPrefixRefForwardingComponent<'div', CarouselItemProps>;
declare const CarouselItem: CarouselItem;
export default CarouselItem;

23
web/node_modules/react-bootstrap/esm/CarouselItem.js generated vendored Normal file
View file

@ -0,0 +1,23 @@
import _extends from "@babel/runtime/helpers/esm/extends";
import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
var _excluded = ["as", "bsPrefix", "children", "className"];
import classNames from 'classnames';
import React from 'react';
import { useBootstrapPrefix } from './ThemeProvider';
var CarouselItem = /*#__PURE__*/React.forwardRef(function (_ref, ref) {
var _ref$as = _ref.as,
Component = _ref$as === void 0 ? 'div' : _ref$as,
bsPrefix = _ref.bsPrefix,
children = _ref.children,
className = _ref.className,
props = _objectWithoutPropertiesLoose(_ref, _excluded);
var finalClassName = classNames(className, useBootstrapPrefix(bsPrefix, 'carousel-item'));
return /*#__PURE__*/React.createElement(Component, _extends({
ref: ref
}, props, {
className: finalClassName
}), children);
});
CarouselItem.displayName = 'CarouselItem';
export default CarouselItem;

6
web/node_modules/react-bootstrap/esm/CloseButton.d.ts generated vendored Normal file
View file

@ -0,0 +1,6 @@
import React from 'react';
export interface CloseButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
label?: string;
}
declare const CloseButton: React.ForwardRefExoticComponent<CloseButtonProps & React.RefAttributes<HTMLButtonElement>>;
export default CloseButton;

34
web/node_modules/react-bootstrap/esm/CloseButton.js generated vendored Normal file
View file

@ -0,0 +1,34 @@
import _extends from "@babel/runtime/helpers/esm/extends";
import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
var _excluded = ["label", "onClick", "className"];
import PropTypes from 'prop-types';
import React from 'react';
import classNames from 'classnames';
var propTypes = {
label: PropTypes.string.isRequired,
onClick: PropTypes.func
};
var defaultProps = {
label: 'Close'
};
var CloseButton = /*#__PURE__*/React.forwardRef(function (_ref, ref) {
var label = _ref.label,
onClick = _ref.onClick,
className = _ref.className,
props = _objectWithoutPropertiesLoose(_ref, _excluded);
return /*#__PURE__*/React.createElement("button", _extends({
ref: ref,
type: "button",
className: classNames('close', className),
onClick: onClick
}, props), /*#__PURE__*/React.createElement("span", {
"aria-hidden": "true"
}, "\xD7"), /*#__PURE__*/React.createElement("span", {
className: "sr-only"
}, label));
});
CloseButton.displayName = 'CloseButton';
CloseButton.propTypes = propTypes;
CloseButton.defaultProps = defaultProps;
export default CloseButton;

18
web/node_modules/react-bootstrap/esm/Col.d.ts generated vendored Normal file
View file

@ -0,0 +1,18 @@
import { BsPrefixPropsWithChildren, BsPrefixRefForwardingComponent } from './helpers';
declare type NumberAttr = number | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' | '10' | '11' | '12';
declare type ColOrder = 'first' | 'last' | NumberAttr;
declare type ColSize = boolean | 'auto' | NumberAttr;
declare type ColSpec = ColSize | {
span?: ColSize;
offset?: NumberAttr;
order?: ColOrder;
};
export interface ColProps extends BsPrefixPropsWithChildren {
xs?: ColSpec;
sm?: ColSpec;
md?: ColSpec;
lg?: ColSpec;
xl?: ColSpec;
}
declare const Col: BsPrefixRefForwardingComponent<'div', ColProps>;
export default Col;

51
web/node_modules/react-bootstrap/esm/Col.js generated vendored Normal file
View file

@ -0,0 +1,51 @@
import _extends from "@babel/runtime/helpers/esm/extends";
import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
var _excluded = ["bsPrefix", "className", "as"];
import classNames from 'classnames';
import React from 'react';
import { useBootstrapPrefix } from './ThemeProvider';
var DEVICE_SIZES = ['xl', 'lg', 'md', 'sm', 'xs'];
var Col = /*#__PURE__*/React.forwardRef( // Need to define the default "as" during prop destructuring to be compatible with styled-components github.com/react-bootstrap/react-bootstrap/issues/3595
function (_ref, ref) {
var bsPrefix = _ref.bsPrefix,
className = _ref.className,
_ref$as = _ref.as,
Component = _ref$as === void 0 ? 'div' : _ref$as,
props = _objectWithoutPropertiesLoose(_ref, _excluded);
var prefix = useBootstrapPrefix(bsPrefix, 'col');
var spans = [];
var classes = [];
DEVICE_SIZES.forEach(function (brkPoint) {
var propValue = props[brkPoint];
delete props[brkPoint];
var span;
var offset;
var order;
if (typeof propValue === 'object' && propValue != null) {
var _propValue$span = propValue.span;
span = _propValue$span === void 0 ? true : _propValue$span;
offset = propValue.offset;
order = propValue.order;
} else {
span = propValue;
}
var infix = brkPoint !== 'xs' ? "-" + brkPoint : '';
if (span) spans.push(span === true ? "" + prefix + infix : "" + prefix + infix + "-" + span);
if (order != null) classes.push("order" + infix + "-" + order);
if (offset != null) classes.push("offset" + infix + "-" + offset);
});
if (!spans.length) {
spans.push(prefix); // plain 'col'
}
return /*#__PURE__*/React.createElement(Component, _extends({}, props, {
ref: ref,
className: classNames.apply(void 0, [className].concat(spans, classes))
}));
});
Col.displayName = 'Col';
export default Col;

16
web/node_modules/react-bootstrap/esm/Collapse.d.ts generated vendored Normal file
View file

@ -0,0 +1,16 @@
import React from 'react';
import { TransitionCallbacks } from './helpers';
declare type Dimension = 'height' | 'width';
export interface CollapseProps extends TransitionCallbacks, Pick<React.HTMLAttributes<HTMLElement>, 'role'> {
className?: string;
in?: boolean;
mountOnEnter?: boolean;
unmountOnExit?: boolean;
appear?: boolean;
timeout?: number;
dimension?: Dimension | (() => Dimension);
getDimensionValue?: (dimension: Dimension, element: HTMLElement) => number;
children: React.ReactElement;
}
declare const Collapse: React.ForwardRefExoticComponent<CollapseProps & React.RefAttributes<unknown>>;
export default Collapse;

104
web/node_modules/react-bootstrap/esm/Collapse.js generated vendored Normal file
View file

@ -0,0 +1,104 @@
import _extends from "@babel/runtime/helpers/esm/extends";
import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
var _excluded = ["onEnter", "onEntering", "onEntered", "onExit", "onExiting", "className", "children", "dimension", "getDimensionValue"];
var _collapseStyles;
import classNames from 'classnames';
import css from 'dom-helpers/css';
import React, { useMemo } from 'react';
import Transition, { ENTERED, ENTERING, EXITED, EXITING } from 'react-transition-group/Transition';
import transitionEndListener from './transitionEndListener';
import createChainedFunction from './createChainedFunction';
import triggerBrowserReflow from './triggerBrowserReflow';
var MARGINS = {
height: ['marginTop', 'marginBottom'],
width: ['marginLeft', 'marginRight']
};
function getDefaultDimensionValue(dimension, elem) {
var offset = "offset" + dimension[0].toUpperCase() + dimension.slice(1);
var value = elem[offset];
var margins = MARGINS[dimension];
return value + // @ts-ignore
parseInt(css(elem, margins[0]), 10) + // @ts-ignore
parseInt(css(elem, margins[1]), 10);
}
var collapseStyles = (_collapseStyles = {}, _collapseStyles[EXITED] = 'collapse', _collapseStyles[EXITING] = 'collapsing', _collapseStyles[ENTERING] = 'collapsing', _collapseStyles[ENTERED] = 'collapse show', _collapseStyles);
var defaultProps = {
in: false,
timeout: 300,
mountOnEnter: false,
unmountOnExit: false,
appear: false,
getDimensionValue: getDefaultDimensionValue
};
var Collapse = /*#__PURE__*/React.forwardRef(function (_ref, ref) {
var onEnter = _ref.onEnter,
onEntering = _ref.onEntering,
onEntered = _ref.onEntered,
onExit = _ref.onExit,
onExiting = _ref.onExiting,
className = _ref.className,
children = _ref.children,
_ref$dimension = _ref.dimension,
dimension = _ref$dimension === void 0 ? 'height' : _ref$dimension,
_ref$getDimensionValu = _ref.getDimensionValue,
getDimensionValue = _ref$getDimensionValu === void 0 ? getDefaultDimensionValue : _ref$getDimensionValu,
props = _objectWithoutPropertiesLoose(_ref, _excluded);
/* Compute dimension */
var computedDimension = typeof dimension === 'function' ? dimension() : dimension;
/* -- Expanding -- */
var handleEnter = useMemo(function () {
return createChainedFunction(function (elem) {
elem.style[computedDimension] = '0';
}, onEnter);
}, [computedDimension, onEnter]);
var handleEntering = useMemo(function () {
return createChainedFunction(function (elem) {
var scroll = "scroll" + computedDimension[0].toUpperCase() + computedDimension.slice(1);
elem.style[computedDimension] = elem[scroll] + "px";
}, onEntering);
}, [computedDimension, onEntering]);
var handleEntered = useMemo(function () {
return createChainedFunction(function (elem) {
elem.style[computedDimension] = null;
}, onEntered);
}, [computedDimension, onEntered]);
/* -- Collapsing -- */
var handleExit = useMemo(function () {
return createChainedFunction(function (elem) {
elem.style[computedDimension] = getDimensionValue(computedDimension, elem) + "px";
triggerBrowserReflow(elem);
}, onExit);
}, [onExit, getDimensionValue, computedDimension]);
var handleExiting = useMemo(function () {
return createChainedFunction(function (elem) {
elem.style[computedDimension] = null;
}, onExiting);
}, [computedDimension, onExiting]);
return /*#__PURE__*/React.createElement(Transition // @ts-ignore
, _extends({
ref: ref,
addEndListener: transitionEndListener
}, props, {
"aria-expanded": props.role ? props.in : null,
onEnter: handleEnter,
onEntering: handleEntering,
onEntered: handleEntered,
onExit: handleExit,
onExiting: handleExiting
}), function (state, innerProps) {
return /*#__PURE__*/React.cloneElement(children, _extends({}, innerProps, {
className: classNames(className, children.props.className, collapseStyles[state], computedDimension === 'width' && 'width')
}));
});
}); // @ts-ignore
// @ts-ignore
Collapse.defaultProps = defaultProps;
export default Collapse;

7
web/node_modules/react-bootstrap/esm/Container.d.ts generated vendored Normal file
View file

@ -0,0 +1,7 @@
import { BsPrefixPropsWithChildren, BsPrefixRefForwardingComponent } from './helpers';
export interface ContainerProps extends BsPrefixPropsWithChildren {
fluid?: boolean | 'sm' | 'md' | 'lg' | 'xl';
}
declare type Container = BsPrefixRefForwardingComponent<'div', ContainerProps>;
declare const Container: Container;
export default Container;

28
web/node_modules/react-bootstrap/esm/Container.js generated vendored Normal file
View file

@ -0,0 +1,28 @@
import _extends from "@babel/runtime/helpers/esm/extends";
import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
var _excluded = ["bsPrefix", "fluid", "as", "className"];
import classNames from 'classnames';
import React from 'react';
import { useBootstrapPrefix } from './ThemeProvider';
var defaultProps = {
fluid: false
};
var Container = /*#__PURE__*/React.forwardRef(function (_ref, ref) {
var bsPrefix = _ref.bsPrefix,
fluid = _ref.fluid,
_ref$as = _ref.as,
Component = _ref$as === void 0 ? 'div' : _ref$as,
className = _ref.className,
props = _objectWithoutPropertiesLoose(_ref, _excluded);
var prefix = useBootstrapPrefix(bsPrefix, 'container');
var suffix = typeof fluid === 'string' ? "-" + fluid : '-fluid';
return /*#__PURE__*/React.createElement(Component, _extends({
ref: ref
}, props, {
className: classNames(className, fluid ? "" + prefix + suffix : prefix)
}));
});
Container.displayName = 'Container';
Container.defaultProps = defaultProps;
export default Container;

30
web/node_modules/react-bootstrap/esm/Dropdown.d.ts generated vendored Normal file
View file

@ -0,0 +1,30 @@
import React from 'react';
import DropdownItem from './DropdownItem';
import DropdownMenu from './DropdownMenu';
import DropdownToggle from './DropdownToggle';
import { BsPrefixPropsWithChildren, BsPrefixRefForwardingComponent, SelectCallback } from './helpers';
declare const DropdownHeader: BsPrefixRefForwardingComponent<"div", unknown>;
declare const DropdownDivider: BsPrefixRefForwardingComponent<"div", unknown>;
declare const DropdownItemText: BsPrefixRefForwardingComponent<"span", unknown>;
export interface DropdownProps extends BsPrefixPropsWithChildren {
drop?: 'up' | 'left' | 'right' | 'down';
alignRight?: boolean;
show?: boolean;
flip?: boolean;
onToggle?: (isOpen: boolean, event: React.SyntheticEvent<Dropdown>, metadata: {
source: 'select' | 'click' | 'rootClose' | 'keydown';
}) => void;
focusFirstItemOnShow?: boolean | 'keyboard';
onSelect?: SelectCallback;
navbar?: boolean;
}
declare type Dropdown = BsPrefixRefForwardingComponent<'div', DropdownProps> & {
Toggle: typeof DropdownToggle;
Menu: typeof DropdownMenu;
Item: typeof DropdownItem;
ItemText: typeof DropdownItemText;
Divider: typeof DropdownDivider;
Header: typeof DropdownHeader;
};
declare const Dropdown: Dropdown;
export default Dropdown;

90
web/node_modules/react-bootstrap/esm/Dropdown.js generated vendored Normal file
View file

@ -0,0 +1,90 @@
import _extends from "@babel/runtime/helpers/esm/extends";
import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
var _excluded = ["bsPrefix", "drop", "show", "className", "alignRight", "onSelect", "onToggle", "focusFirstItemOnShow", "as", "navbar"];
import classNames from 'classnames';
import React, { useContext } from 'react';
import BaseDropdown from 'react-overlays/Dropdown';
import { useUncontrolled } from 'uncontrollable';
import useEventCallback from '@restart/hooks/useEventCallback';
import DropdownItem from './DropdownItem';
import DropdownMenu from './DropdownMenu';
import DropdownToggle from './DropdownToggle';
import SelectableContext from './SelectableContext';
import { useBootstrapPrefix } from './ThemeProvider';
import createWithBsPrefix from './createWithBsPrefix';
var DropdownHeader = createWithBsPrefix('dropdown-header', {
defaultProps: {
role: 'heading'
}
});
var DropdownDivider = createWithBsPrefix('dropdown-divider', {
defaultProps: {
role: 'separator'
}
});
var DropdownItemText = createWithBsPrefix('dropdown-item-text', {
Component: 'span'
});
var defaultProps = {
navbar: false
};
var Dropdown = /*#__PURE__*/React.forwardRef(function (pProps, ref) {
var _useUncontrolled = useUncontrolled(pProps, {
show: 'onToggle'
}),
bsPrefix = _useUncontrolled.bsPrefix,
drop = _useUncontrolled.drop,
show = _useUncontrolled.show,
className = _useUncontrolled.className,
alignRight = _useUncontrolled.alignRight,
onSelect = _useUncontrolled.onSelect,
onToggle = _useUncontrolled.onToggle,
focusFirstItemOnShow = _useUncontrolled.focusFirstItemOnShow,
_useUncontrolled$as = _useUncontrolled.as,
Component = _useUncontrolled$as === void 0 ? 'div' : _useUncontrolled$as,
_4 = _useUncontrolled.navbar,
props = _objectWithoutPropertiesLoose(_useUncontrolled, _excluded);
var onSelectCtx = useContext(SelectableContext);
var prefix = useBootstrapPrefix(bsPrefix, 'dropdown');
var handleToggle = useEventCallback(function (nextShow, event, source) {
if (source === void 0) {
source = event.type;
}
if (event.currentTarget === document && (source !== 'keydown' || event.key === 'Escape')) source = 'rootClose';
if (onToggle) {
onToggle(nextShow, event, {
source: source
});
}
});
var handleSelect = useEventCallback(function (key, event) {
if (onSelectCtx) onSelectCtx(key, event);
if (onSelect) onSelect(key, event);
handleToggle(false, event, 'select');
});
return /*#__PURE__*/React.createElement(SelectableContext.Provider, {
value: handleSelect
}, /*#__PURE__*/React.createElement(BaseDropdown, {
drop: drop,
show: show,
alignEnd: alignRight,
onToggle: handleToggle,
focusFirstItemOnShow: focusFirstItemOnShow,
itemSelector: "." + prefix + "-item:not(.disabled):not(:disabled)"
}, /*#__PURE__*/React.createElement(Component, _extends({}, props, {
ref: ref,
className: classNames(className, show && 'show', (!drop || drop === 'down') && prefix, drop === 'up' && 'dropup', drop === 'right' && 'dropright', drop === 'left' && 'dropleft')
}))));
});
Dropdown.displayName = 'Dropdown';
Dropdown.defaultProps = defaultProps;
Dropdown.Divider = DropdownDivider;
Dropdown.Header = DropdownHeader;
Dropdown.Item = DropdownItem;
Dropdown.ItemText = DropdownItemText;
Dropdown.Menu = DropdownMenu;
Dropdown.Toggle = DropdownToggle;
export default Dropdown;

24
web/node_modules/react-bootstrap/esm/DropdownButton.d.ts generated vendored Normal file
View file

@ -0,0 +1,24 @@
import React from 'react';
import { DropdownProps } from './Dropdown';
import { PropsFromToggle } from './DropdownToggle';
import { AlignType } from './DropdownMenu';
import { BsPrefixPropsWithChildren, BsPrefixRefForwardingComponent } from './helpers';
export interface DropdownButtonProps extends DropdownProps, Omit<React.HTMLAttributes<HTMLElement>, 'onSelect' | 'title'>, PropsFromToggle, BsPrefixPropsWithChildren {
title: React.ReactNode;
menuAlign?: AlignType;
menuRole?: string;
renderMenuOnMount?: boolean;
rootCloseEvent?: 'click' | 'mousedown';
}
declare type DropdownButton = BsPrefixRefForwardingComponent<'div', DropdownButtonProps>;
/**
* A convenience component for simple or general use dropdowns. Renders a `Button` toggle and all `children`
* are passed directly to the default `Dropdown.Menu`. This component accepts all of
* [`Dropdown`'s props](#dropdown-props).
*
* _All unknown props are passed through to the `Dropdown` component._ Only
* the Button `variant`, `size` and `bsPrefix` props are passed to the toggle,
* along with menu-related props are passed to the `Dropdown.Menu`
*/
declare const DropdownButton: DropdownButton;
export default DropdownButton;

103
web/node_modules/react-bootstrap/esm/DropdownButton.js generated vendored Normal file
View file

@ -0,0 +1,103 @@
import _extends from "@babel/runtime/helpers/esm/extends";
import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
var _excluded = ["title", "children", "bsPrefix", "rootCloseEvent", "variant", "size", "menuAlign", "menuRole", "renderMenuOnMount", "disabled", "href", "id"];
import React from 'react';
import PropTypes from 'prop-types';
import Dropdown from './Dropdown';
import DropdownToggle from './DropdownToggle';
import DropdownMenu, { alignPropType } from './DropdownMenu';
var propTypes = {
/**
* An html id attribute for the Toggle button, necessary for assistive technologies, such as screen readers.
* @type {string|number}
* @required
*/
id: PropTypes.any,
/** An `href` passed to the Toggle component */
href: PropTypes.string,
/** An `onClick` handler passed to the Toggle component */
onClick: PropTypes.func,
/** The content of the non-toggle Button. */
title: PropTypes.node.isRequired,
/** Disables both Buttons */
disabled: PropTypes.bool,
/**
* Aligns the dropdown menu responsively.
*
* _see [DropdownMenu](#dropdown-menu-props) for more details_
*
* @type {"left"|"right"|{ sm: "left"|"right" }|{ md: "left"|"right" }|{ lg: "left"|"right" }|{ xl: "left"|"right"} }
*/
menuAlign: alignPropType,
/** An ARIA accessible role applied to the Menu component. When set to 'menu', The dropdown */
menuRole: PropTypes.string,
/** Whether to render the dropdown menu in the DOM before the first time it is shown */
renderMenuOnMount: PropTypes.bool,
/**
* Which event when fired outside the component will cause it to be closed.
*
* _see [DropdownMenu](#dropdown-menu-props) for more details_
*/
rootCloseEvent: PropTypes.string,
/** @ignore */
bsPrefix: PropTypes.string,
/** @ignore */
variant: PropTypes.string,
/** @ignore */
size: PropTypes.string
};
/**
* A convenience component for simple or general use dropdowns. Renders a `Button` toggle and all `children`
* are passed directly to the default `Dropdown.Menu`. This component accepts all of
* [`Dropdown`'s props](#dropdown-props).
*
* _All unknown props are passed through to the `Dropdown` component._ Only
* the Button `variant`, `size` and `bsPrefix` props are passed to the toggle,
* along with menu-related props are passed to the `Dropdown.Menu`
*/
var DropdownButton = /*#__PURE__*/React.forwardRef(function (_ref, ref) {
var title = _ref.title,
children = _ref.children,
bsPrefix = _ref.bsPrefix,
rootCloseEvent = _ref.rootCloseEvent,
variant = _ref.variant,
size = _ref.size,
menuAlign = _ref.menuAlign,
menuRole = _ref.menuRole,
renderMenuOnMount = _ref.renderMenuOnMount,
disabled = _ref.disabled,
href = _ref.href,
id = _ref.id,
props = _objectWithoutPropertiesLoose(_ref, _excluded);
return /*#__PURE__*/React.createElement(Dropdown, _extends({
ref: ref
}, props), /*#__PURE__*/React.createElement(DropdownToggle, {
id: id,
href: href,
size: size,
variant: variant,
disabled: disabled,
childBsPrefix: bsPrefix
}, title), /*#__PURE__*/React.createElement(DropdownMenu, {
align: menuAlign,
role: menuRole,
renderOnMount: renderMenuOnMount,
rootCloseEvent: rootCloseEvent
}, children));
});
DropdownButton.displayName = 'DropdownButton';
DropdownButton.propTypes = propTypes;
export default DropdownButton;

7
web/node_modules/react-bootstrap/esm/DropdownContext.d.ts generated vendored Normal file
View file

@ -0,0 +1,7 @@
import * as React from 'react';
import { AlignType } from './types';
export declare type DropdownContextValue = {
align?: AlignType;
};
declare const DropdownContext: React.Context<DropdownContextValue>;
export default DropdownContext;

15
web/node_modules/react-bootstrap/esm/DropdownItem.d.ts generated vendored Normal file
View file

@ -0,0 +1,15 @@
import React from 'react';
import SafeAnchor from './SafeAnchor';
import { BsPrefixPropsWithChildren, BsPrefixRefForwardingComponent, SelectCallback } from './helpers';
import { EventKey } from './types';
export interface DropdownItemProps extends BsPrefixPropsWithChildren {
active?: boolean;
disabled?: boolean;
eventKey?: EventKey;
href?: string;
onClick?: React.MouseEventHandler<this>;
onSelect?: SelectCallback;
}
declare type DropdownItem = BsPrefixRefForwardingComponent<typeof SafeAnchor, DropdownItemProps>;
declare const DropdownItem: DropdownItem;
export default DropdownItem;

60
web/node_modules/react-bootstrap/esm/DropdownItem.js generated vendored Normal file
View file

@ -0,0 +1,60 @@
import _extends from "@babel/runtime/helpers/esm/extends";
import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
var _excluded = ["bsPrefix", "className", "children", "eventKey", "disabled", "href", "onClick", "onSelect", "active", "as"];
import classNames from 'classnames';
import React, { useContext } from 'react';
import useEventCallback from '@restart/hooks/useEventCallback';
import SelectableContext, { makeEventKey } from './SelectableContext';
import { useBootstrapPrefix } from './ThemeProvider';
import NavContext from './NavContext';
import SafeAnchor from './SafeAnchor';
var defaultProps = {
as: SafeAnchor,
disabled: false
};
var DropdownItem = /*#__PURE__*/React.forwardRef(function (_ref, ref) {
var bsPrefix = _ref.bsPrefix,
className = _ref.className,
children = _ref.children,
eventKey = _ref.eventKey,
disabled = _ref.disabled,
href = _ref.href,
onClick = _ref.onClick,
onSelect = _ref.onSelect,
propActive = _ref.active,
Component = _ref.as,
props = _objectWithoutPropertiesLoose(_ref, _excluded);
var prefix = useBootstrapPrefix(bsPrefix, 'dropdown-item');
var onSelectCtx = useContext(SelectableContext);
var navContext = useContext(NavContext);
var _ref2 = navContext || {},
activeKey = _ref2.activeKey;
var key = makeEventKey(eventKey, href);
var active = propActive == null && key != null ? makeEventKey(activeKey) === key : propActive;
var handleClick = useEventCallback(function (event) {
// SafeAnchor handles the disabled case, but we handle it here
// for other components
if (disabled) return;
if (onClick) onClick(event);
if (onSelectCtx) onSelectCtx(key, event);
if (onSelect) onSelect(key, event);
});
return (
/*#__PURE__*/
// "TS2604: JSX element type 'Component' does not have any construct or call signatures."
// @ts-ignore
React.createElement(Component, _extends({}, props, {
ref: ref,
href: href,
disabled: disabled,
className: classNames(className, prefix, active && 'active', disabled && 'disabled'),
onClick: handleClick
}), children)
);
});
DropdownItem.displayName = 'DropdownItem';
DropdownItem.defaultProps = defaultProps;
export default DropdownItem;

36
web/node_modules/react-bootstrap/esm/DropdownMenu.d.ts generated vendored Normal file
View file

@ -0,0 +1,36 @@
import PropTypes from 'prop-types';
import { UseDropdownMenuOptions } from 'react-overlays/DropdownMenu';
import { BsPrefixPropsWithChildren, BsPrefixRefForwardingComponent, SelectCallback } from './helpers';
export declare type AlignDirection = 'left' | 'right';
export declare type ResponsiveAlignProp = {
sm: AlignDirection;
} | {
md: AlignDirection;
} | {
lg: AlignDirection;
} | {
xl: AlignDirection;
};
export declare type AlignType = AlignDirection | ResponsiveAlignProp;
export interface DropdownMenuProps extends BsPrefixPropsWithChildren {
show?: boolean;
renderOnMount?: boolean;
flip?: boolean;
align?: AlignType;
alignRight?: boolean;
onSelect?: SelectCallback;
rootCloseEvent?: 'click' | 'mousedown';
popperConfig?: UseDropdownMenuOptions['popperConfig'];
}
declare type DropdownMenu = BsPrefixRefForwardingComponent<'div', DropdownMenuProps>;
export declare const alignPropType: PropTypes.Requireable<string | PropTypes.InferProps<{
sm: PropTypes.Requireable<string>;
}> | PropTypes.InferProps<{
md: PropTypes.Requireable<string>;
}> | PropTypes.InferProps<{
lg: PropTypes.Requireable<string>;
}> | PropTypes.InferProps<{
xl: PropTypes.Requireable<string>;
}>>;
declare const DropdownMenu: DropdownMenu;
export default DropdownMenu;

118
web/node_modules/react-bootstrap/esm/DropdownMenu.js generated vendored Normal file
View file

@ -0,0 +1,118 @@
import _extends from "@babel/runtime/helpers/esm/extends";
import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
var _excluded = ["bsPrefix", "className", "align", "alignRight", "rootCloseEvent", "flip", "show", "renderOnMount", "as", "popperConfig"];
import classNames from 'classnames';
import PropTypes from 'prop-types';
import React, { useContext } from 'react';
import { useDropdownMenu } from 'react-overlays/DropdownMenu';
import useMergedRefs from '@restart/hooks/useMergedRefs';
import warning from 'warning';
import NavbarContext from './NavbarContext';
import { useBootstrapPrefix } from './ThemeProvider';
import useWrappedRefWithWarning from './useWrappedRefWithWarning';
import usePopperMarginModifiers from './usePopperMarginModifiers';
var alignDirection = PropTypes.oneOf(['left', 'right']);
export var alignPropType = PropTypes.oneOfType([alignDirection, PropTypes.shape({
sm: alignDirection
}), PropTypes.shape({
md: alignDirection
}), PropTypes.shape({
lg: alignDirection
}), PropTypes.shape({
xl: alignDirection
})]);
var defaultProps = {
align: 'left',
alignRight: false,
flip: true
};
var DropdownMenu = /*#__PURE__*/React.forwardRef(function (_ref, ref) {
var bsPrefix = _ref.bsPrefix,
className = _ref.className,
align = _ref.align,
alignRight = _ref.alignRight,
rootCloseEvent = _ref.rootCloseEvent,
flip = _ref.flip,
showProps = _ref.show,
renderOnMount = _ref.renderOnMount,
_ref$as = _ref.as,
Component = _ref$as === void 0 ? 'div' : _ref$as,
popperConfig = _ref.popperConfig,
props = _objectWithoutPropertiesLoose(_ref, _excluded);
var isNavbar = useContext(NavbarContext);
var prefix = useBootstrapPrefix(bsPrefix, 'dropdown-menu');
var _usePopperMarginModif = usePopperMarginModifiers(),
popperRef = _usePopperMarginModif[0],
marginModifiers = _usePopperMarginModif[1];
var alignClasses = [];
if (align) {
if (typeof align === 'object') {
var keys = Object.keys(align);
process.env.NODE_ENV !== "production" ? warning(keys.length === 1, 'There should only be 1 breakpoint when passing an object to `align`') : void 0;
if (keys.length) {
var brkPoint = keys[0];
var direction = align[brkPoint]; // .dropdown-menu-right is required for responsively aligning
// left in addition to align left classes.
// Reuse alignRight to toggle the class below.
alignRight = direction === 'left';
alignClasses.push(prefix + "-" + brkPoint + "-" + direction);
}
} else if (align === 'right') {
alignRight = true;
}
}
var _useDropdownMenu = useDropdownMenu({
flip: flip,
rootCloseEvent: rootCloseEvent,
show: showProps,
alignEnd: alignRight,
usePopper: !isNavbar && alignClasses.length === 0,
popperConfig: _extends({}, popperConfig, {
modifiers: marginModifiers.concat((popperConfig == null ? void 0 : popperConfig.modifiers) || [])
})
}),
menuProps = _useDropdownMenu[0],
_useDropdownMenu$ = _useDropdownMenu[1],
hasShown = _useDropdownMenu$.hasShown,
popper = _useDropdownMenu$.popper,
show = _useDropdownMenu$.show,
alignEnd = _useDropdownMenu$.alignEnd,
toggle = _useDropdownMenu$.toggle;
menuProps.ref = useMergedRefs(popperRef, useMergedRefs(useWrappedRefWithWarning(ref, 'DropdownMenu'), menuProps.ref));
if (!hasShown && !renderOnMount) return null; // For custom components provide additional, non-DOM, props;
if (typeof Component !== 'string') {
menuProps.show = show;
menuProps.close = function () {
return toggle == null ? void 0 : toggle(false);
};
menuProps.alignRight = alignEnd;
}
var style = props.style;
if (popper != null && popper.placement) {
// we don't need the default popper style,
// menus are display: none when not shown.
style = _extends({}, props.style, menuProps.style);
props['x-placement'] = popper.placement;
}
return /*#__PURE__*/React.createElement(Component, _extends({}, props, menuProps, {
style: style,
className: classNames.apply(void 0, [className, prefix, show && 'show', alignEnd && prefix + "-right"].concat(alignClasses))
}));
});
DropdownMenu.displayName = 'DropdownMenu';
DropdownMenu.defaultProps = defaultProps;
export default DropdownMenu;

11
web/node_modules/react-bootstrap/esm/DropdownToggle.d.ts generated vendored Normal file
View file

@ -0,0 +1,11 @@
import React from 'react';
import { ButtonProps, CommonButtonProps } from './Button';
import { BsPrefixPropsWithChildren, BsPrefixRefForwardingComponent } from './helpers';
export interface DropdownToggleProps extends BsPrefixPropsWithChildren, ButtonProps {
split?: boolean;
childBsPrefix?: string;
}
declare type DropdownToggle = BsPrefixRefForwardingComponent<'button', DropdownToggleProps>;
export declare type PropsFromToggle = Partial<Pick<React.ComponentPropsWithRef<DropdownToggle>, CommonButtonProps>>;
declare const DropdownToggle: DropdownToggle;
export default DropdownToggle;

38
web/node_modules/react-bootstrap/esm/DropdownToggle.js generated vendored Normal file
View file

@ -0,0 +1,38 @@
import _extends from "@babel/runtime/helpers/esm/extends";
import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
var _excluded = ["bsPrefix", "split", "className", "childBsPrefix", "as"];
import classNames from 'classnames';
import isRequiredForA11y from 'prop-types-extra/lib/isRequiredForA11y';
import React from 'react';
import { useDropdownToggle } from 'react-overlays/DropdownToggle';
import useMergedRefs from '@restart/hooks/useMergedRefs';
import Button from './Button';
import { useBootstrapPrefix } from './ThemeProvider';
import useWrappedRefWithWarning from './useWrappedRefWithWarning';
var DropdownToggle = /*#__PURE__*/React.forwardRef(function (_ref, ref) {
var bsPrefix = _ref.bsPrefix,
split = _ref.split,
className = _ref.className,
childBsPrefix = _ref.childBsPrefix,
_ref$as = _ref.as,
Component = _ref$as === void 0 ? Button : _ref$as,
props = _objectWithoutPropertiesLoose(_ref, _excluded);
var prefix = useBootstrapPrefix(bsPrefix, 'dropdown-toggle');
if (childBsPrefix !== undefined) {
props.bsPrefix = childBsPrefix;
}
var _useDropdownToggle = useDropdownToggle(),
toggleProps = _useDropdownToggle[0];
toggleProps.ref = useMergedRefs(toggleProps.ref, useWrappedRefWithWarning(ref, 'DropdownToggle')); // This intentionally forwards size and variant (if set) to the
// underlying component, to allow it to render size and style variants.
return /*#__PURE__*/React.createElement(Component, _extends({
className: classNames(className, prefix, split && prefix + "-split")
}, toggleProps, props));
});
DropdownToggle.displayName = 'DropdownToggle';
export default DropdownToggle;

18
web/node_modules/react-bootstrap/esm/ElementChildren.d.ts generated vendored Normal file
View file

@ -0,0 +1,18 @@
import React from 'react';
/**
* Iterates through children that are typically specified as `props.children`,
* but only maps over children that are "valid elements".
*
* The mapFunction provided index will be normalised to the components mapped,
* so an invalid component would not increase the index.
*
*/
declare function map<P = any>(children: any, func: (el: React.ReactElement<P>, index: number) => any): any;
/**
* Iterates through children that are "valid elements".
*
* The provided forEachFunc(child, index) will be called for each
* leaf child with the index reflecting the position relative to "valid components".
*/
declare function forEach<P = any>(children: any, func: (el: React.ReactElement<P>, index: number) => void): void;
export { map, forEach };

32
web/node_modules/react-bootstrap/esm/ElementChildren.js generated vendored Normal file
View file

@ -0,0 +1,32 @@
import React from 'react';
/**
* Iterates through children that are typically specified as `props.children`,
* but only maps over children that are "valid elements".
*
* The mapFunction provided index will be normalised to the components mapped,
* so an invalid component would not increase the index.
*
*/
function map(children, func) {
var index = 0;
return React.Children.map(children, function (child) {
return /*#__PURE__*/React.isValidElement(child) ? func(child, index++) : child;
});
}
/**
* Iterates through children that are "valid elements".
*
* The provided forEachFunc(child, index) will be called for each
* leaf child with the index reflecting the position relative to "valid components".
*/
function forEach(children, func) {
var index = 0;
React.Children.forEach(children, function (child) {
if ( /*#__PURE__*/React.isValidElement(child)) func(child, index++);
});
}
export { map, forEach };

14
web/node_modules/react-bootstrap/esm/Fade.d.ts generated vendored Normal file
View file

@ -0,0 +1,14 @@
import React from 'react';
import Transition from 'react-transition-group/Transition';
import { TransitionCallbacks } from './helpers';
export interface FadeProps extends TransitionCallbacks {
className?: string;
in?: boolean;
mountOnEnter?: boolean;
unmountOnExit?: boolean;
appear?: boolean;
timeout?: number;
children: React.ReactElement;
}
declare const Fade: React.ForwardRefExoticComponent<FadeProps & React.RefAttributes<Transition<any>>>;
export default Fade;

42
web/node_modules/react-bootstrap/esm/Fade.js generated vendored Normal file
View file

@ -0,0 +1,42 @@
import _extends from "@babel/runtime/helpers/esm/extends";
import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
var _excluded = ["className", "children"];
var _fadeStyles;
import classNames from 'classnames';
import React, { useCallback } from 'react';
import Transition, { ENTERED, ENTERING } from 'react-transition-group/Transition';
import transitionEndListener from './transitionEndListener';
import triggerBrowserReflow from './triggerBrowserReflow';
var defaultProps = {
in: false,
timeout: 300,
mountOnEnter: false,
unmountOnExit: false,
appear: false
};
var fadeStyles = (_fadeStyles = {}, _fadeStyles[ENTERING] = 'show', _fadeStyles[ENTERED] = 'show', _fadeStyles);
var Fade = /*#__PURE__*/React.forwardRef(function (_ref, ref) {
var className = _ref.className,
children = _ref.children,
props = _objectWithoutPropertiesLoose(_ref, _excluded);
var handleEnter = useCallback(function (node) {
triggerBrowserReflow(node);
if (props.onEnter) props.onEnter(node);
}, [props]);
return /*#__PURE__*/React.createElement(Transition, _extends({
ref: ref,
addEndListener: transitionEndListener
}, props, {
onEnter: handleEnter
}), function (status, innerProps) {
return /*#__PURE__*/React.cloneElement(children, _extends({}, innerProps, {
className: classNames('fade', className, children.props.className, fadeStyles[status])
}));
});
});
Fade.defaultProps = defaultProps;
Fade.displayName = 'Fade';
export default Fade;

10
web/node_modules/react-bootstrap/esm/Feedback.d.ts generated vendored Normal file
View file

@ -0,0 +1,10 @@
import { BsPrefixProps, BsPrefixRefForwardingComponent } from './helpers';
export interface FeedbackProps extends BsPrefixProps {
className?: string;
bsPrefix?: never;
type?: 'valid' | 'invalid';
tooltip?: boolean;
}
declare type Feedback = BsPrefixRefForwardingComponent<'div', FeedbackProps>;
declare const Feedback: Feedback;
export default Feedback;

37
web/node_modules/react-bootstrap/esm/Feedback.js generated vendored Normal file
View file

@ -0,0 +1,37 @@
import _extends from "@babel/runtime/helpers/esm/extends";
import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
var _excluded = ["as", "className", "type", "tooltip"];
import classNames from 'classnames';
import React from 'react';
import PropTypes from 'prop-types';
var propTypes = {
/**
* Specify whether the feedback is for valid or invalid fields
*
* @type {('valid'|'invalid')}
*/
type: PropTypes.string,
/** Display feedback as a tooltip. */
tooltip: PropTypes.bool,
as: PropTypes.elementType
};
var Feedback = /*#__PURE__*/React.forwardRef( // Need to define the default "as" during prop destructuring to be compatible with styled-components github.com/react-bootstrap/react-bootstrap/issues/3595
function (_ref, ref) {
var _ref$as = _ref.as,
Component = _ref$as === void 0 ? 'div' : _ref$as,
className = _ref.className,
_ref$type = _ref.type,
type = _ref$type === void 0 ? 'valid' : _ref$type,
_ref$tooltip = _ref.tooltip,
tooltip = _ref$tooltip === void 0 ? false : _ref$tooltip,
props = _objectWithoutPropertiesLoose(_ref, _excluded);
return /*#__PURE__*/React.createElement(Component, _extends({}, props, {
ref: ref,
className: classNames(className, type + "-" + (tooltip ? 'tooltip' : 'feedback'))
}));
});
Feedback.displayName = 'Feedback';
Feedback.propTypes = propTypes;
export default Feedback;

9
web/node_modules/react-bootstrap/esm/Figure.d.ts generated vendored Normal file
View file

@ -0,0 +1,9 @@
import { BsPrefixRefForwardingComponent } from './helpers';
import FigureImage from './FigureImage';
import FigureCaption from './FigureCaption';
declare type Figure = BsPrefixRefForwardingComponent<'figure'> & {
Image: typeof FigureImage;
Caption: typeof FigureCaption;
};
declare const Figure: Figure;
export default Figure;

9
web/node_modules/react-bootstrap/esm/Figure.js generated vendored Normal file
View file

@ -0,0 +1,9 @@
import createWithBsPrefix from './createWithBsPrefix';
import FigureImage from './FigureImage';
import FigureCaption from './FigureCaption';
var Figure = createWithBsPrefix('figure', {
Component: 'figure'
});
Figure.Image = FigureImage;
Figure.Caption = FigureCaption;
export default Figure;

2
web/node_modules/react-bootstrap/esm/FigureCaption.d.ts generated vendored Normal file
View file

@ -0,0 +1,2 @@
declare const FigureCaption: import("./helpers").BsPrefixRefForwardingComponent<"figcaption", unknown>;
export default FigureCaption;

5
web/node_modules/react-bootstrap/esm/FigureCaption.js generated vendored Normal file
View file

@ -0,0 +1,5 @@
import createWithBsPrefix from './createWithBsPrefix';
var FigureCaption = createWithBsPrefix('figure-caption', {
Component: 'figcaption'
});
export default FigureCaption;

4
web/node_modules/react-bootstrap/esm/FigureImage.d.ts generated vendored Normal file
View file

@ -0,0 +1,4 @@
import React from 'react';
import { ImageProps } from './Image';
declare const FigureImage: React.ForwardRefExoticComponent<ImageProps & React.RefAttributes<HTMLImageElement>>;
export default FigureImage;

23
web/node_modules/react-bootstrap/esm/FigureImage.js generated vendored Normal file
View file

@ -0,0 +1,23 @@
import _extends from "@babel/runtime/helpers/esm/extends";
import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
var _excluded = ["className"];
import classNames from 'classnames';
import React from 'react';
import Image, { propTypes as imagePropTypes } from './Image';
var defaultProps = {
fluid: true
};
var FigureImage = /*#__PURE__*/React.forwardRef(function (_ref, ref) {
var className = _ref.className,
props = _objectWithoutPropertiesLoose(_ref, _excluded);
return /*#__PURE__*/React.createElement(Image, _extends({
ref: ref
}, props, {
className: classNames(className, 'figure-img')
}));
});
FigureImage.displayName = 'FigureImage';
FigureImage.propTypes = imagePropTypes;
FigureImage.defaultProps = defaultProps;
export default FigureImage;

9
web/node_modules/react-bootstrap/esm/FloatingLabel.d.ts generated vendored Normal file
View file

@ -0,0 +1,9 @@
import * as React from 'react';
import { FormGroupProps } from './FormGroup';
import { BsPrefixProps, BsPrefixRefForwardingComponent } from './helpers';
export interface FloatingLabelProps extends FormGroupProps, BsPrefixProps {
controlId?: string;
label: React.ReactNode;
}
declare const FloatingLabel: BsPrefixRefForwardingComponent<'div', FloatingLabelProps>;
export default FloatingLabel;

26
web/node_modules/react-bootstrap/esm/Form.d.ts generated vendored Normal file
View file

@ -0,0 +1,26 @@
import React from 'react';
import FormCheck from './FormCheck';
import FormFile from './FormFile';
import FormControl from './FormControl';
import FormGroup from './FormGroup';
import FormLabel from './FormLabel';
import FormText from './FormText';
import Switch from './Switch';
import { BsPrefixProps, BsPrefixRefForwardingComponent } from './helpers';
declare const FormRow: BsPrefixRefForwardingComponent<"div", unknown>;
export interface FormProps extends React.HTMLAttributes<HTMLFormElement>, BsPrefixProps {
inline?: boolean;
validated?: boolean;
}
declare type Form = BsPrefixRefForwardingComponent<'form', FormProps> & {
Row: typeof FormRow;
Group: typeof FormGroup;
Control: typeof FormControl;
Check: typeof FormCheck;
File: typeof FormFile;
Switch: typeof Switch;
Label: typeof FormLabel;
Text: typeof FormText;
};
declare const FormImpl: Form;
export default FormImpl;

44
web/node_modules/react-bootstrap/esm/Form.js generated vendored Normal file
View file

@ -0,0 +1,44 @@
import _extends from "@babel/runtime/helpers/esm/extends";
import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
var _excluded = ["bsPrefix", "inline", "className", "validated", "as"];
import classNames from 'classnames';
import React from 'react';
import FormCheck from './FormCheck';
import FormFile from './FormFile';
import FormControl from './FormControl';
import FormGroup from './FormGroup';
import FormLabel from './FormLabel';
import FormText from './FormText';
import Switch from './Switch';
import { useBootstrapPrefix } from './ThemeProvider';
import createWithBsPrefix from './createWithBsPrefix';
var FormRow = createWithBsPrefix('form-row');
var defaultProps = {
inline: false
};
var FormImpl = /*#__PURE__*/React.forwardRef(function (_ref, ref) {
var bsPrefix = _ref.bsPrefix,
inline = _ref.inline,
className = _ref.className,
validated = _ref.validated,
_ref$as = _ref.as,
Component = _ref$as === void 0 ? 'form' : _ref$as,
props = _objectWithoutPropertiesLoose(_ref, _excluded);
bsPrefix = useBootstrapPrefix(bsPrefix, 'form');
return /*#__PURE__*/React.createElement(Component, _extends({}, props, {
ref: ref,
className: classNames(className, validated && 'was-validated', inline && bsPrefix + "-inline")
}));
});
FormImpl.displayName = 'Form';
FormImpl.defaultProps = defaultProps;
FormImpl.Row = FormRow;
FormImpl.Group = FormGroup;
FormImpl.Control = FormControl;
FormImpl.Check = FormCheck;
FormImpl.File = FormFile;
FormImpl.Switch = Switch;
FormImpl.Label = FormLabel;
FormImpl.Text = FormText;
export default FormImpl;

23
web/node_modules/react-bootstrap/esm/FormCheck.d.ts generated vendored Normal file
View file

@ -0,0 +1,23 @@
import React from 'react';
import FormCheckInput from './FormCheckInput';
import FormCheckLabel from './FormCheckLabel';
import { BsPrefixPropsWithChildren, BsPrefixRefForwardingComponent } from './helpers';
export declare type FormCheckType = 'checkbox' | 'radio' | 'switch';
export interface FormCheckProps extends BsPrefixPropsWithChildren, React.InputHTMLAttributes<HTMLInputElement> {
bsCustomPrefix?: string;
inline?: boolean;
disabled?: boolean;
label?: React.ReactNode;
custom?: boolean;
type?: FormCheckType;
isValid?: boolean;
isInvalid?: boolean;
feedbackTooltip?: boolean;
feedback?: React.ReactNode;
}
declare type FormCheck = BsPrefixRefForwardingComponent<'input', FormCheckProps> & {
Input: typeof FormCheckInput;
Label: typeof FormCheckLabel;
};
declare const FormCheck: FormCheck;
export default FormCheck;

82
web/node_modules/react-bootstrap/esm/FormCheck.js generated vendored Normal file
View file

@ -0,0 +1,82 @@
import _extends from "@babel/runtime/helpers/esm/extends";
import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
var _excluded = ["id", "bsPrefix", "bsCustomPrefix", "inline", "disabled", "isValid", "isInvalid", "feedbackTooltip", "feedback", "className", "style", "title", "type", "label", "children", "custom", "as"];
import classNames from 'classnames';
import all from 'prop-types-extra/lib/all';
import React, { useContext, useMemo } from 'react';
import Feedback from './Feedback';
import FormCheckInput from './FormCheckInput';
import FormCheckLabel from './FormCheckLabel';
import FormContext from './FormContext';
import { useBootstrapPrefix } from './ThemeProvider';
var FormCheck = /*#__PURE__*/React.forwardRef(function (_ref, ref) {
var id = _ref.id,
bsPrefix = _ref.bsPrefix,
bsCustomPrefix = _ref.bsCustomPrefix,
_ref$inline = _ref.inline,
inline = _ref$inline === void 0 ? false : _ref$inline,
_ref$disabled = _ref.disabled,
disabled = _ref$disabled === void 0 ? false : _ref$disabled,
_ref$isValid = _ref.isValid,
isValid = _ref$isValid === void 0 ? false : _ref$isValid,
_ref$isInvalid = _ref.isInvalid,
isInvalid = _ref$isInvalid === void 0 ? false : _ref$isInvalid,
_ref$feedbackTooltip = _ref.feedbackTooltip,
feedbackTooltip = _ref$feedbackTooltip === void 0 ? false : _ref$feedbackTooltip,
feedback = _ref.feedback,
className = _ref.className,
style = _ref.style,
_ref$title = _ref.title,
title = _ref$title === void 0 ? '' : _ref$title,
_ref$type = _ref.type,
type = _ref$type === void 0 ? 'checkbox' : _ref$type,
label = _ref.label,
children = _ref.children,
propCustom = _ref.custom,
_ref$as = _ref.as,
as = _ref$as === void 0 ? 'input' : _ref$as,
props = _objectWithoutPropertiesLoose(_ref, _excluded);
var custom = type === 'switch' ? true : propCustom;
var _ref2 = custom ? [bsCustomPrefix, 'custom-control'] : [bsPrefix, 'form-check'],
prefix = _ref2[0],
defaultPrefix = _ref2[1];
bsPrefix = useBootstrapPrefix(prefix, defaultPrefix);
var _useContext = useContext(FormContext),
controlId = _useContext.controlId;
var innerFormContext = useMemo(function () {
return {
controlId: id || controlId,
custom: custom
};
}, [controlId, custom, id]);
var hasLabel = custom || label != null && label !== false && !children;
var input = /*#__PURE__*/React.createElement(FormCheckInput, _extends({}, props, {
type: type === 'switch' ? 'checkbox' : type,
ref: ref,
isValid: isValid,
isInvalid: isInvalid,
isStatic: !hasLabel,
disabled: disabled,
as: as
}));
return /*#__PURE__*/React.createElement(FormContext.Provider, {
value: innerFormContext
}, /*#__PURE__*/React.createElement("div", {
style: style,
className: classNames(className, bsPrefix, custom && "custom-" + type, inline && bsPrefix + "-inline")
}, children || /*#__PURE__*/React.createElement(React.Fragment, null, input, hasLabel && /*#__PURE__*/React.createElement(FormCheckLabel, {
title: title
}, label), (isValid || isInvalid) && /*#__PURE__*/React.createElement(Feedback, {
type: isValid ? 'valid' : 'invalid',
tooltip: feedbackTooltip
}, feedback))));
});
FormCheck.displayName = 'FormCheck';
FormCheck.Input = FormCheckInput;
FormCheck.Label = FormCheckLabel;
export default FormCheck;

13
web/node_modules/react-bootstrap/esm/FormCheckInput.d.ts generated vendored Normal file
View file

@ -0,0 +1,13 @@
import { BsPrefixProps, BsPrefixRefForwardingComponent } from './helpers';
declare type FormCheckInputType = 'checkbox' | 'radio';
export interface FormCheckInputProps extends BsPrefixProps {
id?: string;
bsCustomPrefix?: string;
type?: FormCheckInputType;
isStatic?: boolean;
isValid?: boolean;
isInvalid?: boolean;
}
declare type FormCheckInput = BsPrefixRefForwardingComponent<'input', FormCheckInputProps>;
declare const FormCheckInput: FormCheckInput;
export default FormCheckInput;

41
web/node_modules/react-bootstrap/esm/FormCheckInput.js generated vendored Normal file
View file

@ -0,0 +1,41 @@
import _extends from "@babel/runtime/helpers/esm/extends";
import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
var _excluded = ["id", "bsPrefix", "bsCustomPrefix", "className", "type", "isValid", "isInvalid", "isStatic", "as"];
import classNames from 'classnames';
import React, { useContext } from 'react';
import FormContext from './FormContext';
import { useBootstrapPrefix } from './ThemeProvider';
var FormCheckInput = /*#__PURE__*/React.forwardRef(function (_ref, ref) {
var id = _ref.id,
bsPrefix = _ref.bsPrefix,
bsCustomPrefix = _ref.bsCustomPrefix,
className = _ref.className,
_ref$type = _ref.type,
type = _ref$type === void 0 ? 'checkbox' : _ref$type,
_ref$isValid = _ref.isValid,
isValid = _ref$isValid === void 0 ? false : _ref$isValid,
_ref$isInvalid = _ref.isInvalid,
isInvalid = _ref$isInvalid === void 0 ? false : _ref$isInvalid,
isStatic = _ref.isStatic,
_ref$as = _ref.as,
Component = _ref$as === void 0 ? 'input' : _ref$as,
props = _objectWithoutPropertiesLoose(_ref, _excluded);
var _useContext = useContext(FormContext),
controlId = _useContext.controlId,
custom = _useContext.custom;
var _ref2 = custom ? [bsCustomPrefix, 'custom-control-input'] : [bsPrefix, 'form-check-input'],
prefix = _ref2[0],
defaultPrefix = _ref2[1];
bsPrefix = useBootstrapPrefix(prefix, defaultPrefix);
return /*#__PURE__*/React.createElement(Component, _extends({}, props, {
ref: ref,
type: type,
id: id || controlId,
className: classNames(className, bsPrefix, isValid && 'is-valid', isInvalid && 'is-invalid', isStatic && 'position-static')
}));
});
FormCheckInput.displayName = 'FormCheckInput';
export default FormCheckInput;

7
web/node_modules/react-bootstrap/esm/FormCheckLabel.d.ts generated vendored Normal file
View file

@ -0,0 +1,7 @@
import React from 'react';
import { BsPrefixProps } from './helpers';
export interface FormCheckLabelProps extends React.LabelHTMLAttributes<HTMLLabelElement>, BsPrefixProps {
bsCustomPrefix?: string;
}
declare const FormCheckLabel: React.ForwardRefExoticComponent<FormCheckLabelProps & React.RefAttributes<HTMLLabelElement>>;
export default FormCheckLabel;

31
web/node_modules/react-bootstrap/esm/FormCheckLabel.js generated vendored Normal file
View file

@ -0,0 +1,31 @@
import _extends from "@babel/runtime/helpers/esm/extends";
import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
var _excluded = ["bsPrefix", "bsCustomPrefix", "className", "htmlFor"];
import classNames from 'classnames';
import React, { useContext } from 'react';
import FormContext from './FormContext';
import { useBootstrapPrefix } from './ThemeProvider';
var FormCheckLabel = /*#__PURE__*/React.forwardRef(function (_ref, ref) {
var bsPrefix = _ref.bsPrefix,
bsCustomPrefix = _ref.bsCustomPrefix,
className = _ref.className,
htmlFor = _ref.htmlFor,
props = _objectWithoutPropertiesLoose(_ref, _excluded);
var _useContext = useContext(FormContext),
controlId = _useContext.controlId,
custom = _useContext.custom;
var _ref2 = custom ? [bsCustomPrefix, 'custom-control-label'] : [bsPrefix, 'form-check-label'],
prefix = _ref2[0],
defaultPrefix = _ref2[1];
bsPrefix = useBootstrapPrefix(prefix, defaultPrefix);
return /*#__PURE__*/React.createElement("label", _extends({}, props, {
ref: ref,
htmlFor: htmlFor || controlId,
className: classNames(className, bsPrefix)
}));
});
FormCheckLabel.displayName = 'FormCheckLabel';
export default FormCheckLabel;

7
web/node_modules/react-bootstrap/esm/FormContext.d.ts generated vendored Normal file
View file

@ -0,0 +1,7 @@
import React from 'react';
interface FormContextType {
controlId: any;
custom?: boolean;
}
declare const FormContext: React.Context<FormContextType>;
export default FormContext;

6
web/node_modules/react-bootstrap/esm/FormContext.js generated vendored Normal file
View file

@ -0,0 +1,6 @@
import React from 'react'; // TODO
var FormContext = /*#__PURE__*/React.createContext({
controlId: undefined
});
export default FormContext;

23
web/node_modules/react-bootstrap/esm/FormControl.d.ts generated vendored Normal file
View file

@ -0,0 +1,23 @@
import React from 'react';
import Feedback from './Feedback';
import { BsPrefixProps, BsPrefixRefForwardingComponent } from './helpers';
declare type FormControlElement = HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement;
export interface FormControlProps extends BsPrefixProps {
bsCustomPrefix?: string;
htmlSize?: number;
size?: 'sm' | 'lg';
plaintext?: boolean;
readOnly?: boolean;
disabled?: boolean;
value?: string | string[] | number;
onChange?: React.ChangeEventHandler<FormControlElement>;
custom?: boolean;
type?: string;
id?: string;
isValid?: boolean;
isInvalid?: boolean;
}
declare const _default: BsPrefixRefForwardingComponent<"input", FormControlProps> & {
Feedback: Feedback;
};
export default _default;

75
web/node_modules/react-bootstrap/esm/FormControl.js generated vendored Normal file
View file

@ -0,0 +1,75 @@
import _extends from "@babel/runtime/helpers/esm/extends";
import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
var _excluded = ["bsPrefix", "bsCustomPrefix", "type", "size", "htmlSize", "id", "className", "isValid", "isInvalid", "plaintext", "readOnly", "custom", "as"];
import classNames from 'classnames';
import all from 'prop-types-extra/lib/all';
import React, { useContext } from 'react';
import warning from 'warning';
import Feedback from './Feedback';
import FormContext from './FormContext';
import { useBootstrapPrefix } from './ThemeProvider';
var FormControl = /*#__PURE__*/React.forwardRef(function (_ref, ref) {
var bsPrefix = _ref.bsPrefix,
bsCustomPrefix = _ref.bsCustomPrefix,
type = _ref.type,
size = _ref.size,
htmlSize = _ref.htmlSize,
id = _ref.id,
className = _ref.className,
_ref$isValid = _ref.isValid,
isValid = _ref$isValid === void 0 ? false : _ref$isValid,
_ref$isInvalid = _ref.isInvalid,
isInvalid = _ref$isInvalid === void 0 ? false : _ref$isInvalid,
plaintext = _ref.plaintext,
readOnly = _ref.readOnly,
custom = _ref.custom,
_ref$as = _ref.as,
Component = _ref$as === void 0 ? 'input' : _ref$as,
props = _objectWithoutPropertiesLoose(_ref, _excluded);
var _useContext = useContext(FormContext),
controlId = _useContext.controlId;
var _ref2 = custom ? [bsCustomPrefix, 'custom'] : [bsPrefix, 'form-control'],
prefix = _ref2[0],
defaultPrefix = _ref2[1];
bsPrefix = useBootstrapPrefix(prefix, defaultPrefix);
var classes;
if (plaintext) {
var _classes;
classes = (_classes = {}, _classes[bsPrefix + "-plaintext"] = true, _classes);
} else if (type === 'file') {
var _classes2;
classes = (_classes2 = {}, _classes2[bsPrefix + "-file"] = true, _classes2);
} else if (type === 'range') {
var _classes3;
classes = (_classes3 = {}, _classes3[bsPrefix + "-range"] = true, _classes3);
} else if (Component === 'select' && custom) {
var _classes4;
classes = (_classes4 = {}, _classes4[bsPrefix + "-select"] = true, _classes4[bsPrefix + "-select-" + size] = size, _classes4);
} else {
var _classes5;
classes = (_classes5 = {}, _classes5[bsPrefix] = true, _classes5[bsPrefix + "-" + size] = size, _classes5);
}
process.env.NODE_ENV !== "production" ? warning(controlId == null || !id, '`controlId` is ignored on `<FormControl>` when `id` is specified.') : void 0;
return /*#__PURE__*/React.createElement(Component, _extends({}, props, {
type: type,
size: htmlSize,
ref: ref,
readOnly: readOnly,
id: id || controlId,
className: classNames(className, classes, isValid && "is-valid", isInvalid && "is-invalid")
}));
});
FormControl.displayName = 'FormControl';
export default Object.assign(FormControl, {
Feedback: Feedback
});

23
web/node_modules/react-bootstrap/esm/FormFile.d.ts generated vendored Normal file
View file

@ -0,0 +1,23 @@
import React from 'react';
import FormFileInput from './FormFileInput';
import FormFileLabel from './FormFileLabel';
import { BsCustomPrefixProps, BsPrefixPropsWithChildren, BsPrefixRefForwardingComponent } from './helpers';
export interface FormFileProps extends BsPrefixPropsWithChildren, BsCustomPrefixProps, Pick<React.HTMLAttributes<HTMLElement>, 'style'> {
inputAs?: React.ElementType;
id?: string;
disabled?: boolean;
label?: React.ReactNode;
custom?: boolean;
isValid?: boolean;
isInvalid?: boolean;
feedback?: React.ReactNode;
feedbackTooltip?: boolean;
lang?: string;
'data-browse'?: any;
}
declare type FormFile = BsPrefixRefForwardingComponent<'input', FormFileProps> & {
Input: typeof FormFileInput;
Label: typeof FormFileLabel;
};
declare const FormFile: FormFile;
export default FormFile;

78
web/node_modules/react-bootstrap/esm/FormFile.js generated vendored Normal file
View file

@ -0,0 +1,78 @@
import _extends from "@babel/runtime/helpers/esm/extends";
import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
var _excluded = ["id", "bsPrefix", "bsCustomPrefix", "disabled", "isValid", "isInvalid", "feedbackTooltip", "feedback", "className", "style", "label", "children", "custom", "lang", "data-browse", "as", "inputAs"];
import classNames from 'classnames';
import React, { useContext, useMemo } from 'react';
import all from 'prop-types-extra/lib/all';
import Feedback from './Feedback';
import FormFileInput from './FormFileInput';
import FormFileLabel from './FormFileLabel';
import FormContext from './FormContext';
import { useBootstrapPrefix } from './ThemeProvider';
var FormFile = /*#__PURE__*/React.forwardRef(function (_ref, ref) {
var id = _ref.id,
bsPrefix = _ref.bsPrefix,
bsCustomPrefix = _ref.bsCustomPrefix,
_ref$disabled = _ref.disabled,
disabled = _ref$disabled === void 0 ? false : _ref$disabled,
_ref$isValid = _ref.isValid,
isValid = _ref$isValid === void 0 ? false : _ref$isValid,
_ref$isInvalid = _ref.isInvalid,
isInvalid = _ref$isInvalid === void 0 ? false : _ref$isInvalid,
_ref$feedbackTooltip = _ref.feedbackTooltip,
feedbackTooltip = _ref$feedbackTooltip === void 0 ? false : _ref$feedbackTooltip,
feedback = _ref.feedback,
className = _ref.className,
style = _ref.style,
label = _ref.label,
children = _ref.children,
custom = _ref.custom,
lang = _ref.lang,
dataBrowse = _ref['data-browse'],
_ref$as = _ref.as,
Component = _ref$as === void 0 ? 'div' : _ref$as,
_ref$inputAs = _ref.inputAs,
inputAs = _ref$inputAs === void 0 ? 'input' : _ref$inputAs,
props = _objectWithoutPropertiesLoose(_ref, _excluded);
var _ref2 = custom ? [bsCustomPrefix, 'custom'] : [bsPrefix, 'form-file'],
prefix = _ref2[0],
defaultPrefix = _ref2[1];
bsPrefix = useBootstrapPrefix(prefix, defaultPrefix);
var type = 'file';
var _useContext = useContext(FormContext),
controlId = _useContext.controlId;
var innerFormContext = useMemo(function () {
return {
controlId: id || controlId,
custom: custom
};
}, [controlId, custom, id]);
var hasLabel = label != null && label !== false && !children;
var input = /*#__PURE__*/React.createElement(FormFileInput, _extends({}, props, {
ref: ref,
isValid: isValid,
isInvalid: isInvalid,
disabled: disabled,
as: inputAs,
lang: lang
}));
return /*#__PURE__*/React.createElement(FormContext.Provider, {
value: innerFormContext
}, /*#__PURE__*/React.createElement(Component, {
style: style,
className: classNames(className, bsPrefix, custom && "custom-" + type)
}, children || /*#__PURE__*/React.createElement(React.Fragment, null, custom ? /*#__PURE__*/React.createElement(React.Fragment, null, input, hasLabel && /*#__PURE__*/React.createElement(FormFileLabel, {
"data-browse": dataBrowse
}, label)) : /*#__PURE__*/React.createElement(React.Fragment, null, hasLabel && /*#__PURE__*/React.createElement(FormFileLabel, null, label), input), (isValid || isInvalid) && /*#__PURE__*/React.createElement(Feedback, {
type: isValid ? 'valid' : 'invalid',
tooltip: feedbackTooltip
}, feedback))));
});
FormFile.displayName = 'FormFile';
FormFile.Input = FormFileInput;
FormFile.Label = FormFileLabel;
export default FormFile;

Some files were not shown because too many files have changed in this diff Show more