@pisell/private-materials 6.6.8 → 6.6.10

package/dist/es/plus/productSelect/components/TabsStructure/hooks.js

@@ -0,0 +1,189 @@
+import { debounce } from "./utils.js";
+import { useCallback, useEffect, useMemo, useState } from "react";
+
+//#region src/plus/productSelect/components/TabsStructure/hooks.ts
+/**
+* Hook for managing selection indicator position with enhanced features
+* @param containerRef - Ref to the tab container
+* @param selectedTabId - ID of the currently selected tab (optional)
+* @param transition - Custom transition string (optional)
+* @returns Selection indicator props and list container props
+*/
+function useSelectionIndicator(containerRef, selectedTabId, transition) {
+	const [indicatorStyle, setIndicatorStyle] = useState({
+		width: 0,
+		transform: "translateX(0)",
+		transition: "none"
+	});
+	const [selectedTabRef, setSelectedTabRef] = useState();
+	const [isFocusVisible, setIsFocusVisible] = useState(false);
+	const [focusRingClasses, setFocusRingClasses] = useState("");
+	const setSelectedTab = useCallback((element) => {
+		setSelectedTabRef((prevRef) => prevRef?.current === element ? prevRef : { current: element });
+	}, []);
+	const findSelectedTabByAttribute = useCallback(() => {
+		if (!containerRef.current) return null;
+		const selectedTab = containerRef.current.querySelector("[role=\"tab\"][aria-selected=\"true\"]");
+		if (selectedTab) setSelectedTab(selectedTab);
+		return selectedTab;
+	}, [containerRef, setSelectedTab]);
+	const findSelectedTabById = useCallback(() => {
+		if (!selectedTabId || !containerRef.current) return null;
+		return containerRef.current.querySelector(`[id="${selectedTabId}"]`);
+	}, [containerRef, selectedTabId]);
+	const getTransition = useCallback((customTransition) => {
+		return customTransition || "transform 300ms, width 100ms";
+	}, []);
+	const getDirection = useCallback(() => {
+		if (!containerRef.current) return "ltr";
+		return window.getComputedStyle(containerRef.current).direction || "ltr";
+	}, [containerRef]);
+	const updateIndicatorPosition = useCallback(() => {
+		try {
+			const selectedTab = findSelectedTabByAttribute() || findSelectedTabById();
+			if (!selectedTab || !containerRef.current) {
+				setIndicatorStyle((prev) => ({
+					...prev,
+					width: 0,
+					transform: "translateX(0)"
+				}));
+				return;
+			}
+			containerRef.current;
+			const offsetParent = selectedTab.offsetParent;
+			if (!offsetParent) {
+				setIndicatorStyle((prev) => ({
+					...prev,
+					width: 0,
+					transform: "translateX(0)"
+				}));
+				return;
+			}
+			if (!selectedTab.isConnected) {
+				console.warn("useSelectionIndicator: Selected tab is no longer connected to DOM");
+				return;
+			}
+			const direction = getDirection();
+			const width = selectedTab.offsetWidth;
+			if (width <= 0) {
+				setIndicatorStyle((prev) => ({
+					...prev,
+					width: 0,
+					transform: "translateX(0)"
+				}));
+				return;
+			}
+			let left;
+			if (direction === "rtl") left = -1 * (offsetParent.clientWidth - selectedTab.offsetLeft - selectedTab.offsetWidth);
+			else left = selectedTab.offsetLeft;
+			const transitionValue = getTransition(transition);
+			setIndicatorStyle({
+				width: `${width}px`,
+				transform: `translateX(${left}px)`,
+				transition: transitionValue
+			});
+		} catch (error) {
+			console.warn("useSelectionIndicator: Error updating indicator position:", error);
+			setIndicatorStyle((prev) => ({
+				...prev,
+				width: 0,
+				transform: "translateX(0)"
+			}));
+		}
+	}, [
+		containerRef,
+		selectedTabId,
+		transition,
+		findSelectedTabByAttribute,
+		findSelectedTabById,
+		getDirection,
+		getTransition
+	]);
+	const debouncedUpdate = useMemo(() => debounce(updateIndicatorPosition, 50), [updateIndicatorPosition]);
+	const handleFocusIn = useCallback((event) => {
+		setIsFocusVisible(event.target instanceof HTMLElement && event.target.matches(":focus-visible"));
+		setFocusRingClasses(event.target instanceof HTMLElement && event.target.matches(":focus-visible") ? "focus-visible" : "");
+	}, []);
+	const handleFocusOut = useCallback(() => {
+		setIsFocusVisible(false);
+		setFocusRingClasses("");
+	}, []);
+	const handleMouseDown = useCallback(() => {
+		setIsFocusVisible(false);
+		setFocusRingClasses("");
+	}, []);
+	useEffect(() => {
+		debouncedUpdate();
+	}, [debouncedUpdate, selectedTabId]);
+	useEffect(() => {
+		const container = containerRef.current;
+		if (!container) return;
+		let resizeObserver = null;
+		try {
+			resizeObserver = new ResizeObserver((entries) => {
+				try {
+					if (entries.filter((entry) => entry.target && entry.target.isConnected).length > 0) debouncedUpdate();
+				} catch (error) {
+					console.warn("useSelectionIndicator: Error in ResizeObserver callback:", error);
+				}
+			});
+			resizeObserver.observe(container);
+			if (selectedTabRef?.current) resizeObserver.observe(selectedTabRef.current);
+		} catch (error) {
+			console.warn("useSelectionIndicator: Failed to create ResizeObserver:", error);
+		}
+		return () => {
+			if (resizeObserver) try {
+				resizeObserver.disconnect();
+			} catch (error) {
+				console.warn("useSelectionIndicator: Error disconnecting ResizeObserver:", error);
+			}
+		};
+	}, [
+		containerRef,
+		selectedTabRef,
+		debouncedUpdate
+	]);
+	useEffect(() => {
+		const container = containerRef.current;
+		if (!container) return;
+		const nativeFocusIn = (event) => {
+			handleFocusIn({
+				...event,
+				currentTarget: event.currentTarget,
+				target: event.target
+			});
+		};
+		container.addEventListener("focusin", nativeFocusIn);
+		container.addEventListener("focusout", handleFocusOut);
+		container.addEventListener("mousedown", handleMouseDown);
+		return () => {
+			container.removeEventListener("focusin", nativeFocusIn);
+			container.removeEventListener("focusout", handleFocusOut);
+			container.removeEventListener("mousedown", handleMouseDown);
+		};
+	}, [
+		containerRef,
+		handleFocusIn,
+		handleFocusOut,
+		handleMouseDown
+	]);
+	return {
+		selectionIndicatorProps: {
+			focusRingClasses,
+			isFocusVisible,
+			style: {
+				...indicatorStyle,
+				transition: getTransition(transition)
+			}
+		},
+		listContainerProps: {
+			onFocus: handleFocusIn,
+			onBlur: handleFocusOut,
+			onMouseDown: handleMouseDown
+		}
+	};
+}
+
+//#endregion
+export { useSelectionIndicator };

