pds-dev-kit-web-test 2.5.709 → 2.5.712

package/dist/desktop/components/Dropdown/index.js

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

package/dist/desktop/components/DynamicDesktopNavBar/DynamicDesktopNavBar.js

@@ -0,0 +1,176 @@
+import { createContext, useMemo, useEffect, useReducer, useRef } from 'react';
+import { useLocation } from 'react-router-dom';
+import styled, { ThemeProvider, useTheme } from 'styled-components';
+import { Grid } from '../../../common/components/BoxLayout';
+import { usePrevious } from '../../../common/hooks';
+import { themeByGivenTone } from '../../../common/styles/theme';
+import { BrandLogo, PrimaryMenu, SecondaryMenu, UserProfile } from './blocks';
+import reducer, { defaultValue } from './reducer';
+import { DynamicDesktopNavBarTemplates } from './templates';
+import { getSearchExceptGivenName } from './utils';
+export const BasePathContext = /*#__PURE__*/createContext({
+  basePath: '',
+  activeMode: 'BY_URL',
+  handleClickInternalMenuItemNav: () => {
+    // NOTE: noop function
+    return;
+  }
+});
+function DynamicDesktopNavBar({
+  isPreview = false,
+  template,
+  brandLogo,
+  primaryMenus,
+  secondaryMenus,
+  userProfile,
+  basePath,
+  colorTheme = 'none'
+}) {
+  const {
+    gridStyle,
+    gridTemplate,
+    showSecondaryMenu,
+    primaryMenuOptions,
+    secondaryMenuOptions,
+    userProfileOptions
+  } = DynamicDesktopNavBarTemplates.getTemplate(template);
+  const [state, dispatch] = useReducer(reducer, defaultValue);
+  const location = useLocation();
+  const prevLocation = usePrevious(location.pathname + location.search);
+  const theme = useTheme();
+  const profileArea = useRef(null);
+  const userProfileAreaWidth = profileArea?.current?.offsetWidth || 0;
+  const GRID_GAP = 24;
+  const gridStyleMarginLeft = `${userProfileAreaWidth + GRID_GAP}px`;
+  const style = template === 'W1_0011' ? {
+    ...gridStyle,
+    marginLeft: gridStyleMarginLeft
+  } : gridStyle;
+  const isFixedWidth = template === 'W1_0006' || template === 'W1_0007' || template === 'W1_0008' || template === 'W1_0009' || template === 'W1_0010';
+  const isCenteredLogo = template === 'W1_0011';
+  const navBarHeight = '63px';
+  useEffect(() => {
+    const currentSearch = getSearchExceptGivenName(location.search, 'from');
+    const currentLocation = location.pathname + currentSearch;
+    if (currentLocation === state.clickedURL) {
+      return;
+    }
+    if (currentLocation !== prevLocation) {
+      dispatch({
+        type: 'URL_CHANGED'
+      });
+    }
+  }, [location.pathname, location.search, prevLocation]);
+  const slicedPrimaryMenus = useMemo(() => primaryMenus?.slice(0, primaryMenuOptions.maxLength), [primaryMenus, primaryMenuOptions]);
+  const slicedSecondaryMenus = useMemo(() => secondaryMenus?.slice(0, secondaryMenuOptions.maxLength) ?? [], [secondaryMenus, secondaryMenuOptions]);
+  function handleClickInternalMenuItemNav(url) {
+    dispatch({
+      type: 'INTERNAL_CLICKED',
+      payload: {
+        clickedURL: url
+      }
+    });
+  }
+  return /*#__PURE__*/React.createElement(BasePathContext.Provider, {
+    value: {
+      basePath,
+      activeMode: state.mode,
+      handleClickInternalMenuItemNav
+    }
+  }, colorTheme === 'transparent' ? /*#__PURE__*/React.createElement(ThemeProvider, {
+    theme: {
+      ...theme,
+      ...themeByGivenTone('DARK'),
+      ui_menu_background: theme.ui_menu_background_transparent,
+      ui_menu_button_base: theme.ui_menu_button_base_transparent
+    }
+  }, /*#__PURE__*/React.createElement(S_DynamicDesktopNavBar, {
+    "x-pds-name": "DynamicDesktopNavBar",
+    "x-pds-element-type": "component",
+    "x-pds-device-type": "desktop",
+    isFixedWidth: isFixedWidth,
+    isPreview: isPreview,
+    navBarHeight: navBarHeight
+  }, /*#__PURE__*/React.createElement(S_Grid, {
+    className: "DynamicDesktopNavBarGrid",
+    gridTemplate: gridTemplate,
+    style: style
+  }, /*#__PURE__*/React.createElement(BrandLogo, {
+    to: brandLogo.href,
+    logoSrc: brandLogo.src,
+    fallbackText: brandLogo.text,
+    isCenteredLogo: isCenteredLogo
+  }), /*#__PURE__*/React.createElement(PrimaryMenu, {
+    menus: slicedPrimaryMenus,
+    showMenuAsIcon: primaryMenuOptions.showMenuAsIcon,
+    style: primaryMenuOptions.style
+  }), showSecondaryMenu && /*#__PURE__*/React.createElement(SecondaryMenu, {
+    menus: slicedSecondaryMenus,
+    showMenuAsIcon: secondaryMenuOptions.showMenuAsIcon,
+    style: secondaryMenuOptions.style
+  }), /*#__PURE__*/React.createElement(UserProfile, {
+    ref: profileArea,
+    src: userProfile.src,
+    to: userProfile.href,
+    leftIconButton: userProfile.leftIconButton,
+    leftIconButton2: userProfile.leftIconButton2,
+    overrideUserProfile: userProfile.overrideUserProfile,
+    style: userProfileOptions.style
+  })))) : /*#__PURE__*/React.createElement(S_DynamicDesktopNavBar, {
+    "x-pds-name": "DynamicDesktopNavBar",
+    "x-pds-element-type": "component",
+    "x-pds-device-type": "desktop",
+    isPreview: isPreview,
+    isFixedWidth: isFixedWidth,
+    navBarHeight: navBarHeight
+  }, /*#__PURE__*/React.createElement(S_Grid, {
+    className: "DynamicDesktopNavBarGrid",
+    gridTemplate: gridTemplate,
+    style: style
+  }, /*#__PURE__*/React.createElement(BrandLogo, {
+    to: brandLogo.href,
+    logoSrc: brandLogo.src,
+    fallbackText: brandLogo.text,
+    isCenteredLogo: isCenteredLogo
+  }), /*#__PURE__*/React.createElement(PrimaryMenu, {
+    menus: slicedPrimaryMenus,
+    showMenuAsIcon: primaryMenuOptions.showMenuAsIcon,
+    style: primaryMenuOptions.style
+  }), showSecondaryMenu && /*#__PURE__*/React.createElement(SecondaryMenu, {
+    menus: slicedSecondaryMenus,
+    showMenuAsIcon: secondaryMenuOptions.showMenuAsIcon,
+    style: secondaryMenuOptions.style
+  }), /*#__PURE__*/React.createElement(UserProfile, {
+    ref: profileArea,
+    src: userProfile.src,
+    to: userProfile.href,
+    leftIconButton: userProfile.leftIconButton,
+    leftIconButton2: userProfile.leftIconButton2,
+    overrideUserProfile: userProfile.overrideUserProfile,
+    style: userProfileOptions.style
+  }))));
+}
+const S_Grid = styled(Grid).withConfig({
+  displayName: "DynamicDesktopNavBar__S_Grid",
+  componentId: "sc-4zki3g-0"
+})(["align-items:center;grid-column-gap:24px;justify-items:center;padding-left:", ";padding-right:", ";"], ({
+  theme
+}) => theme.spacing.spacingE, ({
+  theme
+}) => theme.spacing.spacingE);
+const S_DynamicDesktopNavBar = styled.div.withConfig({
+  displayName: "DynamicDesktopNavBar__S_DynamicDesktopNavBar",
+  componentId: "sc-4zki3g-1"
+})(["background-color:", ";display:flex;height:", ";justify-content:", ";min-width:", ";*{box-sizing:border-box;}a:active{pointer-events:", ";}"], ({
+  theme
+}) => theme.ui_menu_background, ({
+  navBarHeight
+}) => navBarHeight, ({
+  isFixedWidth
+}) => isFixedWidth && 'center', ({
+  isPreview
+}) => isPreview ? '1100px' : '1200px', ({
+  isPreview
+}) => isPreview ? 'none' : 'auto');
+export default DynamicDesktopNavBar;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["createContext","useMemo","useEffect","useReducer","useRef","useLocation","styled","ThemeProvider","useTheme","Grid","usePrevious","themeByGivenTone","BrandLogo","PrimaryMenu","SecondaryMenu","UserProfile","reducer","defaultValue","DynamicDesktopNavBarTemplates","getSearchExceptGivenName","BasePathContext","basePath","activeMode","handleClickInternalMenuItemNav","DynamicDesktopNavBar","isPreview","template","brandLogo","primaryMenus","secondaryMenus","userProfile","colorTheme","gridStyle","gridTemplate","showSecondaryMenu","primaryMenuOptions","secondaryMenuOptions","userProfileOptions","getTemplate","state","dispatch","location","prevLocation","pathname","search","theme","profileArea","userProfileAreaWidth","current","offsetWidth","GRID_GAP","gridStyleMarginLeft","style","marginLeft","isFixedWidth","isCenteredLogo","navBarHeight","currentSearch","currentLocation","clickedURL","type","slicedPrimaryMenus","slice","maxLength","slicedSecondaryMenus","url","payload","React","createElement","Provider","value","mode","ui_menu_background","ui_menu_background_transparent","ui_menu_button_base","ui_menu_button_base_transparent","S_DynamicDesktopNavBar","S_Grid","className","to","href","logoSrc","src","fallbackText","text","menus","showMenuAsIcon","ref","leftIconButton","leftIconButton2","overrideUserProfile","withConfig","displayName","componentId","spacing","spacingE","div"],"sources":["../../../../src/desktop/components/DynamicDesktopNavBar/DynamicDesktopNavBar.tsx"],"sourcesContent":["import { createContext, useMemo, useEffect, useReducer, useRef } from 'react';\nimport { useLocation } from 'react-router-dom';\n\nimport styled, { ThemeProvider, useTheme } from 'styled-components';\n\nimport { Grid } from '../../../common/components/BoxLayout';\nimport { usePrevious } from '../../../common/hooks';\nimport { themeByGivenTone } from '../../../common/styles/theme';\n\nimport { BrandLogo, PrimaryMenu, SecondaryMenu, UserProfile } from './blocks';\nimport reducer, { ActiveModeTypes, defaultValue } from './reducer';\nimport { DynamicDesktopNavBarTemplates, TemplateNamesType } from './templates';\nimport { getSearchExceptGivenName } from './utils';\n\nimport type { ParsedNode } from './types';\n\ntype BrandLogo = {\n  src: string;\n  text: string;\n  href: string;\n};\n\ntype UserProfile = {\n  src: string;\n  href: string;\n  leftIconButton?: React.ReactNode;\n  leftIconButton2?: React.ReactNode;\n  overrideUserProfile?: React.ReactNode;\n};\n\nexport type Props = {\n  isPreview?: boolean;\n  brandLogo: BrandLogo;\n  userProfile: UserProfile;\n  primaryMenus: ParsedNode[];\n  secondaryMenus: ParsedNode[] | null;\n  template: TemplateNamesType;\n  basePath: string;\n  colorTheme?: 'none' | 'transparent';\n};\n\ntype ContextProp = {\n  basePath: string;\n  // NOTE: url을 기반으로 nav의 active를 할지, 클릭을 기반으로 할지 상태입니다.\n  activeMode: ActiveModeTypes;\n  handleClickInternalMenuItemNav: (url: string) => void;\n};\n\nexport const BasePathContext = createContext<ContextProp>({\n  basePath: '',\n  activeMode: 'BY_URL',\n  handleClickInternalMenuItemNav: () => {\n    // NOTE: noop function\n    return;\n  }\n});\n\nfunction DynamicDesktopNavBar({\n  isPreview = false,\n  template,\n  brandLogo,\n  primaryMenus,\n  secondaryMenus,\n  userProfile,\n  basePath,\n  colorTheme = 'none'\n}: Props) {\n  const {\n    gridStyle,\n    gridTemplate,\n    showSecondaryMenu,\n    primaryMenuOptions,\n    secondaryMenuOptions,\n    userProfileOptions\n  } = DynamicDesktopNavBarTemplates.getTemplate(template);\n  const [state, dispatch] = useReducer(reducer, defaultValue);\n\n  const location = useLocation();\n  const prevLocation = usePrevious(location.pathname + location.search);\n  const theme = useTheme();\n\n  const profileArea = useRef<HTMLDivElement | null>(null);\n  const userProfileAreaWidth = profileArea?.current?.offsetWidth || 0;\n  const GRID_GAP = 24;\n  const gridStyleMarginLeft = `${userProfileAreaWidth + GRID_GAP}px`;\n\n  const style =\n    template === 'W1_0011' ? { ...gridStyle, marginLeft: gridStyleMarginLeft } : gridStyle;\n\n  const isFixedWidth =\n    template === 'W1_0006' ||\n    template === 'W1_0007' ||\n    template === 'W1_0008' ||\n    template === 'W1_0009' ||\n    template === 'W1_0010';\n\n  const isCenteredLogo = template === 'W1_0011';\n  const navBarHeight = '63px';\n\n  useEffect(() => {\n    const currentSearch = getSearchExceptGivenName(location.search, 'from');\n    const currentLocation = location.pathname + currentSearch;\n\n    if (currentLocation === state.clickedURL) {\n      return;\n    }\n\n    if (currentLocation !== prevLocation) {\n      dispatch({ type: 'URL_CHANGED' });\n    }\n  }, [location.pathname, location.search, prevLocation]);\n\n  const slicedPrimaryMenus = useMemo(\n    () => primaryMenus?.slice(0, primaryMenuOptions.maxLength),\n    [primaryMenus, primaryMenuOptions]\n  );\n\n  const slicedSecondaryMenus = useMemo(\n    () => secondaryMenus?.slice(0, secondaryMenuOptions.maxLength) ?? [],\n    [secondaryMenus, secondaryMenuOptions]\n  );\n\n  function handleClickInternalMenuItemNav(url: string) {\n    dispatch({ type: 'INTERNAL_CLICKED', payload: { clickedURL: url } });\n  }\n\n  return (\n    <BasePathContext.Provider\n      value={{ basePath, activeMode: state.mode, handleClickInternalMenuItemNav }}\n    >\n      {colorTheme === 'transparent' ? (\n        <ThemeProvider\n          theme={{\n            ...theme,\n            ...themeByGivenTone('DARK'),\n            ui_menu_background: theme.ui_menu_background_transparent,\n            ui_menu_button_base: theme.ui_menu_button_base_transparent\n          }}\n        >\n          <S_DynamicDesktopNavBar\n            x-pds-name=\"DynamicDesktopNavBar\"\n            x-pds-element-type=\"component\"\n            x-pds-device-type=\"desktop\"\n            isFixedWidth={isFixedWidth}\n            isPreview={isPreview}\n            navBarHeight={navBarHeight}\n          >\n            <S_Grid className=\"DynamicDesktopNavBarGrid\" gridTemplate={gridTemplate} style={style}>\n              <BrandLogo\n                to={brandLogo.href}\n                logoSrc={brandLogo.src}\n                fallbackText={brandLogo.text}\n                isCenteredLogo={isCenteredLogo}\n              />\n              <PrimaryMenu\n                menus={slicedPrimaryMenus}\n                showMenuAsIcon={primaryMenuOptions.showMenuAsIcon}\n                style={primaryMenuOptions.style}\n              />\n\n              {showSecondaryMenu && (\n                <SecondaryMenu\n                  menus={slicedSecondaryMenus}\n                  showMenuAsIcon={secondaryMenuOptions.showMenuAsIcon}\n                  style={secondaryMenuOptions.style}\n                />\n              )}\n              <UserProfile\n                ref={profileArea}\n                src={userProfile.src}\n                to={userProfile.href}\n                leftIconButton={userProfile.leftIconButton}\n                leftIconButton2={userProfile.leftIconButton2}\n                overrideUserProfile={userProfile.overrideUserProfile}\n                style={userProfileOptions.style}\n              />\n            </S_Grid>\n          </S_DynamicDesktopNavBar>\n        </ThemeProvider>\n      ) : (\n        <S_DynamicDesktopNavBar\n          x-pds-name=\"DynamicDesktopNavBar\"\n          x-pds-element-type=\"component\"\n          x-pds-device-type=\"desktop\"\n          isPreview={isPreview}\n          isFixedWidth={isFixedWidth}\n          navBarHeight={navBarHeight}\n        >\n          <S_Grid className=\"DynamicDesktopNavBarGrid\" gridTemplate={gridTemplate} style={style}>\n            <BrandLogo\n              to={brandLogo.href}\n              logoSrc={brandLogo.src}\n              fallbackText={brandLogo.text}\n              isCenteredLogo={isCenteredLogo}\n            />\n            <PrimaryMenu\n              menus={slicedPrimaryMenus}\n              showMenuAsIcon={primaryMenuOptions.showMenuAsIcon}\n              style={primaryMenuOptions.style}\n            />\n\n            {showSecondaryMenu && (\n              <SecondaryMenu\n                menus={slicedSecondaryMenus}\n                showMenuAsIcon={secondaryMenuOptions.showMenuAsIcon}\n                style={secondaryMenuOptions.style}\n              />\n            )}\n            <UserProfile\n              ref={profileArea}\n              src={userProfile.src}\n              to={userProfile.href}\n              leftIconButton={userProfile.leftIconButton}\n              leftIconButton2={userProfile.leftIconButton2}\n              overrideUserProfile={userProfile.overrideUserProfile}\n              style={userProfileOptions.style}\n            />\n          </S_Grid>\n        </S_DynamicDesktopNavBar>\n      )}\n    </BasePathContext.Provider>\n  );\n}\n\nconst S_Grid = styled(Grid)`\n  align-items: center;\n  grid-column-gap: 24px;\n  justify-items: center;\n  padding-left: ${({ theme }) => theme.spacing.spacingE};\n  padding-right: ${({ theme }) => theme.spacing.spacingE};\n`;\n\nconst S_DynamicDesktopNavBar = styled.div<{\n  isFixedWidth: boolean;\n  isPreview: boolean;\n  navBarHeight: string;\n}>`\n  background-color: ${({ theme }) => theme.ui_menu_background};\n  display: flex;\n  height: ${({ navBarHeight }) => navBarHeight};\n  justify-content: ${({ isFixedWidth }) => isFixedWidth && 'center'};\n  min-width: ${({ isPreview }) => (isPreview ? '1100px' : '1200px')};\n\n  * {\n    box-sizing: border-box;\n  }\n\n  a:active {\n    pointer-events: ${({ isPreview }) => (isPreview ? 'none' : 'auto')};\n  }\n`;\n\nexport default DynamicDesktopNavBar;\n"],"mappings":"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","ignoreList":[]}

