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

package/dist/sub/DynamicLayout/sections/MembershipSection/EditType/templates/TemplateA/desktop/components/MembershipSheet.js

@@ -0,0 +1,108 @@
+import { useContext, useState } from 'react';
+import { ContentSheet } from '@desktop/panels';
+import { sectionContext } from '@sub/DynamicLayout/components/Section';
+import { D_MembershipSectionItem } from '@sub/DynamicLayout/sections/MembershipSection/components';
+import { MEMBERSHIP_SECTION_TONE_COLOR } from '@sub/DynamicLayout/sections/MembershipSection/constants';
+import styled, { css } from 'styled-components';
+import MembershipBenefitInfo from './MembershipBenefitInfo';
+import MembershipPlanSheet from './MembershipPlanSheet';
+import NarrowMembershipListView from './NarrowMembershipListView';
+import UnavailableMembershipPlanSheet from './UnavailableMembershipPlanSheet';
+import WideMembershipListView from './WideMembershipListView';
+function MembershipSheet({
+  connectedMemberships,
+  isWideView
+}) {
+  const [currentIndex, setCurrentIndex] = useState(0);
+  const section = useContext(sectionContext);
+  if (!section) {
+    return /*#__PURE__*/React.createElement(React.Fragment, null);
+  }
+  const {
+    membership,
+    connectedSubscriptionProducts
+  } = connectedMemberships[currentIndex];
+  const {
+    itemHighlightingColorInHex,
+    itemToneType
+  } = section.styles;
+  const handleMembershipClick = currentIndex => {
+    setCurrentIndex(currentIndex);
+  };
+  const isOnlyMembership = connectedMemberships.length === 1;
+  return /*#__PURE__*/React.createElement(S_MembershipBox, {
+    isWideView: isWideView
+  }, isWideView ? /*#__PURE__*/React.createElement(React.Fragment, null, !isOnlyMembership && /*#__PURE__*/React.createElement(WideMembershipListView, {
+    connectedMemberships: connectedMemberships,
+    currentIndex: currentIndex,
+    handleMembershipClick: handleMembershipClick,
+    itemToneType: itemToneType,
+    itemHighlightingColorInHex: itemHighlightingColorInHex
+  })) : /*#__PURE__*/React.createElement(React.Fragment, null, !isOnlyMembership && /*#__PURE__*/React.createElement(NarrowMembershipListView, {
+    connectedMemberships: connectedMemberships,
+    currentIndex: currentIndex,
+    handleMembershipClick: handleMembershipClick,
+    itemToneType: itemToneType,
+    itemHighlightingColorInHex: itemHighlightingColorInHex
+  })), /*#__PURE__*/React.createElement(S_ScrollBarVisible, {
+    isWideView: isWideView,
+    itemToneType: itemToneType,
+    isOnlyMembership: isOnlyMembership
+  }, /*#__PURE__*/React.createElement(ContentSheet, {
+    overrideCSS: {
+      backgroundColor: MEMBERSHIP_SECTION_TONE_COLOR[itemToneType].membershipSheetBackgroundColor,
+      display: 'flex',
+      flex: '2',
+      overflow: 'auto',
+      padding: isOnlyMembership ? '56px 10%' : '56px 0 56px 56px'
+    },
+    width: "100%",
+    height: "720px",
+    shapeType: "round"
+  }, membership.membershipCardTemplate && /*#__PURE__*/React.createElement(D_MembershipSectionItem.MembershipCard, {
+    membershipCardTemplate: membership.membershipCardTemplate
+  }), /*#__PURE__*/React.createElement(S_MembershipDetailBox, {
+    isOnlyMembership: isOnlyMembership
+  }, membership.title && /*#__PURE__*/React.createElement(D_MembershipSectionItem.Title, {
+    text: membership.title,
+    styleTheme: "displayBold",
+    color: MEMBERSHIP_SECTION_TONE_COLOR[itemToneType].membershipSheetTextLabelColor,
+    textAlign: "left",
+    wordBreak: "break_all"
+  }), membership.membershipBenefitInfo && /*#__PURE__*/React.createElement(MembershipBenefitInfo, {
+    membershipBenefitInfo: membership.membershipBenefitInfo,
+    itemToneTextLabelColor: MEMBERSHIP_SECTION_TONE_COLOR[itemToneType].membershipSheetTextLabelColor
+  }), connectedSubscriptionProducts.length > 0 ? /*#__PURE__*/React.createElement(MembershipPlanSheet, {
+    connectedSubscriptionProducts: connectedSubscriptionProducts[0],
+    sectionStyles: section.styles
+  }) : /*#__PURE__*/React.createElement(UnavailableMembershipPlanSheet, {
+    sectionStyles: section.styles
+  })))));
+}
+const scrollVisible = css(["::-webkit-scrollbar-thumb{background-clip:padding-box;background-color:", ";border:8px solid transparent;border-radius:24px;}::-webkit-scrollbar{display:block;height:10px;width:24px;}"], ({
+  itemToneType
+}) => MEMBERSHIP_SECTION_TONE_COLOR[itemToneType].scrollbarColor);
+const S_ScrollBarVisible = styled.div.withConfig({
+  displayName: "MembershipSheet__S_ScrollBarVisible",
+  componentId: "sc-1a64ook-0"
+})(["width:", ";& > div{", "}"], ({
+  isWideView,
+  isOnlyMembership
+}) => isWideView && !isOnlyMembership ? 'calc(67% - 48px)' : '100%', scrollVisible);
+const S_MembershipBox = styled.div.withConfig({
+  displayName: "MembershipSheet__S_MembershipBox",
+  componentId: "sc-1a64ook-1"
+})(["display:flex;flex-direction:", ";justify-content:space-between;position:relative;"], ({
+  isWideView
+}) => isWideView ? 'row' : 'column');
+const S_MembershipDetailBox = styled.div.withConfig({
+  displayName: "MembershipSheet__S_MembershipDetailBox",
+  componentId: "sc-1a64ook-2"
+})(["margin-left:", ";margin-right:", ";position:relative;width:100%;"], ({
+  theme
+}) => theme.spacing.spacingH, ({
+  isOnlyMembership,
+  theme
+}) => isOnlyMembership ? 0 : theme.spacing.spacingH);
+export default MembershipSheet;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["useContext","useState","ContentSheet","sectionContext","D_MembershipSectionItem","MEMBERSHIP_SECTION_TONE_COLOR","styled","css","MembershipBenefitInfo","MembershipPlanSheet","NarrowMembershipListView","UnavailableMembershipPlanSheet","WideMembershipListView","MembershipSheet","connectedMemberships","isWideView","currentIndex","setCurrentIndex","section","React","createElement","Fragment","membership","connectedSubscriptionProducts","itemHighlightingColorInHex","itemToneType","styles","handleMembershipClick","isOnlyMembership","length","S_MembershipBox","S_ScrollBarVisible","overrideCSS","backgroundColor","membershipSheetBackgroundColor","display","flex","overflow","padding","width","height","shapeType","membershipCardTemplate","MembershipCard","S_MembershipDetailBox","title","Title","text","styleTheme","color","membershipSheetTextLabelColor","textAlign","wordBreak","membershipBenefitInfo","itemToneTextLabelColor","sectionStyles","scrollVisible","scrollbarColor","div","withConfig","displayName","componentId","theme","spacing","spacingH"],"sources":["../../../../../../../../../../src/sub/DynamicLayout/sections/MembershipSection/EditType/templates/TemplateA/desktop/components/MembershipSheet.tsx"],"sourcesContent":["import { useContext, useState } from 'react';\n\nimport { ContentSheet } from '@desktop/panels';\nimport { sectionContext } from '@sub/DynamicLayout/components/Section';\nimport { D_MembershipSectionItem } from '@sub/DynamicLayout/sections/MembershipSection/components';\nimport { MEMBERSHIP_SECTION_TONE_COLOR } from '@sub/DynamicLayout/sections/MembershipSection/constants';\nimport styled, { css } from 'styled-components';\n\nimport MembershipBenefitInfo from './MembershipBenefitInfo';\nimport MembershipPlanSheet from './MembershipPlanSheet';\nimport NarrowMembershipListView from './NarrowMembershipListView';\nimport UnavailableMembershipPlanSheet from './UnavailableMembershipPlanSheet';\nimport WideMembershipListView from './WideMembershipListView';\n\nimport type { IConnectedMembership, TypeOfItemToneType, ISection } from '@sub/DynamicLayout/types';\n\ntype Props = {\n  connectedMemberships: IConnectedMembership[];\n  isWideView: boolean;\n};\n\nfunction MembershipSheet({ connectedMemberships, isWideView }: Props) {\n  const [currentIndex, setCurrentIndex] = useState<number>(0);\n\n  const section = useContext(sectionContext) as ISection;\n\n  if (!section) {\n    return <></>;\n  }\n\n  const { membership, connectedSubscriptionProducts } = connectedMemberships[currentIndex];\n  const { itemHighlightingColorInHex, itemToneType } = section.styles;\n\n  const handleMembershipClick = (currentIndex: number) => {\n    setCurrentIndex(currentIndex);\n  };\n\n  const isOnlyMembership = connectedMemberships.length === 1;\n\n  return (\n    <S_MembershipBox isWideView={isWideView}>\n      {isWideView ? (\n        <>\n          {!isOnlyMembership && (\n            <WideMembershipListView\n              connectedMemberships={connectedMemberships}\n              currentIndex={currentIndex}\n              handleMembershipClick={handleMembershipClick}\n              itemToneType={itemToneType}\n              itemHighlightingColorInHex={itemHighlightingColorInHex}\n            />\n          )}\n        </>\n      ) : (\n        <>\n          {!isOnlyMembership && (\n            <NarrowMembershipListView\n              connectedMemberships={connectedMemberships}\n              currentIndex={currentIndex}\n              handleMembershipClick={handleMembershipClick}\n              itemToneType={itemToneType}\n              itemHighlightingColorInHex={itemHighlightingColorInHex}\n            />\n          )}\n        </>\n      )}\n\n      <S_ScrollBarVisible\n        isWideView={isWideView}\n        itemToneType={itemToneType}\n        isOnlyMembership={isOnlyMembership}\n      >\n        <ContentSheet\n          overrideCSS={{\n            backgroundColor:\n              MEMBERSHIP_SECTION_TONE_COLOR[itemToneType].membershipSheetBackgroundColor,\n            display: 'flex',\n            flex: '2',\n            overflow: 'auto',\n            padding: isOnlyMembership ? '56px 10%' : '56px 0 56px 56px'\n          }}\n          width=\"100%\"\n          height=\"720px\"\n          shapeType=\"round\"\n        >\n          {membership.membershipCardTemplate && (\n            <D_MembershipSectionItem.MembershipCard\n              membershipCardTemplate={membership.membershipCardTemplate}\n            />\n          )}\n          <S_MembershipDetailBox isOnlyMembership={isOnlyMembership}>\n            {membership.title && (\n              <D_MembershipSectionItem.Title\n                text={membership.title}\n                styleTheme=\"displayBold\"\n                color={MEMBERSHIP_SECTION_TONE_COLOR[itemToneType].membershipSheetTextLabelColor}\n                textAlign=\"left\"\n                wordBreak=\"break_all\"\n              />\n            )}\n\n            {membership.membershipBenefitInfo && (\n              <MembershipBenefitInfo\n                membershipBenefitInfo={membership.membershipBenefitInfo}\n                itemToneTextLabelColor={\n                  MEMBERSHIP_SECTION_TONE_COLOR[itemToneType].membershipSheetTextLabelColor\n                }\n              />\n            )}\n\n            {connectedSubscriptionProducts.length > 0 ? (\n              <MembershipPlanSheet\n                connectedSubscriptionProducts={connectedSubscriptionProducts[0]}\n                sectionStyles={section.styles}\n              />\n            ) : (\n              <UnavailableMembershipPlanSheet sectionStyles={section.styles} />\n            )}\n          </S_MembershipDetailBox>\n        </ContentSheet>\n      </S_ScrollBarVisible>\n    </S_MembershipBox>\n  );\n}\n\nconst scrollVisible = css<{ itemToneType: TypeOfItemToneType }>`\n  ::-webkit-scrollbar-thumb {\n    background-clip: padding-box;\n    background-color: ${({ itemToneType }) =>\n      MEMBERSHIP_SECTION_TONE_COLOR[itemToneType].scrollbarColor};\n    border: 8px solid transparent;\n    border-radius: 24px;\n  }\n\n  ::-webkit-scrollbar {\n    display: block;\n    height: 10px;\n    width: 24px;\n  }\n`;\n\nconst S_ScrollBarVisible = styled.div<{\n  isWideView: boolean;\n  itemToneType: TypeOfItemToneType;\n  isOnlyMembership: boolean;\n}>`\n  width: ${({ isWideView, isOnlyMembership }) =>\n    isWideView && !isOnlyMembership ? 'calc(67% - 48px)' : '100%'};\n\n  & > div {\n    ${scrollVisible}\n  }\n`;\n\nconst S_MembershipBox = styled.div<{ isWideView: boolean }>`\n  display: flex;\n  flex-direction: ${({ isWideView }) => (isWideView ? 'row' : 'column')};\n  justify-content: space-between;\n  position: relative;\n`;\n\nconst S_MembershipDetailBox = styled.div<{ isOnlyMembership: boolean }>`\n  margin-left: ${({ theme }) => theme.spacing.spacingH};\n  margin-right: ${({ isOnlyMembership, theme }) => (isOnlyMembership ? 0 : theme.spacing.spacingH)};\n  position: relative;\n  width: 100%;\n`;\n\nexport default MembershipSheet;\n"],"mappings":"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","ignoreList":[]}

