pds-dev-kit-web-test 2.5.708 → 2.5.710

package/dist/mobile/components/Select/Select.js

@@ -0,0 +1,250 @@
+function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+import { useFormContext } from 'react-hook-form';
+import { getErrorByName } from '@common/types';
+import styled, { css } from 'styled-components';
+import { InputTransition } from '../../../common/styles/movement/transitionStyle';
+import { Icon } from '../../../hybrid';
+
+// NOTE Select 컴포넌트는 select, option 태그의 특성상 PDSValueOption을 사용하지 않고 SelectOption으로 대체합니다.
+
+function Select({
+  name,
+  hintText,
+  defaultValue,
+  value,
+  valueArray,
+  size = 'large',
+  responsiveMode = 'none',
+  state = 'normal',
+  colorTheme = 'none',
+  customWidth,
+  validation,
+  onChange
+}) {
+  // validation을 확장하여 힌트 체크 추가
+  const extendedValidation = {
+    ...validation,
+    validate: value => {
+      // 값이 없으면 required.message 노출
+      if (!value || value.length === 0) {
+        if (validation?.required) {
+          return validation?.required?.message || false;
+        }
+      }
+      // 기존 validate 함수가 있다면 실행
+      if (validation?.validate) {
+        return validation.validate(value);
+      }
+      return true;
+    }
+  };
+  const formContext = useFormContext();
+  const register = name && formContext ? formContext.register(name, extendedValidation) : null;
+  const isError = name && formContext ? Boolean(getErrorByName(formContext.formState.errors, name)) : false;
+  const handleChange = e => {
+    register?.onChange(e);
+    onChange?.(e);
+  };
+  const handleBlur = e => {
+    if (register) {
+      register.onBlur(e);
+      formContext.trigger(name);
+    }
+  };
+  const getIconColorKey = () => {
+    if (state === 'disabled' || state === 'read_only') {
+      if (colorTheme === 'dark') {
+        return 'ui_cpnt_select_icon_darktheme_disabled';
+      }
+      return 'ui_cpnt_select_icon_02';
+    }
+    if (colorTheme === 'dark') {
+      return 'ui_cpnt_select_icon_darktheme_default';
+    }
+    return 'ui_cpnt_select_icon_01';
+  };
+  return /*#__PURE__*/React.createElement(S_Box, {
+    "x-pds-name": "Select",
+    "x-pds-element-type": "component",
+    "x-pds-device-type": "mobile",
+    $size: size,
+    responsiveMode: responsiveMode,
+    tabIndex: 0,
+    customWidth: customWidth
+  }, /*#__PURE__*/React.createElement(S_SelectWrapper, null, /*#__PURE__*/React.createElement(S_Icon_Wrapper, {
+    state: state
+  }, /*#__PURE__*/React.createElement(Icon, {
+    size: 16,
+    fillType: "line",
+    iconName: "ic_arrow_down",
+    colorKey: getIconColorKey()
+  })), /*#__PURE__*/React.createElement(S_Select, _extends({}, register, {
+    disabled: state === 'disabled' || state === 'read_only',
+    state: state,
+    isError: isError,
+    $size: size,
+    colorTheme: colorTheme,
+    onChange: handleChange,
+    onBlur: handleBlur,
+    defaultValue: defaultValue?.value ?? '',
+    value: value || undefined
+  }), hintText && /*#__PURE__*/React.createElement("option", {
+    disabled: true,
+    value: ""
+  }, hintText), valueArray.map(el => /*#__PURE__*/React.createElement("option", {
+    key: el.value,
+    value: el.value
+  }, el.text)))), name && getErrorByName(formContext.formState.errors, name)?.message && state === 'normal' && /*#__PURE__*/React.createElement(S_Error, {
+    colorTheme: colorTheme
+  }, getErrorByName(formContext.formState.errors, name).message));
+}
+const large = css(["height:48px;width:432px;"]);
+const medium = css(["height:40px;width:188px;"]);
+const small = css(["height:32px;width:188px;"]);
+const rlarge = css(["height:48px;width:100%;"]);
+const dark = css(["background-color:", ";border:2px solid ", ";color:", ";:disabled{background-color:", ";border:2px solid ", ";color:", ";}:focus{border:2px solid ", " !important;color:", ";}"], ({
+  theme
+}) => theme.ui_cpnt_select_base_darktheme_normal, ({
+  theme,
+  isError
+}) => {
+  if (isError) return theme.ui_cpnt_select_dropdown_border_darktheme_error;
+  return theme.ui_cpnt_select_border_darktheme_normal;
+}, ({
+  theme
+}) => theme.ui_cpnt_select_text_darktheme_hint, ({
+  theme
+}) => theme.ui_cpnt_select_base_darktheme_disabled, ({
+  theme
+}) => theme.ui_cpnt_select_border_darktheme_disabled, ({
+  theme,
+  state
+}) => state === 'read_only' ? theme.ui_cpnt_select_text_darktheme_readonly : theme.ui_cpnt_select_text_darktheme_disabled, ({
+  theme,
+  isError
+}) => {
+  if (isError) return theme.ui_cpnt_select_dropdown_border_darktheme_error;
+  return theme.ui_cpnt_select_border_darktheme_focus;
+}, ({
+  theme
+}) => theme.ui_cpnt_select_text_darktheme_enabled);
+const S_Box = styled.div.withConfig({
+  displayName: "Select__S_Box",
+  componentId: "sc-hdy5ww-0"
+})(["position:relative;z-index:0;", " ", ";", ""], ({
+  $size
+}) => $size && {
+  small: 'width: 188px;',
+  medium: 'width: 188px;',
+  large: 'width: 432px;',
+  rlarge: 'width: 100%'
+}[$size], ({
+  responsiveMode
+}) => responsiveMode === 'use' && 'width: 100%', ({
+  customWidth
+}) => customWidth && `width: ${customWidth};`);
+const S_SelectWrapper = styled.div.withConfig({
+  displayName: "Select__S_SelectWrapper",
+  componentId: "sc-hdy5ww-1"
+})(["position:relative;width:100%;"]);
+const S_Icon_Wrapper = styled.div.withConfig({
+  displayName: "Select__S_Icon_Wrapper",
+  componentId: "sc-hdy5ww-2"
+})(["align-items:center;display:flex;height:16px;position:absolute;right:", ";top:50%;transform:translateY(-50%);width:16px;"], ({
+  theme
+}) => theme.spacing.spacingD);
+const backgroundActiveColor = css(["", ";"], ({
+  colorTheme,
+  theme
+}) => {
+  switch (colorTheme) {
+    case 'none':
+      return theme.ui_cpnt_textfield_base_pressed;
+    case 'dark':
+      return theme.ui_cpnt_select_base_hover_darktheme;
+    default:
+      return theme.ui_cpnt_textfield_base_pressed;
+  }
+});
+const normalActionColor = css(["&:active{background-color:", ";}"], backgroundActiveColor);
+const S_Select = styled.select.withConfig({
+  displayName: "Select__S_Select",
+  componentId: "sc-hdy5ww-3"
+})(["-webkit-box-orient:vertical;-webkit-line-clamp:1;appearance:none;background-color:", ";", ";border:2px solid ", ";border-radius:", ";box-sizing:border-box;color:", ";display:-webkit-box;font-family:inherit;font-size:", ";overflow:hidden;padding-left:", ";padding-right:", ";text-overflow:ellipsis;width:100%;word-break:break-all;:disabled{background-color:", ";border:2px solid ", ";color:", ";opacity:1;}:focus{border:2px solid ", " !important;color:", ";outline:0 !important;outline-offset:0 !important;}", " ", " ", ""], ({
+  theme
+}) => theme.ui_cpnt_select_base_normal, ({
+  $size
+}) => $size && {
+  large,
+  medium,
+  small,
+  rlarge
+}[$size], ({
+  theme,
+  isError
+}) => {
+  if (isError) return theme.ui_cpnt_select_dropdown_border_error;
+  return theme.ui_cpnt_select_border_normal;
+}, ({
+  $size
+}) => $size && {
+  small: '10px',
+  medium: '12px',
+  large: '14px',
+  rlarge: '14px'
+}[$size], ({
+  theme
+}) => theme.ui_cpnt_select_text_hint, ({
+  theme
+}) => theme.mobileFontSize.form2, ({
+  theme
+}) => theme.spacing.spacingD, ({
+  theme
+}) => theme.spacing.spacingF, ({
+  theme
+}) => theme.ui_cpnt_select_base_disabled, ({
+  theme
+}) => theme.ui_cpnt_select_border_disabled, ({
+  theme,
+  state
+}) => state === 'read_only' ? theme.ui_cpnt_select_text_readonly : theme.ui_cpnt_select_text_disabled, ({
+  theme,
+  isError
+}) => {
+  if (isError) return theme.ui_cpnt_select_dropdown_border_error;
+  return theme.ui_cpnt_select_border_focus;
+}, ({
+  theme
+}) => theme.ui_cpnt_select_text_selected, ({
+  colorTheme
+}) => colorTheme === 'dark' && dark, InputTransition, ({
+  state
+}) => state === 'normal' && normalActionColor);
+const S_Error = styled.div.withConfig({
+  displayName: "Select__S_Error",
+  componentId: "sc-hdy5ww-4"
+})(["color:", ";font-size:", ";font-weight:", ";line-height:", ";margin-top:", ";text-align:left;white-space:pre-wrap;"], ({
+  theme,
+  colorTheme
+}) => {
+  switch (colorTheme) {
+    case 'none':
+      {
+        return theme.ui_cpnt_select_dropdown_text_error;
+      }
+    case 'dark':
+      {
+        return theme.ui_cpnt_select_dropdown_text_darktheme_error;
+      }
+  }
+}, ({
+  theme
+}) => theme.desktopFontSize.caption2, ({
+  theme
+}) => theme.fontWeight.normal, ({
+  theme
+}) => theme.desktopLineHeight.caption2, ({
+  theme
+}) => theme.spacing.spacingA);
+export default Select;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["useFormContext","getErrorByName","styled","css","InputTransition","Icon","Select","name","hintText","defaultValue","value","valueArray","size","responsiveMode","state","colorTheme","customWidth","validation","onChange","extendedValidation","validate","length","required","message","formContext","register","isError","Boolean","formState","errors","handleChange","e","handleBlur","onBlur","trigger","getIconColorKey","React","createElement","S_Box","$size","tabIndex","S_SelectWrapper","S_Icon_Wrapper","fillType","iconName","colorKey","S_Select","_extends","disabled","undefined","map","el","key","text","S_Error","large","medium","small","rlarge","dark","theme","ui_cpnt_select_base_darktheme_normal","ui_cpnt_select_dropdown_border_darktheme_error","ui_cpnt_select_border_darktheme_normal","ui_cpnt_select_text_darktheme_hint","ui_cpnt_select_base_darktheme_disabled","ui_cpnt_select_border_darktheme_disabled","ui_cpnt_select_text_darktheme_readonly","ui_cpnt_select_text_darktheme_disabled","ui_cpnt_select_border_darktheme_focus","ui_cpnt_select_text_darktheme_enabled","div","withConfig","displayName","componentId","spacing","spacingD","backgroundActiveColor","ui_cpnt_textfield_base_pressed","ui_cpnt_select_base_hover_darktheme","normalActionColor","select","ui_cpnt_select_base_normal","ui_cpnt_select_dropdown_border_error","ui_cpnt_select_border_normal","ui_cpnt_select_text_hint","mobileFontSize","form2","spacingF","ui_cpnt_select_base_disabled","ui_cpnt_select_border_disabled","ui_cpnt_select_text_readonly","ui_cpnt_select_text_disabled","ui_cpnt_select_border_focus","ui_cpnt_select_text_selected","ui_cpnt_select_dropdown_text_error","ui_cpnt_select_dropdown_text_darktheme_error","desktopFontSize","caption2","fontWeight","normal","desktopLineHeight","spacingA"],"sources":["../../../../src/mobile/components/Select/Select.tsx"],"sourcesContent":["import { Path, useFormContext } from 'react-hook-form';\n\nimport { getErrorByName } from '@common/types';\nimport styled, { css } from 'styled-components';\n\nimport { InputTransition } from '../../../common/styles/movement/transitionStyle';\nimport { Icon } from '../../../hybrid';\n\nimport type { IFormValues, PDSTextType } from '../../../common';\nimport type { Key, SelectHTMLAttributes } from 'react';\n\n// NOTE Select 컴포넌트는 select, option 태그의 특성상 PDSValueOption을 사용하지 않고 SelectOption으로 대체합니다.\ntype SelectOption = {\n  text: string;\n  value: SelectHTMLAttributes<HTMLSelectElement>['value'];\n};\n\ntype SelectProps = {\n  name?: Path<IFormValues>;\n  hintText?: PDSTextType;\n  defaultValue?: SelectOption;\n  value?: SelectOption['value'];\n  valueArray: SelectOption[];\n  // TODO: 각 프로젝트에 쓰이는 rlage제거 후, 해당 컴포넌트 사이즈의 rlarge도 제거 필요\n  size?: 'large' | 'medium' | 'small' | 'rlarge';\n  responsiveMode?: 'none' | 'use';\n  state?: 'normal' | 'read_only' | 'disabled';\n  colorTheme?: 'none' | 'dark';\n  customWidth?: string;\n  validation?: { [key: string]: any };\n  onChange?: (e: React.ChangeEvent<HTMLSelectElement>) => void;\n};\n\ntype StyleTypes = {\n  colorTheme?: 'none' | 'dark';\n  isError?: boolean;\n  $size?: 'large' | 'medium' | 'small' | 'rlarge';\n  responsiveMode?: 'none' | 'use';\n  state?: 'normal' | 'read_only' | 'disabled';\n  customWidth?: string;\n};\n\nfunction Select({\n  name,\n  hintText,\n  defaultValue,\n  value,\n  valueArray,\n  size = 'large',\n  responsiveMode = 'none',\n  state = 'normal',\n  colorTheme = 'none',\n  customWidth,\n  validation,\n  onChange\n}: SelectProps) {\n  // validation을 확장하여 힌트 체크 추가\n  const extendedValidation = {\n    ...validation,\n    validate: (value: string) => {\n      // 값이 없으면 required.message 노출\n      if (!value || value.length === 0) {\n        if (validation?.required) {\n          return validation?.required?.message || false;\n        }\n      }\n      // 기존 validate 함수가 있다면 실행\n      if (validation?.validate) {\n        return validation.validate(value);\n      }\n      return true;\n    }\n  };\n\n  const formContext = useFormContext();\n  const register = name && formContext ? formContext.register(name, extendedValidation) : null;\n  const isError =\n    name && formContext ? Boolean(getErrorByName(formContext.formState.errors, name)) : false;\n\n  const handleChange = (e: React.ChangeEvent<HTMLSelectElement>) => {\n    register?.onChange(e);\n    onChange?.(e);\n  };\n\n  const handleBlur = (e: React.FocusEvent<HTMLSelectElement>) => {\n    if (register) {\n      register.onBlur(e);\n      formContext.trigger(name);\n    }\n  };\n\n  const getIconColorKey = () => {\n    if (state === 'disabled' || state === 'read_only') {\n      if (colorTheme === 'dark') {\n        return 'ui_cpnt_select_icon_darktheme_disabled';\n      }\n\n      return 'ui_cpnt_select_icon_02';\n    }\n\n    if (colorTheme === 'dark') {\n      return 'ui_cpnt_select_icon_darktheme_default';\n    }\n\n    return 'ui_cpnt_select_icon_01';\n  };\n\n  return (\n    <S_Box\n      x-pds-name=\"Select\"\n      x-pds-element-type=\"component\"\n      x-pds-device-type=\"mobile\"\n      $size={size}\n      responsiveMode={responsiveMode}\n      tabIndex={0}\n      customWidth={customWidth}\n    >\n      <S_SelectWrapper>\n        <S_Icon_Wrapper state={state}>\n          <Icon size={16} fillType=\"line\" iconName=\"ic_arrow_down\" colorKey={getIconColorKey()} />\n        </S_Icon_Wrapper>\n        <S_Select\n          {...register}\n          disabled={state === 'disabled' || state === 'read_only'}\n          state={state}\n          isError={isError}\n          $size={size}\n          colorTheme={colorTheme}\n          onChange={handleChange}\n          onBlur={handleBlur}\n          defaultValue={defaultValue?.value ?? ''}\n          value={value || undefined}\n        >\n          {hintText && (\n            <option disabled value=\"\">\n              {hintText}\n            </option>\n          )}\n\n          {valueArray.map((el) => (\n            <option key={el.value as Key} value={el.value}>\n              {el.text}\n            </option>\n          ))}\n        </S_Select>\n      </S_SelectWrapper>\n      {name &&\n        getErrorByName(formContext.formState.errors, name)?.message &&\n        state === 'normal' && (\n          <S_Error colorTheme={colorTheme}>\n            {getErrorByName(formContext.formState.errors, name).message}\n          </S_Error>\n        )}\n    </S_Box>\n  );\n}\n\nconst large = css`\n  height: 48px;\n  width: 432px;\n`;\n\nconst medium = css`\n  height: 40px;\n  width: 188px;\n`;\n\nconst small = css`\n  height: 32px;\n  width: 188px;\n`;\n\nconst rlarge = css`\n  height: 48px;\n  width: 100%;\n`;\n\nconst dark = css<StyleTypes>`\n  background-color: ${({ theme }) => theme.ui_cpnt_select_base_darktheme_normal};\n  border: 2px solid\n    ${({ theme, isError }) => {\n      if (isError) return theme.ui_cpnt_select_dropdown_border_darktheme_error;\n      return theme.ui_cpnt_select_border_darktheme_normal;\n    }};\n  color: ${({ theme }) => theme.ui_cpnt_select_text_darktheme_hint};\n\n  :disabled {\n    background-color: ${({ theme }) => theme.ui_cpnt_select_base_darktheme_disabled};\n    border: 2px solid ${({ theme }) => theme.ui_cpnt_select_border_darktheme_disabled};\n    color: ${({ theme, state }) =>\n      state === 'read_only'\n        ? theme.ui_cpnt_select_text_darktheme_readonly\n        : theme.ui_cpnt_select_text_darktheme_disabled};\n  }\n\n  :focus {\n    border: 2px solid\n      ${({ theme, isError }) => {\n        if (isError) return theme.ui_cpnt_select_dropdown_border_darktheme_error;\n        return theme.ui_cpnt_select_border_darktheme_focus;\n      }} !important;\n    color: ${({ theme }) => theme.ui_cpnt_select_text_darktheme_enabled};\n  }\n`;\n\nconst S_Box = styled.div<StyleTypes>`\n  position: relative;\n  z-index: 0;\n\n  ${({ $size }) =>\n    $size &&\n    {\n      small: 'width: 188px;',\n      medium: 'width: 188px;',\n      large: 'width: 432px;',\n      rlarge: 'width: 100%'\n    }[$size]}\n  ${({ responsiveMode }) => responsiveMode === 'use' && 'width: 100%'};\n  ${({ customWidth }) => customWidth && `width: ${customWidth};`}\n`;\n\nconst S_SelectWrapper = styled.div`\n  position: relative;\n  width: 100%;\n`;\n\nconst S_Icon_Wrapper = styled.div<StyleTypes>`\n  align-items: center;\n  display: flex;\n  height: 16px;\n  position: absolute;\n  right: ${({ theme }) => theme.spacing.spacingD};\n  top: 50%;\n  transform: translateY(-50%);\n  width: 16px;\n`;\n\nconst backgroundActiveColor = css<StyleTypes>`\n  ${({ colorTheme, theme }) => {\n    switch (colorTheme) {\n      case 'none':\n        return theme.ui_cpnt_textfield_base_pressed;\n      case 'dark':\n        return theme.ui_cpnt_select_base_hover_darktheme;\n      default:\n        return theme.ui_cpnt_textfield_base_pressed;\n    }\n  }};\n`;\nconst normalActionColor = css`\n  &:active {\n    background-color: ${backgroundActiveColor};\n  }\n`;\n\nconst S_Select = styled.select<StyleTypes>`\n  -webkit-box-orient: vertical;\n  -webkit-line-clamp: 1;\n  appearance: none;\n  background-color: ${({ theme }) => theme.ui_cpnt_select_base_normal};\n  ${({ $size }) =>\n    $size &&\n    {\n      large,\n      medium,\n      small,\n      rlarge\n    }[$size]};\n  border: 2px solid\n    ${({ theme, isError }) => {\n      if (isError) return theme.ui_cpnt_select_dropdown_border_error;\n      return theme.ui_cpnt_select_border_normal;\n    }};\n  border-radius: ${({ $size }) =>\n    $size &&\n    {\n      small: '10px',\n      medium: '12px',\n      large: '14px',\n      rlarge: '14px'\n    }[$size]};\n  box-sizing: border-box;\n  color: ${({ theme }) => theme.ui_cpnt_select_text_hint};\n  display: -webkit-box;\n  font-family: inherit;\n  font-size: ${({ theme }) => theme.mobileFontSize.form2};\n  overflow: hidden;\n  padding-left: ${({ theme }) => theme.spacing.spacingD};\n  padding-right: ${({ theme }) => theme.spacing.spacingF};\n  text-overflow: ellipsis;\n  width: 100%;\n  word-break: break-all;\n\n  :disabled {\n    background-color: ${({ theme }) => theme.ui_cpnt_select_base_disabled};\n    border: 2px solid ${({ theme }) => theme.ui_cpnt_select_border_disabled};\n    color: ${({ theme, state }) =>\n      state === 'read_only'\n        ? theme.ui_cpnt_select_text_readonly\n        : theme.ui_cpnt_select_text_disabled};\n    opacity: 1;\n  }\n\n  :focus {\n    border: 2px solid\n      ${({ theme, isError }) => {\n        if (isError) return theme.ui_cpnt_select_dropdown_border_error;\n        return theme.ui_cpnt_select_border_focus;\n      }} !important;\n    color: ${({ theme }) => theme.ui_cpnt_select_text_selected};\n    outline: 0 !important;\n    outline-offset: 0 !important;\n  }\n\n  ${({ colorTheme }) => colorTheme === 'dark' && dark}\n\n  ${InputTransition}\n\n  ${({ state }) => state === 'normal' && normalActionColor}\n`;\n\nconst S_Error = styled.div<StyleTypes>`\n  color: ${({ theme, colorTheme }) => {\n    switch (colorTheme) {\n      case 'none': {\n        return theme.ui_cpnt_select_dropdown_text_error;\n      }\n      case 'dark': {\n        return theme.ui_cpnt_select_dropdown_text_darktheme_error;\n      }\n    }\n  }};\n  font-size: ${({ theme }) => theme.desktopFontSize.caption2};\n  font-weight: ${({ theme }) => theme.fontWeight.normal};\n  line-height: ${({ theme }) => theme.desktopLineHeight.caption2};\n  margin-top: ${({ theme }) => theme.spacing.spacingA};\n  text-align: left;\n  white-space: pre-wrap;\n`;\n\nexport default Select;\n"],"mappings":"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","ignoreList":[]}