package/dist/desktop/components/DynamicDesktopNavBar/blocks/BrandLogo.js

@@ -0,0 +1,24 @@
+import styled from 'styled-components';
+import LogoNav from '../components/LogoNav';
+function BrandLogo({
+  to,
+  logoSrc,
+  fallbackText,
+  isCenteredLogo,
+  style
+}) {
+  return /*#__PURE__*/React.createElement(S_BrandLogo, {
+    style: style
+  }, /*#__PURE__*/React.createElement(LogoNav, {
+    to: to,
+    logoSrc: logoSrc,
+    fallbackText: fallbackText,
+    isCenteredLogo: isCenteredLogo
+  }));
+}
+const S_BrandLogo = styled.div.withConfig({
+  displayName: "BrandLogo__S_BrandLogo",
+  componentId: "sc-1sllafd-0"
+})(["display:flex;grid-area:BRAND_LOGO;"]);
+export default BrandLogo;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJzdHlsZWQiLCJMb2dvTmF2IiwiQnJhbmRMb2dvIiwidG8iLCJsb2dvU3JjIiwiZmFsbGJhY2tUZXh0IiwiaXNDZW50ZXJlZExvZ28iLCJzdHlsZSIsIlJlYWN0IiwiY3JlYXRlRWxlbWVudCIsIlNfQnJhbmRMb2dvIiwiZGl2Iiwid2l0aENvbmZpZyIsImRpc3BsYXlOYW1lIiwiY29tcG9uZW50SWQiXSwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvZGVza3RvcC9jb21wb25lbnRzL0R5bmFtaWNEZXNrdG9wTmF2QmFyL2Jsb2Nrcy9CcmFuZExvZ28udHN4Il0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBzdHlsZWQsIHsgQ1NTUHJvcGVydGllcyB9IGZyb20gJ3N0eWxlZC1jb21wb25lbnRzJztcblxuaW1wb3J0IExvZ29OYXYgZnJvbSAnLi4vY29tcG9uZW50cy9Mb2dvTmF2JztcblxudHlwZSBQcm9wcyA9IHtcbiAgdG86IHN0cmluZztcbiAgbG9nb1NyYzogc3RyaW5nO1xuICBmYWxsYmFja1RleHQ6IHN0cmluZztcbiAgaXNDZW50ZXJlZExvZ286IGJvb2xlYW47XG4gIHN0eWxlPzogQ1NTUHJvcGVydGllcztcbn07XG5cbmZ1bmN0aW9uIEJyYW5kTG9nbyh7IHRvLCBsb2dvU3JjLCBmYWxsYmFja1RleHQsIGlzQ2VudGVyZWRMb2dvLCBzdHlsZSB9OiBQcm9wcykge1xuICByZXR1cm4gKFxuICAgIDxTX0JyYW5kTG9nbyBzdHlsZT17c3R5bGV9PlxuICAgICAgPExvZ29OYXZcbiAgICAgICAgdG89e3RvfVxuICAgICAgICBsb2dvU3JjPXtsb2dvU3JjfVxuICAgICAgICBmYWxsYmFja1RleHQ9e2ZhbGxiYWNrVGV4dH1cbiAgICAgICAgaXNDZW50ZXJlZExvZ289e2lzQ2VudGVyZWRMb2dvfVxuICAgICAgLz5cbiAgICA8L1NfQnJhbmRMb2dvPlxuICApO1xufVxuXG5jb25zdCBTX0JyYW5kTG9nbyA9IHN0eWxlZC5kaXZgXG4gIGRpc3BsYXk6IGZsZXg7XG4gIGdyaWQtYXJlYTogQlJBTkRfTE9HTztcbmA7XG5cbmV4cG9ydCBkZWZhdWx0IEJyYW5kTG9nbztcbiJdLCJtYXBwaW5ncyI6IkFBQUEsT0FBT0EsTUFBTSxNQUF5QixtQkFBbUI7QUFFekQsT0FBT0MsT0FBTyxNQUFNLHVCQUF1QjtBQVUzQyxTQUFTQyxTQUFTQSxDQUFDO0VBQUVDLEVBQUU7RUFBRUMsT0FBTztFQUFFQyxZQUFZO0VBQUVDLGNBQWM7RUFBRUM7QUFBYSxDQUFDLEVBQUU7RUFDOUUsb0JBQ0VDLEtBQUEsQ0FBQUMsYUFBQSxDQUFDQyxXQUFXO0lBQUNILEtBQUssRUFBRUE7RUFBTSxnQkFDeEJDLEtBQUEsQ0FBQUMsYUFBQSxDQUFDUixPQUFPO0lBQ05FLEVBQUUsRUFBRUEsRUFBRztJQUNQQyxPQUFPLEVBQUVBLE9BQVE7SUFDakJDLFlBQVksRUFBRUEsWUFBYTtJQUMzQkMsY0FBYyxFQUFFQTtFQUFlLENBQ2hDLENBQ1UsQ0FBQztBQUVsQjtBQUVBLE1BQU1JLFdBQVcsR0FBR1YsTUFBTSxDQUFDVyxHQUFHLENBQUFDLFVBQUE7RUFBQUMsV0FBQTtFQUFBQyxXQUFBO0FBQUEsMENBRzdCO0FBRUQsZUFBZVosU0FBUyIsImlnbm9yZUxpc3QiOltdfQ==