package/dist/sub/DynamicLayout/sections/MembershipSection/EditType/templates/TemplateA/desktop/components/NarrowMembershipListView.js

@@ -0,0 +1,196 @@
+import { Fragment, useEffect, useMemo, useRef, useState } from 'react';
+import { ContentSheet } from '@desktop/panels';
+import { D_MembershipSectionItem } from '@sub/DynamicLayout/sections/MembershipSection/components';
+import { MEMBERSHIP_SECTION_TONE_COLOR } from '@sub/DynamicLayout/sections/MembershipSection/constants';
+import styled, { css } from 'styled-components';
+function NarrowMembershipListView({
+  connectedMemberships,
+  itemHighlightingColorInHex,
+  itemToneType,
+  currentIndex,
+  handleMembershipClick
+}) {
+  const resizeTarget = useRef(null);
+  const membershipListRef = useRef(null);
+  const [scrollValue, setScrollValue] = useState(0);
+  const [targetWidth, setTargetWidth] = useState(0);
+  const handleScroll = () => {
+    if (membershipListRef === null || membershipListRef.current === null) {
+      return;
+    }
+    setScrollValue(membershipListRef.current.scrollLeft);
+  };
+
+  /**
+   * @when : 화면 진입 시
+   * @expected : 스크롤을 감지하는 이벤트 핸들러를 추가합니다.
+   * @clear : 스크롤을 감지하는 이벤트 핸들러를 제거합니다.
+   */
+  useEffect(() => {
+    if (!membershipListRef.current) {
+      return;
+    }
+    membershipListRef.current.addEventListener('scroll', handleScroll);
+    return () => {
+      if (!membershipListRef.current) {
+        return;
+      }
+      membershipListRef.current.removeEventListener('scroll', handleScroll);
+    };
+  }, []);
+
+  /**
+   * @when : 화면 진입 시
+   * @expected : 콘텐츠 영역의 크기를 확인해서 observer를 추가합니다.
+   * @clear : observer를 제거합니다.
+   */
+  useEffect(() => {
+    const element = resizeTarget?.current;
+    if (!element) return;
+    const observer = new ResizeObserver(entries => {
+      entries.forEach(entry => {
+        setTargetWidth(entry.contentRect.width);
+      });
+    });
+    observer.observe(element);
+    return () => {
+      observer.disconnect();
+    };
+  }, []);
+  const isLeftMaskingCoverShow = connectedMemberships.length > 2 && scrollValue > 0;
+  const isRightMaskingCoverShow = useMemo(() => {
+    if (connectedMemberships.length < 3) {
+      return false;
+    }
+    if (scrollValue === 0) {
+      return true;
+    }
+    return membershipListRef.current ? membershipListRef.current.scrollLeft + membershipListRef.current.clientWidth < membershipListRef.current.scrollWidth - 1 : scrollValue === 0;
+  }, [connectedMemberships, membershipListRef.current, scrollValue, targetWidth]);
+  const scrollPrev = x => {
+    const {
+      scrollLeft
+    } = membershipListRef.current || {};
+    if (membershipListRef.current && typeof scrollLeft === 'number') {
+      membershipListRef.current.scroll({
+        left: scrollLeft - x,
+        behavior: 'smooth'
+      });
+      setScrollValue(scrollLeft - x);
+    }
+  };
+  const scrollNext = x => {
+    const {
+      scrollLeft
+    } = membershipListRef.current || {};
+    if (membershipListRef.current && typeof scrollLeft === 'number') {
+      membershipListRef.current.scroll({
+        left: scrollLeft + x,
+        behavior: 'smooth'
+      });
+      setScrollValue(scrollLeft + x);
+    }
+  };
+  return /*#__PURE__*/React.createElement(S_NarrowMembershipList, null, connectedMemberships.length > 0 && /*#__PURE__*/React.createElement(S_MembershipListBox, null, isLeftMaskingCoverShow && /*#__PURE__*/React.createElement(S_ArrowIconCover, {
+    position: "left"
+  }, /*#__PURE__*/React.createElement(D_MembershipSectionItem.IconButton, {
+    iconButtonBorderColor: MEMBERSHIP_SECTION_TONE_COLOR[itemToneType].iconButtonBorderColor,
+    iconName: "ic_arrow_left",
+    iconButtonIconColor: MEMBERSHIP_SECTION_TONE_COLOR[itemToneType].iconButtonIconColor,
+    iconButtonDisabledIconColor: MEMBERSHIP_SECTION_TONE_COLOR[itemToneType].iconButtonDisabledIconColor,
+    iconButtonBackgroundColor: MEMBERSHIP_SECTION_TONE_COLOR[itemToneType].iconButtonBackgroundColor,
+    iconButtonDisabledBackgroundColor: MEMBERSHIP_SECTION_TONE_COLOR[itemToneType].iconButtonDisabledBackgroundColor,
+    onClick: () => scrollPrev(500)
+  })), /*#__PURE__*/React.createElement(S_ContentOperatorPanel, {
+    ref: membershipListRef,
+    isLeftMaskingCoverShow: isLeftMaskingCoverShow,
+    isRightMaskingCoverShow: isRightMaskingCoverShow,
+    centered: connectedMemberships.length <= 2
+  }, connectedMemberships.map(({
+    id,
+    membership
+  }, i) => /*#__PURE__*/React.createElement(Fragment, {
+    key: id
+  }, /*#__PURE__*/React.createElement(ContentSheet, {
+    overrideCSS: {
+      backgroundColor: i === currentIndex ? itemHighlightingColorInHex : MEMBERSHIP_SECTION_TONE_COLOR[itemToneType].membershipSheetBackgroundColor,
+      display: 'flex',
+      flexDirection: 'column',
+      height: '120px',
+      justifyContent: 'center',
+      marginRight: '24px',
+      width: '384px',
+      maxWidth: '384px',
+      minWidth: '384px',
+      paddingLeft: '40px',
+      paddingRight: '40px'
+    },
+    radius: 24,
+    shapeType: "round",
+    width: "100%",
+    height: "120px",
+    onClick: () => {
+      handleMembershipClick(i);
+    }
+  }, /*#__PURE__*/React.createElement(D_MembershipSectionItem.Title, {
+    text: membership.title,
+    styleTheme: "headingBold",
+    ellipsisMode: "use",
+    lineLimit: 2,
+    color: i === currentIndex ? '#FDFDFDFF' : MEMBERSHIP_SECTION_TONE_COLOR[itemToneType].membershipSheetTextLabelColor,
+    textAlign: "left"
+  }))))), isRightMaskingCoverShow && /*#__PURE__*/React.createElement(S_ArrowIconCover, {
+    position: "right"
+  }, /*#__PURE__*/React.createElement(D_MembershipSectionItem.IconButton, {
+    iconButtonBorderColor: MEMBERSHIP_SECTION_TONE_COLOR[itemToneType].iconButtonBorderColor,
+    iconName: "ic_arrow_right",
+    iconButtonIconColor: MEMBERSHIP_SECTION_TONE_COLOR[itemToneType].iconButtonIconColor,
+    iconButtonDisabledIconColor: MEMBERSHIP_SECTION_TONE_COLOR[itemToneType].iconButtonDisabledIconColor,
+    iconButtonBackgroundColor: MEMBERSHIP_SECTION_TONE_COLOR[itemToneType].iconButtonBackgroundColor,
+    iconButtonDisabledBackgroundColor: MEMBERSHIP_SECTION_TONE_COLOR[itemToneType].iconButtonDisabledBackgroundColor,
+    onClick: () => scrollNext(500)
+  }))));
+}
+const S_NarrowMembershipList = styled.div.withConfig({
+  displayName: "NarrowMembershipListView__S_NarrowMembershipList",
+  componentId: "sc-1otp696-0"
+})(["width:100%;"]);
+const S_MembershipListBox = styled.div.withConfig({
+  displayName: "NarrowMembershipListView__S_MembershipListBox",
+  componentId: "sc-1otp696-1"
+})(["margin-bottom:", ";overflow:hidden;position:relative;"], ({
+  theme
+}) => theme.spacing.spacingF);
+const Centered = css(["justify-content:center;"]);
+const LeftMasking = css(["-webkit-mask-image:linear-gradient(90deg,transparent 0%,white 7.5%);"]);
+const RightMasking = css(["-webkit-mask-image:linear-gradient(90deg,white 92.5%,transparent 100%);"]);
+const BothMasking = css(["-webkit-mask-image:linear-gradient( 90deg,transparent 0%,white 7.5%,white 92.5%,transparent 100% );"]);
+const S_ContentOperatorPanel = styled.div.withConfig({
+  displayName: "NarrowMembershipListView__S_ContentOperatorPanel",
+  componentId: "sc-1otp696-2"
+})(["display:flex;overflow:scroll;", ";", ""], ({
+  centered
+}) => centered && Centered, ({
+  isLeftMaskingCoverShow,
+  isRightMaskingCoverShow
+}) => {
+  if (isLeftMaskingCoverShow && isRightMaskingCoverShow) {
+    return BothMasking;
+  }
+  if (isLeftMaskingCoverShow) {
+    return LeftMasking;
+  }
+  if (isRightMaskingCoverShow) {
+    return RightMasking;
+  }
+});
+const S_ArrowIconCover = styled.div.withConfig({
+  displayName: "NarrowMembershipListView__S_ArrowIconCover",
+  componentId: "sc-1otp696-3"
+})(["align-items:center;display:flex;height:120px;justify-content:", ";position:absolute;top:0;width:48px;z-index:1;", ""], ({
+  position
+}) => position === 'left' ? 'flex-start' : 'flex-end', ({
+  position
+}) => position && `${position}:0`);
+export default NarrowMembershipListView;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["Fragment","useEffect","useMemo","useRef","useState","ContentSheet","D_MembershipSectionItem","MEMBERSHIP_SECTION_TONE_COLOR","styled","css","NarrowMembershipListView","connectedMemberships","itemHighlightingColorInHex","itemToneType","currentIndex","handleMembershipClick","resizeTarget","membershipListRef","scrollValue","setScrollValue","targetWidth","setTargetWidth","handleScroll","current","scrollLeft","addEventListener","removeEventListener","element","observer","ResizeObserver","entries","forEach","entry","contentRect","width","observe","disconnect","isLeftMaskingCoverShow","length","isRightMaskingCoverShow","clientWidth","scrollWidth","scrollPrev","x","scroll","left","behavior","scrollNext","React","createElement","S_NarrowMembershipList","S_MembershipListBox","S_ArrowIconCover","position","IconButton","iconButtonBorderColor","iconName","iconButtonIconColor","iconButtonDisabledIconColor","iconButtonBackgroundColor","iconButtonDisabledBackgroundColor","onClick","S_ContentOperatorPanel","ref","centered","map","id","membership","i","key","overrideCSS","backgroundColor","membershipSheetBackgroundColor","display","flexDirection","height","justifyContent","marginRight","maxWidth","minWidth","paddingLeft","paddingRight","radius","shapeType","Title","text","title","styleTheme","ellipsisMode","lineLimit","color","membershipSheetTextLabelColor","textAlign","div","withConfig","displayName","componentId","theme","spacing","spacingF","Centered","LeftMasking","RightMasking","BothMasking"],"sources":["../../../../../../../../../../src/sub/DynamicLayout/sections/MembershipSection/EditType/templates/TemplateA/desktop/components/NarrowMembershipListView.tsx"],"sourcesContent":["import { Fragment, useEffect, useMemo, useRef, useState } from 'react';\n\nimport { ContentSheet } from '@desktop/panels';\nimport { D_MembershipSectionItem } from '@sub/DynamicLayout/sections/MembershipSection/components';\nimport { MEMBERSHIP_SECTION_TONE_COLOR } from '@sub/DynamicLayout/sections/MembershipSection/constants';\nimport styled, { css } from 'styled-components';\n\nimport type { IConnectedMembership, TypeOfItemToneType } from '@sub/DynamicLayout/types';\n\ntype Props = {\n  connectedMemberships: IConnectedMembership[];\n  itemHighlightingColorInHex: string;\n  itemToneType: TypeOfItemToneType;\n  currentIndex: number;\n  handleMembershipClick: (currentIndex: number) => void;\n};\n\nfunction NarrowMembershipListView({\n  connectedMemberships,\n  itemHighlightingColorInHex,\n  itemToneType,\n  currentIndex,\n  handleMembershipClick\n}: Props) {\n  const resizeTarget = useRef<HTMLDivElement | null>(null);\n  const membershipListRef = useRef<HTMLDivElement | null>(null);\n\n  const [scrollValue, setScrollValue] = useState<number>(0);\n  const [targetWidth, setTargetWidth] = useState<number>(0);\n\n  const handleScroll = () => {\n    if (membershipListRef === null || membershipListRef.current === null) {\n      return;\n    }\n    setScrollValue(membershipListRef.current.scrollLeft);\n  };\n\n  /**\n   * @when : 화면 진입 시\n   * @expected : 스크롤을 감지하는 이벤트 핸들러를 추가합니다.\n   * @clear : 스크롤을 감지하는 이벤트 핸들러를 제거합니다.\n   */\n  useEffect(() => {\n    if (!membershipListRef.current) {\n      return;\n    }\n    membershipListRef.current.addEventListener('scroll', handleScroll);\n\n    return () => {\n      if (!membershipListRef.current) {\n        return;\n      }\n      membershipListRef.current.removeEventListener('scroll', handleScroll);\n    };\n  }, []);\n\n  /**\n   * @when : 화면 진입 시\n   * @expected : 콘텐츠 영역의 크기를 확인해서 observer를 추가합니다.\n   * @clear : observer를 제거합니다.\n   */\n  useEffect(() => {\n    const element = resizeTarget?.current;\n\n    if (!element) return;\n\n    const observer = new ResizeObserver((entries) => {\n      entries.forEach((entry) => {\n        setTargetWidth(entry.contentRect.width);\n      });\n    });\n\n    observer.observe(element);\n\n    return () => {\n      observer.disconnect();\n    };\n  }, []);\n\n  const isLeftMaskingCoverShow = connectedMemberships.length > 2 && scrollValue > 0;\n  const isRightMaskingCoverShow = useMemo(() => {\n    if (connectedMemberships.length < 3) {\n      return false;\n    }\n\n    if (scrollValue === 0) {\n      return true;\n    }\n\n    return membershipListRef.current\n      ? membershipListRef.current.scrollLeft + membershipListRef.current.clientWidth <\n          membershipListRef.current.scrollWidth - 1\n      : scrollValue === 0;\n  }, [connectedMemberships, membershipListRef.current, scrollValue, targetWidth]);\n\n  const scrollPrev = (x: number) => {\n    const { scrollLeft } = membershipListRef.current || {};\n    if (membershipListRef.current && typeof scrollLeft === 'number') {\n      membershipListRef.current.scroll({ left: scrollLeft - x, behavior: 'smooth' });\n      setScrollValue(scrollLeft - x);\n    }\n  };\n\n  const scrollNext = (x: number) => {\n    const { scrollLeft } = membershipListRef.current || {};\n    if (membershipListRef.current && typeof scrollLeft === 'number') {\n      membershipListRef.current.scroll({ left: scrollLeft + x, behavior: 'smooth' });\n      setScrollValue(scrollLeft + x);\n    }\n  };\n\n  return (\n    <S_NarrowMembershipList>\n      {connectedMemberships.length > 0 && (\n        <S_MembershipListBox>\n          {isLeftMaskingCoverShow && (\n            <S_ArrowIconCover position=\"left\">\n              <D_MembershipSectionItem.IconButton\n                iconButtonBorderColor={\n                  MEMBERSHIP_SECTION_TONE_COLOR[itemToneType].iconButtonBorderColor\n                }\n                iconName=\"ic_arrow_left\"\n                iconButtonIconColor={\n                  MEMBERSHIP_SECTION_TONE_COLOR[itemToneType].iconButtonIconColor\n                }\n                iconButtonDisabledIconColor={\n                  MEMBERSHIP_SECTION_TONE_COLOR[itemToneType].iconButtonDisabledIconColor\n                }\n                iconButtonBackgroundColor={\n                  MEMBERSHIP_SECTION_TONE_COLOR[itemToneType].iconButtonBackgroundColor\n                }\n                iconButtonDisabledBackgroundColor={\n                  MEMBERSHIP_SECTION_TONE_COLOR[itemToneType].iconButtonDisabledBackgroundColor\n                }\n                onClick={() => scrollPrev(500)}\n              />\n            </S_ArrowIconCover>\n          )}\n\n          <S_ContentOperatorPanel\n            ref={membershipListRef}\n            isLeftMaskingCoverShow={isLeftMaskingCoverShow}\n            isRightMaskingCoverShow={isRightMaskingCoverShow}\n            centered={connectedMemberships.length <= 2}\n          >\n            {connectedMemberships.map(({ id, membership }, i) => (\n              <Fragment key={id}>\n                <ContentSheet\n                  overrideCSS={{\n                    backgroundColor:\n                      i === currentIndex\n                        ? itemHighlightingColorInHex\n                        : MEMBERSHIP_SECTION_TONE_COLOR[itemToneType]\n                            .membershipSheetBackgroundColor,\n                    display: 'flex',\n                    flexDirection: 'column',\n                    height: '120px',\n                    justifyContent: 'center',\n                    marginRight: '24px',\n                    width: '384px',\n                    maxWidth: '384px',\n                    minWidth: '384px',\n                    paddingLeft: '40px',\n                    paddingRight: '40px'\n                  }}\n                  radius={24}\n                  shapeType=\"round\"\n                  width=\"100%\"\n                  height=\"120px\"\n                  onClick={() => {\n                    handleMembershipClick(i);\n                  }}\n                >\n                  <D_MembershipSectionItem.Title\n                    text={membership.title}\n                    styleTheme=\"headingBold\"\n                    ellipsisMode=\"use\"\n                    lineLimit={2}\n                    color={\n                      i === currentIndex\n                        ? '#FDFDFDFF'\n                        : MEMBERSHIP_SECTION_TONE_COLOR[itemToneType].membershipSheetTextLabelColor\n                    }\n                    textAlign=\"left\"\n                  />\n                </ContentSheet>\n              </Fragment>\n            ))}\n          </S_ContentOperatorPanel>\n\n          {isRightMaskingCoverShow && (\n            <S_ArrowIconCover position=\"right\">\n              <D_MembershipSectionItem.IconButton\n                iconButtonBorderColor={\n                  MEMBERSHIP_SECTION_TONE_COLOR[itemToneType].iconButtonBorderColor\n                }\n                iconName=\"ic_arrow_right\"\n                iconButtonIconColor={\n                  MEMBERSHIP_SECTION_TONE_COLOR[itemToneType].iconButtonIconColor\n                }\n                iconButtonDisabledIconColor={\n                  MEMBERSHIP_SECTION_TONE_COLOR[itemToneType].iconButtonDisabledIconColor\n                }\n                iconButtonBackgroundColor={\n                  MEMBERSHIP_SECTION_TONE_COLOR[itemToneType].iconButtonBackgroundColor\n                }\n                iconButtonDisabledBackgroundColor={\n                  MEMBERSHIP_SECTION_TONE_COLOR[itemToneType].iconButtonDisabledBackgroundColor\n                }\n                onClick={() => scrollNext(500)}\n              />\n            </S_ArrowIconCover>\n          )}\n        </S_MembershipListBox>\n      )}\n    </S_NarrowMembershipList>\n  );\n}\n\nconst S_NarrowMembershipList = styled.div`\n  width: 100%;\n`;\n\nconst S_MembershipListBox = styled.div`\n  margin-bottom: ${({ theme }) => theme.spacing.spacingF};\n  overflow: hidden;\n  position: relative;\n`;\n\nconst Centered = css`\n  justify-content: center;\n`;\n\nconst LeftMasking = css`\n  -webkit-mask-image: linear-gradient(90deg, transparent 0%, white 7.5%);\n`;\n\nconst RightMasking = css`\n  -webkit-mask-image: linear-gradient(90deg, white 92.5%, transparent 100%);\n`;\n\nconst BothMasking = css`\n  -webkit-mask-image: linear-gradient(\n    90deg,\n    transparent 0%,\n    white 7.5%,\n    white 92.5%,\n    transparent 100%\n  );\n`;\n\nconst S_ContentOperatorPanel = styled.div<{\n  isLeftMaskingCoverShow: boolean;\n  isRightMaskingCoverShow: boolean;\n  centered: boolean;\n}>`\n  display: flex;\n  overflow: scroll;\n\n  ${({ centered }) => centered && Centered};\n  ${({ isLeftMaskingCoverShow, isRightMaskingCoverShow }) => {\n    if (isLeftMaskingCoverShow && isRightMaskingCoverShow) {\n      return BothMasking;\n    }\n    if (isLeftMaskingCoverShow) {\n      return LeftMasking;\n    }\n    if (isRightMaskingCoverShow) {\n      return RightMasking;\n    }\n  }}\n`;\n\nconst S_ArrowIconCover = styled.div<{\n  position: 'left' | 'right';\n}>`\n  align-items: center;\n  display: flex;\n  height: 120px;\n  justify-content: ${({ position }) => (position === 'left' ? 'flex-start' : 'flex-end')};\n  position: absolute;\n  top: 0;\n  width: 48px;\n  z-index: 1;\n\n  ${({ position }) => position && `${position}:0`}\n`;\n\nexport default NarrowMembershipListView;\n"],"mappings":"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","ignoreList":[]}