package/dist/es/plus/productSelect/components/TabsStructure/styles.js

@@ -0,0 +1,58 @@
+//#region src/plus/productSelect/components/TabsStructure/styles.ts
+const tabWrapperClasses = { wrapper: "pisell-tabstruct-wrapper" };
+const tabListClasses = { list: "pisell-tabstruct-list" };
+const tabItemClasses = {
+	item: "pisell-tabstruct-item",
+	selected: "pisell-tabstruct-item--selected",
+	disabled: "pisell-tabstruct-item--disabled"
+};
+const railClasses = { rail: "pisell-tabstruct-rail" };
+const selectionClasses = {
+	selection: "pisell-tabstruct-selection",
+	position: "pisell-tabstruct-selection--positioned",
+	focused: "pisell-tabstruct-selection--focused"
+};
+const shadowClasses = {
+	shadow: "pisell-tabstruct-shadow",
+	isVisible: "pisell-tabstruct-shadow--visible",
+	locationStart: "pisell-tabstruct-shadow--start",
+	locationEnd: "pisell-tabstruct-shadow--end"
+};
+const chevronClasses = {
+	controls: "pisell-tabstruct-chevron-controls",
+	button: "pisell-tabstruct-chevron-button",
+	disabled: "pisell-tabstruct-chevron-button--disabled"
+};
+const chevronButtonClasses = {
+	button: "pisell-tabstruct-chevron-button",
+	disabled: "pisell-tabstruct-chevron-button--disabled",
+	prev: "pisell-tabstruct-chevron-button--prev",
+	next: "pisell-tabstruct-chevron-button--next"
+};
+const tabWrapperClassNames = { wrapper: tabWrapperClasses.wrapper };
+const tabListClassNames = { list: tabListClasses.list };
+const tabItemClassNames = {
+	item: tabItemClasses.item,
+	selected: tabItemClasses.selected,
+	disabled: tabItemClasses.disabled
+};
+const railClassNames = { rail: railClasses.rail };
+const selectionClassNames = {
+	selection: selectionClasses.selection,
+	position: selectionClasses.position,
+	focused: selectionClasses.focused
+};
+const shadowClassNames = {
+	shadow: shadowClasses.shadow,
+	isVisible: shadowClasses.isVisible,
+	locationStart: shadowClasses.locationStart,
+	locationEnd: shadowClasses.locationEnd
+};
+const chevronClassNames = {
+	controls: chevronClasses.controls,
+	button: chevronClasses.button,
+	disabled: chevronClasses.disabled
+};
+
+//#endregion
+export { chevronButtonClasses, chevronClasses, railClasses, selectionClasses, shadowClasses, tabItemClasses, tabListClasses, tabWrapperClasses };