package/dist/desktop/components/DynamicDesktopNavBar/blocks/PrimaryMenu.js

@@ -0,0 +1,125 @@
+import { useCallback, useEffect, useState } from 'react';
+import smoothscroll from 'smoothscroll-polyfill';
+import styled from 'styled-components';
+import { D_IconButton } from '../../..';
+import { useDetectOverflow } from '../../../../common/hooks';
+import { MenuItemNav } from '../components/MenuItemNav';
+// NOTE: safari-scroll-behavior-smooth polyfill
+smoothscroll.polyfill();
+const DESKTOP_SCROLL_LEFT = 320;
+function PrimaryMenu({
+  menus,
+  showMenuAsIcon,
+  style
+}) {
+  const [primaryRef, setPrimaryRef] = useState({
+    node: null
+  });
+  const primaryCallbackRef = useCallback(node => {
+    if (!node) {
+      return;
+    }
+    setPrimaryRef({
+      node
+    });
+  }, [menus]);
+  useEffect(() => {
+    if (!primaryRef.node) {
+      return;
+    }
+    primaryRef.node.addEventListener('wheel', handleScroll);
+    function handleScroll(e) {
+      if (primaryRef.node) {
+        primaryRef.node.scrollTo({
+          left: primaryRef.node.scrollLeft + e.deltaY
+        });
+      }
+    }
+    return () => {
+      if (!primaryRef.node) {
+        return;
+      }
+      primaryRef.node.removeEventListener('scroll', handleScroll);
+    };
+  }, [primaryRef]);
+  const {
+    trigger,
+    isOverflow,
+    isScrollBoxStart,
+    isScrollBoxEnd
+  } = useDetectOverflow(primaryRef, true);
+  const onClickLeftButton = () => {
+    primaryRef.node && primaryRef.node.scroll({
+      left: primaryRef.node.scrollLeft - DESKTOP_SCROLL_LEFT,
+      behavior: 'smooth'
+    });
+  };
+  const onClickRightButton = () => {
+    primaryRef.node && primaryRef.node.scroll({
+      left: primaryRef.node.scrollLeft + DESKTOP_SCROLL_LEFT,
+      behavior: 'smooth'
+    });
+  };
+  return /*#__PURE__*/React.createElement(S_PrimaryMenuBox, {
+    style: style
+  }, isOverflow && !isScrollBoxStart && /*#__PURE__*/React.createElement(S_LeftButtonWrapper, null, /*#__PURE__*/React.createElement(S_ButtonWrapper, null, /*#__PURE__*/React.createElement(D_IconButton, {
+    fillType: "fill",
+    baseSize: "medium",
+    baseColorKey: "ui_menu_background",
+    iconName: "ic_arrow_left",
+    iconFillType: "line",
+    iconColorKey: "ui_cpnt_button_icon_default",
+    shapeType: "circular",
+    iconSize: 20,
+    onClick: onClickLeftButton
+  }))), /*#__PURE__*/React.createElement(S_Main_PrimaryMenu, {
+    onScroll: () => trigger(),
+    ref: primaryCallbackRef
+  }, menus.map((menu, index) => /*#__PURE__*/React.createElement(MenuItemNav, {
+    key: index,
+    menu: menu,
+    showMenuAsIcon: showMenuAsIcon
+  }))), isOverflow && !isScrollBoxEnd && /*#__PURE__*/React.createElement(S_RightButtonWrapper, null, /*#__PURE__*/React.createElement(S_ButtonWrapper, null, /*#__PURE__*/React.createElement(D_IconButton, {
+    fillType: "fill",
+    baseSize: "medium",
+    baseColorKey: "ui_menu_background",
+    iconName: "ic_arrow_right",
+    iconFillType: "line",
+    iconColorKey: "ui_cpnt_button_icon_default",
+    shapeType: "circular",
+    iconSize: 20,
+    onClick: onClickRightButton
+  }))));
+}
+const S_Main_PrimaryMenu = styled.div.withConfig({
+  displayName: "PrimaryMenu__S_Main_PrimaryMenu",
+  componentId: "sc-r8ur8y-0"
+})(["display:flex;grid-area:PRIMARY_MENU;overflow-x:auto;overscroll-behavior-y:none;width:max-content;& > div:first-child{margin-left:32px;}"]);
+const S_PrimaryMenuBox = styled.div.withConfig({
+  displayName: "PrimaryMenu__S_PrimaryMenuBox",
+  componentId: "sc-r8ur8y-1"
+})(["display:flex;height:48px;max-height:100%;max-width:100%;overflow-x:hidden;overflow-y:hidden;position:relative;width:100%;"]);
+const S_RightButtonWrapper = styled.div.withConfig({
+  displayName: "PrimaryMenu__S_RightButtonWrapper",
+  componentId: "sc-r8ur8y-2"
+})(["align-items:center;display:flex;height:100%;position:absolute;right:0;&::before{background:", ";content:'';display:block;height:100%;pointer-events:none;width:50px;}"], ({
+  theme
+}) => `linear-gradient(to left, ${theme.ui_menu_background} 10%, ${theme.ui_cpnt_pg_gradient_02} 90%)`);
+const S_LeftButtonWrapper = styled.div.withConfig({
+  displayName: "PrimaryMenu__S_LeftButtonWrapper",
+  componentId: "sc-r8ur8y-3"
+})(["align-items:center;display:flex;height:100%;left:0;position:absolute;&::after{background:", ";content:'';display:block;height:100%;pointer-events:none;width:50px;}"], ({
+  theme
+}) => `linear-gradient(to right, ${theme.ui_menu_background} 20%, ${theme.ui_cpnt_pg_gradient_02} 80%)`);
+const S_ButtonWrapper = styled.div.withConfig({
+  displayName: "PrimaryMenu__S_ButtonWrapper",
+  componentId: "sc-r8ur8y-4"
+})(["align-items:center;background-color:", ";display:flex;height:50px;& > button{background-color:", ";* path{stroke:", ";}}"], ({
+  theme
+}) => theme.ui_menu_background, ({
+  theme
+}) => theme.ui_menu_button_base, ({
+  theme
+}) => theme.ui_temp_grey_02);
+export default PrimaryMenu;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["useCallback","useEffect","useState","smoothscroll","styled","D_IconButton","useDetectOverflow","MenuItemNav","polyfill","DESKTOP_SCROLL_LEFT","PrimaryMenu","menus","showMenuAsIcon","style","primaryRef","setPrimaryRef","node","primaryCallbackRef","addEventListener","handleScroll","e","scrollTo","left","scrollLeft","deltaY","removeEventListener","trigger","isOverflow","isScrollBoxStart","isScrollBoxEnd","onClickLeftButton","scroll","behavior","onClickRightButton","React","createElement","S_PrimaryMenuBox","S_LeftButtonWrapper","S_ButtonWrapper","fillType","baseSize","baseColorKey","iconName","iconFillType","iconColorKey","shapeType","iconSize","onClick","S_Main_PrimaryMenu","onScroll","ref","map","menu","index","key","S_RightButtonWrapper","div","withConfig","displayName","componentId","theme","ui_menu_background","ui_cpnt_pg_gradient_02","ui_menu_button_base","ui_temp_grey_02"],"sources":["../../../../../src/desktop/components/DynamicDesktopNavBar/blocks/PrimaryMenu.tsx"],"sourcesContent":["import { useCallback, useEffect, useState } from 'react';\nimport smoothscroll from 'smoothscroll-polyfill';\n\nimport styled, { CSSProperties } from 'styled-components';\n\nimport { D_IconButton } from '../../..';\nimport { useDetectOverflow } from '../../../../common/hooks';\nimport { MenuItemNav } from '../components/MenuItemNav';\n\nimport type { ParsedNode } from '../types';\n\n// NOTE: safari-scroll-behavior-smooth polyfill\nsmoothscroll.polyfill();\n\ntype Props = {\n  menus: ParsedNode[];\n  showMenuAsIcon: boolean;\n  style?: CSSProperties;\n};\n\nconst DESKTOP_SCROLL_LEFT = 320;\n\nfunction PrimaryMenu({ menus, showMenuAsIcon, style }: Props) {\n  const [primaryRef, setPrimaryRef] = useState<{ node: HTMLUListElement | null }>({ node: null });\n\n  const primaryCallbackRef = useCallback(\n    (node) => {\n      if (!node) {\n        return;\n      }\n\n      setPrimaryRef({ node });\n    },\n    [menus]\n  );\n\n  useEffect(() => {\n    if (!primaryRef.node) {\n      return;\n    }\n\n    primaryRef.node.addEventListener('wheel', handleScroll);\n\n    function handleScroll(e: WheelEvent) {\n      if (primaryRef.node) {\n        primaryRef.node.scrollTo({ left: primaryRef.node.scrollLeft + e.deltaY });\n      }\n    }\n\n    return () => {\n      if (!primaryRef.node) {\n        return;\n      }\n\n      primaryRef.node.removeEventListener('scroll', handleScroll);\n    };\n  }, [primaryRef]);\n\n  const { trigger, isOverflow, isScrollBoxStart, isScrollBoxEnd } = useDetectOverflow(\n    primaryRef,\n    true\n  );\n\n  const onClickLeftButton = () => {\n    primaryRef.node &&\n      primaryRef.node.scroll({\n        left: primaryRef.node.scrollLeft - DESKTOP_SCROLL_LEFT,\n        behavior: 'smooth'\n      });\n  };\n\n  const onClickRightButton = () => {\n    primaryRef.node &&\n      primaryRef.node.scroll({\n        left: primaryRef.node.scrollLeft + DESKTOP_SCROLL_LEFT,\n        behavior: 'smooth'\n      });\n  };\n\n  return (\n    <S_PrimaryMenuBox style={style}>\n      {isOverflow && !isScrollBoxStart && (\n        <S_LeftButtonWrapper>\n          <S_ButtonWrapper>\n            <D_IconButton\n              fillType=\"fill\"\n              baseSize=\"medium\"\n              baseColorKey=\"ui_menu_background\"\n              iconName=\"ic_arrow_left\"\n              iconFillType=\"line\"\n              iconColorKey=\"ui_cpnt_button_icon_default\"\n              shapeType=\"circular\"\n              iconSize={20}\n              onClick={onClickLeftButton}\n            />\n          </S_ButtonWrapper>\n        </S_LeftButtonWrapper>\n      )}\n\n      <S_Main_PrimaryMenu onScroll={() => trigger()} ref={primaryCallbackRef}>\n        {menus.map((menu, index) => (\n          <MenuItemNav key={index} menu={menu} showMenuAsIcon={showMenuAsIcon} />\n        ))}\n      </S_Main_PrimaryMenu>\n\n      {isOverflow && !isScrollBoxEnd && (\n        <S_RightButtonWrapper>\n          <S_ButtonWrapper>\n            <D_IconButton\n              fillType=\"fill\"\n              baseSize=\"medium\"\n              baseColorKey=\"ui_menu_background\"\n              iconName=\"ic_arrow_right\"\n              iconFillType=\"line\"\n              iconColorKey=\"ui_cpnt_button_icon_default\"\n              shapeType=\"circular\"\n              iconSize={20}\n              onClick={onClickRightButton}\n            />\n          </S_ButtonWrapper>\n        </S_RightButtonWrapper>\n      )}\n    </S_PrimaryMenuBox>\n  );\n}\n\nconst S_Main_PrimaryMenu = styled.div`\n  display: flex;\n  grid-area: PRIMARY_MENU;\n  overflow-x: auto;\n  overscroll-behavior-y: none;\n  width: max-content;\n\n  & > div:first-child {\n    margin-left: 32px;\n  }\n`;\n\nconst S_PrimaryMenuBox = styled.div`\n  display: flex;\n  height: 48px;\n  max-height: 100%;\n  max-width: 100%;\n  overflow-x: hidden;\n  overflow-y: hidden;\n  position: relative;\n  width: 100%;\n`;\n\nconst S_RightButtonWrapper = styled.div`\n  align-items: center;\n  display: flex;\n  height: 100%;\n  position: absolute;\n  right: 0;\n\n  &::before {\n    background: ${({ theme }) =>\n      `linear-gradient(to left, ${theme.ui_menu_background} 10%, ${theme.ui_cpnt_pg_gradient_02} 90%)`};\n    content: '';\n    display: block;\n    height: 100%;\n    pointer-events: none;\n    width: 50px;\n  }\n`;\n\nconst S_LeftButtonWrapper = styled.div`\n  align-items: center;\n  display: flex;\n  height: 100%;\n  left: 0;\n  position: absolute;\n\n  &::after {\n    background: ${({ theme }) =>\n      `linear-gradient(to right, ${theme.ui_menu_background} 20%, ${theme.ui_cpnt_pg_gradient_02} 80%)`};\n    content: '';\n    display: block;\n    height: 100%;\n    pointer-events: none;\n    width: 50px;\n  }\n`;\n\nconst S_ButtonWrapper = styled.div`\n  align-items: center;\n  background-color: ${({ theme }) => theme.ui_menu_background};\n  display: flex;\n  height: 50px;\n\n  & > button {\n    background-color: ${({ theme }) => theme.ui_menu_button_base};\n\n    * path {\n      stroke: ${({ theme }) => theme.ui_temp_grey_02};\n    }\n  }\n`;\n\nexport default PrimaryMenu;\n"],"mappings":"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","ignoreList":[]}