package/dist/mobile/components/Select/index.js

@@ -0,0 +1,2 @@
+export { default as Select } from './Select';
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJkZWZhdWx0IiwiU2VsZWN0Il0sInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL21vYmlsZS9jb21wb25lbnRzL1NlbGVjdC9pbmRleC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBkZWZhdWx0IGFzIFNlbGVjdCB9IGZyb20gJy4vU2VsZWN0JztcbiJdLCJtYXBwaW5ncyI6IkFBQUEsU0FBU0EsT0FBTyxJQUFJQyxNQUFNLFFBQVEsVUFBVSIsImlnbm9yZUxpc3QiOltdfQ==

package/dist/mobile/components/Slider/Slider.js

@@ -0,0 +1,259 @@
+import { forwardRef, useEffect, useRef, useState } from 'react';
+import { Spacing } from '@hybrid/components';
+import styled from 'styled-components';
+import { TextLabel } from '../TextLabel';
+function Slider({
+  min,
+  max,
+  step = 1,
+  name,
+  value,
+  tooltipText,
+  state = 'normal',
+  prefixText,
+  suffixText,
+  customWidth,
+  responsiveMode = 'none',
+  onChange,
+  onClick
+}, ref) {
+  const [isTooltipVisible, setIsTooltipVisible] = useState(false);
+  const [isTouching, setIsTouching] = useState(false);
+  const trackRef = useRef(null);
+  const thumbRef = useRef(null);
+  const inputRef = useRef(null);
+  useEffect(() => {
+    if (!trackRef.current || !thumbRef.current) {
+      return;
+    }
+    const {
+      width
+    } = trackRef.current.getBoundingClientRect();
+    const thumbPosition = getThumbPositionOnTrack((value - min) / (max - min), value, width);
+    updateFillTrackAndThumb(trackRef.current, thumbRef.current, thumbPosition);
+  }, [value]);
+  function getPercent(pointValue, width) {
+    if (pointValue <= 0) {
+      return 0;
+    }
+    if (pointValue >= width) {
+      return 1;
+    }
+    return pointValue / width;
+  }
+  function percentToValue(percent, min, max) {
+    return (max - min) * percent + min;
+  }
+  function getThumbOffset(percent, width) {
+    return (width * percent - width / 2) / (width / 2) * -10;
+  }
+  const getNewValue = (clientX, left, width) => {
+    const percent = getPercent(clientX - (left + 10), width - 20);
+    const newValue = percentToValue(percent, min, max);
+    return String(newValue);
+  };
+  const getThumbPositionOnTrack = (percent, value, width) => {
+    const thumbOffset = getThumbOffset(percent, width);
+    const calcValue = (Number(value) - min) / (max - min) * 100;
+    if (!calcValue || calcValue < 0) {
+      return `calc(0% + 10px)`;
+    }
+    if (calcValue > 100) {
+      return `calc(100% - 10px)`;
+    }
+    return `calc(${calcValue}% + ${thumbOffset}px)`;
+  };
+  const updateFillTrackAndThumb = (trackElement, thumbElement, thumbPosition) => {
+    trackElement.style.backgroundSize = `${thumbPosition} 100%`;
+    thumbElement.style.left = thumbPosition;
+  };
+  const changeSliderValue = clientX => {
+    if (inputRef.current === null || trackRef.current === null) {
+      return;
+    }
+    const {
+      left,
+      width
+    } = trackRef.current.getBoundingClientRect();
+    const newValue = getNewValue(clientX, left, width);
+    const prevInputValue = inputRef.current.value;
+    inputRef.current.value = String(newValue);
+    const newInputValue = inputRef.current.value;
+    if (prevInputValue === newInputValue) {
+      return;
+    }
+    inputRef.current.dispatchEvent(new Event('input', {
+      bubbles: true
+    }));
+  };
+  const handleTouchMove = e => {
+    changeSliderValue(e.changedTouches[0].clientX);
+  };
+  const handleTouchEnd = () => {
+    document.removeEventListener('touchmove', handleTouchMove);
+    setIsTouching(false);
+    if (tooltipText) {
+      setIsTooltipVisible(false);
+    }
+    if (inputRef.current !== null) {
+      inputRef.current.dispatchEvent(new Event('click', {
+        bubbles: true
+      }));
+      inputRef.current.focus();
+    }
+  };
+  const handleTouchStart = e => {
+    if (state === 'disabled') {
+      return;
+    }
+    setIsTouching(true);
+    changeSliderValue(e.changedTouches[0].clientX);
+    if (tooltipText) {
+      setIsTooltipVisible(true);
+    }
+    document.addEventListener('touchmove', handleTouchMove);
+    document.addEventListener('touchend', handleTouchEnd, {
+      once: true
+    });
+  };
+  const handleChange = e => {
+    if (onChange) {
+      onChange(e);
+    }
+  };
+  const handleClick = e => {
+    if (onClick) {
+      onClick(e);
+    }
+  };
+  const handleRangeRef = node => {
+    if (typeof ref === 'function') {
+      ref(node);
+    } else {
+      ref && (ref.current = node);
+    }
+    inputRef.current = node;
+  };
+  return /*#__PURE__*/React.createElement(S_SliderBox, {
+    "x-pds-name": "Slider",
+    "x-pds-element-type": "component",
+    "x-pds-device-type": "mobile"
+  }, prefixText && /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(TextLabel, {
+    text: prefixText,
+    styleTheme: "caption2Bold",
+    colorTheme: state === 'normal' ? 'sysTextSecondary' : 'sysTextTertiary',
+    singleLineMode: "use",
+    textAlign: "right"
+  }), /*#__PURE__*/React.createElement(Spacing, {
+    spacingType: "width",
+    size: "spacing_b"
+  })), /*#__PURE__*/React.createElement(S_SliderWrapper, {
+    customWidth: customWidth,
+    responsiveMode: responsiveMode
+  }, /*#__PURE__*/React.createElement(S_Slider, {
+    customWidth: customWidth,
+    isDisabled: state === 'disabled',
+    responsiveMode: responsiveMode,
+    onTouchStart: handleTouchStart
+  }, /*#__PURE__*/React.createElement(S_Track, {
+    ref: trackRef,
+    isDisabled: state === 'disabled'
+  }), /*#__PURE__*/React.createElement(S_Thumb, {
+    ref: thumbRef,
+    isTouching: isTouching,
+    isDisabled: state === 'disabled'
+  }, /*#__PURE__*/React.createElement(S_Range, {
+    ref: handleRangeRef,
+    type: "range",
+    name: name,
+    min: min,
+    max: max,
+    step: step,
+    value: value,
+    onInput: handleChange,
+    onClick: handleClick
+  }), !!tooltipText && isTooltipVisible && /*#__PURE__*/React.createElement(S_Tooltip, null, /*#__PURE__*/React.createElement(TextLabel, {
+    text: tooltipText,
+    styleTheme: "caption2Regular",
+    colorOverride: "ui_cpnt_textlabel_button_tooltip",
+    singleLineMode: "use"
+  }))))), suffixText && /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(Spacing, {
+    spacingType: "width",
+    size: "spacing_b"
+  }), /*#__PURE__*/React.createElement(TextLabel, {
+    text: suffixText,
+    styleTheme: "caption2Bold",
+    colorTheme: state === 'normal' ? 'sysTextSecondary' : 'sysTextTertiary',
+    singleLineMode: "use"
+  })));
+}
+const S_SliderBox = styled.div.withConfig({
+  displayName: "Slider__S_SliderBox",
+  componentId: "sc-1y1ni9z-0"
+})(["align-items:center;display:flex;flex-direction:row;"]);
+const S_SliderWrapper = styled.div.withConfig({
+  displayName: "Slider__S_SliderWrapper",
+  componentId: "sc-1y1ni9z-1"
+})(["display:flex;position:relative;width:", ";"], ({
+  responsiveMode,
+  customWidth
+}) => {
+  if (customWidth) {
+    return customWidth;
+  }
+  if (responsiveMode === 'use') {
+    return '100%';
+  }
+  return '324px';
+});
+const S_Tooltip = styled.div.withConfig({
+  displayName: "Slider__S_Tooltip",
+  componentId: "sc-1y1ni9z-2"
+})(["background-color:", ";border-radius:4px;padding:", ";position:absolute;top:-10px;transform:translateY(-100%);"], ({
+  theme
+}) => theme.ui_cpnt_button_tooltip_base, ({
+  theme
+}) => `${theme.spacing.spacingA} ${theme.spacing.spacingB}`);
+const S_Slider = styled.div.withConfig({
+  displayName: "Slider__S_Slider",
+  componentId: "sc-1y1ni9z-3"
+})(["align-items:center;cursor:", ";display:flex;height:20px;width:", ";"], ({
+  isDisabled
+}) => isDisabled ? 'auto' : 'pointer', ({
+  responsiveMode,
+  customWidth
+}) => {
+  if (customWidth) {
+    return customWidth;
+  }
+  if (responsiveMode === 'use') {
+    return '100%';
+  }
+  return '324px';
+});
+const S_Track = styled.div.withConfig({
+  displayName: "Slider__S_Track",
+  componentId: "sc-1y1ni9z-4"
+})(["background-color:", ";background-image:", ";background-repeat:no-repeat;border-radius:2px;height:4px;position:absolute;width:inherit;"], ({
+  theme
+}) => theme.ui_cpnt_slider_track, ({
+  theme,
+  isDisabled
+}) => isDisabled ? `linear-gradient(${theme.ui_cpnt_slider_track_disabled}, ${theme.ui_cpnt_slider_track_disabled})` : `linear-gradient(${theme.ui_cpnt_slider_track_active}, ${theme.ui_cpnt_slider_track_active})`);
+const S_Thumb = styled.div.withConfig({
+  displayName: "Slider__S_Thumb",
+  componentId: "sc-1y1ni9z-5"
+})(["background-color:", ";border-radius:100%;box-shadow:", ";display:flex;height:20px;justify-content:center;position:absolute;transform:translateX(-10px);width:20px;"], ({
+  theme,
+  isDisabled
+}) => isDisabled ? theme.ui_cpnt_slider_thumb_disabled : theme.ui_cpnt_slider_thumb_normal, ({
+  theme,
+  isTouching,
+  isDisabled
+}) => isTouching && !isDisabled ? `0 0 0 8px ${theme.ui_cpnt_slider_thumb_pressed_circle}` : 'none');
+const S_Range = styled.input.withConfig({
+  displayName: "Slider__S_Range",
+  componentId: "sc-1y1ni9z-6"
+})(["clip:rect(0 0 0 0);height:100%;margin:0;outline:none;position:absolute;width:100%;"]);
+export default /*#__PURE__*/forwardRef(Slider);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["forwardRef","useEffect","useRef","useState","Spacing","styled","TextLabel","Slider","min","max","step","name","value","tooltipText","state","prefixText","suffixText","customWidth","responsiveMode","onChange","onClick","ref","isTooltipVisible","setIsTooltipVisible","isTouching","setIsTouching","trackRef","thumbRef","inputRef","current","width","getBoundingClientRect","thumbPosition","getThumbPositionOnTrack","updateFillTrackAndThumb","getPercent","pointValue","percentToValue","percent","getThumbOffset","getNewValue","clientX","left","newValue","String","thumbOffset","calcValue","Number","trackElement","thumbElement","style","backgroundSize","changeSliderValue","prevInputValue","newInputValue","dispatchEvent","Event","bubbles","handleTouchMove","e","changedTouches","handleTouchEnd","document","removeEventListener","focus","handleTouchStart","addEventListener","once","handleChange","handleClick","handleRangeRef","node","React","createElement","S_SliderBox","Fragment","text","styleTheme","colorTheme","singleLineMode","textAlign","spacingType","size","S_SliderWrapper","S_Slider","isDisabled","onTouchStart","S_Track","S_Thumb","S_Range","type","onInput","S_Tooltip","colorOverride","div","withConfig","displayName","componentId","theme","ui_cpnt_button_tooltip_base","spacing","spacingA","spacingB","ui_cpnt_slider_track","ui_cpnt_slider_track_disabled","ui_cpnt_slider_track_active","ui_cpnt_slider_thumb_disabled","ui_cpnt_slider_thumb_normal","ui_cpnt_slider_thumb_pressed_circle","input"],"sources":["../../../../src/mobile/components/Slider/Slider.tsx"],"sourcesContent":["import { forwardRef, useEffect, useRef, useState } from 'react';\n\nimport { Spacing } from '@hybrid/components';\nimport styled from 'styled-components';\n\nimport { TextLabel } from '../TextLabel';\n\nimport type { ForwardedRefType, PDSTextType } from '@common/types';\n\nexport type Props = {\n  min: number;\n  max: number;\n  step?: number;\n  name?: string;\n  value: number;\n  tooltipText?: PDSTextType;\n  state?: 'normal' | 'disabled';\n  prefixText?: PDSTextType;\n  suffixText?: PDSTextType;\n  customWidth?: string;\n  responsiveMode?: 'none' | 'use';\n  onChange?: (e: React.ChangeEvent<HTMLInputElement>) => void;\n  onClick?: (e: React.MouseEvent<HTMLInputElement>) => void;\n};\n\ntype StyleProps = {\n  responsiveMode?: Props['responsiveMode'];\n  customWidth?: Props['customWidth'];\n  isTouching?: boolean;\n  isDisabled?: boolean;\n};\n\nfunction Slider(\n  {\n    min,\n    max,\n    step = 1,\n    name,\n    value,\n    tooltipText,\n    state = 'normal',\n    prefixText,\n    suffixText,\n    customWidth,\n    responsiveMode = 'none',\n    onChange,\n    onClick\n  }: Props,\n  ref: ForwardedRefType<HTMLInputElement>\n) {\n  const [isTooltipVisible, setIsTooltipVisible] = useState(false);\n  const [isTouching, setIsTouching] = useState(false);\n  const trackRef = useRef<HTMLDivElement | null>(null);\n  const thumbRef = useRef<HTMLDivElement | null>(null);\n  const inputRef = useRef<HTMLInputElement | null>(null);\n\n  useEffect(() => {\n    if (!trackRef.current || !thumbRef.current) {\n      return;\n    }\n    const { width } = trackRef.current.getBoundingClientRect();\n\n    const thumbPosition = getThumbPositionOnTrack((value - min) / (max - min), value, width);\n\n    updateFillTrackAndThumb(trackRef.current, thumbRef.current, thumbPosition);\n  }, [value]);\n\n  function getPercent(pointValue: number, width: number) {\n    if (pointValue <= 0) {\n      return 0;\n    }\n\n    if (pointValue >= width) {\n      return 1;\n    }\n\n    return pointValue / width;\n  }\n\n  function percentToValue(percent: number, min: number, max: number) {\n    return (max - min) * percent + min;\n  }\n\n  function getThumbOffset(percent: number, width: number) {\n    return ((width * percent - width / 2) / (width / 2)) * -10;\n  }\n\n  const getNewValue = (clientX: number, left: number, width: number) => {\n    const percent = getPercent(clientX - (left + 10), width - 20);\n    const newValue = percentToValue(percent, min, max);\n\n    return String(newValue);\n  };\n\n  const getThumbPositionOnTrack = (percent: number, value: number, width: number) => {\n    const thumbOffset = getThumbOffset(percent, width);\n    const calcValue = ((Number(value) - min) / (max - min)) * 100;\n\n    if (!calcValue || calcValue < 0) {\n      return `calc(0% + 10px)`;\n    }\n    if (calcValue > 100) {\n      return `calc(100% - 10px)`;\n    }\n    return `calc(${calcValue}% + ${thumbOffset}px)`;\n  };\n\n  const updateFillTrackAndThumb = (\n    trackElement: HTMLDivElement,\n    thumbElement: HTMLDivElement,\n    thumbPosition: string\n  ) => {\n    trackElement.style.backgroundSize = `${thumbPosition} 100%`;\n    thumbElement.style.left = thumbPosition;\n  };\n\n  const changeSliderValue = (clientX: number) => {\n    if (inputRef.current === null || trackRef.current === null) {\n      return;\n    }\n\n    const { left, width } = trackRef.current.getBoundingClientRect();\n    const newValue = getNewValue(clientX, left, width);\n\n    const prevInputValue = inputRef.current.value;\n    inputRef.current.value = String(newValue);\n    const newInputValue = inputRef.current.value;\n\n    if (prevInputValue === newInputValue) {\n      return;\n    }\n\n    inputRef.current.dispatchEvent(new Event('input', { bubbles: true }));\n  };\n\n  const handleTouchMove = (e: TouchEvent) => {\n    changeSliderValue(e.changedTouches[0].clientX);\n  };\n\n  const handleTouchEnd = () => {\n    document.removeEventListener('touchmove', handleTouchMove);\n\n    setIsTouching(false);\n\n    if (tooltipText) {\n      setIsTooltipVisible(false);\n    }\n\n    if (inputRef.current !== null) {\n      inputRef.current.dispatchEvent(new Event('click', { bubbles: true }));\n      inputRef.current.focus();\n    }\n  };\n\n  const handleTouchStart = (e: React.TouchEvent<HTMLDivElement>) => {\n    if (state === 'disabled') {\n      return;\n    }\n    setIsTouching(true);\n\n    changeSliderValue(e.changedTouches[0].clientX);\n\n    if (tooltipText) {\n      setIsTooltipVisible(true);\n    }\n\n    document.addEventListener('touchmove', handleTouchMove);\n    document.addEventListener('touchend', handleTouchEnd, { once: true });\n  };\n\n  const handleChange = (e: React.ChangeEvent<HTMLInputElement>) => {\n    if (onChange) {\n      onChange(e);\n    }\n  };\n\n  const handleClick = (e: React.MouseEvent<HTMLInputElement>) => {\n    if (onClick) {\n      onClick(e);\n    }\n  };\n\n  const handleRangeRef = (node: HTMLInputElement | null) => {\n    if (typeof ref === 'function') {\n      ref(node);\n    } else {\n      ref && (ref.current = node);\n    }\n\n    inputRef.current = node;\n  };\n\n  return (\n    <S_SliderBox x-pds-name=\"Slider\" x-pds-element-type=\"component\" x-pds-device-type=\"mobile\">\n      {prefixText && (\n        <>\n          <TextLabel\n            text={prefixText}\n            styleTheme=\"caption2Bold\"\n            colorTheme={state === 'normal' ? 'sysTextSecondary' : 'sysTextTertiary'}\n            singleLineMode=\"use\"\n            textAlign=\"right\"\n          />\n          <Spacing spacingType=\"width\" size=\"spacing_b\" />\n        </>\n      )}\n\n      <S_SliderWrapper customWidth={customWidth} responsiveMode={responsiveMode}>\n        <S_Slider\n          customWidth={customWidth}\n          isDisabled={state === 'disabled'}\n          responsiveMode={responsiveMode}\n          onTouchStart={handleTouchStart}\n        >\n          <S_Track ref={trackRef} isDisabled={state === 'disabled'} />\n          <S_Thumb ref={thumbRef} isTouching={isTouching} isDisabled={state === 'disabled'}>\n            <S_Range\n              ref={handleRangeRef}\n              type=\"range\"\n              name={name}\n              min={min}\n              max={max}\n              step={step}\n              value={value}\n              onInput={handleChange}\n              onClick={handleClick}\n            />\n            {!!tooltipText && isTooltipVisible && (\n              <S_Tooltip>\n                <TextLabel\n                  text={tooltipText}\n                  styleTheme=\"caption2Regular\"\n                  colorOverride=\"ui_cpnt_textlabel_button_tooltip\"\n                  singleLineMode=\"use\"\n                />\n              </S_Tooltip>\n            )}\n          </S_Thumb>\n        </S_Slider>\n      </S_SliderWrapper>\n\n      {suffixText && (\n        <>\n          <Spacing spacingType=\"width\" size=\"spacing_b\" />\n          <TextLabel\n            text={suffixText}\n            styleTheme=\"caption2Bold\"\n            colorTheme={state === 'normal' ? 'sysTextSecondary' : 'sysTextTertiary'}\n            singleLineMode=\"use\"\n          />\n        </>\n      )}\n    </S_SliderBox>\n  );\n}\n\nconst S_SliderBox = styled.div`\n  align-items: center;\n  display: flex;\n  flex-direction: row;\n`;\n\nconst S_SliderWrapper = styled.div<StyleProps>`\n  display: flex;\n  position: relative;\n  width: ${({ responsiveMode, customWidth }) => {\n    if (customWidth) {\n      return customWidth;\n    }\n\n    if (responsiveMode === 'use') {\n      return '100%';\n    }\n\n    return '324px';\n  }};\n`;\n\nconst S_Tooltip = styled.div`\n  background-color: ${({ theme }) => theme.ui_cpnt_button_tooltip_base};\n  border-radius: 4px;\n  padding: ${({ theme }) => `${theme.spacing.spacingA} ${theme.spacing.spacingB}`};\n  position: absolute;\n  top: -10px;\n  transform: translateY(-100%);\n`;\n\nconst S_Slider = styled.div<StyleProps>`\n  align-items: center;\n  cursor: ${({ isDisabled }) => (isDisabled ? 'auto' : 'pointer')};\n  display: flex;\n  height: 20px;\n  width: ${({ responsiveMode, customWidth }) => {\n    if (customWidth) {\n      return customWidth;\n    }\n\n    if (responsiveMode === 'use') {\n      return '100%';\n    }\n\n    return '324px';\n  }};\n`;\n\nconst S_Track = styled.div<StyleProps>`\n  background-color: ${({ theme }) => theme.ui_cpnt_slider_track};\n  background-image: ${({ theme, isDisabled }) =>\n    isDisabled\n      ? `linear-gradient(${theme.ui_cpnt_slider_track_disabled}, ${theme.ui_cpnt_slider_track_disabled})`\n      : `linear-gradient(${theme.ui_cpnt_slider_track_active}, ${theme.ui_cpnt_slider_track_active})`};\n  background-repeat: no-repeat;\n  border-radius: 2px;\n  height: 4px;\n  position: absolute;\n  width: inherit;\n`;\n\nconst S_Thumb = styled.div<StyleProps>`\n  background-color: ${({ theme, isDisabled }) =>\n    isDisabled ? theme.ui_cpnt_slider_thumb_disabled : theme.ui_cpnt_slider_thumb_normal};\n  border-radius: 100%;\n  box-shadow: ${({ theme, isTouching, isDisabled }) =>\n    isTouching && !isDisabled ? `0 0 0 8px ${theme.ui_cpnt_slider_thumb_pressed_circle}` : 'none'};\n  display: flex;\n  height: 20px;\n  justify-content: center;\n  position: absolute;\n  transform: translateX(-10px);\n  width: 20px;\n`;\n\nconst S_Range = styled.input`\n  clip: rect(0 0 0 0);\n  height: 100%;\n  margin: 0;\n  outline: none;\n  position: absolute;\n  width: 100%;\n`;\n\nexport default forwardRef(Slider);\n"],"mappings":"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","ignoreList":[]}

package/dist/mobile/components/Slider/index.js

@@ -0,0 +1,2 @@
+export { default as Slider } from './Slider';
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJkZWZhdWx0IiwiU2xpZGVyIl0sInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL21vYmlsZS9jb21wb25lbnRzL1NsaWRlci9pbmRleC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBkZWZhdWx0IGFzIFNsaWRlciB9IGZyb20gJy4vU2xpZGVyJztcbiJdLCJtYXBwaW5ncyI6IkFBQUEsU0FBU0EsT0FBTyxJQUFJQyxNQUFNLFFBQVEsVUFBVSIsImlnbm9yZUxpc3QiOltdfQ==