gamealgo-cli 0.3.8 → 0.4.1

package/dist/report-v2/expression.js

@@ -0,0 +1,130 @@
+export function parseReportFormula(source) {
+    const tokens = tokenize(String(source ?? ""));
+    let cursor = 0;
+    const peek = (value) => tokens[cursor]?.value === value;
+    const take = (value) => {
+        if (!peek(value))
+            throw new Error(`expected ${value || "expression"}`);
+        return tokens[cursor++];
+    };
+    const parsePrimary = () => {
+        const token = tokens[cursor];
+        if (!token)
+            throw new Error("unexpected end of formula");
+        if (token.type === "number") {
+            cursor += 1;
+            return { type: "number", value: Number(token.value) };
+        }
+        if (token.type === "identifier") {
+            cursor += 1;
+            return { type: "identifier", name: token.value };
+        }
+        if (token.value === "(") {
+            cursor += 1;
+            const expression = parseAdditive();
+            take(")");
+            return expression;
+        }
+        throw new Error(`unexpected token ${token.value}`);
+    };
+    const parseUnary = () => {
+        if (peek("+") || peek("-")) {
+            const operator = tokens[cursor++].value;
+            return { type: "unary", operator, argument: parseUnary() };
+        }
+        return parsePrimary();
+    };
+    const parseMultiplicative = () => {
+        let expression = parseUnary();
+        while (peek("*") || peek("/")) {
+            const operator = tokens[cursor++].value;
+            expression = { type: "binary", operator, left: expression, right: parseUnary() };
+        }
+        return expression;
+    };
+    const parseAdditive = () => {
+        let expression = parseMultiplicative();
+        while (peek("+") || peek("-")) {
+            const operator = tokens[cursor++].value;
+            expression = { type: "binary", operator, left: expression, right: parseMultiplicative() };
+        }
+        return expression;
+    };
+    if (!tokens.length)
+        throw new Error("formula must not be empty");
+    const expression = parseAdditive();
+    if (cursor !== tokens.length)
+        throw new Error(`unexpected token ${tokens[cursor].value}`);
+    return expression;
+}
+export function reportFormulaReferences(source) {
+    const references = new Set();
+    visit(parseReportFormula(source), (node) => {
+        if (node.type === "identifier")
+            references.add(node.name);
+    });
+    return [...references].sort();
+}
+export function evaluateReportFormula(expression, values) {
+    if (expression.type === "number")
+        return expression.value;
+    if (expression.type === "identifier")
+        return finiteNumber(values[expression.name]);
+    if (expression.type === "unary") {
+        const value = evaluateReportFormula(expression.argument, values);
+        if (value === null)
+            return null;
+        return expression.operator === "-" ? -value : value;
+    }
+    const left = evaluateReportFormula(expression.left, values);
+    const right = evaluateReportFormula(expression.right, values);
+    if (left === null || right === null)
+        return null;
+    const result = expression.operator === "+" ? left + right
+        : expression.operator === "-" ? left - right
+            : expression.operator === "*" ? left * right
+                : right === 0 ? null : left / right;
+    return typeof result === "number" && Number.isFinite(result) ? result : null;
+}
+function tokenize(source) {
+    const tokens = [];
+    let cursor = 0;
+    while (cursor < source.length) {
+        const char = source[cursor];
+        if (/\s/.test(char)) {
+            cursor += 1;
+            continue;
+        }
+        if ("+-*/()".includes(char)) {
+            tokens.push({ type: "operator", value: char });
+            cursor += 1;
+            continue;
+        }
+        const number = source.slice(cursor).match(/^(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?/);
+        if (number) {
+            tokens.push({ type: "number", value: number[0] });
+            cursor += number[0].length;
+            continue;
+        }
+        const identifier = source.slice(cursor).match(/^[A-Za-z_][A-Za-z0-9_]*/);
+        if (identifier) {
+            tokens.push({ type: "identifier", value: identifier[0] });
+            cursor += identifier[0].length;
+            continue;
+        }
+        throw new Error(`unsupported formula token at position ${cursor}`);
+    }
+    return tokens;
+}
+function visit(node, callback) {
+    callback(node);
+    if (node.type === "unary")
+        visit(node.argument, callback);
+    if (node.type === "binary") {
+        visit(node.left, callback);
+        visit(node.right, callback);
+    }
+}
+function finiteNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}