package/dist/desktop/components/DynamicDesktopNavBar/blocks/SecondaryMenu.js

@@ -0,0 +1,126 @@
+import { useCallback, useEffect, useState } from 'react';
+import smoothscroll from 'smoothscroll-polyfill';
+import styled from 'styled-components';
+import { D_IconButton } from '../../..';
+import { useDetectOverflow } from '../../../../common/hooks';
+import { MenuItemNav } from '../components/MenuItemNav';
+// NOTE: safari-scroll-behavior-smooth polyfill
+smoothscroll.polyfill();
+const DESKTOP_SCROLL_LEFT = 320;
+function SecondaryMenu({
+  menus,
+  showMenuAsIcon,
+  style
+}) {
+  const [primaryRef, setPrimaryRef] = useState({
+    node: null
+  });
+  const primaryCallbackRef = useCallback(node => {
+    if (!node) {
+      return;
+    }
+    setPrimaryRef({
+      node
+    });
+  }, [menus]);
+  useEffect(() => {
+    if (!primaryRef.node) {
+      return;
+    }
+    primaryRef.node.addEventListener('wheel', handleScroll);
+    function handleScroll(e) {
+      if (primaryRef.node) {
+        primaryRef.node.scrollTo({
+          left: primaryRef.node.scrollLeft + e.deltaY
+        });
+      }
+    }
+    return () => {
+      if (!primaryRef.node) {
+        return;
+      }
+      primaryRef.node.removeEventListener('scroll', handleScroll);
+    };
+  }, [primaryRef]);
+  const {
+    trigger,
+    isOverflow,
+    isScrollBoxStart,
+    isScrollBoxEnd
+  } = useDetectOverflow(primaryRef, true);
+  const onClickLeftButton = () => {
+    primaryRef.node && primaryRef.node.scroll({
+      left: primaryRef.node.scrollLeft - DESKTOP_SCROLL_LEFT,
+      behavior: 'smooth'
+    });
+  };
+  const onClickRightButton = () => {
+    primaryRef.node && primaryRef.node.scroll({
+      left: primaryRef.node.scrollLeft + DESKTOP_SCROLL_LEFT,
+      behavior: 'smooth'
+    });
+  };
+  return /*#__PURE__*/React.createElement(S_SecondaryMenu, {
+    style: style
+  }, isOverflow && !isScrollBoxStart && /*#__PURE__*/React.createElement(S_LeftButtonWrapper, null, /*#__PURE__*/React.createElement(S_ButtonWrapper, null, /*#__PURE__*/React.createElement(D_IconButton, {
+    fillType: "fill",
+    baseSize: "medium",
+    baseColorKey: "ui_menu_background",
+    iconName: "ic_arrow_left",
+    iconFillType: "line",
+    iconColorKey: "ui_cpnt_button_icon_default",
+    shapeType: "circular",
+    iconSize: 20,
+    onClick: onClickLeftButton
+  }))), /*#__PURE__*/React.createElement(S_Main_SecondaryMenu, {
+    style: style,
+    onScroll: () => trigger(),
+    ref: primaryCallbackRef
+  }, menus.map((menu, index) => /*#__PURE__*/React.createElement(MenuItemNav, {
+    key: index,
+    menu: menu,
+    showMenuAsIcon: showMenuAsIcon
+  }))), isOverflow && !isScrollBoxEnd && /*#__PURE__*/React.createElement(S_RightButtonWrapper, null, /*#__PURE__*/React.createElement(S_ButtonWrapper, null, /*#__PURE__*/React.createElement(D_IconButton, {
+    fillType: "fill",
+    baseSize: "medium",
+    baseColorKey: "ui_menu_background",
+    iconName: "ic_arrow_right",
+    iconFillType: "line",
+    iconColorKey: "ui_cpnt_button_icon_default",
+    shapeType: "circular",
+    iconSize: 20,
+    onClick: onClickRightButton
+  }))));
+}
+const S_Main_SecondaryMenu = styled.div.withConfig({
+  displayName: "SecondaryMenu__S_Main_SecondaryMenu",
+  componentId: "sc-62rx7y-0"
+})(["display:flex;grid-area:SECONDARY_MENU;overflow-x:auto;overscroll-behavior-y:none;width:max-content;& > div:first-child{margin-left:32px;}"]);
+const S_SecondaryMenu = styled.div.withConfig({
+  displayName: "SecondaryMenu__S_SecondaryMenu",
+  componentId: "sc-62rx7y-1"
+})(["display:flex;height:48px;max-height:100%;max-width:100%;overflow-x:hidden;overflow-y:hidden;position:relative;width:100%;"]);
+const S_RightButtonWrapper = styled.div.withConfig({
+  displayName: "SecondaryMenu__S_RightButtonWrapper",
+  componentId: "sc-62rx7y-2"
+})(["align-items:center;display:flex;height:100%;position:absolute;right:0;&::before{background:", ";content:'';display:block;height:100%;pointer-events:none;width:50px;}"], ({
+  theme
+}) => `linear-gradient(to left, ${theme.ui_menu_background} 10%, ${theme.ui_cpnt_pg_gradient_02} 90%)`);
+const S_LeftButtonWrapper = styled.div.withConfig({
+  displayName: "SecondaryMenu__S_LeftButtonWrapper",
+  componentId: "sc-62rx7y-3"
+})(["align-items:center;display:flex;height:100%;left:0;position:absolute;&::after{background:", ";content:'';display:block;height:100%;pointer-events:none;width:50px;}"], ({
+  theme
+}) => `linear-gradient(to right, ${theme.ui_menu_background} 20%, ${theme.ui_cpnt_pg_gradient_02} 80%)`);
+const S_ButtonWrapper = styled.div.withConfig({
+  displayName: "SecondaryMenu__S_ButtonWrapper",
+  componentId: "sc-62rx7y-4"
+})(["align-items:center;background-color:", ";display:flex;height:50px;& > button{background-color:", ";* path{stroke:", ";}}"], ({
+  theme
+}) => theme.ui_menu_background, ({
+  theme
+}) => theme.ui_menu_button_base, ({
+  theme
+}) => theme.ui_temp_grey_02);
+export default SecondaryMenu;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["useCallback","useEffect","useState","smoothscroll","styled","D_IconButton","useDetectOverflow","MenuItemNav","polyfill","DESKTOP_SCROLL_LEFT","SecondaryMenu","menus","showMenuAsIcon","style","primaryRef","setPrimaryRef","node","primaryCallbackRef","addEventListener","handleScroll","e","scrollTo","left","scrollLeft","deltaY","removeEventListener","trigger","isOverflow","isScrollBoxStart","isScrollBoxEnd","onClickLeftButton","scroll","behavior","onClickRightButton","React","createElement","S_SecondaryMenu","S_LeftButtonWrapper","S_ButtonWrapper","fillType","baseSize","baseColorKey","iconName","iconFillType","iconColorKey","shapeType","iconSize","onClick","S_Main_SecondaryMenu","onScroll","ref","map","menu","index","key","S_RightButtonWrapper","div","withConfig","displayName","componentId","theme","ui_menu_background","ui_cpnt_pg_gradient_02","ui_menu_button_base","ui_temp_grey_02"],"sources":["../../../../../src/desktop/components/DynamicDesktopNavBar/blocks/SecondaryMenu.tsx"],"sourcesContent":["import { useCallback, useEffect, useState } from 'react';\nimport smoothscroll from 'smoothscroll-polyfill';\n\nimport styled, { CSSProperties } from 'styled-components';\n\nimport { D_IconButton } from '../../..';\nimport { useDetectOverflow } from '../../../../common/hooks';\nimport { MenuItemNav } from '../components/MenuItemNav';\n\nimport type { ParsedNode } from '../types';\n\n// NOTE: safari-scroll-behavior-smooth polyfill\nsmoothscroll.polyfill();\n\ntype Props = {\n  menus: ParsedNode[];\n  showMenuAsIcon: boolean;\n  style?: CSSProperties;\n};\n\nconst DESKTOP_SCROLL_LEFT = 320;\n\nfunction SecondaryMenu({ menus, showMenuAsIcon, style }: Props) {\n  const [primaryRef, setPrimaryRef] = useState<{ node: HTMLUListElement | null }>({ node: null });\n\n  const primaryCallbackRef = useCallback(\n    (node) => {\n      if (!node) {\n        return;\n      }\n\n      setPrimaryRef({ node });\n    },\n    [menus]\n  );\n\n  useEffect(() => {\n    if (!primaryRef.node) {\n      return;\n    }\n\n    primaryRef.node.addEventListener('wheel', handleScroll);\n\n    function handleScroll(e: WheelEvent) {\n      if (primaryRef.node) {\n        primaryRef.node.scrollTo({ left: primaryRef.node.scrollLeft + e.deltaY });\n      }\n    }\n\n    return () => {\n      if (!primaryRef.node) {\n        return;\n      }\n\n      primaryRef.node.removeEventListener('scroll', handleScroll);\n    };\n  }, [primaryRef]);\n\n  const { trigger, isOverflow, isScrollBoxStart, isScrollBoxEnd } = useDetectOverflow(\n    primaryRef,\n    true\n  );\n\n  const onClickLeftButton = () => {\n    primaryRef.node &&\n      primaryRef.node.scroll({\n        left: primaryRef.node.scrollLeft - DESKTOP_SCROLL_LEFT,\n        behavior: 'smooth'\n      });\n  };\n\n  const onClickRightButton = () => {\n    primaryRef.node &&\n      primaryRef.node.scroll({\n        left: primaryRef.node.scrollLeft + DESKTOP_SCROLL_LEFT,\n        behavior: 'smooth'\n      });\n  };\n\n  return (\n    <S_SecondaryMenu style={style}>\n      {isOverflow && !isScrollBoxStart && (\n        <S_LeftButtonWrapper>\n          <S_ButtonWrapper>\n            <D_IconButton\n              fillType=\"fill\"\n              baseSize=\"medium\"\n              baseColorKey=\"ui_menu_background\"\n              iconName=\"ic_arrow_left\"\n              iconFillType=\"line\"\n              iconColorKey=\"ui_cpnt_button_icon_default\"\n              shapeType=\"circular\"\n              iconSize={20}\n              onClick={onClickLeftButton}\n            />\n          </S_ButtonWrapper>\n        </S_LeftButtonWrapper>\n      )}\n      <S_Main_SecondaryMenu style={style} onScroll={() => trigger()} ref={primaryCallbackRef}>\n        {menus.map((menu, index) => (\n          <MenuItemNav key={index} menu={menu} showMenuAsIcon={showMenuAsIcon} />\n        ))}\n      </S_Main_SecondaryMenu>\n\n      {isOverflow && !isScrollBoxEnd && (\n        <S_RightButtonWrapper>\n          <S_ButtonWrapper>\n            <D_IconButton\n              fillType=\"fill\"\n              baseSize=\"medium\"\n              baseColorKey=\"ui_menu_background\"\n              iconName=\"ic_arrow_right\"\n              iconFillType=\"line\"\n              iconColorKey=\"ui_cpnt_button_icon_default\"\n              shapeType=\"circular\"\n              iconSize={20}\n              onClick={onClickRightButton}\n            />\n          </S_ButtonWrapper>\n        </S_RightButtonWrapper>\n      )}\n    </S_SecondaryMenu>\n  );\n}\n\nconst S_Main_SecondaryMenu = styled.div`\n  display: flex;\n  grid-area: SECONDARY_MENU;\n  overflow-x: auto;\n  overscroll-behavior-y: none;\n  width: max-content;\n\n  & > div:first-child {\n    margin-left: 32px;\n  }\n`;\n\nconst S_SecondaryMenu = styled.div`\n  display: flex;\n  height: 48px;\n  max-height: 100%;\n  max-width: 100%;\n  overflow-x: hidden;\n  overflow-y: hidden;\n  position: relative;\n  width: 100%;\n`;\n\nconst S_RightButtonWrapper = styled.div`\n  align-items: center;\n  display: flex;\n  height: 100%;\n  position: absolute;\n  right: 0;\n\n  &::before {\n    background: ${({ theme }) =>\n      `linear-gradient(to left, ${theme.ui_menu_background} 10%, ${theme.ui_cpnt_pg_gradient_02} 90%)`};\n    content: '';\n    display: block;\n    height: 100%;\n    pointer-events: none;\n    width: 50px;\n  }\n`;\n\nconst S_LeftButtonWrapper = styled.div`\n  align-items: center;\n  display: flex;\n  height: 100%;\n  left: 0;\n  position: absolute;\n\n  &::after {\n    background: ${({ theme }) =>\n      `linear-gradient(to right, ${theme.ui_menu_background} 20%, ${theme.ui_cpnt_pg_gradient_02} 80%)`};\n    content: '';\n    display: block;\n    height: 100%;\n    pointer-events: none;\n    width: 50px;\n  }\n`;\n\nconst S_ButtonWrapper = styled.div`\n  align-items: center;\n  background-color: ${({ theme }) => theme.ui_menu_background};\n  display: flex;\n  height: 50px;\n\n  & > button {\n    background-color: ${({ theme }) => theme.ui_menu_button_base};\n\n    * path {\n      stroke: ${({ theme }) => theme.ui_temp_grey_02};\n    }\n  }\n`;\n\nexport default SecondaryMenu;\n"],"mappings":"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","ignoreList":[]}