package/dist/es/plus/productSelect/components/TabsStructure/utils.js

@@ -0,0 +1,34 @@
+//#region src/plus/productSelect/components/TabsStructure/utils.ts
+function debounce(func, wait) {
+	let timeout = null;
+	return (...args) => {
+		if (timeout) clearTimeout(timeout);
+		timeout = setTimeout(() => {
+			func(...args);
+		}, wait);
+	};
+}
+/**
+* 安全的滚动函数，包含错误处理和边界检查
+* @param element - 要滚动的元素
+* @param options - 滚动选项
+*/
+function safeScrollTo(element, options) {
+	try {
+		if (!element || !element.scrollTo) return false;
+		const { left = 0, behavior = "smooth" } = options;
+		const maxScrollLeft = Math.max(0, element.scrollWidth - element.clientWidth);
+		const safeLeft = Math.max(0, Math.min(left, maxScrollLeft));
+		element.scrollTo({
+			left: safeLeft,
+			behavior
+		});
+		return true;
+	} catch (error) {
+		console.warn("Failed to scroll element:", error);
+		return false;
+	}
+}
+
+//#endregion
+export { debounce, safeScrollTo };

package/dist/es/plus/productSelect/components/pisellPriceText/index.js

@@ -0,0 +1,35 @@
+import useEngineContext_default from "../../../../hooks/useEngineContext.js";
+import React, { useMemo } from "react";
+import classNames from "classnames";
+import { PisellText } from "@pisell/materials";
+import "./index.less";
+
+//#region src/plus/productSelect/components/pisellPriceText/index.tsx
+const index = (props) => {
+	const context = useEngineContext_default();
+	const { value } = props;
+	const locale = context.appHelper.utils?.storage?.get("umi_locale") || "en";
+	const [_prefix, _suffix] = useMemo(() => {
+		if (!props.isMini) return ["", ""];
+		if (!locale) return ["From", ""];
+		if (locale.toLowerCase().includes("zh")) return ["", "起"];
+		return ["From", ""];
+	}, [locale, props.isMini]);
+	return /* @__PURE__ */ React.createElement("div", { className: classNames("pisell-price-text", props.className) }, props.prefix, _prefix ? /* @__PURE__ */ React.createElement("span", {
+		className: "pisell-price-text-prefix-text",
+		style: {
+			fontSize: "0.65em",
+			marginRight: 4
+		}
+	}, _prefix) : null, /* @__PURE__ */ React.createElement(PisellText.Amount, { value }), _suffix ? /* @__PURE__ */ React.createElement("span", {
+		style: {
+			fontSize: "0.65em",
+			marginLeft: 4
+		},
+		className: "pisell-price-text-suffix-text"
+	}, _suffix) : null, props.suffix);
+};
+var pisellPriceText_default = index;
+
+//#endregion
+export { pisellPriceText_default as default };

package/dist/es/plus/productSelect/components/pisellPriceText/index.less

@@ -0,0 +1,4 @@
+.pisell-price-text {
+  overflow: hidden;
+  text-overflow: ellipsis;
+}