package/dist/report-v2/result.js

@@ -0,0 +1,209 @@
+import { executeReportPackV2View } from "./view-executor.js";
+export async function queryReportPackV2Result(client, manifestResponse, options) {
+    const root = requiredObject(manifestResponse, "manifest response");
+    const manifest = requiredObject(root.manifest, "manifest");
+    if (manifest.schemaVersion !== 2)
+        throw new Error("Report Pack v2 manifest is required");
+    const selected = selectResultItems(manifest, options);
+    if (options.refresh && selected.standardCharts.length === 0) {
+        throw new Error("--refresh is only supported for standard Groups; custom v2 Views read materialized Dataset snapshots");
+    }
+    const fingerprints = new Set(selected.views.map(({ view }) => viewDatasetFingerprint(view)));
+    const datasets = new Map();
+    const standardPromise = selected.standardCharts.length
+        ? client.queryReportDashboard({
+            startDate: options.startDate,
+            endDate: options.endDate,
+            platform: options.platform,
+            selectors: options.selectors,
+            refresh: Boolean(options.refresh),
+            responseMode: "full",
+            ...queryScope(options),
+        }, { timeoutMs: options.timeoutMs })
+        : Promise.resolve(null);
+    const [, standardPayload] = await Promise.all([
+        Promise.all([...fingerprints].map(async (datasetFingerprint) => {
+            const payload = requiredObject(await client.readReportDataset({
+                datasetFingerprint,
+                platform: options.platform,
+                startDate: options.startDate,
+                endDate: options.endDate,
+            }), `Dataset ${datasetFingerprint}`);
+            datasets.set(datasetFingerprint, payload);
+        })),
+        standardPromise,
+    ]);
+    const viewResults = selected.views.map(({ tab, group, view }) => {
+        const fingerprint = viewDatasetFingerprint(view);
+        const dataset = datasets.get(fingerprint);
+        const status = String(dataset.status || "waiting");
+        if (status === "abnormal") {
+            return reportResult(tab, group, view, fingerprint, [], [], {
+                error: String(dataset.abnormalMessage || dataset.abnormalCode || "Dataset materialization is abnormal"),
+            });
+        }
+        const data = requiredObject(view.data, "view.data");
+        const rows = status === "waiting"
+            ? []
+            : executeReportPackV2View(view, recordRows(dataset.rows), {
+                selectorFilters: selectorFilters(group, data, options.selectors, recordRows(dataset.rows)),
+            });
+        const columns = [
+            ...stringArray(data.groupBy, "view.data.groupBy"),
+            ...Object.keys(requiredObject(data.metrics, "view.data.metrics")),
+        ];
+        return reportResult(tab, group, view, fingerprint, columns, rows, {
+            cached: true,
+            cachedAt: dataset.updatedAt,
+            pending: status === "waiting" || undefined,
+            partial: status === "partial" || undefined,
+            missingDates: dataset.missingDates,
+            snapshotVersion: dataset.snapshotVersion,
+        });
+    });
+    const standardResults = standardPayload
+        ? arrayValues(requiredObject(standardPayload, "standard report result").results)
+        : [];
+    return {
+        reportPack: root.reportPack,
+        dateRange: { startDate: options.startDate, endDate: options.endDate, platform: options.platform },
+        selectors: options.selectors,
+        results: [...standardResults, ...viewResults],
+    };
+}
+function selectResultItems(manifest, options) {
+    const views = [];
+    const standardCharts = [];
+    const groups = [];
+    arrayValues(manifest.tabs).forEach((rawTab) => {
+        const tab = requiredObject(rawTab, "manifest tab");
+        arrayValues(tab.groups).forEach((rawGroup) => {
+            const group = requiredObject(rawGroup, "manifest group");
+            groups.push({ tab, group });
+            arrayValues(group.views).forEach((rawView) => {
+                views.push({ tab, group, view: requiredObject(rawView, "manifest view") });
+            });
+            arrayValues(group.charts).forEach((rawChart) => {
+                standardCharts.push({ tab, group, chart: requiredObject(rawChart, "manifest chart") });
+            });
+        });
+    });
+    const chart = options.chartId || options.chart;
+    if (chart) {
+        const matchingViews = views.filter(({ group, view }) => matchesValue(chart, [
+            view.id,
+            view.title,
+            `${group.id}/${view.id}`,
+            `${group.id}__${view.id}`,
+        ]));
+        const matchingCharts = standardCharts.filter(({ group, chart: standardChart }) => matchesValue(chart, [
+            standardChart.id,
+            standardChart.title,
+            `${group.id}/${standardChart.id}`,
+            `${group.id}__${standardChart.id}`,
+        ]));
+        if (matchingViews.length + matchingCharts.length === 0)
+            throw new Error(`chart not found: ${chart}`);
+        if (matchingViews.length + matchingCharts.length > 1) {
+            const ids = [
+                ...matchingViews.map(({ group, view }) => `${String(group.id)}/${String(view.id)}`),
+                ...matchingCharts.map(({ group, chart: item }) => `${String(group.id)}/${String(item.id)}`),
+            ];
+            throw new Error(`ambiguous_chart_id: ${chart}; candidates: ${ids.join(", ")}`);
+        }
+        return { views: matchingViews, standardCharts: matchingCharts };
+    }
+    const group = options.groupId || options.group;
+    if (group) {
+        const matchingGroups = groups.filter((entry) => matches(group, [entry.group.id, entry.group.title]));
+        if (!matchingGroups.length)
+            throw new Error(`group not found: ${group}`);
+        const selectedGroups = new Set(matchingGroups.map((entry) => entry.group));
+        return {
+            views: views.filter((entry) => selectedGroups.has(entry.group)),
+            standardCharts: standardCharts.filter((entry) => selectedGroups.has(entry.group)),
+        };
+    }
+    const tab = options.tabId || options.tab;
+    if (tab) {
+        const matchingTabs = new Set(groups
+            .filter((entry) => matches(tab, [entry.tab.id, entry.tab.title]))
+            .map((entry) => entry.tab));
+        if (!matchingTabs.size)
+            throw new Error(`tab not found: ${tab}`);
+        return {
+            views: views.filter((entry) => matchingTabs.has(entry.tab)),
+            standardCharts: standardCharts.filter((entry) => matchingTabs.has(entry.tab)),
+        };
+    }
+    throw new Error("report result requires one of --tab, --tab-id, --group, --group-id, --chart, or --chart-id");
+}
+function queryScope(options) {
+    return Object.fromEntries(Object.entries({
+        tab: options.tab,
+        tabId: options.tabId,
+        group: options.group,
+        groupId: options.groupId,
+        chart: options.chart,
+        chartId: options.chartId,
+    }).filter((entry) => typeof entry[1] === "string"));
+}
+function matches(query, candidates) {
+    return matchesValue(query, candidates);
+}
+function matchesValue(query, candidates) {
+    return candidates.some((candidate) => typeof candidate === "string" && candidate.toLocaleLowerCase() === query.toLocaleLowerCase());
+}
+function selectorFilters(group, data, values, rows) {
+    const bindings = objectValue(data.selectorBindings) ?? {};
+    const selectors = arrayValues(group.selectors).map((value) => requiredObject(value, "selector"));
+    return Object.entries(bindings).flatMap(([selectorId, rawField]) => {
+        const selector = selectors.find((item) => item.id === selectorId);
+        const value = values[selectorId] ?? (typeof selector?.defaultValue === "string" ? selector.defaultValue : "all");
+        if (!value || value === "all")
+            return [];
+        const field = String(rawField);
+        const sample = rows.find((row) => row[field] !== undefined)?.[field];
+        const typed = typeof sample === "number" && Number.isFinite(Number(value))
+            ? Number(value)
+            : typeof sample === "boolean" ? value === "true" : value;
+        return [{ field, op: "eq", value: typed }];
+    });
+}
+function reportResult(tab, group, view, fingerprint, columns, rows, extra) {
+    return {
+        tab: { id: tab.id, title: tab.title },
+        group: { id: group.id, title: group.title },
+        chart: view,
+        reportId: `dataset:${fingerprint}`,
+        columns,
+        rows,
+        ...extra,
+    };
+}
+function viewDatasetFingerprint(view) {
+    const fingerprint = requiredObject(view.data, "view.data").datasetFingerprint;
+    if (typeof fingerprint !== "string" || !fingerprint)
+        throw new Error("v2 View is missing datasetFingerprint");
+    return fingerprint;
+}
+function recordRows(value) {
+    return arrayValues(value).map((row) => requiredObject(row, "Dataset row"));
+}
+function requiredObject(value, path) {
+    const object = objectValue(value);
+    if (!object)
+        throw new Error(`${path} must be an object`);
+    return object;
+}
+function objectValue(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function arrayValues(value) {
+    return Array.isArray(value) ? value : [];
+}
+function stringArray(value, path) {
+    if (!Array.isArray(value) || value.some((item) => typeof item !== "string"))
+        throw new Error(`${path} must be an array of strings`);
+    return value;
+}

package/dist/report-v2/schema.js

@@ -0,0 +1,18 @@
+export function reportPackSchemaVersion(value) {
+    const pack = objectValue(value);
+    if (!pack)
+        throw new Error("Report Pack must be a JSON object");
+    if (pack.schemaVersion === undefined)
+        return 1;
+    if (pack.schemaVersion === 2)
+        return 2;
+    throw new Error(`unsupported Report Pack schemaVersion: ${String(pack.schemaVersion)}`);
+}
+export function assertWritableReportPackV2(value, command) {
+    if (reportPackSchemaVersion(value) !== 2) {
+        throw new Error(`${command} only accepts Report Pack schemaVersion 2; pull the current Pack and migrate it before writing`);
+    }
+}
+function objectValue(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}

package/dist/report-v2/summary.js

@@ -0,0 +1,110 @@
+import { REPORT_SUMMARY_MAX_ITEMS, REPORT_SUMMARY_SCHEMA_VERSION } from "../report-summary.js";
+export function summarizeReportPackV2Manifest(value) {
+    const root = objectValue(value);
+    const manifest = objectValue(root?.manifest);
+    if (!manifest || manifest.schemaVersion !== 2) {
+        return {
+            schemaVersion: REPORT_SUMMARY_SCHEMA_VERSION,
+            command: "report.manifest",
+            ok: false,
+            summary: {},
+            errors: [{ scope: "manifest", message: "Report Pack v2 manifest is missing" }],
+            warnings: [],
+            items: [],
+            truncated: false,
+        };
+    }
+    const tabs = arrayValues(manifest.tabs);
+    const advancedQueries = arrayValues(manifest.advancedQueries);
+    const allItems = [];
+    let groupCount = 0;
+    let viewCount = 0;
+    let standardChartCount = 0;
+    for (const [scope, containers] of [["dashboard", tabs], ["advanced", advancedQueries]]) {
+        for (const rawContainer of containers) {
+            const container = objectValue(rawContainer);
+            for (const rawGroup of arrayValues(container?.groups)) {
+                const group = objectValue(rawGroup);
+                groupCount += 1;
+                for (const rawView of arrayValues(group?.views)) {
+                    const view = objectValue(rawView);
+                    const data = objectValue(view?.data);
+                    viewCount += 1;
+                    allItems.push(compact({
+                        kind: "view",
+                        scope,
+                        containerId: text(container?.id),
+                        containerTitle: text(container?.title),
+                        groupId: text(group?.id),
+                        groupTitle: text(group?.title),
+                        viewId: text(view?.id),
+                        viewTitle: text(view?.title),
+                        viewType: text(view?.type),
+                        datasetId: text(data?.dataset),
+                        datasetFingerprint: text(data?.datasetFingerprint),
+                        selectorIds: arrayValues(group?.selectors).flatMap((rawSelector) => {
+                            const id = text(objectValue(rawSelector)?.id);
+                            return id ? [id] : [];
+                        }),
+                    }));
+                }
+                if (scope === "dashboard") {
+                    for (const rawChart of arrayValues(group?.charts)) {
+                        const chart = objectValue(rawChart);
+                        standardChartCount += 1;
+                        allItems.push(compact({
+                            kind: "standard_chart",
+                            scope,
+                            containerId: text(container?.id),
+                            containerTitle: text(container?.title),
+                            groupId: text(group?.id),
+                            groupTitle: text(group?.title),
+                            standardRef: text(group?.standardRef),
+                            chartId: text(chart?.id),
+                            chartTitle: text(chart?.title),
+                            chartType: text(chart?.type),
+                            reportId: text(chart?.report),
+                        }));
+                    }
+                }
+            }
+        }
+    }
+    const datasets = objectValue(manifest.datasets) ?? {};
+    const items = allItems.slice(0, REPORT_SUMMARY_MAX_ITEMS);
+    return {
+        schemaVersion: REPORT_SUMMARY_SCHEMA_VERSION,
+        command: "report.manifest",
+        ok: true,
+        summary: compact({
+            reportPack: root?.reportPack,
+            reportPackSchemaVersion: 2,
+            title: text(manifest.title),
+            packFingerprint: text(manifest.packFingerprint),
+            tabCount: tabs.length,
+            advancedQueryCount: advancedQueries.length,
+            groupCount,
+            viewCount,
+            standardChartCount,
+            datasetCount: Object.keys(datasets).length,
+            datasetIds: Object.keys(datasets),
+            returnedItemCount: items.length,
+        }),
+        errors: [],
+        warnings: [],
+        items,
+        truncated: allItems.length > items.length,
+    };
+}
+function objectValue(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function arrayValues(value) {
+    return Array.isArray(value) ? value : [];
+}
+function text(value) {
+    return typeof value === "string" && value ? value : undefined;
+}
+function compact(value) {
+    return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== undefined));
+}

