@levi-gemcommerce/analytics 0.0.0-test.1

package/dist/esm/components/CardPathAnalysis/hooks/usePathAnalysisFunnel.mjs

@@ -0,0 +1,159 @@
+"use client"
+import { processPathAnalyticsTree, processPathAnalytics, getFunnelChildrenPages } from '../helpers/pathAnalysis.mjs';
+import { usePathAnalysisStore } from '../stores/path-analysis.mjs';
+import '../stores/path-analysis-campaign.mjs';
+import { useFunnelChartStore } from '../stores/funnel-chart.mjs';
+import { useState, useMemo, useCallback, useEffect } from 'react';
+import { MAX_FUNNEL_ADDITIONAL_LEVEL } from '../configs/index.mjs';
+import '../../../utils/dayjs.mjs';
+import '../../../utils/analytics.mjs';
+import '../../../types/template.mjs';
+
+const usePathAnalysisFunnel = ({ pathAnalytics, pathAnalysisCacheKey, dataFirstLevels, locationPath, autoExpandLevels, }) => {
+    const setFirstLevelLocationPath = usePathAnalysisStore((state) => state.setFirstLevelLocationPath);
+    const firstLevelLocationPath = usePathAnalysisStore((state) => state.firstLevelLocationPath) || locationPath;
+    const setCachedFunnelChartData = useFunnelChartStore((state) => state.setCachedFunnelChartData);
+    const resetCachedFunnelChartData = useFunnelChartStore((state) => state.resetData);
+    const cachedFunnelChartData = useFunnelChartStore((state) => state.cachedFunnelChartData);
+    const [firstLevelPage, setFirstLevelPage] = useState(undefined);
+    const [dynamicLevels, setDynamicLevels] = useState([]);
+    const dataTree = useMemo(() => processPathAnalyticsTree(pathAnalytics), [pathAnalytics]);
+    const listPageAnalyticFirstLevel = useMemo(() => {
+        return dataTree?.filter((item) => item.level === 1 && item.id) || [];
+    }, [dataTree]);
+    //pageWithMetric: Build path tree by level 1
+    const pageWithMetric = useMemo(() => processPathAnalytics(pathAnalytics, firstLevelPage || ''), [pathAnalytics, firstLevelPage]);
+    const nextLevelPages = useMemo(() => {
+        const lastLevel = dynamicLevels[dynamicLevels.length - 1] || pageWithMetric;
+        const nextLevelPages = getFunnelChildrenPages(lastLevel);
+        return nextLevelPages;
+    }, [dynamicLevels, pageWithMetric]);
+    const handleSetFirstLevelPage = (path) => {
+        setFirstLevelPage(path);
+        const cachedData = cachedFunnelChartData[pathAnalysisCacheKey];
+        setDynamicLevels(cachedData?.dynamicLevels || []);
+    };
+    const handleAddNextLevel = useCallback((childId) => {
+        if (dynamicLevels.length >= MAX_FUNNEL_ADDITIONAL_LEVEL) {
+            return;
+        }
+        const selectedPage = nextLevelPages.find((page) => page.id === childId);
+        if (selectedPage) {
+            setDynamicLevels((prev) => [...prev, selectedPage]);
+        }
+    }, [dynamicLevels.length, nextLevelPages]);
+    const getPagesByParentID = (data) => {
+        const { level, parentID } = data;
+        if (level === 0 && dataTree) {
+            return dataTree;
+        }
+        if (!parentID)
+            return [];
+        const findCurrentLevel = dynamicLevels.find((item) => item.id === parentID);
+        if (findCurrentLevel) {
+            return findCurrentLevel.children || [];
+        }
+        //Children of first level
+        return pageWithMetric?.children || [];
+    };
+    const handleChangeLevel = (data) => {
+        const { id: newPathId, parentID, selectedID: oldPathId, level, locationPath } = data;
+        //Change first level
+        if (level === 0) {
+            setDynamicLevels([]);
+            setFirstLevelLocationPath(locationPath);
+            setCachedFunnelChartData(pathAnalysisCacheKey, {
+                firstLocationPath: locationPath,
+                dynamicLevels: [],
+            });
+            return;
+        }
+        const oldIndex = dynamicLevels.findIndex((level) => level.id === oldPathId);
+        if (oldIndex === -1)
+            return;
+        //Remove all levels after oldId
+        const updatedLevels = dynamicLevels.slice(0, oldIndex + 1);
+        //Find new page based on newId and parentID
+        const availableChildren = getPagesByParentID({ parentID });
+        const selectedPage = availableChildren.find((page) => page.id === newPathId);
+        if (selectedPage) {
+            //Replace old page with new page
+            updatedLevels[oldIndex] = selectedPage;
+            setDynamicLevels(updatedLevels);
+        }
+    };
+    const handleDeleteLevel = (id) => {
+        if (!id)
+            return;
+        const index = dynamicLevels.findIndex((level) => level.id === id);
+        if (index === -1)
+            return;
+        const updatedLevels = dynamicLevels.slice(0, index);
+        setDynamicLevels(updatedLevels);
+    };
+    const updateFirstLevel = () => {
+        if (!listPageAnalyticFirstLevel.length || !firstLevelLocationPath)
+            return;
+        const matchingPage = listPageAnalyticFirstLevel.find((page) => page.locationPath === firstLevelLocationPath);
+        if (matchingPage?.id) {
+            handleSetFirstLevelPage(matchingPage.id);
+            return;
+        }
+        if (listPageAnalyticFirstLevel[0]?.id) {
+            handleSetFirstLevelPage(listPageAnalyticFirstLevel[0].id);
+        }
+    };
+    useEffect(() => {
+        updateFirstLevel();
+    }, [listPageAnalyticFirstLevel, firstLevelLocationPath]);
+    useEffect(() => {
+        if (dataFirstLevels && dataFirstLevels.length > 0) {
+            const cachedData = cachedFunnelChartData[pathAnalysisCacheKey];
+            const firstLocationPath = cachedData?.firstLocationPath || dataFirstLevels[0].locationPath;
+            setFirstLevelLocationPath(firstLocationPath);
+        }
+    }, [dataFirstLevels]);
+    useEffect(() => {
+        if (!pathAnalysisCacheKey)
+            return;
+        setCachedFunnelChartData(pathAnalysisCacheKey, {
+            dynamicLevels: dynamicLevels,
+        });
+    }, [dynamicLevels]);
+    // Auto-expand the dominant path down every level when the flag is enabled:
+    // first level → highest-traffic child → ... up to MAX_FUNNEL_ADDITIONAL_LEVEL,
+    // stopping as soon as a level has no further paths.
+    useEffect(() => {
+        if (!autoExpandLevels || !pageWithMetric)
+            return;
+        const expandedLevels = [];
+        let currentPage = pageWithMetric;
+        while (expandedLevels.length < MAX_FUNNEL_ADDITIONAL_LEVEL) {
+            const childrenPages = getFunnelChildrenPages(currentPage);
+            if (!childrenPages.length)
+                break;
+            // Pick the dominant child (highest sessions) — matches the top of the "+" popover.
+            const nextPage = childrenPages.reduce((prev, curr) => (curr.metric?.totalSessions || 0) > (prev.metric?.totalSessions || 0) ? curr : prev);
+            expandedLevels.push(nextPage);
+            currentPage = nextPage;
+        }
+        setDynamicLevels(expandedLevels);
+    }, [autoExpandLevels, pageWithMetric]);
+    useEffect(() => {
+        return () => {
+            setFirstLevelLocationPath(undefined);
+            resetCachedFunnelChartData();
+        };
+    }, []);
+    return {
+        pageWithMetric,
+        dynamicLevels,
+        nextLevelPages,
+        handleAddNextLevel,
+        handleChangeLevel,
+        getPagesByParentID,
+        handleDeleteLevel,
+    };
+};
+
+export { usePathAnalysisFunnel };