package/dist/sub/DynamicLayout/sections/MembershipSection/EditType/templates/TemplateA/desktop/components/SectionContents.js

@@ -0,0 +1,68 @@
+import { useContext } from 'react';
+import { sectionContext } from '@sub/DynamicLayout/components/Section';
+import { D_MembershipSectionItem } from '@sub/DynamicLayout/sections/MembershipSection/components';
+import styled from 'styled-components';
+function SectionContents() {
+  const section = useContext(sectionContext);
+  if (!section) {
+    return /*#__PURE__*/React.createElement(React.Fragment, null);
+  }
+  const {
+    buttonAlphaBackgroundColorInHex,
+    buttonAlphaLabelColorInHex,
+    buttonAlphaDesignType,
+    descriptionColorInHex,
+    titleColorInHex
+  } = section.styles;
+  const {
+    title,
+    description,
+    buttonAlphaLabel,
+    buttonAlphaLinkSrc,
+    buttonAlphaLinkType
+  } = section.properties;
+  const isEmptySection = !title && !description && !buttonAlphaLabel;
+  return /*#__PURE__*/React.createElement(S_SectionDataBox, {
+    isEmptySection: isEmptySection
+  }, title && /*#__PURE__*/React.createElement(D_MembershipSectionItem.Title, {
+    text: title,
+    textAlign: "center",
+    color: titleColorInHex,
+    customFontSize: "48px",
+    customFontWeight: "bold"
+  }), description && /*#__PURE__*/React.createElement(S_DescriptionWrapper, null, /*#__PURE__*/React.createElement(D_MembershipSectionItem.Description, {
+    text: description,
+    textAlign: "center",
+    color: descriptionColorInHex,
+    customFontSize: "20px",
+    fontWeight: "600"
+  })), buttonAlphaLinkSrc && /*#__PURE__*/React.createElement(S_ButtonWrapper, null, /*#__PURE__*/React.createElement(D_MembershipSectionItem.DesignedSectionButton, {
+    buttonType: buttonAlphaDesignType,
+    text: buttonAlphaLabel,
+    linkType: buttonAlphaLinkType,
+    src: buttonAlphaLinkSrc,
+    textColor: buttonAlphaLabelColorInHex,
+    backgroundColor: buttonAlphaBackgroundColorInHex,
+    borderColor: buttonAlphaLabelColorInHex
+  })));
+}
+const S_SectionDataBox = styled.div.withConfig({
+  displayName: "SectionContents__S_SectionDataBox",
+  componentId: "sc-18xzm5m-0"
+})(["margin-bottom:", ";"], ({
+  isEmptySection
+}) => isEmptySection ? 0 : '80px');
+const S_DescriptionWrapper = styled.div.withConfig({
+  displayName: "SectionContents__S_DescriptionWrapper",
+  componentId: "sc-18xzm5m-1"
+})(["padding-top:", ";"], ({
+  theme
+}) => theme.spacing.spacingF);
+const S_ButtonWrapper = styled.div.withConfig({
+  displayName: "SectionContents__S_ButtonWrapper",
+  componentId: "sc-18xzm5m-2"
+})(["align-items:center;display:flex;justify-content:center;padding-top:", ";"], ({
+  theme
+}) => theme.spacing.spacingG);
+export default SectionContents;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/sub/DynamicLayout/sections/MembershipSection/EditType/templates/TemplateA/desktop/components/UnavailableMembershipPlanSheet.js

