@levi-gemcommerce/analytics 0.0.1-dev.6 → 0.0.1-dev.7

package/dist/esm/gemxql.js

@@ -0,0 +1,1046 @@
+import { useQuery } from '@tanstack/react-query';
+import dayjs from 'dayjs';
+import quarterOfYear from 'dayjs/plugin/quarterOfYear';
+import timezone from 'dayjs/plugin/timezone';
+import utc from 'dayjs/plugin/utc';
+import { useState, useRef, useCallback, useEffect } from 'react';
+
+const ColumnSelectFragmentDoc = `
+    fragment ColumnSelect on Column {
+  dataType
+  displayName
+  name
+}
+    `;
+const TableDataSelectFragmentDoc = `
+    fragment TableDataSelect on TableData {
+  columns {
+    ...ColumnSelect
+  }
+  rows
+}
+    `;
+const GemXqlResultSelectFragmentDoc = `
+    fragment GemXQLResultSelect on GemxQLResult {
+  tableData {
+    ...TableDataSelect
+  }
+}
+    `;
+
+const GemxQlDocument = `
+    query GemxQL($input: String!) {
+  gemxQLQuery(query: $input) {
+    ...GemXQLResultSelect
+  }
+}
+    ${GemXqlResultSelectFragmentDoc}
+${TableDataSelectFragmentDoc}
+${ColumnSelectFragmentDoc}`;
+
+const useCustomGemXQlQuery = (variables, fetcher, options) => {
+    return useQuery({
+        queryKey: ['GemXQlCustom', variables],
+        queryFn: fetcher(GemxQlDocument, variables),
+        ...options,
+    });
+};
+useCustomGemXQlQuery.getKey = (variables) => ['GemXQlCustom', variables];
+
+const useGemxQlNamedQuery = ({ name, variables, fetcher }, options) => {
+    const document = GemxQlDocument.replace(/query\s+GemxQL\b/, `query ${name}`);
+    return useQuery({
+        queryKey: [name, variables],
+        queryFn: fetcher(document, variables),
+        retry: 0,
+        ...options,
+    });
+};
+useGemxQlNamedQuery.getKey = (name, variables) => [name, variables];
+
+const NONE_VALUE = 'None';
+const PLACEHOLDER_VALUE = '-';
+
+const TOTALS_SUFFIX = '___totals';
+const COMPARE_PREFIX = 'comparison___';
+const COMPARE_SUFFIX = '___previous_period';
+const COMPARE_TOTALS_SUFFIX = `${COMPARE_SUFFIX}${TOTALS_SUFFIX}`;
+
+const OPERATOR_IS = 'is';
+const OPERATOR_IS_ONE_OF = 'is_one_of';
+
+var EAnalyticDataType;
+(function (EAnalyticDataType) {
+    EAnalyticDataType["DATE"] = "DATE";
+    EAnalyticDataType["ARRAY"] = "ARRAY";
+    EAnalyticDataType["OBJECT"] = "OBJECT";
+    EAnalyticDataType["STRING"] = "STRING";
+    EAnalyticDataType["INTEGER"] = "INTEGER";
+    EAnalyticDataType["CURRENCY"] = "CURRENCY";
+    EAnalyticDataType["PERCENT"] = "PERCENT";
+    EAnalyticDataType["DURATION"] = "DURATION";
+    EAnalyticDataType["MONTH"] = "MONTH_TIMESTAMP";
+    EAnalyticDataType["QUARTER"] = "QUARTER_TIMESTAMP";
+    EAnalyticDataType["DAY"] = "DAY_TIMESTAMP";
+    EAnalyticDataType["WEEK"] = "WEEK_TIMESTAMP";
+    EAnalyticDataType["YEAR"] = "YEAR_TIMESTAMP";
+    EAnalyticDataType["HOUR"] = "HOUR_TIMESTAMP";
+})(EAnalyticDataType || (EAnalyticDataType = {}));
+var EAnalyticColumnKey;
+(function (EAnalyticColumnKey) {
+    EAnalyticColumnKey["CAMPAIGNS"] = "experiments";
+    EAnalyticColumnKey["VISITOR_ITEMS"] = "visitor_items";
+    EAnalyticColumnKey["DEVICE_ITEMS"] = "device_items";
+    EAnalyticColumnKey["TRAFFIC_SOURCE_ITEMS"] = "traffic_source_items";
+})(EAnalyticColumnKey || (EAnalyticColumnKey = {}));
+
+var EAnalyticMode;
+(function (EAnalyticMode) {
+    EAnalyticMode["ALL_SESSION"] = "ALL_SESSION";
+    EAnalyticMode["FIRST_SESSION"] = "FIRST_SESSION";
+    EAnalyticMode["PAGE_ONLY"] = "PAGE_ONLY";
+})(EAnalyticMode || (EAnalyticMode = {}));
+
+var EAnalyticSource;
+(function (EAnalyticSource) {
+    EAnalyticSource["SESSIONS"] = "sessions";
+    EAnalyticSource["SALES"] = "sales";
+})(EAnalyticSource || (EAnalyticSource = {}));
+
+var EVisitorType;
+(function (EVisitorType) {
+    EVisitorType["NEW"] = "new";
+    EVisitorType["RETURNING"] = "returning";
+})(EVisitorType || (EVisitorType = {}));
+var EDeviceType;
+(function (EDeviceType) {
+    EDeviceType["DESKTOP"] = "desktop";
+    EDeviceType["MOBILE"] = "mobile";
+    EDeviceType["TABLET"] = "tablet";
+})(EDeviceType || (EDeviceType = {}));
+var ETrafficSourceType;
+(function (ETrafficSourceType) {
+    ETrafficSourceType["DIRECT"] = "direct";
+    ETrafficSourceType["EMAIL"] = "email";
+    ETrafficSourceType["REFERRAL"] = "referral";
+    ETrafficSourceType["ORGANIC_SOCIAL"] = "organic-social";
+    ETrafficSourceType["ORGANIC_SEARCH"] = "organic-search";
+    ETrafficSourceType["PAID_SOCIAL"] = "paid-social";
+    ETrafficSourceType["PAID_SEARCH"] = "paid-search";
+    ETrafficSourceType["SMS"] = "sms";
+})(ETrafficSourceType || (ETrafficSourceType = {}));
+
+var EComparisonOperator;
+(function (EComparisonOperator) {
+    EComparisonOperator["EQ"] = "=";
+    EComparisonOperator["IN"] = "IN";
+    EComparisonOperator["LIKE"] = "LIKE";
+})(EComparisonOperator || (EComparisonOperator = {}));
+var EGroupOperator;
+(function (EGroupOperator) {
+    EGroupOperator["OR"] = "OR";
+    EGroupOperator["AND"] = "AND";
+})(EGroupOperator || (EGroupOperator = {}));
+
+var EFilterField;
+(function (EFilterField) {
+    EFilterField["DEVICE"] = "device";
+    EFilterField["DEVICES"] = "devices";
+    EFilterField["VISITOR"] = "visitor_type";
+    EFilterField["VISITORS"] = "visitor_types";
+    EFilterField["TRAFFIC_SOURCE"] = "traffic_source";
+    EFilterField["TRAFFIC_SOURCES"] = "traffic_sources";
+    EFilterField["VERSION"] = "version";
+    EFilterField["VERSIONS"] = "versions";
+    EFilterField["SINGLE_PAGE"] = "page_path";
+    EFilterField["LIST_PAGE"] = "page_paths";
+    EFilterField["GROUP_CAMPAIGN_ITEM"] = "group_campaign_item";
+    EFilterField["GROUP_CAMPAIGN_ITEMS"] = "group_campaign_items";
+    EFilterField["SINGLE_CAMPAIGN"] = "experiment_id";
+    EFilterField["GROUP_CAMPAIGN"] = "experiment_group_id";
+    EFilterField["CAMPAIGN_VERSION_ID"] = "version_id";
+    EFilterField["GROUP_CAMPAIGN_VERSION_ID"] = "group_version_id";
+})(EFilterField || (EFilterField = {}));
+
+var EOperatorField;
+(function (EOperatorField) {
+    EOperatorField["DEVICE_OPERATOR"] = "deviceOperator";
+    EOperatorField["VISITOR_OPERATOR"] = "visitorOperator";
+    EOperatorField["TRAFFIC_SOURCE_OPERATOR"] = "trafficSourceOperator";
+    EOperatorField["VERSION_OPERATOR"] = "versionOperator";
+    EOperatorField["PAGE_OPERATOR"] = "pageOperator";
+    EOperatorField["CAMPAIGN_ITEM_OPERATOR"] = "campaignItemOperator";
+})(EOperatorField || (EOperatorField = {}));
+
+/**
+ * Controls which totals columns are appended to the query result.
+ *
+ * - NONE   → no totals, GROUP BY only.
+ * - TOTALS → adds `<metric>___totals` (grand total only). Use with single-dimension GROUP BY.
+ * - ALL    → adds subtotals per dimension group + grand total. Use with multi-dimension GROUP BY.
+ */
+var EGroupWithClause;
+(function (EGroupWithClause) {
+    EGroupWithClause["NONE"] = "";
+    EGroupWithClause["TOTALS"] = "TOTALS";
+    EGroupWithClause["ALL"] = "WITH GROUP_TOTALS, TOTALS";
+})(EGroupWithClause || (EGroupWithClause = {}));
+
+var EOrderDirectionType;
+(function (EOrderDirectionType) {
+    EOrderDirectionType["ASC"] = "ASC";
+    EOrderDirectionType["DESC"] = "DESC";
+})(EOrderDirectionType || (EOrderDirectionType = {}));
+
+var EPageMetric;
+(function (EPageMetric) {
+    EPageMetric["PAGE_ITEMS"] = "page_items";
+    EPageMetric["PAGE_PATHS"] = "page_paths";
+})(EPageMetric || (EPageMetric = {}));
+var EPageDimension;
+(function (EPageDimension) {
+    EPageDimension["PAGE_PATH"] = "page_path";
+})(EPageDimension || (EPageDimension = {}));
+var EPageField;
+(function (EPageField) {
+    EPageField["SHOPIFY_PAGE_ID"] = "shopify_page_id";
+    EPageField["LOCATION_PATH"] = "location_path";
+    EPageField["PAGE_TYPE"] = "page_type";
+    EPageField["PAGE_TITLE"] = "page_title";
+    EPageField["PAGE_PATH"] = "page_path";
+    EPageField["TEMPLATE_SUFFIX"] = "template_suffix";
+})(EPageField || (EPageField = {}));
+
+var ERowReaderMode;
+(function (ERowReaderMode) {
+    ERowReaderMode["DEFAULT"] = "DEFAULT";
+    ERowReaderMode["COMPARISON"] = "COMPARISON";
+    ERowReaderMode["TOTALS"] = "TOTALS";
+    ERowReaderMode["COMPARISON_TOTALS"] = "COMPARISON_TOTALS";
+})(ERowReaderMode || (ERowReaderMode = {}));
+
+var ETimeDimension;
+(function (ETimeDimension) {
+    ETimeDimension["HOUR"] = "hour";
+    ETimeDimension["DAY"] = "day";
+    ETimeDimension["WEEK"] = "week";
+    ETimeDimension["MONTH"] = "month";
+    ETimeDimension["QUARTER"] = "quarter";
+    ETimeDimension["YEAR"] = "year";
+})(ETimeDimension || (ETimeDimension = {}));
+
+const ROW_READER_MODE_CONFIG = {
+    [ERowReaderMode.DEFAULT]: { prefix: '', suffix: '' },
+    [ERowReaderMode.COMPARISON]: { prefix: COMPARE_PREFIX, suffix: COMPARE_SUFFIX },
+    [ERowReaderMode.TOTALS]: { prefix: '', suffix: TOTALS_SUFFIX },
+    [ERowReaderMode.COMPARISON_TOTALS]: { prefix: COMPARE_PREFIX, suffix: COMPARE_TOTALS_SUFFIX },
+};
+
+const DATE_QUERY_FORMAT = 'YYYY-MM-DDTHH:mm:ss';
+
+const CLAUSE_KEYWORDS = [
+    'MODE',
+    'FROM',
+    'SHOW',
+    'GROUP BY',
+    'TIMESERIES',
+    'SINCE',
+    'DURING',
+    'TIMEZONE',
+    'WHERE',
+    'ORDER BY',
+    'LIMIT',
+    'OFFSET',
+];
+const CLAUSE_KEYWORD_BOUNDARY = CLAUSE_KEYWORDS.join('|');
+
+const DEFAULT_QUERY_LIMIT = 1000;
+
+const DEFAULT_GROUP_OPERATOR = EGroupOperator.OR;
+const joinFieldClauses = (parts, groupOperator = DEFAULT_GROUP_OPERATOR) => {
+    if (!parts.length)
+        return '';
+    if (parts.length === 1)
+        return parts[0] ?? '';
+    return `(${parts.join(` ${groupOperator} `)})`;
+};
+const buildEq = ({ fields, value, groupOperator }) => {
+    if (!fields.length)
+        return '';
+    return joinFieldClauses(fields.map((field) => `${field} = ${value}`), groupOperator);
+};
+const buildIn = ({ fields, values, groupOperator }) => {
+    if (!fields.length || !values.length)
+        return '';
+    return joinFieldClauses(fields.map((field) => `${field} IN (${values.join(', ')})`), groupOperator);
+};
+const buildLike = ({ fields, value, groupOperator }) => {
+    const trimmed = value.trim();
+    if (!trimmed || !fields.length)
+        return '';
+    return joinFieldClauses(fields.map((field) => `${field} LIKE '%${trimmed}%'`), groupOperator);
+};
+const buildExtraCondition = (condition) => {
+    switch (condition.operator) {
+        case EComparisonOperator.EQ:
+            return buildEq(condition);
+        case EComparisonOperator.IN:
+            return buildIn(condition);
+        case EComparisonOperator.LIKE:
+            return buildLike(condition);
+    }
+};
+const buildExtraConditions = (conditions) => {
+    if (!conditions?.length)
+        return [];
+    return conditions.map(buildExtraCondition).filter(Boolean);
+};
+
+const filterConfigs = [
+    {
+        operator: EOperatorField.DEVICE_OPERATOR,
+        singleField: EFilterField.DEVICE,
+        multiField: EFilterField.DEVICES,
+        fieldName: EFilterField.DEVICE,
+    },
+    {
+        operator: EOperatorField.VISITOR_OPERATOR,
+        singleField: EFilterField.VISITOR,
+        multiField: EFilterField.VISITORS,
+        fieldName: EFilterField.VISITOR,
+    },
+    {
+        operator: EOperatorField.TRAFFIC_SOURCE_OPERATOR,
+        singleField: EFilterField.TRAFFIC_SOURCE,
+        multiField: EFilterField.TRAFFIC_SOURCES,
+        fieldName: EFilterField.TRAFFIC_SOURCE,
+    },
+    {
+        operator: EOperatorField.VERSION_OPERATOR,
+        singleField: EFilterField.VERSION,
+        multiField: EFilterField.VERSIONS,
+        fieldName: EFilterField.VERSION,
+    },
+    {
+        operator: EOperatorField.PAGE_OPERATOR,
+        singleField: EFilterField.SINGLE_PAGE,
+        multiField: EFilterField.LIST_PAGE,
+        fieldName: EFilterField.SINGLE_PAGE,
+    },
+    {
+        operator: EOperatorField.CAMPAIGN_ITEM_OPERATOR,
+        singleField: EFilterField.GROUP_CAMPAIGN_ITEM,
+        multiField: EFilterField.GROUP_CAMPAIGN_ITEMS,
+        condition: EFilterField.GROUP_CAMPAIGN,
+        fieldName: EFilterField.SINGLE_CAMPAIGN,
+    },
+    {
+        operatorVal: OPERATOR_IS,
+        singleField: EFilterField.SINGLE_CAMPAIGN,
+        multiField: EFilterField.GROUP_CAMPAIGN,
+    },
+];
+const buildCondition = (data) => {
+    const { operatorValue, singleValue, multiValue, fieldName } = data;
+    if (operatorValue === OPERATOR_IS && singleValue) {
+        return `${fieldName} = ${singleValue}`;
+    }
+    else if (operatorValue === OPERATOR_IS_ONE_OF && Array.isArray(multiValue) && multiValue.length > 0) {
+        return `${fieldName} IN (${multiValue.join(', ')})`;
+    }
+    return '';
+};
+const buildOverrideFilterConditions = (overrideFilters) => {
+    if (!overrideFilters)
+        return {};
+    return Object.fromEntries(Object.entries(overrideFilters)
+        .filter(([, value]) => value !== undefined)
+        .map(([key, value]) => {
+        const condition = Array.isArray(value) ? `${key} IN (${value.join(', ')})` : `${key} = ${value}`;
+        return [key, condition];
+    }));
+};
+const generateFilterConditions = (filters, overrideFilters) => {
+    const conditions = [];
+    const hasFilters = Object.keys(filters).length > 0;
+    const hasOverride = !!overrideFilters && Object.keys(overrideFilters).length > 0;
+    if (!hasFilters && !hasOverride)
+        return conditions;
+    const overrideConditionsMap = buildOverrideFilterConditions(overrideFilters);
+    filterConfigs.forEach(({ operator, operatorVal, singleField, multiField, condition, fieldName }) => {
+        if (overrideConditionsMap[singleField]) {
+            conditions.push(overrideConditionsMap[singleField]);
+            return;
+        }
+        const operatorValue = operator ? filters[operator] : operatorVal;
+        let singleValue = filters[singleField];
+        const multiValue = filters[multiField];
+        const conditionValue = condition && filters[condition];
+        if (condition && !conditionValue) {
+            return;
+        }
+        const resolvedFieldName = fieldName ?? (singleValue ? singleField : multiField);
+        if (operatorVal && !singleValue) {
+            singleValue = filters[multiField];
+        }
+        const result = buildCondition({
+            operatorValue,
+            singleValue: Array.isArray(singleValue) ? undefined : singleValue,
+            multiValue: Array.isArray(multiValue) ? multiValue : undefined,
+            fieldName: resolvedFieldName,
+        });
+        if (result)
+            conditions.push(result);
+    });
+    return conditions;
+};
+const buildVersionIdCondition = (versionIds) => {
+    const conditions = [];
+    if (!versionIds)
+        return conditions;
+    Object.entries(versionIds).forEach(([key, value]) => {
+        if (!value)
+            return;
+        conditions.push(`${key} = ${value}`);
+    });
+    return conditions;
+};
+const getFirstMetricInOrderBy = (orderBy, metrics) => {
+    if (!orderBy || metrics.length === 0)
+        return [];
+    const metric = metrics.find((metric) => orderBy[metric]);
+    return metric ? [metric] : [];
+};
+
+const build$a = ({ filters, overrideFilters, versionIds, extraConditions }) => {
+    const conditions = generateFilterConditions(filters, overrideFilters);
+    const versionIdConditions = buildVersionIdCondition(versionIds);
+    const builtExtraConditions = buildExtraConditions(extraConditions);
+    const allConditions = [...conditions, ...versionIdConditions, ...builtExtraConditions];
+    return allConditions.length > 0 ? `WHERE ${allConditions.join(' AND ')}` : '';
+};
+const parse$b = (query) => {
+    const match = query.match(new RegExp(`\\bWHERE\\s+([\\s\\S]+?)(?=\\s+(?:${CLAUSE_KEYWORD_BOUNDARY})\\b|$)`, 'i'));
+    if (!match)
+        return { filters: {} };
+    const conditions = (match[1] ?? '').trim().split(/\s+AND\s+/i);
+    const filters = {};
+    const versionIds = {};
+    conditions.forEach((condition) => {
+        const trimmed = condition.trim();
+        const inMatch = trimmed.match(/^(\S+)\s+IN\s+\((.+)\)$/i);
+        if (inMatch) {
+            const field = inMatch[1] ?? '';
+            const valuesStr = inMatch[2] ?? '';
+            const values = valuesStr.split(',').map((v) => v.trim());
+            const config = filterConfigs.find((c) => c.fieldName === field || c.multiField === field);
+            if (config?.operator) {
+                filters[config.multiField] = values;
+                filters[config.operator] = OPERATOR_IS_ONE_OF;
+            }
+            return;
+        }
+        const eqMatch = trimmed.match(/^(\S+)\s+=\s+(.+)$/);
+        if (eqMatch) {
+            const field = eqMatch[1] ?? '';
+            const value = eqMatch[2] ?? '';
+            const config = filterConfigs.find((c) => c.fieldName === field || c.singleField === field);
+            if (config) {
+                filters[config.singleField] = value;
+                if (config.operator)
+                    filters[config.operator] = OPERATOR_IS;
+            }
+            else if (field) {
+                versionIds[field] = value;
+            }
+        }
+    });
+    return {
+        filters: filters,
+        versionIds: Object.keys(versionIds).length > 0 ? versionIds : undefined,
+    };
+};
+
+const build$9 = (sources) => `FROM ${sources.join(', ')}`;
+const parse$a = (query) => {
+    const match = query.match(new RegExp(`\\bFROM\\s+([\\s\\S]+?)(?=\\s+(?:${CLAUSE_KEYWORD_BOUNDARY})\\b)`, 'i'));
+    if (!match)
+        return [];
+    return (match[1] ?? '')
+        .split(',')
+        .map((s) => s.trim())
+        .filter(Boolean);
+};
+
+const build$8 = (dimensions, withClause = EGroupWithClause.ALL) => dimensions.length === 0 ? '' : `GROUP BY ${dimensions.join(', ')} ${withClause}`;
+const parse$9 = (query) => {
+    const match = query.match(new RegExp(`\\bGROUP BY\\s+([\\s\\S]+?)(?=\\s+(?:${CLAUSE_KEYWORD_BOUNDARY})\\b)`, 'i'));
+    if (!match)
+        return { dimensions: [] };
+    const content = (match[1] ?? '').trim();
+    const withIdx = content.toUpperCase().indexOf(' WITH ');
+    if (withIdx === -1) {
+        return {
+            dimensions: content
+                .split(',')
+                .map((s) => s.trim())
+                .filter(Boolean),
+            groupWithClause: EGroupWithClause.NONE,
+        };
+    }
+    return {
+        dimensions: content
+            .slice(0, withIdx)
+            .split(',')
+            .map((s) => s.trim())
+            .filter(Boolean),
+        groupWithClause: content.slice(withIdx + 1).trim(),
+    };
+};
+
+const build$7 = (limit) => {
+    if (!limit)
+        return '';
+    return `LIMIT ${limit}`;
+};
+const parse$8 = (query) => {
+    const match = query.match(/\bLIMIT\s+(\d+)/i);
+    return match ? parseInt(match[1] ?? '0', 10) : undefined;
+};
+
+const build$6 = (mode) => `MODE ${mode}`;
+const parse$7 = (query) => {
+    const match = query.match(/\bMODE\s+(\S+)/i);
+    return match?.[1];
+};
+
+const build$5 = (offset) => {
+    if (!offset || offset < 0)
+        return '';
+    return `OFFSET ${offset}`;
+};
+const parse$6 = (query) => {
+    const match = query.match(/\bOFFSET\s+(\d+)/i);
+    return match ? parseInt(match[1] ?? '0', 10) : undefined;
+};
+
+const build$4 = (orderBy, columns) => {
+    if (!orderBy)
+        return '';
+    const orderByQuery = Object.values(orderBy)
+        .filter((item) => columns?.includes(item.field))
+        .map((item) => `${item.field} ${item.direction}`)
+        .join(', ');
+    return orderByQuery ? `ORDER BY ${orderByQuery}` : '';
+};
+const parse$5 = (query) => {
+    const match = query.match(new RegExp(`\\bORDER BY\\s+([\\s\\S]+?)(?=\\s+(?:${CLAUSE_KEYWORD_BOUNDARY})\\b|$)`, 'i'));
+    if (!match)
+        return undefined;
+    const orderBy = {};
+    (match[1] ?? '').split(',').forEach((item) => {
+        const parts = item.trim().split(/\s+/);
+        if (parts.length === 2) {
+            const field = parts[0] ?? '';
+            const direction = parts[1] ?? '';
+            if (field)
+                orderBy[field] = { field, direction: direction };
+        }
+    });
+    return Object.keys(orderBy).length > 0 ? orderBy : undefined;
+};
+
+const build$3 = (metrics) => `SHOW ${metrics.join(', ')}`;
+const parse$4 = (query) => {
+    const match = query.match(new RegExp(`\\bSHOW\\s+([\\s\\S]+?)(?=\\s+(?:${CLAUSE_KEYWORD_BOUNDARY})\\b)`, 'i'));
+    if (!match)
+        return [];
+    return (match[1] ?? '')
+        .split(',')
+        .map((s) => s.trim())
+        .filter(Boolean);
+};
+
+dayjs.extend(utc);
+dayjs.extend(timezone);
+dayjs.extend(quarterOfYear);
+let tz = 'UTC';
+const DEFAULT_DATE_FORMAT = 'YYYY-MM-DD HH:mm:ss';
+function getInitialTimezone() {
+    return tz;
+}
+function setTz(value) {
+    tz = value;
+    dayjs.tz.setDefault(value);
+}
+const dayjsTz = (date) => {
+    if (!date)
+        return dayjs().tz(tz);
+    return dayjs(date).tz(tz);
+};
+const convertDateToTz = (date) => {
+    if (!date)
+        return dayjs.tz(dayjs().format(DEFAULT_DATE_FORMAT), tz);
+    return dayjs.tz(dayjs(date).format(DEFAULT_DATE_FORMAT), tz);
+};
+
+const toDate = (value) => (typeof value === 'string' ? dayjsTz(value) : value);
+const isMidnight = (date) => date.hour() === 0 && date.minute() === 0;
+const formatDateForQuery = (date, isEndDay = false) => {
+    if (isEndDay && isMidnight(date)) {
+        return date.endOf('day').format(DATE_QUERY_FORMAT);
+    }
+    return date.format(DATE_QUERY_FORMAT);
+};
+const getEndOfDayForQuery = (value) => {
+    if (!value) {
+        return formatDateForQuery(dayjsTz().endOf('day'));
+    }
+    return formatDateForQuery(dayjsTz(value).endOf('day'));
+};
+const getDateRangeForQuery = (dateRange) => {
+    const startDate = toDate(dateRange.startDate);
+    const endDate = toDate(dateRange.endDate);
+    const isInTheDay = startDate.isSame(endDate);
+    if (isInTheDay) {
+        return {
+            dateGTE: formatDateForQuery(startDate),
+            dateLTE: getEndOfDayForQuery(endDate),
+        };
+    }
+    return {
+        dateGTE: formatDateForQuery(startDate),
+        dateLTE: formatDateForQuery(endDate, true),
+    };
+};
+
+const buildOverrideTimeQuery = (key, value) => `DURING (${value}, ${key})`;
+const build$2 = (data) => {
+    const { dateRange, compareDateRange, overrideFilters, timeDimension } = data;
+    const overrideTimeValue = timeDimension
+        ? overrideFilters?.[timeDimension]
+        : undefined;
+    if (timeDimension && overrideTimeValue) {
+        return buildOverrideTimeQuery(timeDimension, overrideTimeValue);
+    }
+    if (!dateRange)
+        return '';
+    const { dateGTE, dateLTE } = getDateRangeForQuery(dateRange);
+    const { dateGTE: compareDateGTE, dateLTE: compareDateLTE } = compareDateRange
+        ? getDateRangeForQuery(compareDateRange)
+        : {};
+    const compareToClause = compareDateRange ? `COMPARE TO ${compareDateGTE} UNTIL ${compareDateLTE}` : '';
+    return `SINCE ${dateGTE} UNTIL ${dateLTE} ${compareToClause}`;
+};
+const parse$3 = (query) => {
+    const duringMatch = query.match(/\bDURING\s+\(([^,]+),\s*([^)]+)\)/i);
+    if (duringMatch) {
+        const value = duringMatch[1] ?? '';
+        const key = duringMatch[2] ?? '';
+        return {
+            timeDimension: key.trim(),
+            overrideFilters: { [key.trim()]: value.trim() },
+        };
+    }
+    const sinceMatch = query.match(/\bSINCE\s+(\S+)\s+UNTIL\s+(\S+)/i);
+    if (!sinceMatch)
+        return {};
+    const dateRange = { startDate: dayjsTz(sinceMatch[1] ?? ''), endDate: dayjsTz(sinceMatch[2] ?? '') };
+    const compareMatch = query.match(/\bCOMPARE TO\s+(\S+)\s+UNTIL\s+(\S+)/i);
+    const compareDateRange = compareMatch
+        ? { startDate: dayjsTz(compareMatch[1] ?? ''), endDate: dayjsTz(compareMatch[2] ?? '') }
+        : undefined;
+    return { dateRange, compareDateRange };
+};
+
+const build$1 = (time) => {
+    if (!time)
+        return '';
+    return `TIMESERIES ${time}`;
+};
+const parse$2 = (query) => {
+    const match = query.match(/\bTIMESERIES\s+(\S+)/i);
+    return match?.[1];
+};
+
+const build = (timezone) => {
+    const tz = timezone ?? getInitialTimezone();
+    return tz ? `TIMEZONE ${tz}` : '';
+};
+const parse$1 = (query) => {
+    const match = query.match(/\bTIMEZONE\s+(\S+)/i);
+    return match?.[1];
+};
+
+function isValidQueryInput(query) {
+    if (typeof query !== 'string')
+        return false;
+    const q = query.trim();
+    const pattern = /^MODE\b[\s\S]*\bFROM\b[\s\S]*\bSHOW\b[\s\S]*$/;
+    return pattern.test(q);
+}
+
+const buildGemXQlQuery = (params) => {
+    const { mode, metrics, dimensions, dateRange, compareDateRange, filters, overrideFilters, versionIds, extraConditions, orderBy, sources, timeDimension, groupWithClause, timezone, limit = DEFAULT_QUERY_LIMIT, offset, extraOrderByFields, } = params;
+    const columns = [...dimensions, ...getFirstMetricInOrderBy(orderBy, metrics), ...(extraOrderByFields ?? [])];
+    const builtQuery = [
+        build$6(mode),
+        build$9(sources),
+        build$3(metrics),
+        build$8(dimensions, groupWithClause),
+        build$1(timeDimension),
+        build$2({ dateRange, compareDateRange, timeDimension, overrideFilters }),
+        build(timezone),
+        build$a({ filters, overrideFilters, versionIds, extraConditions }),
+        build$4(orderBy, columns),
+        build$7(limit),
+        build$5(offset),
+    ]
+        .filter(Boolean)
+        .join(' ');
+    return isValidQueryInput(builtQuery) ? builtQuery : '';
+};
+
+const parse = (query) => {
+    const { dateRange, compareDateRange, timeDimension: overrideTimeDimension, overrideFilters } = parse$3(query);
+    const timeDimension = overrideTimeDimension ?? parse$2(query);
+    const { dimensions, groupWithClause } = parse$9(query);
+    const { filters, versionIds } = parse$b(query);
+    return {
+        mode: parse$7(query),
+        sources: parse$a(query),
+        metrics: parse$4(query),
+        dimensions,
+        groupWithClause,
+        timeDimension,
+        dateRange: dateRange,
+        compareDateRange: compareDateRange,
+        overrideFilters,
+        filters,
+        versionIds,
+        timezone: parse$1(query),
+        orderBy: parse$5(query),
+        limit: parse$8(query),
+        offset: parse$6(query),
+    };
+};
+
+const getTotalsKey = (metric) => `${metric}${TOTALS_SUFFIX}`;
+const getComparisonKey = (metric) => `${COMPARE_PREFIX}${metric}${COMPARE_SUFFIX}`;
+const getComparisonTotalsKey = (metric) => `${COMPARE_PREFIX}${metric}${COMPARE_SUFFIX}${TOTALS_SUFFIX}`;
+
+const extractQueryRows = (response) => response?.gemxQLQuery?.tableData?.rows ?? [];
+const extractQueryColumns = (response) => response?.gemxQLQuery?.tableData?.columns ?? [];
+const extractColumnTypes = (response) => {
+    const columns = extractQueryColumns(response);
+    const columnTypes = {};
+    for (const column of columns) {
+        if (column?.name)
+            columnTypes[column.name] = column.dataType;
+    }
+    return columnTypes;
+};
+
+const TRIM_DECIMAL_ZEROS_REGEX = /\.0+$/;
+const DEFAULT_DECIMALS = 2;
+const trimDecimalZeros = (number) => {
+    return `${number}`.replace(TRIM_DECIMAL_ZEROS_REGEX, '');
+};
+const cleanDecimal = (number, decimals = DEFAULT_DECIMALS) => {
+    return trimDecimalZeros(number.toFixed(decimals));
+};
+
+/**
+ * Utility function to calculate percentage and format it.
+ * @param part - The part value.
+ * @param total - The total value.
+ * @param decimals - The number of decimal places to format the percentage to.
+ * @returns The formatted percentage as a string.
+ */
+const PERCENTAGE_THRESHOLD = 0.005;
+const PERCENTAGE_THRESHOLD_STRING = '~0%';
+const calcPercentage = (part, total, decimals = DEFAULT_DECIMALS) => {
+    if (typeof part !== 'number' || !total)
+        return undefined;
+    if (part === 0)
+        return 0;
+    const percentage = (part / total) * 100;
+    return parseFloat(cleanDecimal(percentage, decimals));
+};
+const isLessThanThreshold = (percentage) => percentage > 0 && percentage < PERCENTAGE_THRESHOLD;
+const calcPercentageString = (part, total, decimals = 2) => {
+    const percentage = calcPercentage(part, total, decimals);
+    if (typeof percentage !== 'number')
+        return undefined;
+    if (isLessThanThreshold(percentage)) {
+        return PERCENTAGE_THRESHOLD_STRING;
+    }
+    return `${percentage}%`;
+};
+
+var AnalyticInterval;
+(function (AnalyticInterval) {
+    AnalyticInterval["DAY"] = "DAY";
+    AnalyticInterval["HOUR"] = "HOUR";
+    AnalyticInterval["MONTH"] = "MONTH";
+    AnalyticInterval["QUARTER"] = "QUARTER";
+    AnalyticInterval["WEEK"] = "WEEK";
+    AnalyticInterval["YEAR"] = "YEAR";
+})(AnalyticInterval || (AnalyticInterval = {}));
+function numberWithCommas(x) {
+    return x.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ',');
+}
+const SECONDS_IN_MINUTE = 60;
+const SECONDS_IN_HOUR = SECONDS_IN_MINUTE * SECONDS_IN_MINUTE;
+const getTimeDurationLabel = (valueInSeconds) => {
+    let data = valueInSeconds;
+    if (!Number.isFinite(valueInSeconds) || valueInSeconds == null) {
+        data = 0;
+    }
+    const fixedValue = cleanDecimal(data);
+    if (data >= SECONDS_IN_HOUR) {
+        const hours = Math.floor(data / SECONDS_IN_HOUR);
+        const minutes = Math.floor((data % SECONDS_IN_HOUR) / SECONDS_IN_MINUTE);
+        const seconds = Math.floor(data % SECONDS_IN_MINUTE);
+        return `${hours}h ${minutes}m ${seconds}s`;
+    }
+    else if (data >= SECONDS_IN_MINUTE) {
+        const minutes = Math.floor(data / SECONDS_IN_MINUTE);
+        const seconds = Math.floor(data % SECONDS_IN_MINUTE);
+        return `${minutes}m ${seconds}s`;
+    }
+    else {
+        return `${fixedValue}s`;
+    }
+};
+const getFormattedByInterval = (value, interval, options) => {
+    if (!value)
+        return '';
+    const optionFormat = options?.isExpandDetail
+        ? {
+            formatHouse: 'MMM D, h:mm A',
+            formatDay: 'MMM D, YYYY',
+            formatMonth: 'MMM YYYY',
+            formatYear: 'MMM YYYY',
+        }
+        : {
+            formatHouse: 'h A',
+            formatDay: 'MMM D',
+            formatMonth: 'MMM YYYY',
+            formatYear: 'YYYY',
+        };
+    switch (interval) {
+        case AnalyticInterval.HOUR:
+            return dayjsTz(value).format(optionFormat.formatHouse);
+        case AnalyticInterval.DAY:
+        case AnalyticInterval.WEEK:
+            return dayjsTz(value).format(optionFormat.formatDay);
+        case AnalyticInterval.MONTH:
+            return dayjsTz(value).format(optionFormat.formatMonth);
+        case AnalyticInterval.QUARTER: {
+            const d = dayjsTz(value);
+            return `Q${d.quarter()} ${d.format('YYYY')}`;
+        }
+        case AnalyticInterval.YEAR:
+            return dayjsTz(value).format(optionFormat.formatYear);
+    }
+    return dayjsTz(value).format(optionFormat.formatMonth);
+};
+
+const formatAnalyticDate = (dateString) => {
+    if (!dateString)
+        return 'None';
+    const date = dayjsTz(dateString);
+    const now = dayjsTz();
+    const yesterday = dayjsTz().subtract(1, 'day');
+    const isToday = date.format('YYYY-MM-DD') === now.format('YYYY-MM-DD');
+    const isYesterday = date.format('YYYY-MM-DD') === yesterday.format('YYYY-MM-DD');
+    if (isToday) {
+        return `Today at ${date.format('HH:mm')}`;
+    }
+    if (isYesterday) {
+        return `Yesterday at ${date.format('HH:mm')}`;
+    }
+    const daysDiff = now.diff(date, 'day');
+    const isWithinWeek = daysDiff >= 0 && daysDiff < 7;
+    if (isWithinWeek) {
+        return `${date.format('dddd')} at ${date.format('HH:mm')}`;
+    }
+    return `${date.format('MMM D')} at ${date.format('hh:mm a')}`;
+};
+
+const formatAnalyticData = ({ value, formatter, getTextPrice, name, }) => {
+    const dataTypeIsObjectOrArray = value !== null && (typeof value === 'object' || Array.isArray(value));
+    if (dataTypeIsObjectOrArray)
+        return value;
+    switch (formatter) {
+        case EAnalyticDataType.INTEGER: {
+            return numberWithCommas((value ?? 0).toString());
+        }
+        case EAnalyticDataType.CURRENCY: {
+            if (!getTextPrice)
+                return `${value ?? 0}`;
+            return getTextPrice(value, false);
+        }
+        case EAnalyticDataType.DATE: {
+            return formatAnalyticDate(value);
+        }
+        case EAnalyticDataType.PERCENT: {
+            if (typeof value !== 'number')
+                return calcPercentageString(0, 1, 2) ?? '';
+            return calcPercentageString(value / 100, 1, 2) ?? '';
+        }
+        case EAnalyticDataType.DURATION: {
+            return getTimeDurationLabel(Number(value));
+        }
+        case EAnalyticDataType.STRING: {
+            const fallbackValue = name === EAnalyticColumnKey.CAMPAIGNS ? '' : NONE_VALUE;
+            return value ?? fallbackValue;
+        }
+        case EAnalyticDataType.DAY: {
+            return getFormattedByInterval(value, AnalyticInterval.DAY, { isExpandDetail: true });
+        }
+        case EAnalyticDataType.HOUR: {
+            return getFormattedByInterval(value, AnalyticInterval.HOUR, { isExpandDetail: true });
+        }
+        case EAnalyticDataType.MONTH: {
+            return getFormattedByInterval(value, AnalyticInterval.MONTH, { isExpandDetail: true });
+        }
+        case EAnalyticDataType.YEAR: {
+            return getFormattedByInterval(value, AnalyticInterval.YEAR);
+        }
+        case EAnalyticDataType.WEEK: {
+            return getFormattedByInterval(value, AnalyticInterval.WEEK, { isExpandDetail: true });
+        }
+        case EAnalyticDataType.QUARTER: {
+            return getFormattedByInterval(value, AnalyticInterval.QUARTER, {
+                isExpandDetail: true,
+            });
+        }
+        case EAnalyticDataType.OBJECT:
+        case EAnalyticDataType.ARRAY: {
+            return value;
+        }
+        default:
+            return `${value}`;
+    }
+};
+
+const getTimeDimensionByDate = (startDate, endDate) => {
+    const durationInDays = endDate.diff(startDate, 'day');
+    if (durationInDays <= 3)
+        return ETimeDimension.HOUR;
+    if (durationInDays <= 93)
+        return ETimeDimension.DAY;
+    return ETimeDimension.MONTH;
+};
+
+const SESSION_KEY = 'sessions';
+const hasMetricData = (metric) => {
+    const sessions = metric?.[SESSION_KEY];
+    return typeof sessions === 'number' && sessions > 0;
+};
+
+const parseRawJson = (raw) => {
+    if (!raw)
+        return undefined;
+    return typeof raw === 'string' ? JSON.parse(raw) : raw;
+};
+const parseJsonObject = (value) => {
+    try {
+        const parsed = parseRawJson(value);
+        if (!parsed || typeof parsed !== 'object')
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+};
+const parseJsonArray = (raw) => {
+    try {
+        const parsed = parseRawJson(raw);
+        if (!Array.isArray(parsed))
+            return undefined;
+        return parsed;
+    }
+    catch {
+        return undefined;
+    }
+};
+const parseBreakdownItems = (raw) => parseJsonArray(raw)?.map((item) => ({ ...item, total: Number(item.total) }));
+const parsePageItems = (value) => parseJsonObject(value);
+
+const readNumeric = (metric, key) => {
+    const raw = metric?.[key];
+    return typeof raw === 'number' ? raw : 0;
+};
+const createNumericRowReader = (row, mode = ERowReaderMode.DEFAULT) => (key) => {
+    const { prefix, suffix } = ROW_READER_MODE_CONFIG[mode];
+    const v = row[`${prefix}${key}${suffix}`];
+    if (typeof v === 'number')
+        return v;
+    if (typeof v === 'string') {
+        const n = parseFloat(v);
+        return isNaN(n) ? 0 : n;
+    }
+    return 0;
+};
+
+const useAnalyticData = (getTextPrice) => {
+    const formatData = ({ value, formatter, name }) => {
+        return formatAnalyticData({ value, formatter, getTextPrice, name });
+    };
+    const computeMetric = ({ metric, previousMetric, metricKey, formatter, }) => {
+        if (!hasMetricData(metric))
+            return { value: 0, change: PLACEHOLDER_VALUE };
+        const currentValue = readNumeric(metric, metricKey);
+        const previousValue = readNumeric(previousMetric, metricKey);
+        const value = formatData({ value: currentValue, formatter, name: metricKey });
+        if (currentValue === 0 && previousValue !== 0)
+            return { value, change: -100 };
+        if (previousValue === 0)
+            return { value, change: PLACEHOLDER_VALUE };
+        const change = ((currentValue - previousValue) / previousValue) * 100;
+        return { value, change };
+    };
+    return { formatData, computeMetric };
+};
+
+var GPaginationDirection;
+(function (GPaginationDirection) {
+    GPaginationDirection["NEXT"] = "NEXT";
+    GPaginationDirection["PREV"] = "PREV";
+})(GPaginationDirection || (GPaginationDirection = {}));
+const useGemXQlPagination = ({ resetKey, itemsPerPage, }) => {
+    const [currentPage, setCurrentPage] = useState(1);
+    const previousResetKeyRef = useRef();
+    const shouldResetPagination = currentPage > 1 && previousResetKeyRef.current !== undefined && previousResetKeyRef.current !== resetKey;
+    const effectivePage = shouldResetPagination ? 1 : currentPage;
+    const offset = (effectivePage - 1) * itemsPerPage;
+    const handlePageChange = useCallback((totalPages) => (direction) => {
+        setCurrentPage((prevPage) => {
+            const isNextPage = direction === GPaginationDirection.NEXT;
+            const nextPage = isNextPage ? prevPage + 1 : prevPage - 1;
+            return Math.min(Math.max(nextPage, 1), totalPages);
+        });
+    }, []);
+    useEffect(() => {
+        if (previousResetKeyRef.current !== resetKey) {
+            previousResetKeyRef.current = resetKey;
+            setCurrentPage(1);
+        }
+    }, [resetKey]);
+    const buildPagination = useCallback(({ totalRecords, isLoading }) => {
+        const totalPages = Math.max(1, Math.ceil(totalRecords / itemsPerPage));
+        return {
+            currentPage: effectivePage,
+            totalPages,
+            loading: isLoading,
+            handlePageChange: handlePageChange(totalPages),
+        };
+    }, [effectivePage, itemsPerPage, handlePageChange]);
+    return { currentPage: effectivePage, offset, buildPagination };
+};
+
+export { AnalyticInterval, CLAUSE_KEYWORDS, CLAUSE_KEYWORD_BOUNDARY, COMPARE_PREFIX, COMPARE_SUFFIX, COMPARE_TOTALS_SUFFIX, ColumnSelectFragmentDoc, DATE_QUERY_FORMAT, DEFAULT_QUERY_LIMIT, EAnalyticColumnKey, EAnalyticDataType, EAnalyticMode, EAnalyticSource, EComparisonOperator, EDeviceType, EFilterField, EGroupOperator, EGroupWithClause, EOperatorField, EOrderDirectionType, EPageDimension, EPageField, EPageMetric, ERowReaderMode, ETimeDimension, ETrafficSourceType, EVisitorType, GPaginationDirection, GemXqlResultSelectFragmentDoc, GemxQlDocument, NONE_VALUE, OPERATOR_IS, OPERATOR_IS_ONE_OF, PLACEHOLDER_VALUE, ROW_READER_MODE_CONFIG, TOTALS_SUFFIX, TableDataSelectFragmentDoc, build$a as buildConditionQuery, buildExtraCondition, buildExtraConditions, build$9 as buildFromQuery, buildGemXQlQuery, build$8 as buildGroupQuery, build$7 as buildLimitQuery, build$6 as buildModeQuery, build$5 as buildOffsetQuery, build$4 as buildOrderByQuery, build$3 as buildShowQuery, build$2 as buildTimeQuery, build$1 as buildTimeSeriesQuery, build as buildTimezoneQuery, buildVersionIdCondition, convertDateToTz, createNumericRowReader, dayjsTz, extractColumnTypes, extractQueryColumns, extractQueryRows, filterConfigs, formatAnalyticData, formatAnalyticDate, generateFilterConditions, getComparisonKey, getComparisonTotalsKey, getFirstMetricInOrderBy, getFormattedByInterval, getInitialTimezone, getTimeDimensionByDate, getTimeDurationLabel, getTotalsKey, hasMetricData, isValidQueryInput, numberWithCommas, parseBreakdownItems, parse$b as parseConditionQuery, parse$a as parseFromQuery, parse as parseGemXQlQuery, parse$9 as parseGroupQuery, parseJsonArray, parseJsonObject, parse$8 as parseLimitQuery, parse$7 as parseModeQuery, parse$6 as parseOffsetQuery, parse$5 as parseOrderByQuery, parsePageItems, parse$4 as parseShowQuery, parse$3 as parseTimeQuery, parse$2 as parseTimeSeriesQuery, parse$1 as parseTimezoneQuery, readNumeric, setTz, useAnalyticData, useCustomGemXQlQuery, useGemXQlPagination, useGemxQlNamedQuery };