package/dist/esm/components/CardPathAnalysis/hooks/usePathAnalyticsMerger.d.ts

@@ -0,0 +1,10 @@
+import type { PathAnalyticPageSelectFragment } from '../../../api/graphql/fragments/pathAnalytic.generated';
+import type { IPathAnalysisFirstLevel } from '../contexts';
+interface IUsePathAnalysisFunnelProps {
+    pathAnalytics: PathAnalyticPageSelectFragment[];
+    dataFirstLevels?: IPathAnalysisFirstLevel[];
+}
+export declare const usePathAnalyticsMerger: ({ pathAnalytics, dataFirstLevels }: IUsePathAnalysisFunnelProps) => {
+    processedPathAnalytics: PathAnalyticPageSelectFragment[];
+};
+export {};

package/dist/esm/components/CardPathAnalysis/hooks/usePathAnalyticsMerger.js

@@ -0,0 +1,34 @@
+"use client"
+import { useMemo } from 'react';
+
+const usePathAnalyticsMerger = ({ pathAnalytics, dataFirstLevels }) => {
+    const { firstLevelData, otherLevelsData } = useMemo(() => {
+        return pathAnalytics.reduce((acc, item) => {
+            if (item.level === 1) {
+                acc.firstLevelData[item.locationPath ?? ''] = item;
+            }
+            else {
+                acc.otherLevelsData.push(item);
+            }
+            return acc;
+        }, {
+            firstLevelData: {},
+            otherLevelsData: [],
+        });
+    }, [pathAnalytics]);
+    const processedPathAnalytics = useMemo(() => {
+        if (!dataFirstLevels)
+            return pathAnalytics;
+        const mergedFirstLevels = dataFirstLevels.map((item) => {
+            const firstLevelDataItem = firstLevelData[item.locationPath];
+            if (!firstLevelDataItem) {
+                return item;
+            }
+            return firstLevelDataItem;
+        });
+        return [...mergedFirstLevels, ...otherLevelsData];
+    }, [pathAnalytics, dataFirstLevels, firstLevelData, otherLevelsData]);
+    return { processedPathAnalytics };
+};
+
+export { usePathAnalyticsMerger };