package/dist/es/plus/productSelect/hooks/useToken.js

@@ -0,0 +1,23 @@
+import { defaultToken } from "../theme/token.js";
+import { useMemo } from "react";
+
+//#region src/plus/productSelect/hooks/useToken.ts
+function useToken(customToken) {
+	return useMemo(() => {
+		return {
+			...defaultToken,
+			...customToken || {}
+		};
+	}, [customToken]);
+}
+function genCSSVars(token) {
+	const cssVars = {};
+	Object.entries(token).forEach(([key, value]) => {
+		const cssKey = `--ps-${key.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`)}`;
+		cssVars[cssKey] = value;
+	});
+	return cssVars;
+}
+
+//#endregion
+export { genCSSVars, useToken };

package/dist/es/plus/productSelect/index.js

@@ -0,0 +1,190 @@
+import useEngineContext_default from "../../hooks/useEngineContext.js";
+import IntersectionObserver_default from "./components/IntersectionObserver.js";
+import CategorySkeleton_default from "./CategoryTabs/CategorySkeleton.js";
+import CategoryTabs_default from "./CategoryTabs/index.js";
+import { createGridComponents } from "./ProductList/gridComponents.js";
+import ProductList_default from "./ProductList/index.js";
+import { genCSSVars, useToken } from "./hooks/useToken.js";
+import { getElementByIdentifier, getOffsetTopRelativeToScrollContainer, groupProductsByCategory } from "./utils.js";
+import ProductCardSkeleton_default from "./ProductCard/ProductCardSkeleton.js";
+import ProductCard_default from "./ProductCard/index.js";
+import locales_default from "./locales.js";
+import React, { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from "react";
+import { locales } from "@pisell/utils";
+import SearchLg from "@pisell/icon/es/SearchLg";
+import classNames from "classnames";
+import { Input, PisellEmpty } from "@pisell/materials";
+import "./index.less";
+
+//#region src/plus/productSelect/index.tsx
+const MOCK_DATA = (() => {
+	const mockData = [];
+	mockData.push({
+		__typename: "category",
+		id: "_c1_1"
+	});
+	for (let productIndex = 0; productIndex < 4; productIndex++) mockData.push({
+		__typename: "product",
+		id: "_pi" + productIndex
+	});
+	return mockData;
+})();
+const PREFIX = "pisell-product-select";
+const CONTAINER_CLASS = `${PREFIX}-wrapper`;
+const index = ({ dataSource = [], emptyDescription, showSearch = true, scrollDom, offsetDom, style = {}, token: customToken, onChange, value, selectedItems, productListSetting = {}, customScrollParent, loading = false, layout, ...rest }) => {
+	const searchRef = useRef(null);
+	const [keyword, setKeyword] = useState("");
+	const [activeKey, setActiveKey] = useState("");
+	const [scrollParent, setScrollParent] = useState(null);
+	const isIndicatorVisibleRef = useRef(false);
+	const containerRef = useRef(null);
+	const _customScrollParent = customScrollParent || scrollDom;
+	const gridComponents = useMemo(() => {
+		return createGridComponents(layout);
+	}, [layout]);
+	const context = useEngineContext_default();
+	useEffect(() => {
+		locales.init(locales_default, context.appHelper.utils?.storage?.get("umi_locale") || "en");
+	}, []);
+	const _filteredList = useMemo(() => {
+		if (!keyword) return dataSource;
+		return dataSource.filter((product) => {
+			if (typeof product?.title !== "string") return false;
+			return product.title.toLowerCase().indexOf(keyword.toLowerCase()) !== -1;
+		});
+	}, [keyword, dataSource]);
+	const _groupedList = useMemo(() => {
+		return groupProductsByCategory(_filteredList || []);
+	}, [_filteredList]);
+	const _categories = useMemo(() => {
+		return _groupedList.filter((item) => item.__typename === "category").map((item) => {
+			return {
+				...item,
+				key: String(item.id),
+				label: item.name
+			};
+		});
+	}, [_groupedList]);
+	useEffect(() => {
+		if (!_categories?.length) {
+			setActiveKey("");
+			return;
+		}
+		if (!activeKey) switchCategory(_categories[0].key);
+		else if (!_categories.find((category) => category.key === activeKey)) switchCategory(_categories[0].key);
+	}, [_categories]);
+	useLayoutEffect(() => {
+		if (_customScrollParent) setScrollParent(getElementByIdentifier(_customScrollParent));
+	}, [_customScrollParent]);
+	const token = useToken(customToken);
+	const cssVars = useMemo(() => genCSSVars(token), [token]);
+	const mergedStyle = useMemo(() => {
+		const baseStyle = {
+			...cssVars,
+			...style
+		};
+		if (!scrollParent) return baseStyle;
+		if (scrollParent !== containerRef.current) return {
+			...baseStyle,
+			overflow: "unset",
+			height: "unset"
+		};
+		return baseStyle;
+	}, [
+		cssVars,
+		style,
+		scrollParent
+	]);
+	const disabled = useMemo(() => {
+		return !!productListSetting?.list_max_length && Array.isArray(selectedItems) && selectedItems?.length > 0;
+	}, [productListSetting, selectedItems]);
+	const _onChange = useCallback((value$1) => {
+		if (disabled) return;
+		onChange?.(value$1);
+	}, [disabled, onChange]);
+	const debounceIndicator = useCallback((delay) => {
+		isIndicatorVisibleRef.current = true;
+		const timeoutId = setTimeout(() => {
+			isIndicatorVisibleRef.current = false;
+		}, delay);
+		return () => clearTimeout(timeoutId);
+	}, []);
+	const lastActiveKeyRef = useRef("");
+	const handleItemIntersectionIn = useCallback((item) => {
+		const _key = String(item.__categoryId);
+		if (!isIndicatorVisibleRef.current && _key && _key !== lastActiveKeyRef.current) {
+			setActiveKey(_key);
+			lastActiveKeyRef.current = _key;
+		}
+	}, []);
+	const switchCategory = (key) => {
+		setActiveKey(key);
+		lastActiveKeyRef.current = key;
+		debounceIndicator(300);
+		const categoryIndex = _groupedList.findIndex((item) => item.__typename === "category" && String(item.id) === key);
+		const _scrollParent = scrollParent || containerRef.current;
+		if (!_scrollParent || !containerRef.current) return;
+		const target = document.getElementById(`ps_category_${key}`);
+		if (!target) return;
+		const productSelectWrapper = document.querySelector(`.${PREFIX}-wrapper`);
+		const tabsHeight = document.querySelector(`.${PREFIX}__tabs-wrapper`)?.offsetHeight || 0;
+		const offsetElement = getElementByIdentifier(offsetDom);
+		const extraOffset = offsetElement ? offsetElement.clientHeight : 0;
+		if (categoryIndex === 0) {
+			if (productSelectWrapper) _scrollParent.scrollTop = getOffsetTopRelativeToScrollContainer(productSelectWrapper, _scrollParent) - extraOffset;
+			return;
+		} else _scrollParent.scrollTop = getOffsetTopRelativeToScrollContainer(target, _scrollParent) - tabsHeight - extraOffset;
+	};
+	return /* @__PURE__ */ React.createElement("div", {
+		ref: containerRef,
+		className: classNames(PREFIX, CONTAINER_CLASS, { disabled }),
+		style: mergedStyle
+	}, showSearch ? /* @__PURE__ */ React.createElement("div", { className: `${PREFIX}__search-wrapper` }, /* @__PURE__ */ React.createElement(Input, {
+		ref: searchRef,
+		prefix: /* @__PURE__ */ React.createElement(SearchLg, null),
+		style: { height: 44 },
+		placeholder: locales.getText("pisell2.product-select.search"),
+		allowClear: true,
+		value: keyword,
+		onChange: (e) => {
+			setKeyword(e.target.value);
+		}
+	})) : null, /* @__PURE__ */ React.createElement(CategoryTabs_default, {
+		activeKey,
+		items: _categories,
+		onChange: switchCategory,
+		loading,
+		skeleton: /* @__PURE__ */ React.createElement(CategorySkeleton_default, null)
+	}), !loading && !_groupedList?.length ? /* @__PURE__ */ React.createElement(PisellEmpty, { description: emptyDescription || locales.getText("pisell2.product-select.empty") }) : /* @__PURE__ */ React.createElement(IntersectionObserver_default, {
+		rootMargin: "-270px 0px -270px 0px",
+		priorityMode: "top"
+	}, /* @__PURE__ */ React.createElement(ProductList_default, {
+		className: `${PREFIX}__product-list`,
+		loading,
+		data: loading ? MOCK_DATA : _groupedList,
+		context: {
+			onItemIntersectionIn: handleItemIntersectionIn,
+			onItemIntersectionOut: () => {}
+		},
+		_customScrollParent: scrollParent,
+		components: gridComponents,
+		itemContent: (index$1, item, context$1) => {
+			if (loading) return /* @__PURE__ */ React.createElement(ProductCardSkeleton_default, {
+				index: index$1,
+				item
+			});
+			return /* @__PURE__ */ React.createElement(ProductCard_default, {
+				index: index$1,
+				item,
+				context: context$1,
+				onSelect: _onChange,
+				isSelected: item.id === value,
+				decorateConfig: productListSetting
+			});
+		}
+	})));
+};
+var productSelect_default = index;
+
+//#endregion
+export { PREFIX, productSelect_default as default };

package/dist/es/plus/productSelect/index.less

@@ -0,0 +1,56 @@
+.pisell-product-select {
+  &-wrapper {
+    height: 100%;
+    background: var(--ps-container-bg, #ffffff);
+    overflow-y: auto;
+
+    &::-webkit-scrollbar {
+      display: none !important;
+    }
+
+    &.disabled {
+      .pisell-product-select__product-card {
+        background: var(--ps-card-hover-bg, #eaecf0);
+        cursor: not-allowed;
+      }
+    }
+  }
+
+  &__search-wrapper {
+    padding: 12px 12px 0px;
+    line-height: 0;
+    margin-top: 0 !important;
+
+    .pisell-lowcode-input-affix-wrapper {
+      &:hover,
+      &:focus,
+      &:focus-within {
+        border-color: var(--ps-color-primary, #8157d5) !important;
+        box-shadow: none !important;
+      }
+    }
+
+    > span {
+      background: var(--ps-container-bg, #ffffff);
+      color: var(--ps-search-input-color, #98a2b3);
+    }
+
+    input {
+      background: transparent;
+      color: var(--ps-search-input-color, #98a2b3);
+    }
+  }
+
+  &__product-list {
+    padding: 0px 12px 12px;
+  }
+
+  &__tabs-wrapper {
+    position: sticky;
+    top: 0;
+    z-index: 10;
+    // 基础样式采用原pill样式
+    padding: 16px 12px;
+    background: var(--ps-container-bg, #fff);
+  }
+}

package/dist/es/plus/productSelect/locales.js

@@ -0,0 +1,21 @@
+//#region src/plus/productSelect/locales.ts
+var locales_default = {
+	en: {
+		"pisell2.product-select.search": "Search",
+		"pisell2.product-select.stock": "Stock",
+		"pisell2.product-select.empty": "No Data"
+	},
+	"zh-CN": {
+		"pisell2.product-select.search": "搜索",
+		"pisell2.product-select.stock": "库存",
+		"pisell2.product-select.empty": "暂无数据"
+	},
+	"zh-HK": {
+		"pisell2.product-select.search": "搜索",
+		"pisell2.product-select.stock": "庫存",
+		"pisell2.product-select.empty": "暂无数据"
+	}
+};
+
+//#endregion
+export { locales_default as default };

package/dist/es/plus/productSelect/theme/token.js

@@ -0,0 +1,20 @@
+//#region src/plus/productSelect/theme/token.ts
+const defaultToken = {
+	colorPrimary: "#8157D5",
+	colorText: "#1B1B1B",
+	colorTextSecondary: "#4E4E4E",
+	containerBg: "#4E4E4E",
+	searchInputColor: "#98a2b3",
+	tabItemBg: "#FFFFFF",
+	tabItemHoverBg: "#FFFFFF",
+	tabItemActiveBg: "#8157D5",
+	categoryTextColor: "#FFFFFF",
+	cardBg: "#FFFFFF",
+	cardHoverBg: "#eaecf0",
+	cardSelectedBg: "#8157D5",
+	cardSelectedTextColor: "#ffffff",
+	cardSelectedSecondaryTextColor: "rgba(255, 255, 255, 0.7)"
+};
+
+//#endregion
+export { defaultToken };