@@ -0,0 +1,41 @@
+import { useTranslation } from 'react-i18next';
+import { ContentSheet } from '@desktop/panels';
+import { Spacing } from '@hybrid/components';
+import { D_MembershipSectionItem } from '@sub/DynamicLayout/sections/MembershipSection/components';
+import { MEMBERSHIP_SECTION_ACTION_BUTTON_TEXT, MEMBERSHIP_SECTION_TONE_COLOR } from '@sub/DynamicLayout/sections/MembershipSection/constants';
+function UnavailableMembershipPlanSheet({
+  sectionStyles
+}) {
+  const {
+    t
+  } = useTranslation('translation');
+  const {
+    itemToneType,
+    programmedItemActionButtonTextType
+  } = sectionStyles;
+  return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(Spacing, {
+    size: "spacing_g"
+  }), /*#__PURE__*/React.createElement(ContentSheet, {
+    width: "100%",
+    height: "auto",
+    shapeType: "round",
+    overrideCSS: {
+      display: 'flex',
+      alignItems: 'center',
+      justifyContent: 'center',
+      height: '112px',
+      backgroundColor: MEMBERSHIP_SECTION_TONE_COLOR[itemToneType].membershipPlanSheetBackgroundColor
+    }
+  }, /*#__PURE__*/React.createElement(D_MembershipSectionItem.Title, {
+    text: t('str_5300'),
+    color: MEMBERSHIP_SECTION_TONE_COLOR[itemToneType].membershipSheetTextLabelColor
+  })), /*#__PURE__*/React.createElement(D_MembershipSectionItem.XlargeMainButton, {
+    buttonText: t(MEMBERSHIP_SECTION_ACTION_BUTTON_TEXT[programmedItemActionButtonTextType]),
+    state: "disabled",
+    buttonTextColor: MEMBERSHIP_SECTION_TONE_COLOR[itemToneType].disabledProgrammedItemActionButtonTextColor,
+    buttonBackgroundColor: MEMBERSHIP_SECTION_TONE_COLOR[itemToneType].disabledProgrammedItemActionButtonBackgroundColor,
+    $paddingBottom: "56px"
+  }));
+}
+export default UnavailableMembershipPlanSheet;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/sub/DynamicLayout/sections/MembershipSection/EditType/templates/TemplateA/desktop/components/WideMembershipListView.js