package/dist/esm/components/CardPathAnalysis/hooks/usePathAnalyticsMerger.mjs

@@ -0,0 +1,34 @@
+"use client"
+import { useMemo } from 'react';
+
+const usePathAnalyticsMerger = ({ pathAnalytics, dataFirstLevels }) => {
+    const { firstLevelData, otherLevelsData } = useMemo(() => {
+        return pathAnalytics.reduce((acc, item) => {
+            if (item.level === 1) {
+                acc.firstLevelData[item.locationPath ?? ''] = item;
+            }
+            else {
+                acc.otherLevelsData.push(item);
+            }
+            return acc;
+        }, {
+            firstLevelData: {},
+            otherLevelsData: [],
+        });
+    }, [pathAnalytics]);
+    const processedPathAnalytics = useMemo(() => {
+        if (!dataFirstLevels)
+            return pathAnalytics;
+        const mergedFirstLevels = dataFirstLevels.map((item) => {
+            const firstLevelDataItem = firstLevelData[item.locationPath];
+            if (!firstLevelDataItem) {
+                return item;
+            }
+            return firstLevelDataItem;
+        });
+        return [...mergedFirstLevels, ...otherLevelsData];
+    }, [pathAnalytics, dataFirstLevels, firstLevelData, otherLevelsData]);
+    return { processedPathAnalytics };
+};
+
+export { usePathAnalyticsMerger };

package/dist/esm/components/CardPathAnalysis/index.d.ts

@@ -0,0 +1,5 @@
+export * from './CardJourneyAnalysis';
+export * from './components';
+export * from './contexts';
+export * from './constants';
+export * from './stores';

package/dist/esm/components/CardPathAnalysis/stores/funnel-chart.d.ts