package/dist/desktop/components/DynamicDesktopNavBar/blocks/UserProfile.js

@@ -0,0 +1,46 @@
+import { forwardRef } from 'react';
+import styled from 'styled-components';
+import { NavLink } from '../../../../common/components/Navigations';
+import { ImageView, Spacing } from '../../../../hybrid';
+function UserProfile({
+  src,
+  to,
+  overrideUserProfile,
+  leftIconButton,
+  leftIconButton2,
+  style
+}, ref) {
+  return /*#__PURE__*/React.createElement(S_UserProfile, {
+    style: style,
+    ref: ref
+  }, overrideUserProfile ? /*#__PURE__*/React.createElement(S_OverrideUserProfile, null, overrideUserProfile) : /*#__PURE__*/React.createElement(S_ImageViewWrapper, null, leftIconButton2 && /*#__PURE__*/React.createElement(React.Fragment, null, leftIconButton2, /*#__PURE__*/React.createElement(Spacing, {
+    size: "spacing_b",
+    spacingType: "width"
+  })), leftIconButton && /*#__PURE__*/React.createElement(React.Fragment, null, leftIconButton, /*#__PURE__*/React.createElement(Spacing, {
+    size: "spacing_b",
+    spacingType: "width"
+  })), /*#__PURE__*/React.createElement(NavLink, {
+    to: to
+  }, /*#__PURE__*/React.createElement(ImageView, {
+    width: 32,
+    ratio: "1_1",
+    scaleType: "cover",
+    shapeType: "circular",
+    src: src,
+    borderMode: "use"
+  }))));
+}
+const S_UserProfile = styled.div.withConfig({
+  displayName: "UserProfile__S_UserProfile",
+  componentId: "sc-171ywyg-0"
+})(["display:flex;grid-area:USER_PROFILE;justify-content:flex-end;"]);
+const S_OverrideUserProfile = styled.div.withConfig({
+  displayName: "UserProfile__S_OverrideUserProfile",
+  componentId: "sc-171ywyg-1"
+})(["width:max-content;"]);
+const S_ImageViewWrapper = styled.div.withConfig({
+  displayName: "UserProfile__S_ImageViewWrapper",
+  componentId: "sc-171ywyg-2"
+})(["align-items:center;display:flex;"]);
+export default /*#__PURE__*/forwardRef(UserProfile);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/desktop/components/DynamicDesktopNavBar/blocks/index.js

