@instructure/ui-time-select 11.7.2-snapshot-48 → 11.7.2-snapshot-50

package/CHANGELOG.md

@@ -3,9 +3,19 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
-## [11.7.2-snapshot-48](https://github.com/instructure/instructure-ui/compare/v11.7.1...v11.7.2-snapshot-48) (2026-04-16)
+## [11.7.2-snapshot-50](https://github.com/instructure/instructure-ui/compare/v11.7.1...v11.7.2-snapshot-50) (2026-04-21)
 
-**Note:** Version bump only for package @instructure/ui-time-select
+
+### Features
+
+* **many:** rework Select, SimpleSelect and TimeSelect ([fb95519](https://github.com/instructure/instructure-ui/commit/fb9551958326bdc8e95d55075c27c7e078c0c69c))
+
+
+### BREAKING CHANGES
+
+* **many:** contains breaking changes due to component using the new theming system
+
+INSTUI-4807
 
 
 

package/es/TimeSelect/v2/index.js

@@ -0,0 +1,535 @@
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+const _excluded = ["value", "defaultValue", "placeholder", "renderLabel", "inputRef", "id", "listRef", "renderBeforeInput", "renderAfterInput", "isRequired", "isInline", "width", "format", "step", "optionsMaxWidth", "visibleOptionsCount", "messages", "placement", "constrain", "onFocus", "onShowOptions", "onHideOptions", "onInputChange", "onKeyDown", "mountNode"];
+var _dec, _class, _TimeSelect;
+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2015 - present Instructure, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+import { Component } from 'react';
+import { ApplyLocaleContext, Locale, DateTime } from '@instructure/ui-i18n';
+import { getInteraction, passthroughProps, callRenderProp, withDeterministicId } from '@instructure/ui-react-utils';
+import { Select } from '@instructure/ui-select/latest';
+import * as utils from '@instructure/ui-utils';
+import { allowedProps } from "./props.js";
+import { jsx as _jsx } from "@emotion/react/jsx-runtime";
+/**
+---
+category: components
+---
+
+A component used to select a time value.
+ **/
+let TimeSelect = (_dec = withDeterministicId(), _dec(_class = (_TimeSelect = class TimeSelect extends Component {
+  constructor(props) {
+    super(props);
+    this.ref = null;
+    this._emptyOptionId = this.props.deterministicId('Select-EmptyOption');
+    this.getOption = (field, value, options = this.state.options) => {
+      return options.find(option => option[field] === value);
+    };
+    this.handleRef = node => {
+      this.ref = node;
+    };
+    this.handleBlur = event => {
+      var _this$props$onBlur, _this$props;
+      (_this$props$onBlur = (_this$props = this.props).onBlur) === null || _this$props$onBlur === void 0 ? void 0 : _this$props$onBlur.call(_this$props, event);
+    };
+    this.handleInputChange = event => {
+      var _this$props$onInputCh, _this$props3;
+      const value = event.target.value;
+      const newOptions = this.filterOptions(value);
+      if ((newOptions === null || newOptions === void 0 ? void 0 : newOptions.length) == 1) {
+        // if there is only 1 option, it will be automatically selected except
+        // if in controlled mode (it would commit this change)
+        if (!this.isControlled) {
+          this.setState({
+            selectedOptionId: newOptions[0].id
+          });
+        }
+        this.setState({
+          fireChangeOnBlur: newOptions[0]
+        });
+      } else {
+        this.setState({
+          fireChangeOnBlur: void 0,
+          isInputCleared: this.props.allowClearingSelection && value === ''
+        });
+      }
+      this.setState({
+        inputValue: value,
+        filteredOptions: newOptions,
+        highlightedOptionId: newOptions.length > 0 ? newOptions[0].id : void 0,
+        isShowingOptions: true
+      });
+      if (!this.state.isShowingOptions) {
+        var _this$props$onShowOpt, _this$props2;
+        (_this$props$onShowOpt = (_this$props2 = this.props).onShowOptions) === null || _this$props$onShowOpt === void 0 ? void 0 : _this$props$onShowOpt.call(_this$props2, event);
+      }
+      const inputAsDate = this.parseInputText(value);
+      (_this$props$onInputCh = (_this$props3 = this.props).onInputChange) === null || _this$props$onInputCh === void 0 ? void 0 : _this$props$onInputCh.call(_this$props3, event, value, inputAsDate.isValid() ? inputAsDate.toISOString() : void 0);
+    };
+    this.onKeyDown = event => {
+      var _this$props$onKeyDown, _this$props4;
+      const input = this.parseInputText(this.state.inputValue);
+      if (event.key === 'Enter' && this.props.allowNonStepInput && input.isValid()) {
+        this.setState(() => ({
+          isShowingOptions: false,
+          highlightedOptionId: void 0
+        }));
+        // others are set in handleBlurOrEsc
+      }
+      (_this$props$onKeyDown = (_this$props4 = this.props).onKeyDown) === null || _this$props$onKeyDown === void 0 ? void 0 : _this$props$onKeyDown.call(_this$props4, event);
+    };
+    this.handleShowOptions = event => {
+      var _this$props$onShowOpt2, _this$props5;
+      this.setState({
+        isShowingOptions: true,
+        highlightedOptionId: this.state.selectedOptionId
+      });
+      (_this$props$onShowOpt2 = (_this$props5 = this.props).onShowOptions) === null || _this$props$onShowOpt2 === void 0 ? void 0 : _this$props$onShowOpt2.call(_this$props5, event);
+      if (event.type.startsWith('key')) {
+        const keyboardEvent = event;
+        const children = this.state.filteredOptions;
+        if (!this.state.inputValue && children.length > 0 && !this.props.allowClearingSelection) {
+          const optionId = keyboardEvent.key === 'ArrowDown' ? children[0].id : keyboardEvent.key === 'ArrowUp' ? children[children.length - 1].id : void 0;
+          optionId && this.setState({
+            highlightedOptionId: optionId
+          });
+        }
+      }
+    };
+    // Called when the input is blurred (=when clicking outside, tabbing away),
+    // when pressing ESC. NOT called when an item is selected via Enter/click,
+    // (but in this case it will be called later when the input is blurred.)
+    this.handleBlurOrEsc = event => {
+      var _this$props$onHideOpt, _this$props8;
+      const _this$state = this.state,
+        selectedOptionId = _this$state.selectedOptionId,
+        inputValue = _this$state.inputValue,
+        isInputCleared = _this$state.isInputCleared;
+      let defaultValue = '';
+      if (this.props.defaultValue) {
+        const date = DateTime.parse(this.props.defaultValue, this.locale(), this.timezone());
+        defaultValue = this.props.format ? date.format(this.props.format) : date.toISOString();
+      }
+      const selectedOption = this.getOption('id', selectedOptionId);
+      let newInputValue = defaultValue;
+      // if input was completely cleared, ensure it stays clear
+      // e.g. defaultValue defined, but no selection yet made
+      if (inputValue === '' && this.props.allowClearingSelection) {
+        newInputValue = '';
+      } else if (selectedOption) {
+        // If there is a selected option use its value in the input field.
+        newInputValue = selectedOption.label;
+      } else if (this.props.value) {
+        // If controlled and input is cleared and blurred after the first render, it should revert to value
+        const date = DateTime.parse(this.props.value, this.locale(), this.timezone());
+        newInputValue = this.props.format ? date.format(this.props.format) : date.toISOString();
+      }
+      this.setState(() => ({
+        isShowingOptions: false,
+        highlightedOptionId: void 0,
+        inputValue: newInputValue,
+        filteredOptions: this.filterOptions('')
+      }));
+      if (this.state.fireChangeOnBlur && event.key !== 'Escape') {
+        var _this$props$onChange, _this$props6;
+        this.setState(() => ({
+          fireChangeOnBlur: void 0
+        }));
+        (_this$props$onChange = (_this$props6 = this.props).onChange) === null || _this$props$onChange === void 0 ? void 0 : _this$props$onChange.call(_this$props6, event, {
+          value: this.state.fireChangeOnBlur.value.toISOString(),
+          inputText: this.state.fireChangeOnBlur.label
+        });
+      } else if (isInputCleared && event.key !== 'Escape' && this.props.allowClearingSelection) {
+        var _this$props$onChange2, _this$props7;
+        this.setState(() => ({
+          isInputCleared: false
+        }));
+        (_this$props$onChange2 = (_this$props7 = this.props).onChange) === null || _this$props$onChange2 === void 0 ? void 0 : _this$props$onChange2.call(_this$props7, event, {
+          value: '',
+          inputText: ''
+        });
+      }
+      // TODO only fire this if handleSelectOption was not called before.
+      (_this$props$onHideOpt = (_this$props8 = this.props).onHideOptions) === null || _this$props$onHideOpt === void 0 ? void 0 : _this$props$onHideOpt.call(_this$props8, event);
+    };
+    // Called when an option is selected via mouse click or Enter.
+    this.handleSelectOption = (event, data) => {
+      var _this$props$onHideOpt2, _this$props0;
+      if (data.id === this._emptyOptionId) {
+        this.setState({
+          isShowingOptions: false
+        });
+        return;
+      }
+      const selectedOption = this.getOption('id', data.id);
+      let newInputValue;
+      const currentSelectedOptionId = this.state.selectedOptionId;
+
+      // Focus needs to be reapplied to input
+      // after selecting an item to make sure VoiceOver behaves correctly on iOS
+      if (utils.isAndroidOrIOS()) {
+        this.blur();
+        this.focus();
+      }
+      if (this.isControlled) {
+        // in controlled mode we leave to the user to set the value of the
+        // component e.g. in the onChange event handler.
+        // This is accomplished by not setting a selectedOptionId
+        const prev = this.getOption('id', this.state.selectedOptionId);
+        newInputValue = prev ? prev.label : '';
+        this.setState({
+          isShowingOptions: false
+        });
+      } else {
+        newInputValue = selectedOption.label;
+        this.setState({
+          isShowingOptions: false,
+          selectedOptionId: data.id,
+          inputValue: newInputValue
+        });
+      }
+      if (data.id !== currentSelectedOptionId) {
+        var _this$props$onChange3, _this$props9;
+        (_this$props$onChange3 = (_this$props9 = this.props).onChange) === null || _this$props$onChange3 === void 0 ? void 0 : _this$props$onChange3.call(_this$props9, event, {
+          value: selectedOption.value.toISOString(),
+          inputText: newInputValue
+        });
+      }
+      (_this$props$onHideOpt2 = (_this$props0 = this.props).onHideOptions) === null || _this$props$onHideOpt2 === void 0 ? void 0 : _this$props$onHideOpt2.call(_this$props0, event);
+    };
+    this.handleHighlightOption = (_event, data) => {
+      if (data.id === this._emptyOptionId) return;
+      this.setState(state => ({
+        highlightedOptionId: data.id,
+        inputValue: state.inputValue
+      }));
+    };
+    this.parseInputText = inputValue => {
+      const input = DateTime.parse(inputValue, this.locale(), this.timezone(), [this.props.format], true);
+      const baseDate = this.getBaseDate();
+      input.year(baseDate.year());
+      input.month(baseDate.month());
+      input.date(baseDate.date());
+      return input;
+    };
+    this.state = this.getInitialState();
+  }
+  componentDidMount() {
+    // we'll need to recalculate the state because the context value is
+    // set at this point (and it might change locale & timezone)
+    this.setState(this.getInitialState());
+  }
+  focus() {
+    var _this$ref;
+    (_this$ref = this.ref) === null || _this$ref === void 0 ? void 0 : _this$ref.focus();
+  }
+  blur() {
+    this.ref && this.ref.blur();
+  }
+  get _select() {
+    return this.ref;
+  }
+  get isControlled() {
+    return typeof this.props.value !== 'undefined';
+  }
+  get interaction() {
+    return getInteraction({
+      props: this.props
+    });
+  }
+  get focused() {
+    return this.ref && this.ref.focused;
+  }
+  get id() {
+    return this.ref && this.ref.id;
+  }
+  locale() {
+    if (this.props.locale) {
+      return this.props.locale;
+    } else if (this.context && this.context.locale) {
+      return this.context.locale;
+    }
+    return Locale.browserLocale();
+  }
+  timezone() {
+    if (this.props.timezone) {
+      return this.props.timezone;
+    } else if (this.context && this.context.timezone) {
+      return this.context.timezone;
+    }
+    return DateTime.browserTimeZone();
+  }
+  componentDidUpdate(prevProps) {
+    if (this.props.step !== prevProps.step || this.props.format !== prevProps.format || this.props.locale !== prevProps.locale || this.props.timezone !== prevProps.timezone || this.props.allowNonStepInput !== prevProps.allowNonStepInput) {
+      // options change, reset everything
+      // when controlled, selection will be preserved
+      // when uncontrolled, selection will be lost
+      this.setState(this.getInitialState());
+    }
+    if (this.props.value !== prevProps.value) {
+      let newValue;
+      if (this.props.value) {
+        newValue = DateTime.parse(this.props.value, this.locale(), this.timezone());
+      }
+      // value changed
+      const initState = this.getInitialState();
+      this.setState(initState);
+      // options need to be passed because state is not set immediately
+      let option;
+      if (!this.isControlled) {
+        // preserve current value when changing from controlled to uncontrolled
+        if (prevProps.value) {
+          option = this.getOption('id', this.getFormattedId(DateTime.parse(prevProps.value, this.locale(), this.timezone())));
+        }
+      } else if (newValue) {
+        option = this.getOption('id', this.getFormattedId(newValue), initState.options);
+      }
+      const outsideVal = this.props.value ? this.props.value : '';
+      // value does not match an existing option
+      const date = DateTime.parse(outsideVal, this.locale(), this.timezone());
+      let label = '';
+      if (date.isValid()) {
+        label = this.props.format ? date.format(this.props.format) : date.toISOString();
+      }
+      this.setState({
+        inputValue: option ? option.label : label,
+        selectedOptionId: option ? option.id : void 0
+      });
+    }
+  }
+  getFormattedId(date) {
+    // ISO8601 strings may contain a space. Remove any spaces before using the
+    // date as the id.
+    return date.toISOString().replace(/\s/g, '');
+  }
+  getInitialState() {
+    const initialOptions = this.generateOptions();
+    const initialSelection = this.getInitialOption(initialOptions);
+    return {
+      inputValue: initialSelection ? initialSelection.label : '',
+      options: initialOptions,
+      // 288 = 5 min step
+      filteredOptions: initialOptions.length > 288 ? initialOptions.filter(opt => opt.value.minute() % this.props.step === 0) : initialOptions,
+      isShowingOptions: false,
+      highlightedOptionId: initialSelection ? initialSelection.id : void 0,
+      selectedOptionId: initialSelection ? initialSelection.id : void 0,
+      isInputCleared: false
+    };
+  }
+  getInitialOption(options) {
+    const _this$props1 = this.props,
+      value = _this$props1.value,
+      defaultValue = _this$props1.defaultValue,
+      defaultToFirstOption = _this$props1.defaultToFirstOption,
+      format = _this$props1.format;
+    const initialValue = value || defaultValue;
+    if (typeof initialValue === 'string') {
+      const date = DateTime.parse(initialValue, this.locale(), this.timezone());
+      // get option based on value or defaultValue, if provided
+      const option = this.getOption('value', date, options);
+      if (option) {
+        // value matches an existing option
+        return option;
+      }
+      // value does not match an existing option
+      return {
+        id: this.getFormattedId(date),
+        label: format ? date.format(format) : date.toISOString(),
+        value: date
+      };
+    }
+    // otherwise, return first option, if desired
+    if (defaultToFirstOption) {
+      return options[0];
+    }
+    return void 0;
+  }
+  getBaseDate() {
+    let baseDate;
+    const baseValue = this.props.value || this.props.defaultValue;
+    if (baseValue) {
+      baseDate = DateTime.parse(baseValue, this.locale(), this.timezone());
+    } else {
+      baseDate = DateTime.now(this.locale(), this.timezone());
+    }
+    return baseDate.set({
+      second: 0,
+      millisecond: 0
+    }).clone();
+  }
+  generateOptions() {
+    const date = this.getBaseDate();
+    const options = [];
+    const step = this.props.step ? this.props.step : 30;
+    const maxMinute = this.props.allowNonStepInput ? 60 : 60 / step;
+    const minuteStep = this.props.allowNonStepInput ? 1 : step;
+    for (let hour = 0; hour < 24; hour++) {
+      for (let minute = 0; minute < maxMinute; minute++) {
+        const minutes = minute * minuteStep;
+        const newDate = date.set({
+          hour: hour,
+          minute: minutes
+        });
+        // store time options
+        options.push({
+          id: this.getFormattedId(newDate),
+          value: newDate.clone(),
+          label: this.props.format ? newDate.format(this.props.format) : newDate.toISOString()
+        });
+      }
+    }
+    return options;
+  }
+  filterOptions(inputValue) {
+    var _this$state3;
+    let inputNoSeconds = inputValue;
+    // if the input contains seconds disregard them (e.g. if format = LTS)
+    if (inputValue.length > 5) {
+      // e.g. "5:34:"
+      const input = this.parseInputText(inputValue);
+      if (input.isValid()) {
+        input.set({
+          second: 0
+        });
+        inputNoSeconds = input.format(this.props.format);
+      }
+    }
+    if (this.props.allowNonStepInput && inputNoSeconds.length < 3) {
+      var _this$state2;
+      // could show too many results, show only step values
+      return (_this$state2 = this.state) === null || _this$state2 === void 0 ? void 0 : _this$state2.options.filter(option => {
+        return option.label.toLowerCase().startsWith(inputNoSeconds.toLowerCase()) && option.value.minute() % this.props.step == 0;
+      });
+    }
+    return (_this$state3 = this.state) === null || _this$state3 === void 0 ? void 0 : _this$state3.options.filter(option => option.label.toLowerCase().startsWith(inputNoSeconds.toLowerCase()));
+  }
+  renderOptions() {
+    const _this$state4 = this.state,
+      filteredOptions = _this$state4.filteredOptions,
+      highlightedOptionId = _this$state4.highlightedOptionId,
+      selectedOptionId = _this$state4.selectedOptionId;
+    if (filteredOptions.length < 1) {
+      return this.renderEmptyOption();
+    }
+    return filteredOptions.map(option => {
+      const id = option.id,
+        label = option.label;
+      return _jsx(Select.Option, {
+        id: id,
+        isHighlighted: id === highlightedOptionId,
+        isSelected: id === selectedOptionId,
+        children: label
+      }, id);
+    });
+  }
+  renderEmptyOption() {
+    return _jsx(Select.Option, {
+      id: this._emptyOptionId,
+      isHighlighted: false,
+      isSelected: false,
+      children: callRenderProp(this.props.renderEmptyOption)
+    });
+  }
+  render() {
+    const _this$props10 = this.props,
+      value = _this$props10.value,
+      defaultValue = _this$props10.defaultValue,
+      placeholder = _this$props10.placeholder,
+      renderLabel = _this$props10.renderLabel,
+      inputRef = _this$props10.inputRef,
+      id = _this$props10.id,
+      listRef = _this$props10.listRef,
+      renderBeforeInput = _this$props10.renderBeforeInput,
+      renderAfterInput = _this$props10.renderAfterInput,
+      isRequired = _this$props10.isRequired,
+      isInline = _this$props10.isInline,
+      width = _this$props10.width,
+      format = _this$props10.format,
+      step = _this$props10.step,
+      optionsMaxWidth = _this$props10.optionsMaxWidth,
+      visibleOptionsCount = _this$props10.visibleOptionsCount,
+      messages = _this$props10.messages,
+      placement = _this$props10.placement,
+      constrain = _this$props10.constrain,
+      onFocus = _this$props10.onFocus,
+      onShowOptions = _this$props10.onShowOptions,
+      onHideOptions = _this$props10.onHideOptions,
+      onInputChange = _this$props10.onInputChange,
+      onKeyDown = _this$props10.onKeyDown,
+      mountNode = _this$props10.mountNode,
+      rest = _objectWithoutProperties(_this$props10, _excluded);
+    const _this$state5 = this.state,
+      inputValue = _this$state5.inputValue,
+      isShowingOptions = _this$state5.isShowingOptions;
+    return _jsx(Select, {
+      mountNode: mountNode,
+      renderLabel: renderLabel,
+      inputValue: inputValue,
+      interaction: this.interaction,
+      placeholder: placeholder,
+      id: id,
+      onFocus: onFocus,
+      onBlur: this.handleBlur,
+      ref: this.handleRef,
+      inputRef: inputRef,
+      listRef: listRef,
+      isRequired: isRequired,
+      isInline: isInline,
+      width: width,
+      optionsMaxWidth: optionsMaxWidth,
+      visibleOptionsCount: visibleOptionsCount,
+      messages: messages,
+      placement: placement,
+      constrain: constrain,
+      renderBeforeInput: renderBeforeInput,
+      renderAfterInput: renderAfterInput,
+      isShowingOptions: isShowingOptions,
+      onRequestShowOptions: this.handleShowOptions,
+      onRequestHideOptions: this.handleBlurOrEsc,
+      onRequestHighlightOption: this.handleHighlightOption,
+      onRequestSelectOption: this.handleSelectOption,
+      onInputChange: this.handleInputChange,
+      onKeyDown: this.onKeyDown,
+      ...passthroughProps(rest),
+      "data-cid": "TimeSelect",
+      children: isShowingOptions && this.renderOptions()
+    });
+  }
+}, _TimeSelect.displayName = "TimeSelect", _TimeSelect.componentId = 'TimeSelect', _TimeSelect.allowedProps = allowedProps, _TimeSelect.defaultProps = {
+  defaultToFirstOption: false,
+  format: 'LT',
+  // see https://momentjs.com/docs/#/displaying/
+  step: 30,
+  isRequired: false,
+  isInline: false,
+  visibleOptionsCount: 8,
+  placement: 'bottom stretch',
+  constrain: 'window',
+  renderEmptyOption: '---',
+  allowNonStepInput: false,
+  allowClearingSelection: false
+}, _TimeSelect.contextType = ApplyLocaleContext, _TimeSelect)) || _class);
+export { TimeSelect };
+export default TimeSelect;

package/es/TimeSelect/v2/props.js

@@ -0,0 +1,26 @@
+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2015 - present Instructure, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+const allowedProps = ['renderLabel', 'defaultToFirstOption', 'value', 'defaultValue', 'id', 'format', 'step', 'interaction', 'placeholder', 'isRequired', 'isInline', 'width', 'optionsMaxWidth', 'mountNode', 'visibleOptionsCount', 'messages', 'placement', 'constrain', 'onChange', 'onFocus', 'onBlur', 'onShowOptions', 'onHideOptions', 'inputRef', 'listRef', 'renderEmptyOption', 'renderBeforeInput', 'renderAfterInput', 'locale', 'timezone', 'allowNonStepInput', 'onInputChange', 'allowClearingSelection'];
+export { allowedProps };

package/es/exports/b.js

@@ -0,0 +1,24 @@
+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2015 - present Instructure, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+export { TimeSelect } from "../TimeSelect/v2/index.js";