@@ -0,0 +1,12 @@
+import type { IBasePathAnalyticPageWithChild } from '../types';
+export interface ICachedFunnelChartDataValue {
+    firstLocationPath?: string;
+    dynamicLevels?: IBasePathAnalyticPageWithChild[];
+}
+interface IFunnelChartStoreState {
+    cachedFunnelChartData: Record<string, ICachedFunnelChartDataValue>;
+    setCachedFunnelChartData: (key: string, funnelChartData: ICachedFunnelChartDataValue) => void;
+    resetData: () => void;
+}
+export declare const useFunnelChartStore: import("zustand").UseBoundStore<import("zustand").StoreApi<IFunnelChartStoreState>>;
+export {};

package/dist/esm/components/CardPathAnalysis/stores/funnel-chart.js

@@ -0,0 +1,23 @@
+"use client"
+import '../../../utils/dayjs.js';
+import '../../../utils/analytics.js';
+import { deepCopy } from '../../../utils/deep-copy.js';
+import '../../../types/template.js';
+import { create } from 'zustand';
+
+const useFunnelChartStore = create()((set, get) => ({
+    cachedFunnelChartData: {},
+    setCachedFunnelChartData: (key, funnelChartData) => {
+        const currentFunnelChartData = deepCopy(get().cachedFunnelChartData);
+        currentFunnelChartData[key] = {
+            ...currentFunnelChartData[key],
+            ...funnelChartData,
+        };
+        set({ cachedFunnelChartData: currentFunnelChartData });
+    },
+    resetData: () => {
+        set({ cachedFunnelChartData: {} });
+    },
+}));
+
+export { useFunnelChartStore };

package/dist/esm/components/CardPathAnalysis/stores/funnel-chart.mjs

@@ -0,0 +1,23 @@
+"use client"
+import '../../../utils/dayjs.mjs';
+import '../../../utils/analytics.mjs';
+import { deepCopy } from '../../../utils/deep-copy.mjs';
+import '../../../types/template.mjs';
+import { create } from 'zustand';
+
+const useFunnelChartStore = create()((set, get) => ({
+    cachedFunnelChartData: {},
+    setCachedFunnelChartData: (key, funnelChartData) => {
+        const currentFunnelChartData = deepCopy(get().cachedFunnelChartData);
+        currentFunnelChartData[key] = {
+            ...currentFunnelChartData[key],
+            ...funnelChartData,
+        };
+        set({ cachedFunnelChartData: currentFunnelChartData });
+    },
+    resetData: () => {
+        set({ cachedFunnelChartData: {} });
+    },
+}));
+
+export { useFunnelChartStore };

package/dist/esm/components/CardPathAnalysis/stores/index.d.ts

@@ -0,0 +1,3 @@
+export * from './path-analysis';
+export * from './path-analysis-campaign';
+export * from './funnel-chart';

package/dist/esm/components/CardPathAnalysis/stores/path-analysis-campaign.d.ts

@@ -0,0 +1,10 @@
+export declare enum IVariantType {
+    VARIANT_A = "A",
+    VARIANT_B = "B"
+}
+interface IPathAnalysisCampaignStoreState {
+    selectedVariantType: IVariantType;
+    setSelectedVariantType: (selectedVariantType: IVariantType) => void;
+}
+export declare const usePathAnalysisCampaignStore: import("zustand").UseBoundStore<import("zustand").StoreApi<IPathAnalysisCampaignStoreState>>;
+export {};

package/dist/esm/components/CardPathAnalysis/stores/path-analysis-campaign.js

@@ -0,0 +1,14 @@
+"use client"
+import { create } from 'zustand';
+
+var IVariantType;
+(function (IVariantType) {
+    IVariantType["VARIANT_A"] = "A";
+    IVariantType["VARIANT_B"] = "B";
+})(IVariantType || (IVariantType = {}));
+const usePathAnalysisCampaignStore = create()((set) => ({
+    selectedVariantType: IVariantType.VARIANT_A,
+    setSelectedVariantType: (selectedVariantType) => set({ selectedVariantType }),
+}));
+
+export { IVariantType, usePathAnalysisCampaignStore };