@@ -0,0 +1,5 @@
+export { default as BrandLogo } from './BrandLogo';
+export { default as PrimaryMenu } from './PrimaryMenu';
+export { default as SecondaryMenu } from './SecondaryMenu';
+export { default as UserProfile } from './UserProfile';
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJkZWZhdWx0IiwiQnJhbmRMb2dvIiwiUHJpbWFyeU1lbnUiLCJTZWNvbmRhcnlNZW51IiwiVXNlclByb2ZpbGUiXSwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvZGVza3RvcC9jb21wb25lbnRzL0R5bmFtaWNEZXNrdG9wTmF2QmFyL2Jsb2Nrcy9pbmRleC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBkZWZhdWx0IGFzIEJyYW5kTG9nbyB9IGZyb20gJy4vQnJhbmRMb2dvJztcbmV4cG9ydCB7IGRlZmF1bHQgYXMgUHJpbWFyeU1lbnUgfSBmcm9tICcuL1ByaW1hcnlNZW51JztcbmV4cG9ydCB7IGRlZmF1bHQgYXMgU2Vjb25kYXJ5TWVudSB9IGZyb20gJy4vU2Vjb25kYXJ5TWVudSc7XG5leHBvcnQgeyBkZWZhdWx0IGFzIFVzZXJQcm9maWxlIH0gZnJvbSAnLi9Vc2VyUHJvZmlsZSc7XG4iXSwibWFwcGluZ3MiOiJBQUFBLFNBQVNBLE9BQU8sSUFBSUMsU0FBUyxRQUFRLGFBQWE7QUFDbEQsU0FBU0QsT0FBTyxJQUFJRSxXQUFXLFFBQVEsZUFBZTtBQUN0RCxTQUFTRixPQUFPLElBQUlHLGFBQWEsUUFBUSxpQkFBaUI7QUFDMUQsU0FBU0gsT0FBTyxJQUFJSSxXQUFXLFFBQVEsZUFBZSIsImlnbm9yZUxpc3QiOltdfQ==