@@ -0,0 +1,94 @@
+import { Fragment, useEffect, useRef, useState } from 'react';
+import { ContentSheet } from '@desktop/panels';
+import { D_MembershipSectionItem } from '@sub/DynamicLayout/sections/MembershipSection/components';
+import { MEMBERSHIP_SECTION_TONE_COLOR } from '@sub/DynamicLayout/sections/MembershipSection/constants';
+import styled from 'styled-components';
+function WideMembershipListView({
+  connectedMemberships,
+  itemHighlightingColorInHex,
+  itemToneType,
+  currentIndex,
+  handleMembershipClick
+}) {
+  const membershipListRef = useRef(null);
+  const [scrollValue, setScrollValue] = useState(0);
+  const handleScroll = () => {
+    if (membershipListRef === null || membershipListRef.current === null) {
+      return;
+    }
+    setScrollValue(membershipListRef.current.scrollTop);
+  };
+  useEffect(() => {
+    if (!membershipListRef.current) {
+      return;
+    }
+    membershipListRef.current.addEventListener('scroll', handleScroll);
+    return () => {
+      if (!membershipListRef.current) {
+        return;
+      }
+      membershipListRef.current.removeEventListener('scroll', handleScroll);
+    };
+  }, []);
+  const isTopMaskingCoverShow = connectedMemberships.length > 5 && scrollValue > 0;
+  const isBottomMaskingCoverShow = membershipListRef.current ? membershipListRef.current.scrollTop + membershipListRef.current.clientHeight < membershipListRef.current.scrollHeight : true;
+  return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(S_MembershipListMaskingBox, {
+    isTopMaskingCoverShow: isTopMaskingCoverShow,
+    isBottomMaskingCoverShow: isBottomMaskingCoverShow
+  }, /*#__PURE__*/React.createElement(S_MembershipList, {
+    ref: membershipListRef
+  }, connectedMemberships.map(({
+    id,
+    membership
+  }, i) => /*#__PURE__*/React.createElement(Fragment, {
+    key: id
+  }, /*#__PURE__*/React.createElement(ContentSheet, {
+    overrideCSS: {
+      backgroundColor: i === currentIndex ? itemHighlightingColorInHex : MEMBERSHIP_SECTION_TONE_COLOR[itemToneType].membershipSheetBackgroundColor,
+      display: 'flex',
+      flexDirection: 'column',
+      height: '120px',
+      justifyContent: 'center',
+      marginBottom: '24px',
+      paddingLeft: '40px',
+      paddingRight: '40px'
+    },
+    radius: 24,
+    shapeType: "round",
+    width: "100%",
+    height: "120px",
+    onClick: () => {
+      handleMembershipClick(i);
+    }
+  }, /*#__PURE__*/React.createElement(D_MembershipSectionItem.Title, {
+    text: membership.title,
+    styleTheme: "headingBold",
+    ellipsisMode: "use",
+    lineLimit: 2,
+    color: i === currentIndex ? '#FDFDFDFF' : MEMBERSHIP_SECTION_TONE_COLOR[itemToneType].membershipSheetTextLabelColor,
+    textAlign: "left"
+  })))))));
+}
+const S_MembershipListMaskingBox = styled.div.withConfig({
+  displayName: "WideMembershipListView__S_MembershipListMaskingBox",
+  componentId: "sc-1u12zfa-0"
+})(["-webkit-mask-image:", ";width:33%;"], ({
+  isTopMaskingCoverShow,
+  isBottomMaskingCoverShow
+}) => {
+  if (isTopMaskingCoverShow && isBottomMaskingCoverShow) {
+    return 'linear-gradient(transparent 0%, white 7.5%, white 92.5%, transparent 100%)';
+  }
+  if (isTopMaskingCoverShow) {
+    return 'linear-gradient(transparent 0%, white 7.5%)';
+  }
+  if (isBottomMaskingCoverShow) {
+    return 'linear-gradient(white 92.5%, transparent 100%)';
+  }
+});
+const S_MembershipList = styled.div.withConfig({
+  displayName: "WideMembershipListView__S_MembershipList",
+  componentId: "sc-1u12zfa-1"
+})(["flex:1;flex-direction:column;height:720px;min-width:33%;overflow:auto;position:relative;"]);
+export default WideMembershipListView;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["Fragment","useEffect","useRef","useState","ContentSheet","D_MembershipSectionItem","MEMBERSHIP_SECTION_TONE_COLOR","styled","WideMembershipListView","connectedMemberships","itemHighlightingColorInHex","itemToneType","currentIndex","handleMembershipClick","membershipListRef","scrollValue","setScrollValue","handleScroll","current","scrollTop","addEventListener","removeEventListener","isTopMaskingCoverShow","length","isBottomMaskingCoverShow","clientHeight","scrollHeight","React","createElement","S_MembershipListMaskingBox","S_MembershipList","ref","map","id","membership","i","key","overrideCSS","backgroundColor","membershipSheetBackgroundColor","display","flexDirection","height","justifyContent","marginBottom","paddingLeft","paddingRight","radius","shapeType","width","onClick","Title","text","title","styleTheme","ellipsisMode","lineLimit","color","membershipSheetTextLabelColor","textAlign","div","withConfig","displayName","componentId"],"sources":["../../../../../../../../../../src/sub/DynamicLayout/sections/MembershipSection/EditType/templates/TemplateA/desktop/components/WideMembershipListView.tsx"],"sourcesContent":["import { Fragment, useEffect, useRef, useState } from 'react';\n\nimport { ContentSheet } from '@desktop/panels';\nimport { D_MembershipSectionItem } from '@sub/DynamicLayout/sections/MembershipSection/components';\nimport { MEMBERSHIP_SECTION_TONE_COLOR } from '@sub/DynamicLayout/sections/MembershipSection/constants';\nimport styled from 'styled-components';\n\nimport type { IConnectedMembership, TypeOfItemToneType } from '@sub/DynamicLayout/types';\n\ntype Props = {\n  connectedMemberships: IConnectedMembership[];\n  itemHighlightingColorInHex: string;\n  itemToneType: TypeOfItemToneType;\n  currentIndex: number;\n  handleMembershipClick: (currentIndex: number) => void;\n};\n\nfunction WideMembershipListView({\n  connectedMemberships,\n  itemHighlightingColorInHex,\n  itemToneType,\n  currentIndex,\n  handleMembershipClick\n}: Props) {\n  const membershipListRef = useRef<HTMLDivElement | null>(null);\n\n  const [scrollValue, setScrollValue] = useState<number>(0);\n\n  const handleScroll = () => {\n    if (membershipListRef === null || membershipListRef.current === null) {\n      return;\n    }\n    setScrollValue(membershipListRef.current.scrollTop);\n  };\n\n  useEffect(() => {\n    if (!membershipListRef.current) {\n      return;\n    }\n    membershipListRef.current.addEventListener('scroll', handleScroll);\n\n    return () => {\n      if (!membershipListRef.current) {\n        return;\n      }\n      membershipListRef.current.removeEventListener('scroll', handleScroll);\n    };\n  }, []);\n\n  const isTopMaskingCoverShow = connectedMemberships.length > 5 && scrollValue > 0;\n  const isBottomMaskingCoverShow = membershipListRef.current\n    ? membershipListRef.current.scrollTop + membershipListRef.current.clientHeight <\n      membershipListRef.current.scrollHeight\n    : true;\n\n  return (\n    <>\n      <S_MembershipListMaskingBox\n        isTopMaskingCoverShow={isTopMaskingCoverShow}\n        isBottomMaskingCoverShow={isBottomMaskingCoverShow}\n      >\n        <S_MembershipList ref={membershipListRef}>\n          {connectedMemberships.map(({ id, membership }, i) => (\n            <Fragment key={id}>\n              <ContentSheet\n                overrideCSS={{\n                  backgroundColor:\n                    i === currentIndex\n                      ? itemHighlightingColorInHex\n                      : MEMBERSHIP_SECTION_TONE_COLOR[itemToneType].membershipSheetBackgroundColor,\n                  display: 'flex',\n                  flexDirection: 'column',\n                  height: '120px',\n                  justifyContent: 'center',\n                  marginBottom: '24px',\n                  paddingLeft: '40px',\n                  paddingRight: '40px'\n                }}\n                radius={24}\n                shapeType=\"round\"\n                width=\"100%\"\n                height=\"120px\"\n                onClick={() => {\n                  handleMembershipClick(i);\n                }}\n              >\n                <D_MembershipSectionItem.Title\n                  text={membership.title}\n                  styleTheme=\"headingBold\"\n                  ellipsisMode=\"use\"\n                  lineLimit={2}\n                  color={\n                    i === currentIndex\n                      ? '#FDFDFDFF'\n                      : MEMBERSHIP_SECTION_TONE_COLOR[itemToneType].membershipSheetTextLabelColor\n                  }\n                  textAlign=\"left\"\n                />\n              </ContentSheet>\n            </Fragment>\n          ))}\n        </S_MembershipList>\n      </S_MembershipListMaskingBox>\n    </>\n  );\n}\n\nconst S_MembershipListMaskingBox = styled.div<{\n  isTopMaskingCoverShow: boolean;\n  isBottomMaskingCoverShow: boolean;\n}>`\n  -webkit-mask-image: ${({ isTopMaskingCoverShow, isBottomMaskingCoverShow }) => {\n    if (isTopMaskingCoverShow && isBottomMaskingCoverShow) {\n      return 'linear-gradient(transparent 0%, white 7.5%, white 92.5%, transparent 100%)';\n    }\n    if (isTopMaskingCoverShow) {\n      return 'linear-gradient(transparent 0%, white 7.5%)';\n    }\n    if (isBottomMaskingCoverShow) {\n      return 'linear-gradient(white 92.5%, transparent 100%)';\n    }\n  }};\n  width: 33%;\n`;\n\nconst S_MembershipList = styled.div`\n  flex: 1;\n  flex-direction: column;\n  height: 720px;\n  min-width: 33%;\n  overflow: auto;\n  position: relative;\n`;\n\nexport default WideMembershipListView;\n"],"mappings":"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","ignoreList":[]}

package/dist/sub/DynamicLayout/sections/MembershipSection/EditType/templates/TemplateA/desktop/index.js

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

package/dist/sub/DynamicLayout/sections/MembershipSection/EditType/templates/TemplateA/index.js

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