package/dist/esm/components/CardPathAnalysis/stores/path-analysis-campaign.mjs

@@ -0,0 +1,14 @@
+"use client"
+import { create } from 'zustand';
+
+var IVariantType;
+(function (IVariantType) {
+    IVariantType["VARIANT_A"] = "A";
+    IVariantType["VARIANT_B"] = "B";
+})(IVariantType || (IVariantType = {}));
+const usePathAnalysisCampaignStore = create()((set) => ({
+    selectedVariantType: IVariantType.VARIANT_A,
+    setSelectedVariantType: (selectedVariantType) => set({ selectedVariantType }),
+}));
+
+export { IVariantType, usePathAnalysisCampaignStore };

package/dist/esm/components/CardPathAnalysis/stores/path-analysis.d.ts

@@ -0,0 +1,6 @@
+interface IPathAnalyticStoreState {
+    firstLevelLocationPath?: string;
+    setFirstLevelLocationPath: (firstLevelLocationPath?: string) => void;
+}
+export declare const usePathAnalysisStore: import("zustand").UseBoundStore<import("zustand").StoreApi<IPathAnalyticStoreState>>;
+export {};

package/dist/esm/components/CardPathAnalysis/stores/path-analysis.js

@@ -0,0 +1,9 @@
+"use client"
+import { create } from 'zustand';
+
+const usePathAnalysisStore = create()((set) => ({
+    firstLevelLocationPath: undefined,
+    setFirstLevelLocationPath: (firstLevelLocationPath) => set({ firstLevelLocationPath }),
+}));
+
+export { usePathAnalysisStore };

package/dist/esm/components/CardPathAnalysis/stores/path-analysis.mjs

@@ -0,0 +1,9 @@
+"use client"
+import { create } from 'zustand';
+
+const usePathAnalysisStore = create()((set) => ({
+    firstLevelLocationPath: undefined,
+    setFirstLevelLocationPath: (firstLevelLocationPath) => set({ firstLevelLocationPath }),
+}));
+
+export { usePathAnalysisStore };

package/dist/esm/components/CardPathAnalysis/types/index.d.ts

@@ -0,0 +1 @@
+export * from './path-analysis';

package/dist/esm/components/CardPathAnalysis/types/path-analysis.d.ts

@@ -0,0 +1,6 @@
+import type { PathAnalyticMetricSelectFragment, PathAnalyticPageSelectFragment } from '../../../api/graphql/fragments/pathAnalytic.generated';
+export interface IBasePathAnalyticPageWithChild extends PathAnalyticPageSelectFragment {
+    children?: IBasePathAnalyticPageWithChild[];
+    metrics?: PathAnalyticMetricSelectFragment[];
+}
+export type IBasePathAnalyticPageWithParent = PathAnalyticPageSelectFragment;

package/dist/esm/components/CurrencySelector/CurrencySelector.d.ts

@@ -0,0 +1,10 @@
+import type { GSelectorProps } from '../../shared';
+import type { CurrencyCode } from '../../types';
+export interface CurrencySelectorProps {
+    currencies?: CurrencyCode[];
+    selected?: CurrencyCode;
+    preferredAlignment?: GSelectorProps['preferredAlignment'];
+    activatorText?: string;
+    onSelect?: (value: CurrencyCode) => void;
+}
+export declare const CurrencySelector: ({ currencies, selected, preferredAlignment, activatorText, onSelect, }: CurrencySelectorProps) => import("react/jsx-runtime").JSX.Element | null;

package/dist/esm/components/CurrencySelector/CurrencySelector.js