package/dist/report-v2/view-executor.js

@@ -0,0 +1,198 @@
+import { evaluateReportFormula, parseReportFormula, reportFormulaReferences } from "./expression.js";
+const BASE_AGGREGATIONS = new Set(["sum", "min", "max", "count"]);
+/** Pure v2 evaluator. It intentionally has no dependency on legacy reports. */
+export function executeReportPackV2View(rawView, datasetRows, options = {}) {
+    const view = requiredObject(rawView, "view");
+    const data = requiredObject(view.data, "view.data");
+    const groupBy = stringArray(data.groupBy, "view.data.groupBy");
+    const metrics = requiredObject(data.metrics, "view.data.metrics");
+    if (!Object.keys(metrics).length)
+        throw new Error("view.data.metrics must not be empty");
+    const selectorFilters = Array.isArray(options.selectorFilters) ? options.selectorFilters : [];
+    const filteredRows = datasetRows.filter((row) => (matchesFilter(row, data.filter)
+        && selectorFilters.every((filter) => matchesFilter(row, filter))));
+    const groups = groupRows(filteredRows, groupBy);
+    const formulas = prepareFormulas(metrics);
+    const rows = [];
+    for (const group of groups.values()) {
+        const output = { ...group.dimensions };
+        for (const [metricId, rawDefinition] of Object.entries(metrics)) {
+            const definition = objectValue(rawDefinition);
+            if (definition?.agg)
+                output[metricId] = aggregateMetric(group.rows, metricId, definition);
+        }
+        evaluateFormulas(output, formulas);
+        rows.push(output);
+    }
+    if (!filteredRows.length && !groupBy.length) {
+        const output = {};
+        for (const [metricId, rawDefinition] of Object.entries(metrics)) {
+            const definition = objectValue(rawDefinition);
+            if (definition?.agg)
+                output[metricId] = aggregateMetric([], metricId, definition);
+        }
+        evaluateFormulas(output, formulas);
+        rows.push(output);
+    }
+    const orderBy = normalizeOrderBy(view.orderBy);
+    if (orderBy.length) {
+        const stable = [
+            ...orderBy,
+            ...groupBy.filter((field) => !orderBy.some((order) => order.field === field)).map((field) => ({ field, direction: "asc" })),
+        ];
+        rows.sort((left, right) => compareRows(left, right, stable));
+    }
+    const limit = view.limit === undefined ? undefined : positiveInteger(view.limit, "view.limit");
+    return limit === undefined ? rows : rows.slice(0, limit);
+}
+function groupRows(rows, groupBy) {
+    const groups = new Map();
+    for (const row of rows) {
+        const dimensions = Object.fromEntries(groupBy.map((field) => [field, row[field] ?? null]));
+        const key = JSON.stringify(groupBy.map((field) => [typeof row[field], row[field] ?? null]));
+        const existing = groups.get(key);
+        if (existing)
+            existing.rows.push(row);
+        else
+            groups.set(key, { dimensions, rows: [row] });
+    }
+    return groups;
+}
+function aggregateMetric(rows, metricId, definition) {
+    const aggregation = String(definition.agg || "");
+    if (!BASE_AGGREGATIONS.has(aggregation))
+        throw new Error(`unsupported aggregation for ${metricId}: ${aggregation}`);
+    if (aggregation === "count")
+        return rows.length;
+    const field = String(definition.field || "");
+    if (!field)
+        throw new Error(`view.data.metrics.${metricId}.field is required`);
+    const values = rows.flatMap((row) => typeof row[field] === "number" && Number.isFinite(row[field]) ? [row[field]] : []);
+    if (aggregation === "sum")
+        return values.reduce((sum, value) => sum + value, 0);
+    if (!values.length)
+        return null;
+    return aggregation === "min" ? Math.min(...values) : Math.max(...values);
+}
+function prepareFormulas(metrics) {
+    const formulas = new Map();
+    for (const [metricId, rawDefinition] of Object.entries(metrics)) {
+        const definition = objectValue(rawDefinition);
+        if (typeof definition?.formula !== "string")
+            continue;
+        formulas.set(metricId, {
+            expression: parseReportFormula(definition.formula),
+            references: reportFormulaReferences(definition.formula),
+        });
+    }
+    return formulas;
+}
+function evaluateFormulas(output, formulas) {
+    const pending = new Map(formulas);
+    while (pending.size) {
+        let progressed = false;
+        for (const [metricId, formula] of pending) {
+            if (formula.references.some((reference) => pending.has(reference)))
+                continue;
+            output[metricId] = evaluateReportFormula(formula.expression, output);
+            pending.delete(metricId);
+            progressed = true;
+        }
+        if (!progressed)
+            throw new Error(`formula dependency cycle: ${[...pending.keys()].sort().join(", ")}`);
+    }
+}
+function matchesFilter(row, rawFilter) {
+    if (rawFilter === undefined || rawFilter === null)
+        return true;
+    const filter = requiredObject(rawFilter, "filter");
+    const op = String(filter.op || "");
+    if (op === "and" || op === "or") {
+        if (!Array.isArray(filter.filters))
+            throw new Error(`filter ${op} requires filters`);
+        return op === "and"
+            ? filter.filters.every((child) => matchesFilter(row, child))
+            : filter.filters.some((child) => matchesFilter(row, child));
+    }
+    if (op === "not")
+        return !matchesFilter(row, filter.filter);
+    const field = String(filter.field || "");
+    if (!field)
+        throw new Error("filter.field is required");
+    const actual = row[field] ?? null;
+    if (op === "eq")
+        return Object.is(actual, filter.value ?? null);
+    if (op === "ne")
+        return !Object.is(actual, filter.value ?? null);
+    if (["gt", "gte", "lt", "lte"].includes(op) && (actual === null || filter.value === null || filter.value === undefined))
+        return false;
+    if (op === "gt")
+        return compareValues(actual, filter.value) > 0;
+    if (op === "gte")
+        return compareValues(actual, filter.value) >= 0;
+    if (op === "lt")
+        return compareValues(actual, filter.value) < 0;
+    if (op === "lte")
+        return compareValues(actual, filter.value) <= 0;
+    if (op === "in" || op === "not_in") {
+        if (!Array.isArray(filter.values))
+            throw new Error(`filter ${op} requires values`);
+        const included = filter.values.some((value) => Object.is(actual, value));
+        return op === "in" ? included : !included;
+    }
+    if (op === "is_null")
+        return actual === null;
+    if (op === "is_not_null")
+        return actual !== null;
+    throw new Error(`unsupported filter operation: ${op}`);
+}
+function normalizeOrderBy(value) {
+    if (value === undefined)
+        return [];
+    return (Array.isArray(value) ? value : [value]).map((raw, index) => {
+        const item = requiredObject(raw, `view.orderBy[${index}]`);
+        const field = String(item.field || "");
+        const direction = String(item.direction || "asc");
+        if (!field || (direction !== "asc" && direction !== "desc"))
+            throw new Error(`invalid view.orderBy[${index}]`);
+        return { field, direction };
+    });
+}
+function compareRows(left, right, orders) {
+    for (const order of orders) {
+        const result = compareValues(left[order.field], right[order.field]);
+        if (result)
+            return order.direction === "desc" ? -result : result;
+    }
+    return 0;
+}
+function compareValues(left, right) {
+    if (Object.is(left, right))
+        return 0;
+    if (left === null || left === undefined)
+        return 1;
+    if (right === null || right === undefined)
+        return -1;
+    if (typeof left === "number" && typeof right === "number")
+        return left - right;
+    return String(left).localeCompare(String(right));
+}
+function requiredObject(value, path) {
+    const object = objectValue(value);
+    if (!object)
+        throw new Error(`${path} must be an object`);
+    return object;
+}
+function objectValue(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function stringArray(value, path) {
+    if (!Array.isArray(value) || value.some((item) => typeof item !== "string" || !item))
+        throw new Error(`${path} must be an array of strings`);
+    return value;
+}
+function positiveInteger(value, path) {
+    if (!Number.isInteger(value) || Number(value) <= 0)
+        throw new Error(`${path} must be a positive integer`);
+    return Number(value);
+}

package/dist/utils.js

@@ -10,15 +10,15 @@ export function integrationEnvironment(value) {
 }
 export function integrationPlatform(value) {
     const platform = optionalString(value);
-    if (platform === "ios" || platform === "android" || platform === "maker" || platform === "rest")
+    if (platform === "ios" || platform === "android" || platform === "maker" || platform === "web")
         return platform;
-    throw new Error("--platform must be ios, android, maker, or rest");
+    throw new Error("--platform must be ios, android, maker, or web");
 }
 export function experimentPlatform(value) {
     const platform = optionalString(value);
-    if (platform === "ios" || platform === "android" || platform === "rest")
+    if (platform === "ios" || platform === "android" || platform === "maker" || platform === "web")
         return platform;
-    throw new Error("--platform must be ios, android, or rest for experiments");
+    throw new Error("--platform must be ios, android, maker, or web for experiments");
 }
 export function optionalString(value) {
     return typeof value === "string" && value.trim() ? value.trim() : undefined;