@powerhousedao/analytics-engine-core 6.0.0-dev.104 → 6.0.0-dev.106

package/dist/index.js

@@ -0,0 +1,672 @@
+import { AnalyticsGranularity, AnalyticsPath, AnalyticsPathSegment, AnalyticsPeriod, AnalyticsSerializerTypes, CompoundOperator } from "@powerhousedao/shared/analytics";
+import { DateTime, Interval } from "luxon";
+//#region src/AnalyticsProfiler.ts
+var AnalyticsProfiler = class {
+	_stack = [];
+	_prefix = "";
+	constructor(_ns, _logger) {
+		this._ns = _ns;
+		this._logger = _logger;
+		this._prefix = _ns;
+	}
+	get prefix() {
+		return this._prefix;
+	}
+	push(system) {
+		this._stack.push(system);
+		this.updatePrefix();
+	}
+	pop() {
+		if (this._stack.pop()) this.updatePrefix();
+	}
+	popAndReturn(result) {
+		this.pop();
+		return result;
+	}
+	async record(metric, fn) {
+		const start = performance.now();
+		const fullMetric = `${this.prefix}.${metric}`;
+		try {
+			return await fn();
+		} finally {
+			this._logger(fullMetric, performance.now() - start);
+		}
+	}
+	recordSync(metric, fn) {
+		const start = performance.now();
+		const fullMetric = `${this.prefix}.${metric}`;
+		try {
+			return fn();
+		} finally {
+			this._logger(fullMetric, performance.now() - start);
+		}
+	}
+	updatePrefix() {
+		if (this._stack.length > 0) this._prefix = `${this._ns}.${this._stack.join(".")}`;
+		else this._prefix = this._ns;
+	}
+};
+var PassthroughAnalyticsProfiler = class {
+	get prefix() {
+		return "";
+	}
+	push(system) {}
+	pop() {}
+	popAndReturn(result) {
+		return result;
+	}
+	async record(metric, fn) {
+		return await fn();
+	}
+	recordSync(metric, fn) {
+		return fn();
+	}
+};
+//#endregion
+//#region src/AnalyticsTimeSlicer.ts
+const getPeriodSeriesArray = (range) => {
+	const result = [];
+	const series = getPeriodSeries(range);
+	let next = series.next();
+	while (next) {
+		result.push(next);
+		next = series.next();
+	}
+	return result;
+};
+const getPeriodSeries = (range) => {
+	return {
+		...range,
+		next: _createFactoryFn(range)
+	};
+};
+const _createFactoryFn = (range) => {
+	let current = range.start;
+	return () => {
+		if (current == null) return null;
+		let result = null;
+		switch (range.granularity) {
+			case AnalyticsGranularity.Total:
+				result = _nextTotalPeriod(current, range.end);
+				break;
+			case AnalyticsGranularity.Annual:
+				result = _nextAnnualPeriod(current, range.end);
+				break;
+			case AnalyticsGranularity.SemiAnnual:
+				result = _nextSemiAnnualPeriod(current, range.end);
+				break;
+			case AnalyticsGranularity.Quarterly:
+				result = _nextQuarterlyPeriod(current, range.end);
+				break;
+			case AnalyticsGranularity.Monthly:
+				result = _nextMonthlyPeriod(current, range.end);
+				break;
+			case AnalyticsGranularity.Weekly:
+				result = _nextWeeklyPeriod(current, range.end);
+				break;
+			case AnalyticsGranularity.Daily:
+				result = _nextDailyPeriod(current, range.end);
+				break;
+			case AnalyticsGranularity.Hourly: result = _nextHourlyPeriod(current, range.end);
+		}
+		if (result === null) current = null;
+		else current = result.end.plus({ milliseconds: 1 });
+		return result;
+	};
+};
+const _nextTotalPeriod = (nextStart, seriesEnd) => {
+	if (seriesEnd <= nextStart) return null;
+	return {
+		period: "total",
+		start: nextStart,
+		end: seriesEnd
+	};
+};
+const _nextAnnualPeriod = (nextStart, seriesEnd) => {
+	if (seriesEnd <= nextStart) return null;
+	const inputUtc = nextStart.toUTC();
+	return {
+		period: "annual",
+		start: nextStart,
+		end: DateTime.utc(inputUtc.year, inputUtc.month, inputUtc.day).plus({ years: 1 })
+	};
+};
+const _nextSemiAnnualPeriod = (nextStart, seriesEnd) => {
+	if (seriesEnd <= nextStart) return null;
+	const midYear = DateTime.utc(nextStart.year, 7, 1);
+	const endYear = DateTime.utc(nextStart.year, 12, 31, 23, 59, 59, 999);
+	let endDate;
+	if (midYear > nextStart) endDate = midYear;
+	else endDate = endYear;
+	if (endDate > seriesEnd) endDate = seriesEnd;
+	return {
+		period: "semiAnnual",
+		start: nextStart,
+		end: endDate
+	};
+};
+const _nextQuarterlyPeriod = (nextStart, seriesEnd) => {
+	if (seriesEnd <= nextStart) return null;
+	let endDate;
+	const nextStartUtc = nextStart.toUTC();
+	const startMonth = nextStartUtc.month;
+	if (startMonth < 3) endDate = DateTime.utc(nextStartUtc.year, 4, 1);
+	else if (startMonth < 6) endDate = DateTime.utc(nextStartUtc.year, 7, 1);
+	else if (startMonth < 9) endDate = DateTime.utc(nextStartUtc.year, 10, 1);
+	else endDate = DateTime.utc(nextStartUtc.year, 12, 31, 23, 59, 59, 999);
+	if (endDate > seriesEnd) endDate = seriesEnd;
+	return {
+		period: "quarterly",
+		start: nextStart,
+		end: endDate
+	};
+};
+const _nextMonthlyPeriod = (nextStart, seriesEnd) => {
+	if (seriesEnd <= nextStart) return null;
+	const nextStartUtc = nextStart.toUTC();
+	let endDate = DateTime.utc(nextStartUtc.year, nextStartUtc.month, nextStartUtc.day).plus({ months: 1 }).startOf("month");
+	if (endDate > seriesEnd) {
+		if (!nextStart.hasSame(seriesEnd, "month")) endDate = seriesEnd;
+	}
+	return {
+		period: "monthly",
+		start: nextStart,
+		end: endDate
+	};
+};
+const _nextWeeklyPeriod = (nextStart, seriesEnd) => {
+	if (seriesEnd <= nextStart) return null;
+	const nextStartUtc = nextStart.toUTC();
+	const nextWeekStartUTC = DateTime.utc(nextStartUtc.year, nextStartUtc.month, nextStartUtc.day).plus({ weeks: 1 }).startOf("week");
+	if (nextWeekStartUTC > seriesEnd) {
+		if (!nextWeekStartUTC.hasSame(seriesEnd, "day")) return {
+			period: "weekly",
+			start: nextStart,
+			end: seriesEnd
+		};
+	}
+	return {
+		period: "weekly",
+		start: nextStart,
+		end: nextWeekStartUTC
+	};
+};
+const _nextDailyPeriod = (nextStart, seriesEnd) => {
+	if (seriesEnd <= nextStart) return null;
+	let endDate = nextStart.toUTC().plus({ days: 1 }).startOf("day");
+	if (endDate > seriesEnd || endDate.hasSame(seriesEnd, "day")) endDate = seriesEnd;
+	return {
+		period: "daily",
+		start: nextStart,
+		end: endDate
+	};
+};
+const _nextHourlyPeriod = (nextStart, seriesEnd) => {
+	if (seriesEnd <= nextStart) return null;
+	let endDate = nextStart.toUTC().plus({ hours: 1 });
+	if (endDate > seriesEnd) {
+		if (nextStart.hour !== seriesEnd.hour) endDate = seriesEnd.toUTC();
+	}
+	return {
+		period: "hourly",
+		start: nextStart,
+		end: endDate
+	};
+};
+//#endregion
+//#region src/AnalyticsDiscretizer.ts
+const getQuarter = (date) => {
+	return Math.floor((date.month - 1) / 3) + 1;
+};
+var AnalyticsDiscretizer = class AnalyticsDiscretizer {
+	static discretize(series, dimensions, start, end, granularity) {
+		const index = this._buildIndex(series, dimensions);
+		const periods = getPeriodSeriesArray(this._calculateRange(start, end, granularity, series));
+		const disretizedResults = this._discretizeNode(index, {}, dimensions, periods);
+		return this._groupResultsByPeriod(periods, disretizedResults);
+	}
+	static _calculateRange(start, end, granularity, results) {
+		let calculatedStart = start || null;
+		let calculatedEnd = end || null;
+		if (calculatedStart == null || calculatedEnd == null) for (const r of results) {
+			if (calculatedStart == null) calculatedStart = r.start;
+			const endValue = r.end || r.start;
+			if (calculatedEnd == null || calculatedEnd < endValue) calculatedEnd = endValue;
+		}
+		if (calculatedStart == null || calculatedEnd == null) throw new Error("Cannot determine query start and/or end.");
+		return {
+			start: calculatedStart,
+			end: calculatedEnd,
+			granularity
+		};
+	}
+	static _groupResultsByPeriod(periods, dimensionedResults) {
+		const result = {};
+		for (const p of periods) {
+			const id = p.start.toISO() + "-" + p.period;
+			result[id] = {
+				period: AnalyticsDiscretizer._getPeriodString(p),
+				start: p.start,
+				end: p.end,
+				rows: []
+			};
+		}
+		for (const r of dimensionedResults) for (const period of Object.keys(r.series)) result[period].rows.push({
+			dimensions: r.dimensions,
+			metric: r.metric,
+			unit: r.unit == "__NULL__" ? null : r.unit,
+			value: r.series[period].inc,
+			sum: r.series[period].sum
+		});
+		return Object.values(result);
+	}
+	static _getPeriodString(p) {
+		switch (p.period) {
+			case "annual": return p.start.year.toString();
+			case "semiAnnual": return `${p.start.year}/${p.start.month < 7 ? "H1" : "H2"}`;
+			case "quarterly": return `${p.start.year}/Q${getQuarter(p.start)}`;
+			case "monthly":
+				const month = p.start.toUTC().month;
+				const formattedMonth = month < 10 ? `0${month}` : `${month}`;
+				return `${p.start.year}/${formattedMonth}`;
+			case "weekly": return `${p.start.weekYear}/W${p.start.weekNumber}`;
+			case "daily":
+				const monthD = p.start.month;
+				const day = p.start.day;
+				const formattedMonthD = monthD < 10 ? `0${monthD}` : `${monthD}`;
+				const formattedDay = day < 10 ? `0${day}` : `${day}`;
+				return `${p.start.year}/${formattedMonthD}/${formattedDay}`;
+			case "hourly":
+				const monthH = p.start.month;
+				const dayH = p.start.day;
+				const hourH = p.start.hour;
+				const formattedMonthH = monthH < 10 ? `0${monthH}` : `${monthH}`;
+				const formattedDayH = dayH < 10 ? `0${dayH}` : `${dayH}`;
+				const formattedHourH = hourH < 10 ? `0${hourH}` : `${hourH}`;
+				return `${p.start.year}/${formattedMonthH}/${formattedDayH}/${formattedHourH}`;
+			default: return p.period;
+		}
+	}
+	static _discretizeNode(node, dimensionValues, remainingDimensions, periods) {
+		const result = [];
+		if (remainingDimensions.length > 0) {
+			const subdimension = remainingDimensions[0];
+			Object.keys(node).forEach((subdimensionValue, index, arr) => {
+				const newDimensionValues = { ...dimensionValues };
+				newDimensionValues[subdimension] = subdimensionValue;
+				result.push(...this._discretizeNode(node[subdimensionValue], newDimensionValues, remainingDimensions.slice(1), periods));
+			});
+		} else Object.keys(node).forEach((metric) => {
+			result.push(...this._discretizeLeaf(node[metric], periods, metric, dimensionValues));
+		});
+		return result;
+	}
+	static _discretizeLeaf(leaf, periods, metric, dimensionValues) {
+		const result = [];
+		Object.keys(leaf).forEach((unit) => {
+			const metaDimensions = {};
+			Object.keys(dimensionValues).forEach((k) => {
+				metaDimensions[k] = {
+					path: leaf[unit][0].dimensions[k],
+					icon: leaf[unit][0].dimensions.icon,
+					label: leaf[unit][0].dimensions.label,
+					description: leaf[unit][0].dimensions.description
+				};
+			});
+			result.push({
+				unit,
+				metric,
+				dimensions: metaDimensions,
+				series: this._discretizeSeries(leaf[unit], periods)
+			});
+		});
+		return result;
+	}
+	static _discretizeSeries(series, periods) {
+		const result = {};
+		for (const s of series) {
+			let oldSum = this._getValue(s, periods[0].start);
+			for (const p of periods) {
+				const newSum = this._getValue(s, p.end);
+				const id = `${p.start.toISO()}-${p.period}`;
+				if (result[id]) {
+					result[id].inc += newSum - oldSum;
+					result[id].sum += newSum;
+				} else result[id] = {
+					inc: newSum - oldSum,
+					sum: newSum
+				};
+				oldSum = newSum;
+			}
+		}
+		return result;
+	}
+	static _getValue(series, when) {
+		switch (series.fn) {
+			case "Single": return this._getSingleValue(series, when);
+			case "DssVest": return this._getVestValue(series, when);
+			default: return 0;
+		}
+	}
+	static _getSingleValue(series, when) {
+		return when >= series.start ? series.value : 0;
+	}
+	static _getVestValue(series, when) {
+		const now = when;
+		const start = series.start;
+		const end = series.end;
+		const cliff = series.params?.cliff ? DateTime.fromISO(series.params.cliff) : null;
+		if (now < start || cliff && now < cliff) return 0;
+		else if (end && now >= end) return series.value;
+		const a = Interval.fromDateTimes(start, now);
+		const b = Interval.fromDateTimes(start, end || now);
+		return a.length() / b.length() * series.value;
+	}
+	static _buildIndex(series, dimensions) {
+		const result = {};
+		const map = {};
+		const dimName = dimensions[0] || "";
+		for (const s of series) {
+			const dimValue = s.dimensions[dimName];
+			if (void 0 === map[dimValue]) map[dimValue] = [];
+			map[dimValue].push(s);
+		}
+		if (dimensions.length > 1) {
+			const newDimensions = dimensions.slice(1);
+			Object.keys(map).forEach((k) => {
+				result[k] = this._buildIndex(map[k], newDimensions);
+			});
+		} else Object.keys(map).forEach((k) => {
+			result[k] = this._buildMetricsIndex(map[k]);
+		});
+		return result;
+	}
+	static _buildMetricsIndex(series) {
+		const result = {};
+		const map = {};
+		for (const s of series) {
+			const metric = s.metric;
+			if (void 0 === map[metric]) map[metric] = [];
+			map[metric].push(s);
+		}
+		Object.keys(map).forEach((k) => result[k] = this._buildUnitIndex(map[k]));
+		return result;
+	}
+	static _buildUnitIndex(series) {
+		const result = {};
+		for (const s of series) {
+			const unit = s.unit || "__NULL__";
+			if (void 0 === result[unit]) result[unit] = [];
+			result[unit].push(s);
+		}
+		return result;
+	}
+};
+//#endregion
+//#region src/AnalyticsQueryEngine.ts
+var AnalyticsQueryEngine = class {
+	_profiler;
+	constructor(_analyticsStore, profiler) {
+		this._analyticsStore = _analyticsStore;
+		this._profiler = profiler ?? new PassthroughAnalyticsProfiler();
+	}
+	async executeCompound(query) {
+		let result;
+		const inputsQuery = {
+			start: query.start,
+			end: query.end,
+			granularity: query.granularity,
+			lod: query.lod,
+			select: query.select,
+			metrics: query.expression.inputs.metrics,
+			currency: query.expression.inputs.currency
+		};
+		const operandQuery = {
+			start: query.start,
+			end: query.end,
+			granularity: query.granularity,
+			lod: { priceData: 1 },
+			select: { priceData: [AnalyticsPath.fromString("atlas")] },
+			metrics: [query.expression.operand.metric],
+			currency: query.expression.operand.currency
+		};
+		const inputExecute = await this.execute(inputsQuery);
+		const operandExecute = await this.execute(operandQuery);
+		if ([CompoundOperator.VectorAdd, CompoundOperator.VectorSubtract].includes(query.expression.operator)) result = await this._profiler.record("ApplyVectorOperator", async () => await this._applyVectorOperator(inputExecute, operandExecute, query.expression.operator, query.expression.resultCurrency));
+		else result = await this._profiler.record("ApplyScalarOperator", async () => await this._applyScalarOperator(inputExecute, operandExecute, query.expression.operator, query.expression.operand.useSum, query.expression.resultCurrency));
+		return result;
+	}
+	async execute(query) {
+		const seriesResults = await this._executeSeriesQuery(query);
+		const normalizedSeriesResults = this._profiler.recordSync("ApplyLODs", () => this._applyLods(seriesResults, query.lod));
+		const dimensions = Object.keys(query.select);
+		return this._profiler.recordSync("Discretize", () => normalizedSeriesResults.length < 1 ? [] : AnalyticsDiscretizer.discretize(normalizedSeriesResults, dimensions, query.start, query.end, query.granularity));
+	}
+	async executeMultiCurrency(query, mcc) {
+		const baseQuery = {
+			...query,
+			currency: mcc.targetCurrency ?? query.currency
+		};
+		let result = await this.execute(baseQuery);
+		for (const conversion of mcc.conversions) {
+			const nextQuery = {
+				start: query.start,
+				end: query.end,
+				granularity: query.granularity,
+				lod: query.lod,
+				select: query.select,
+				expression: {
+					inputs: {
+						metrics: baseQuery.metrics,
+						currency: conversion.currency
+					},
+					operator: CompoundOperator.ScalarMultiply,
+					operand: {
+						metric: conversion.metric,
+						currency: mcc.targetCurrency,
+						useSum: true
+					},
+					resultCurrency: mcc.targetCurrency
+				}
+			};
+			const executedCompound = await this.executeCompound(nextQuery);
+			result = await this._applyVectorOperator(result, executedCompound, CompoundOperator.VectorAdd, mcc.targetCurrency);
+		}
+		return result;
+	}
+	async _applyVectorOperator(inputsA, inputsB, operator, resultCurrency) {
+		if ([CompoundOperator.ScalarMultiply, CompoundOperator.ScalarDivide].includes(operator)) throw new Error("Invalid operator for vector operation");
+		return inputsB;
+	}
+	async _applyScalarOperator(inputs, operand, operator, useOperandSum, resultCurrency) {
+		if ([CompoundOperator.VectorAdd, CompoundOperator.VectorSubtract].includes(operator)) throw new Error("Invalid operator for scalar operation");
+		const result = [];
+		const operandMap = {};
+		const key = useOperandSum ? "sum" : "value";
+		for (const operandPeriod of operand) if (operandPeriod.rows.length > 0) operandMap[operandPeriod.period] = operandPeriod.rows[0][key];
+		for (const inputPeriod of inputs) {
+			const outputPeriod = {
+				period: inputPeriod.period,
+				start: inputPeriod.start,
+				end: inputPeriod.end,
+				rows: inputPeriod.rows.map((row) => {
+					return {
+						dimensions: row.dimensions,
+						metric: row.metric,
+						unit: resultCurrency ? resultCurrency.toString() : row.unit,
+						value: this._calculateOutputValue(row.value, operator, operandMap[inputPeriod.period]),
+						sum: -1
+					};
+				})
+			};
+			result.push(outputPeriod);
+		}
+		return result;
+	}
+	_calculateOutputValue(input, operator, operand) {
+		switch (operator) {
+			case CompoundOperator.VectorAdd: return input + operand;
+			case CompoundOperator.VectorSubtract: return input - operand;
+			case CompoundOperator.ScalarMultiply: return input * operand;
+			case CompoundOperator.ScalarDivide: return input / operand;
+		}
+	}
+	async _executeSeriesQuery(query) {
+		const seriesQuery = {
+			start: query.start,
+			end: query.end,
+			select: query.select,
+			metrics: query.metrics,
+			currency: query.currency
+		};
+		return await this._analyticsStore.getMatchingSeries(seriesQuery);
+	}
+	_applyLods(series, lods) {
+		return series.map((result) => ({
+			...result,
+			dimensions: this._applyDimensionsLods(result.dimensions, lods)
+		}));
+	}
+	_applyDimensionsLods(dimensionMap, lods) {
+		const result = {};
+		for (const [dimension, lod] of Object.entries(lods)) if (lod !== null && dimensionMap[dimension]) {
+			result[dimension] = dimensionMap[dimension]["path"].applyLod(lod).toString();
+			result["icon"] = dimensionMap[dimension]["icon"].toString();
+			result["label"] = dimensionMap[dimension]["label"].toString();
+			result["description"] = dimensionMap[dimension]["description"].toString();
+		}
+		return result;
+	}
+	async getDimensions() {
+		return await this._analyticsStore.getDimensions();
+	}
+};
+//#endregion
+//#region src/AnalyticsSubscriptionManager.ts
+var NotificationError = class extends Error {
+	innerErrors;
+	constructor(errors) {
+		super(errors.map((e) => e.message).join("\n"));
+		this.name = "NotificationError";
+		this.innerErrors = errors;
+	}
+};
+/**
+* Manages subscriptions for analytics paths.
+*/
+var AnalyticsSubscriptionManager = class {
+	_subscriptions = /* @__PURE__ */ new Map();
+	/**
+	* Subscribe to updates for an analytics path. A subscribed function will be
+	* called for:
+	*
+	* - exact path matches
+	* - matching child paths (i.e. an update to /a/b/c will trigger a callback
+	*   for /a/b/c, /a/b, and /a)
+	* - wildcard matches
+	*
+	* @param path The analytics path to subscribe to.
+	* @param callback Function to be called when the path is updated.
+	*
+	* @returns A function that, when called, unsubscribes from the updates.
+	*/
+	subscribeToPath(path, callback) {
+		const pathString = this.normalizePath(path.toString("/"));
+		if (!this._subscriptions.has(pathString)) this._subscriptions.set(pathString, /* @__PURE__ */ new Set());
+		this._subscriptions.get(pathString).add(callback);
+		return () => {
+			const callbacks = this._subscriptions.get(pathString);
+			if (callbacks) {
+				callbacks.delete(callback);
+				if (callbacks.size === 0) this._subscriptions.delete(pathString);
+			}
+		};
+	}
+	/**
+	* Notifies subscribers about updates to paths.
+	*
+	* @param paths The paths that were updated.
+	*/
+	notifySubscribers(paths) {
+		if (paths.length === 0 || this._subscriptions.size === 0) return;
+		const errors = [];
+		for (const path of paths) {
+			const pathString = this.normalizePath(path.toString("/"));
+			const pathPrefixes = this.getPathPrefixes(pathString);
+			const matchingSubscriptions = [];
+			pathPrefixes.filter((prefix) => this._subscriptions.has(prefix)).forEach((prefix) => {
+				matchingSubscriptions.push({
+					prefix,
+					callbacks: this._subscriptions.get(prefix)
+				});
+			});
+			for (const [subscriptionPath, callbacks] of this._subscriptions.entries()) {
+				if (pathPrefixes.includes(subscriptionPath)) continue;
+				if (this.pathMatchesWildcardPattern(pathString, subscriptionPath)) matchingSubscriptions.push({
+					prefix: subscriptionPath,
+					callbacks
+				});
+			}
+			if (matchingSubscriptions.length === 0) continue;
+			for (const { callbacks } of matchingSubscriptions) for (const callback of callbacks) try {
+				callback(path);
+			} catch (e) {
+				errors.push(e);
+			}
+		}
+		if (errors.length > 0) throw new NotificationError(errors);
+	}
+	/**
+	* Normalizes a path string to ensure consistent comparison.
+	*/
+	normalizePath(path) {
+		return "/" + path.split("/").filter((p) => p.length > 0).join("/");
+	}
+	/**
+	* Checks if a path matches a subscription pattern that may contain wildcards.
+	*/
+	pathMatchesWildcardPattern(updatePath, subscriptionPath) {
+		if (subscriptionPath.includes("*")) {
+			const updateSegments = updatePath.split("/").filter((s) => s.length > 0);
+			const subscriptionSegments = subscriptionPath.split("/").filter((s) => s.length > 0);
+			if (subscriptionSegments.length > updateSegments.length) return false;
+			for (let i = 0; i < subscriptionSegments.length; i++) {
+				const subSegment = subscriptionSegments[i];
+				const updateSegment = updateSegments[i];
+				if (subSegment === "*" || subSegment.startsWith("*:")) continue;
+				if (subSegment !== updateSegment) return false;
+			}
+			return true;
+		}
+		return updatePath === subscriptionPath || updatePath.startsWith(subscriptionPath + "/");
+	}
+	/**
+	* Gets all path prefixes for a given path.
+	*
+	* For example, for '/a/b/c' it returns ['/a', '/a/b', '/a/b/c'].
+	*/
+	getPathPrefixes(path) {
+		const segments = path.split("/").filter((s) => s.length > 0);
+		const prefixes = [];
+		let currentPath = "";
+		for (const segment of segments) {
+			currentPath = currentPath ? `${currentPath}/${segment}` : `/${segment}`;
+			prefixes.push(currentPath);
+		}
+		if (prefixes.length === 0 && path === "/") prefixes.push("/");
+		return prefixes;
+	}
+};
+//#endregion
+//#region src/util.ts
+const defaultQueryLogger = (tag) => (index, query) => {
+	console.log(`[${tag}][Q:${index}]: ${query}\n`);
+};
+const defaultResultsLogger = (tag) => (index, results) => {
+	if (Array.isArray(results)) console.log(`[${tag}][R:${index}]: ${results.length} results\n`);
+	else console.log(`[${tag}][R:${index}]: Received ${typeof results}.\n`);
+};
+//#endregion
+export { AnalyticsGranularity, AnalyticsPath, AnalyticsPathSegment, AnalyticsPeriod, AnalyticsProfiler, AnalyticsQueryEngine, AnalyticsSerializerTypes, AnalyticsSubscriptionManager, NotificationError, PassthroughAnalyticsProfiler, defaultQueryLogger, defaultResultsLogger };
+
+//# sourceMappingURL=index.js.map