@@ -0,0 +1,93 @@
+"use client"
+import { jsx } from 'react/jsx-runtime';
+import { Icon, Text, Box } from '@shopify/polaris';
+import { CheckIcon } from '@shopify/polaris-icons';
+import { useRef, useCallback, useMemo, useEffect } from 'react';
+import { sortByConditions } from '../../utils/sort.js';
+import '../../utils/dayjs.js';
+import '../../utils/analytics.js';
+import '../../types/template.js';
+import '../../shared/components/GTooltip/components/GTooltipCard.js';
+import '../../shared/components/GDiv/GDiv.js';
+import { GI18NText } from '../../shared/components/GI18NText/GI18NText.js';
+import { GSelector } from '../../shared/components/GSelector/GSelector.js';
+import { GTextLink } from '../../shared/components/GTextLink/GTextLink.js';
+import '../../shared/components/GFeatureLocked/constants.js';
+import { useTranslation } from 'react-i18next';
+import '../../shared/components/GFeatureLocked/types.js';
+import '../../shared/components/GPagination/GPagination.js';
+import '../../shared/charts/components/GPolarisViz/hooks/useResizeObserver.js';
+import '../../stores/currencyRatesStore.js';
+import '@tanstack/react-query';
+import '../../providers/ConvertMoneyProvider.js';
+import '../../core/gemxql/constants/row-reader-mode.js';
+import '../../core/gemxql/types/analytic-data.js';
+import '../../core/gemxql/types/analytic-source.js';
+import '../../core/gemxql/types/extra-condition.js';
+import '../../core/gemxql/types/field-filters.js';
+import '../../core/gemxql/types/field-operators.js';
+import '../../core/gemxql/types/group-with-clause.js';
+import '../../core/gemxql/types/order-by.js';
+import '../../core/gemxql/types/page-fields.js';
+import '../../core/gemxql/types/row-reader-mode.js';
+import '../../core/gemxql/types/time-dimension.js';
+import '../../constants/analytic-metric-tooltip.js';
+import '../../constants/breakdown-targets.js';
+import { DEFAULT_CURRENCY_ANALYTIC } from '../../constants/currency.js';
+
+const EXCHANGE_RATE_HELP_URL = 'https://help.shopify.com/en/manual/international/pricing/exchange-rates#auto-convert';
+const CurrencySelector = ({ currencies, selected, preferredAlignment = 'left', activatorText, onSelect, }) => {
+    const { t } = useTranslation();
+    const onSelectRef = useRef(onSelect);
+    const handleSelection = useCallback((value) => {
+        onSelectRef.current?.(value);
+    }, []);
+    const actionItems = useMemo(() => {
+        if (!currencies)
+            return [];
+        const formattedCurrencies = currencies.map((currency) => ({
+            content: currency,
+            id: currency,
+        }));
+        const hasCurrencyDefault = formattedCurrencies.some((item) => item.id === DEFAULT_CURRENCY_ANALYTIC);
+        if (!hasCurrencyDefault) {
+            formattedCurrencies.push({
+                content: DEFAULT_CURRENCY_ANALYTIC,
+                id: DEFAULT_CURRENCY_ANALYTIC,
+            });
+        }
+        return sortByConditions(formattedCurrencies, [
+            { attr: 'content', order: 'asc', preferredValue: DEFAULT_CURRENCY_ANALYTIC },
+        ]);
+    }, [currencies]);
+    const actionListItems = useMemo(() => {
+        return actionItems.map((option) => ({
+            id: option.id,
+            content: option.content,
+            onAction: () => handleSelection(option.id),
+            active: option.id === selected,
+            suffix: option.id === selected && jsx(Icon, { source: CheckIcon, tone: "success" }),
+            helpText: option.id === DEFAULT_CURRENCY_ANALYTIC && (jsx(Text, { as: "p", fontWeight: "semibold", children: t('Default') })),
+        }));
+    }, [actionItems, selected, handleSelection, t]);
+    const isHidden = useMemo(() => {
+        if (!actionItems?.length)
+            return true;
+        return actionItems.length === 1 && actionItems[0]?.id === DEFAULT_CURRENCY_ANALYTIC;
+    }, [actionItems]);
+    useEffect(() => {
+        onSelectRef.current = onSelect;
+    });
+    if (isHidden)
+        return null;
+    return (jsx(GSelector, { options: actionListItems, selected: selected, variant: "action-list", 
+        // value originates from our CurrencyCode option ids, so the widen-to-string round trip is safe
+        onSelect: (value) => handleSelection(value), activatorText: activatorText ?? t('Currency'), maxWidth: "225px", preferredAlignment: preferredAlignment, helpText: jsx(Box, { padding: "200", paddingBlockStart: "300", paddingBlockEnd: "300", borderColor: "border-tertiary", background: 'bg', children: jsx(GI18NText, { as: "p", variant: "bodyMd", transformers: {
+                    1: (text) => (jsx(GTextLink, { linkAction: {
+                            url: EXCHANGE_RATE_HELP_URL,
+                            target: '_blank',
+                        }, children: text }, text + 'text-link')),
+                }, children: t("This will follow Shopify's current exchange rate. [1]Read more[]") }) }) }));
+};
+
+export { CurrencySelector };

package/dist/esm/components/CurrencySelector/CurrencySelector.mjs

@@ -0,0 +1,93 @@
+"use client"
+import { jsx } from 'react/jsx-runtime';
+import { Icon, Text, Box } from '@shopify/polaris';
+import { CheckIcon } from '@shopify/polaris-icons';
+import { useRef, useCallback, useMemo, useEffect } from 'react';
+import { sortByConditions } from '../../utils/sort.mjs';
+import '../../utils/dayjs.mjs';
+import '../../utils/analytics.mjs';
+import '../../types/template.mjs';
+import '../../shared/components/GTooltip/components/GTooltipCard.mjs';
+import '../../shared/components/GDiv/GDiv.mjs';
+import { GI18NText } from '../../shared/components/GI18NText/GI18NText.mjs';
+import { GSelector } from '../../shared/components/GSelector/GSelector.mjs';
+import { GTextLink } from '../../shared/components/GTextLink/GTextLink.mjs';
+import '../../shared/components/GFeatureLocked/constants.mjs';
+import { useTranslation } from 'react-i18next';
+import '../../shared/components/GFeatureLocked/types.mjs';
+import '../../shared/components/GPagination/GPagination.mjs';
+import '../../shared/charts/components/GPolarisViz/hooks/useResizeObserver.mjs';
+import '../../stores/currencyRatesStore.mjs';
+import '@tanstack/react-query';
+import '../../providers/ConvertMoneyProvider.mjs';
+import '../../core/gemxql/constants/row-reader-mode.mjs';
+import '../../core/gemxql/types/analytic-data.mjs';
+import '../../core/gemxql/types/analytic-source.mjs';
+import '../../core/gemxql/types/extra-condition.mjs';
+import '../../core/gemxql/types/field-filters.mjs';
+import '../../core/gemxql/types/field-operators.mjs';
+import '../../core/gemxql/types/group-with-clause.mjs';
+import '../../core/gemxql/types/order-by.mjs';
+import '../../core/gemxql/types/page-fields.mjs';
+import '../../core/gemxql/types/row-reader-mode.mjs';
+import '../../core/gemxql/types/time-dimension.mjs';
+import '../../constants/analytic-metric-tooltip.mjs';
+import '../../constants/breakdown-targets.mjs';
+import { DEFAULT_CURRENCY_ANALYTIC } from '../../constants/currency.mjs';
+
+const EXCHANGE_RATE_HELP_URL = 'https://help.shopify.com/en/manual/international/pricing/exchange-rates#auto-convert';
+const CurrencySelector = ({ currencies, selected, preferredAlignment = 'left', activatorText, onSelect, }) => {
+    const { t } = useTranslation();
+    const onSelectRef = useRef(onSelect);
+    const handleSelection = useCallback((value) => {
+        onSelectRef.current?.(value);
+    }, []);
+    const actionItems = useMemo(() => {
+        if (!currencies)
+            return [];
+        const formattedCurrencies = currencies.map((currency) => ({
+            content: currency,
+            id: currency,
+        }));
+        const hasCurrencyDefault = formattedCurrencies.some((item) => item.id === DEFAULT_CURRENCY_ANALYTIC);
+        if (!hasCurrencyDefault) {
+            formattedCurrencies.push({
+                content: DEFAULT_CURRENCY_ANALYTIC,
+                id: DEFAULT_CURRENCY_ANALYTIC,
+            });
+        }
+        return sortByConditions(formattedCurrencies, [
+            { attr: 'content', order: 'asc', preferredValue: DEFAULT_CURRENCY_ANALYTIC },
+        ]);
+    }, [currencies]);
+    const actionListItems = useMemo(() => {
+        return actionItems.map((option) => ({
+            id: option.id,
+            content: option.content,
+            onAction: () => handleSelection(option.id),
+            active: option.id === selected,
+            suffix: option.id === selected && jsx(Icon, { source: CheckIcon, tone: "success" }),
+            helpText: option.id === DEFAULT_CURRENCY_ANALYTIC && (jsx(Text, { as: "p", fontWeight: "semibold", children: t('Default') })),
+        }));
+    }, [actionItems, selected, handleSelection, t]);
+    const isHidden = useMemo(() => {
+        if (!actionItems?.length)
+            return true;
+        return actionItems.length === 1 && actionItems[0]?.id === DEFAULT_CURRENCY_ANALYTIC;
+    }, [actionItems]);
+    useEffect(() => {
+        onSelectRef.current = onSelect;
+    });
+    if (isHidden)
+        return null;
+    return (jsx(GSelector, { options: actionListItems, selected: selected, variant: "action-list", 
+        // value originates from our CurrencyCode option ids, so the widen-to-string round trip is safe
+        onSelect: (value) => handleSelection(value), activatorText: activatorText ?? t('Currency'), maxWidth: "225px", preferredAlignment: preferredAlignment, helpText: jsx(Box, { padding: "200", paddingBlockStart: "300", paddingBlockEnd: "300", borderColor: "border-tertiary", background: 'bg', children: jsx(GI18NText, { as: "p", variant: "bodyMd", transformers: {
+                    1: (text) => (jsx(GTextLink, { linkAction: {
+                            url: EXCHANGE_RATE_HELP_URL,
+                            target: '_blank',
+                        }, children: text }, text + 'text-link')),
+                }, children: t("This will follow Shopify's current exchange rate. [1]Read more[]") }) }) }));
+};
+
+export { CurrencySelector };

package/dist/esm/components/CurrencySelector/index.d.ts

@@ -0,0 +1,2 @@
+export { CurrencySelector } from './CurrencySelector';
+export type { CurrencySelectorProps } from './CurrencySelector';

package/dist/esm/components/GModalOrderJourney/GModalOrderJourney.d.ts

@@ -0,0 +1,20 @@
+import type { IOrderJourneyItem, IOrderPageAnalytic, IReportCampaign } from '../OrderAnalytic/types';
+import type { EAnalyticMode } from '../../types';
+import { EReportSource } from '../OrderAnalytic/types';
+export interface GModalOrderJourneyProps {
+    open: boolean;
+    onClose: () => void;
+    title: string;
+    orderId: string;
+    journeyItems: IOrderJourneyItem[];
+    isLoading?: boolean;
+    hasNextPage?: boolean;
+    isFetchingNextPage?: boolean;
+    fetchNextPage?: () => void;
+    reportCampaign?: IReportCampaign;
+    pageAnalytic?: IOrderPageAnalytic;
+    mode: EAnalyticMode;
+    journeySource?: EReportSource;
+    onViewOrderDetails?: (orderId: string) => void;
+}
+export declare const GModalOrderJourney: ({ open, onClose, title, orderId, journeyItems, isLoading, hasNextPage, isFetchingNextPage, fetchNextPage, reportCampaign, pageAnalytic, mode, journeySource, onViewOrderDetails, }: GModalOrderJourneyProps) => import("react/jsx-runtime").JSX.Element | null;