@hanai/ccusage 18.0.5

package/dist/_types-BFL_bTNX.js

@@ -0,0 +1,588 @@
+function getTotalTokens(tokenCounts) {
+	const cacheCreation = "cacheCreationInputTokens" in tokenCounts ? tokenCounts.cacheCreationInputTokens : tokenCounts.cacheCreationTokens;
+	const cacheRead = "cacheReadInputTokens" in tokenCounts ? tokenCounts.cacheReadInputTokens : tokenCounts.cacheReadTokens;
+	return tokenCounts.inputTokens + tokenCounts.outputTokens + cacheCreation + cacheRead;
+}
+var store;
+/* @__NO_SIDE_EFFECTS__ */
+function getGlobalConfig(config2) {
+	return {
+		lang: config2?.lang ?? store?.lang,
+		message: config2?.message,
+		abortEarly: config2?.abortEarly ?? store?.abortEarly,
+		abortPipeEarly: config2?.abortPipeEarly ?? store?.abortPipeEarly
+	};
+}
+var store2;
+/* @__NO_SIDE_EFFECTS__ */
+function getGlobalMessage(lang) {
+	return store2?.get(lang);
+}
+var store3;
+/* @__NO_SIDE_EFFECTS__ */
+function getSchemaMessage(lang) {
+	return store3?.get(lang);
+}
+var store4;
+/* @__NO_SIDE_EFFECTS__ */
+function getSpecificMessage(reference, lang) {
+	return store4?.get(reference)?.get(lang);
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _stringify(input) {
+	const type = typeof input;
+	if (type === "string") return `"${input}"`;
+	if (type === "number" || type === "bigint" || type === "boolean") return `${input}`;
+	if (type === "object" || type === "function") return (input && Object.getPrototypeOf(input)?.constructor?.name) ?? "null";
+	return type;
+}
+function _addIssue(context, label, dataset, config2, other) {
+	const input = other && "input" in other ? other.input : dataset.value;
+	const expected = other?.expected ?? context.expects ?? null;
+	const received = other?.received ?? /* @__PURE__ */ _stringify(input);
+	const issue = {
+		kind: context.kind,
+		type: context.type,
+		input,
+		expected,
+		received,
+		message: `Invalid ${label}: ${expected ? `Expected ${expected} but r` : "R"}eceived ${received}`,
+		requirement: context.requirement,
+		path: other?.path,
+		issues: other?.issues,
+		lang: config2.lang,
+		abortEarly: config2.abortEarly,
+		abortPipeEarly: config2.abortPipeEarly
+	};
+	const isSchema = context.kind === "schema";
+	const message2 = other?.message ?? context.message ?? /* @__PURE__ */ getSpecificMessage(context.reference, issue.lang) ?? (isSchema ? /* @__PURE__ */ getSchemaMessage(issue.lang) : null) ?? config2.message ?? /* @__PURE__ */ getGlobalMessage(issue.lang);
+	if (message2 !== void 0) issue.message = typeof message2 === "function" ? message2(issue) : message2;
+	if (isSchema) dataset.typed = false;
+	if (dataset.issues) dataset.issues.push(issue);
+	else dataset.issues = [issue];
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _getStandardProps(context) {
+	return {
+		version: 1,
+		vendor: "valibot",
+		validate(value2) {
+			return context["~run"]({ value: value2 }, /* @__PURE__ */ getGlobalConfig());
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _joinExpects(values2, separator) {
+	const list = [...new Set(values2)];
+	if (list.length > 1) return `(${list.join(` ${separator} `)})`;
+	return list[0] ?? "never";
+}
+/* @__NO_SIDE_EFFECTS__ */
+function getDotPath(issue) {
+	if (issue.path) {
+		let key = "";
+		for (const item of issue.path) if (typeof item.key === "string" || typeof item.key === "number") if (key) key += `.${item.key}`;
+		else key += item.key;
+		else return null;
+		return key;
+	}
+	return null;
+}
+var ValiError = class extends Error {
+	constructor(issues) {
+		super(issues[0].message);
+		this.name = "ValiError";
+		this.issues = issues;
+	}
+};
+/* @__NO_SIDE_EFFECTS__ */
+function brand(name) {
+	return {
+		kind: "transformation",
+		type: "brand",
+		reference: brand,
+		async: false,
+		name,
+		"~run"(dataset) {
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function check(requirement, message2) {
+	return {
+		kind: "validation",
+		type: "check",
+		reference: check,
+		async: false,
+		expects: null,
+		requirement,
+		message: message2,
+		"~run"(dataset, config2) {
+			if (dataset.typed && !this.requirement(dataset.value)) _addIssue(this, "input", dataset, config2);
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function integer(message2) {
+	return {
+		kind: "validation",
+		type: "integer",
+		reference: integer,
+		async: false,
+		expects: null,
+		requirement: Number.isInteger,
+		message: message2,
+		"~run"(dataset, config2) {
+			if (dataset.typed && !this.requirement(dataset.value)) _addIssue(this, "integer", dataset, config2);
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function maxValue(requirement, message2) {
+	return {
+		kind: "validation",
+		type: "max_value",
+		reference: maxValue,
+		async: false,
+		expects: `<=${requirement instanceof Date ? requirement.toJSON() : /* @__PURE__ */ _stringify(requirement)}`,
+		requirement,
+		message: message2,
+		"~run"(dataset, config2) {
+			if (dataset.typed && !(dataset.value <= this.requirement)) _addIssue(this, "value", dataset, config2, { received: dataset.value instanceof Date ? dataset.value.toJSON() : /* @__PURE__ */ _stringify(dataset.value) });
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function minLength(requirement, message2) {
+	return {
+		kind: "validation",
+		type: "min_length",
+		reference: minLength,
+		async: false,
+		expects: `>=${requirement}`,
+		requirement,
+		message: message2,
+		"~run"(dataset, config2) {
+			if (dataset.typed && dataset.value.length < this.requirement) _addIssue(this, "length", dataset, config2, { received: `${dataset.value.length}` });
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function minValue(requirement, message2) {
+	return {
+		kind: "validation",
+		type: "min_value",
+		reference: minValue,
+		async: false,
+		expects: `>=${requirement instanceof Date ? requirement.toJSON() : /* @__PURE__ */ _stringify(requirement)}`,
+		requirement,
+		message: message2,
+		"~run"(dataset, config2) {
+			if (dataset.typed && !(dataset.value >= this.requirement)) _addIssue(this, "value", dataset, config2, { received: dataset.value instanceof Date ? dataset.value.toJSON() : /* @__PURE__ */ _stringify(dataset.value) });
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function regex(requirement, message2) {
+	return {
+		kind: "validation",
+		type: "regex",
+		reference: regex,
+		async: false,
+		expects: `${requirement}`,
+		requirement,
+		message: message2,
+		"~run"(dataset, config2) {
+			if (dataset.typed && !this.requirement.test(dataset.value)) _addIssue(this, "format", dataset, config2);
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function transform(operation) {
+	return {
+		kind: "transformation",
+		type: "transform",
+		reference: transform,
+		async: false,
+		operation,
+		"~run"(dataset) {
+			dataset.value = this.operation(dataset.value);
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function trim() {
+	return {
+		kind: "transformation",
+		type: "trim",
+		reference: trim,
+		async: false,
+		"~run"(dataset) {
+			dataset.value = dataset.value.trim();
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function getFallback(schema, dataset, config2) {
+	return typeof schema.fallback === "function" ? schema.fallback(dataset, config2) : schema.fallback;
+}
+/* @__NO_SIDE_EFFECTS__ */
+function flatten(issues) {
+	const flatErrors = {};
+	for (const issue of issues) if (issue.path) {
+		const dotPath = /* @__PURE__ */ getDotPath(issue);
+		if (dotPath) {
+			if (!flatErrors.nested) flatErrors.nested = {};
+			if (flatErrors.nested[dotPath]) flatErrors.nested[dotPath].push(issue.message);
+			else flatErrors.nested[dotPath] = [issue.message];
+		} else if (flatErrors.other) flatErrors.other.push(issue.message);
+		else flatErrors.other = [issue.message];
+	} else if (flatErrors.root) flatErrors.root.push(issue.message);
+	else flatErrors.root = [issue.message];
+	return flatErrors;
+}
+/* @__NO_SIDE_EFFECTS__ */
+function getDefault(schema, dataset, config2) {
+	return typeof schema.default === "function" ? schema.default(dataset, config2) : schema.default;
+}
+/* @__NO_SIDE_EFFECTS__ */
+function array(item, message2) {
+	return {
+		kind: "schema",
+		type: "array",
+		reference: array,
+		expects: "Array",
+		async: false,
+		item,
+		message: message2,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config2) {
+			const input = dataset.value;
+			if (Array.isArray(input)) {
+				dataset.typed = true;
+				dataset.value = [];
+				for (let key = 0; key < input.length; key++) {
+					const value2 = input[key];
+					const itemDataset = this.item["~run"]({ value: value2 }, config2);
+					if (itemDataset.issues) {
+						const pathItem = {
+							type: "array",
+							origin: "value",
+							input,
+							key,
+							value: value2
+						};
+						for (const issue of itemDataset.issues) {
+							if (issue.path) issue.path.unshift(pathItem);
+							else issue.path = [pathItem];
+							dataset.issues?.push(issue);
+						}
+						if (!dataset.issues) dataset.issues = itemDataset.issues;
+						if (config2.abortEarly) {
+							dataset.typed = false;
+							break;
+						}
+					}
+					if (!itemDataset.typed) dataset.typed = false;
+					dataset.value.push(itemDataset.value);
+				}
+			} else _addIssue(this, "type", dataset, config2);
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function boolean(message2) {
+	return {
+		kind: "schema",
+		type: "boolean",
+		reference: boolean,
+		expects: "boolean",
+		async: false,
+		message: message2,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config2) {
+			if (typeof dataset.value === "boolean") dataset.typed = true;
+			else _addIssue(this, "type", dataset, config2);
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function number(message2) {
+	return {
+		kind: "schema",
+		type: "number",
+		reference: number,
+		expects: "number",
+		async: false,
+		message: message2,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config2) {
+			if (typeof dataset.value === "number" && !isNaN(dataset.value)) dataset.typed = true;
+			else _addIssue(this, "type", dataset, config2);
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function object(entries2, message2) {
+	return {
+		kind: "schema",
+		type: "object",
+		reference: object,
+		expects: "Object",
+		async: false,
+		entries: entries2,
+		message: message2,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config2) {
+			const input = dataset.value;
+			if (input && typeof input === "object") {
+				dataset.typed = true;
+				dataset.value = {};
+				for (const key in this.entries) {
+					const valueSchema = this.entries[key];
+					if (key in input || (valueSchema.type === "exact_optional" || valueSchema.type === "optional" || valueSchema.type === "nullish") && valueSchema.default !== void 0) {
+						const value2 = key in input ? input[key] : /* @__PURE__ */ getDefault(valueSchema);
+						const valueDataset = valueSchema["~run"]({ value: value2 }, config2);
+						if (valueDataset.issues) {
+							const pathItem = {
+								type: "object",
+								origin: "value",
+								input,
+								key,
+								value: value2
+							};
+							for (const issue of valueDataset.issues) {
+								if (issue.path) issue.path.unshift(pathItem);
+								else issue.path = [pathItem];
+								dataset.issues?.push(issue);
+							}
+							if (!dataset.issues) dataset.issues = valueDataset.issues;
+							if (config2.abortEarly) {
+								dataset.typed = false;
+								break;
+							}
+						}
+						if (!valueDataset.typed) dataset.typed = false;
+						dataset.value[key] = valueDataset.value;
+					} else if (valueSchema.fallback !== void 0) dataset.value[key] = /* @__PURE__ */ getFallback(valueSchema);
+					else if (valueSchema.type !== "exact_optional" && valueSchema.type !== "optional" && valueSchema.type !== "nullish") {
+						_addIssue(this, "key", dataset, config2, {
+							input: void 0,
+							expected: `"${key}"`,
+							path: [{
+								type: "object",
+								origin: "key",
+								input,
+								key,
+								value: input[key]
+							}]
+						});
+						if (config2.abortEarly) break;
+					}
+				}
+			} else _addIssue(this, "type", dataset, config2);
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function optional(wrapped, default_) {
+	return {
+		kind: "schema",
+		type: "optional",
+		reference: optional,
+		expects: `(${wrapped.expects} | undefined)`,
+		async: false,
+		wrapped,
+		default: default_,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config2) {
+			if (dataset.value === void 0) {
+				if (this.default !== void 0) dataset.value = /* @__PURE__ */ getDefault(this, dataset, config2);
+				if (dataset.value === void 0) {
+					dataset.typed = true;
+					return dataset;
+				}
+			}
+			return this.wrapped["~run"](dataset, config2);
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function string(message2) {
+	return {
+		kind: "schema",
+		type: "string",
+		reference: string,
+		expects: "string",
+		async: false,
+		message: message2,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config2) {
+			if (typeof dataset.value === "string") dataset.typed = true;
+			else _addIssue(this, "type", dataset, config2);
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _subIssues(datasets) {
+	let issues;
+	if (datasets) for (const dataset of datasets) if (issues) issues.push(...dataset.issues);
+	else issues = dataset.issues;
+	return issues;
+}
+/* @__NO_SIDE_EFFECTS__ */
+function union(options, message2) {
+	return {
+		kind: "schema",
+		type: "union",
+		reference: union,
+		expects: /* @__PURE__ */ _joinExpects(options.map((option) => option.expects), "|"),
+		async: false,
+		options,
+		message: message2,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config2) {
+			let validDataset;
+			let typedDatasets;
+			let untypedDatasets;
+			for (const schema of this.options) {
+				const optionDataset = schema["~run"]({ value: dataset.value }, config2);
+				if (optionDataset.typed) if (optionDataset.issues) if (typedDatasets) typedDatasets.push(optionDataset);
+				else typedDatasets = [optionDataset];
+				else {
+					validDataset = optionDataset;
+					break;
+				}
+				else if (untypedDatasets) untypedDatasets.push(optionDataset);
+				else untypedDatasets = [optionDataset];
+			}
+			if (validDataset) return validDataset;
+			if (typedDatasets) {
+				if (typedDatasets.length === 1) return typedDatasets[0];
+				_addIssue(this, "type", dataset, config2, { issues: /* @__PURE__ */ _subIssues(typedDatasets) });
+				dataset.typed = true;
+			} else if (untypedDatasets?.length === 1) return untypedDatasets[0];
+			else _addIssue(this, "type", dataset, config2, { issues: /* @__PURE__ */ _subIssues(untypedDatasets) });
+			return dataset;
+		}
+	};
+}
+function parse(schema, input, config2) {
+	const dataset = schema["~run"]({ value: input }, /* @__PURE__ */ getGlobalConfig(config2));
+	if (dataset.issues) throw new ValiError(dataset.issues);
+	return dataset.value;
+}
+/* @__NO_SIDE_EFFECTS__ */
+function pipe(...pipe2) {
+	return {
+		...pipe2[0],
+		pipe: pipe2,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config2) {
+			for (const item of pipe2) if (item.kind !== "metadata") {
+				if (dataset.issues && (item.kind === "schema" || item.kind === "transformation")) {
+					dataset.typed = false;
+					break;
+				}
+				if (!dataset.issues || !config2.abortEarly && !config2.abortPipeEarly) dataset = item["~run"](dataset, config2);
+			}
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function safeParse(schema, input, config2) {
+	const dataset = schema["~run"]({ value: input }, /* @__PURE__ */ getGlobalConfig(config2));
+	return {
+		typed: dataset.typed,
+		success: !dataset.issues,
+		output: dataset.value,
+		issues: dataset.issues
+	};
+}
+const modelNameSchema = /* @__PURE__ */ pipe(/* @__PURE__ */ string(), /* @__PURE__ */ minLength(1, "Model name cannot be empty"), /* @__PURE__ */ brand("ModelName"));
+const sessionIdSchema = /* @__PURE__ */ pipe(/* @__PURE__ */ string(), /* @__PURE__ */ minLength(1, "Session ID cannot be empty"), /* @__PURE__ */ brand("SessionId"));
+const requestIdSchema = /* @__PURE__ */ pipe(/* @__PURE__ */ string(), /* @__PURE__ */ minLength(1, "Request ID cannot be empty"), /* @__PURE__ */ brand("RequestId"));
+const messageIdSchema = /* @__PURE__ */ pipe(/* @__PURE__ */ string(), /* @__PURE__ */ minLength(1, "Message ID cannot be empty"), /* @__PURE__ */ brand("MessageId"));
+const isoTimestampSchema = /* @__PURE__ */ pipe(/* @__PURE__ */ string(), /* @__PURE__ */ regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z$/, "Invalid ISO timestamp"), /* @__PURE__ */ brand("ISOTimestamp"));
+const yyyymmddRegex = /^\d{4}-\d{2}-\d{2}$/;
+const dailyDateSchema = /* @__PURE__ */ pipe(/* @__PURE__ */ string(), /* @__PURE__ */ regex(yyyymmddRegex, "Date must be in YYYY-MM-DD format"), /* @__PURE__ */ brand("DailyDate"));
+const activityDateSchema = /* @__PURE__ */ pipe(/* @__PURE__ */ string(), /* @__PURE__ */ regex(yyyymmddRegex, "Date must be in YYYY-MM-DD format"), /* @__PURE__ */ brand("ActivityDate"));
+const monthlyDateSchema = /* @__PURE__ */ pipe(/* @__PURE__ */ string(), /* @__PURE__ */ regex(/^\d{4}-\d{2}$/, "Date must be in YYYY-MM format"), /* @__PURE__ */ brand("MonthlyDate"));
+const weeklyDateSchema = /* @__PURE__ */ pipe(/* @__PURE__ */ string(), /* @__PURE__ */ regex(yyyymmddRegex, "Date must be in YYYY-MM-DD format"), /* @__PURE__ */ brand("WeeklyDate"));
+const filterDateSchema = /* @__PURE__ */ pipe(/* @__PURE__ */ string(), /* @__PURE__ */ regex(/^\d{8}$/, "Date must be in YYYYMMDD format"), /* @__PURE__ */ brand("FilterDate"));
+const projectPathSchema = /* @__PURE__ */ pipe(/* @__PURE__ */ string(), /* @__PURE__ */ minLength(1, "Project path cannot be empty"), /* @__PURE__ */ brand("ProjectPath"));
+const versionSchema = /* @__PURE__ */ pipe(/* @__PURE__ */ string(), /* @__PURE__ */ regex(/^\d+\.\d+\.\d+/, "Invalid version format"), /* @__PURE__ */ brand("Version"));
+const createSessionId = (value) => parse(sessionIdSchema, value);
+const createDailyDate = (value) => parse(dailyDateSchema, value);
+const createMonthlyDate = (value) => parse(monthlyDateSchema, value);
+const createWeeklyDate = (value) => parse(weeklyDateSchema, value);
+const createProjectPath = (value) => parse(projectPathSchema, value);
+function createBucket(value) {
+	const weeklyResult = /* @__PURE__ */ safeParse(weeklyDateSchema, value);
+	if (weeklyResult.success) return weeklyResult.output;
+	return createMonthlyDate(value);
+}
+const CostModes = [
+	"auto",
+	"calculate",
+	"display"
+];
+const SortOrders = ["desc", "asc"];
+const statuslineHookJsonSchema = /* @__PURE__ */ object({
+	session_id: /* @__PURE__ */ string(),
+	transcript_path: /* @__PURE__ */ string(),
+	cwd: /* @__PURE__ */ string(),
+	model: /* @__PURE__ */ object({
+		id: /* @__PURE__ */ string(),
+		display_name: /* @__PURE__ */ string()
+	}),
+	workspace: /* @__PURE__ */ object({
+		current_dir: /* @__PURE__ */ string(),
+		project_dir: /* @__PURE__ */ string()
+	}),
+	version: /* @__PURE__ */ optional(/* @__PURE__ */ string()),
+	cost: /* @__PURE__ */ optional(/* @__PURE__ */ object({
+		total_cost_usd: /* @__PURE__ */ number(),
+		total_duration_ms: /* @__PURE__ */ optional(/* @__PURE__ */ number()),
+		total_api_duration_ms: /* @__PURE__ */ optional(/* @__PURE__ */ number()),
+		total_lines_added: /* @__PURE__ */ optional(/* @__PURE__ */ number()),
+		total_lines_removed: /* @__PURE__ */ optional(/* @__PURE__ */ number())
+	})),
+	context_window: /* @__PURE__ */ optional(/* @__PURE__ */ object({
+		total_input_tokens: /* @__PURE__ */ number(),
+		total_output_tokens: /* @__PURE__ */ optional(/* @__PURE__ */ number()),
+		context_window_size: /* @__PURE__ */ number()
+	}))
+});
+export { object as A, boolean as C, maxValue as D, integer as E, string as F, transform as I, trim as L, parse as M, pipe as N, minValue as O, safeParse as P, union as R, array as S, flatten as T, requestIdSchema as _, createDailyDate as a, versionSchema as b, createSessionId as c, filterDateSchema as d, isoTimestampSchema as f, projectPathSchema as g, monthlyDateSchema as h, createBucket as i, optional as j, number as k, createWeeklyDate as l, modelNameSchema as m, SortOrders as n, createMonthlyDate as o, messageIdSchema as p, activityDateSchema as r, createProjectPath as s, CostModes as t, dailyDateSchema as u, sessionIdSchema as v, check as w, weeklyDateSchema as x, statuslineHookJsonSchema as y, getTotalTokens as z };

package/dist/calculate-cost-CKH-OC_c.js

@@ -0,0 +1,23 @@
+import { z as getTotalTokens } from "./_types-BFL_bTNX.js";
+function calculateTotals(data) {
+	return data.reduce((acc, item) => ({
+		inputTokens: acc.inputTokens + item.inputTokens,
+		outputTokens: acc.outputTokens + item.outputTokens,
+		cacheCreationTokens: acc.cacheCreationTokens + item.cacheCreationTokens,
+		cacheReadTokens: acc.cacheReadTokens + item.cacheReadTokens,
+		totalCost: acc.totalCost + item.totalCost
+	}), {
+		inputTokens: 0,
+		outputTokens: 0,
+		cacheCreationTokens: 0,
+		cacheReadTokens: 0,
+		totalCost: 0
+	});
+}
+function createTotalsObject(totals) {
+	return {
+		...totals,
+		totalTokens: getTotalTokens(totals)
+	};
+}
+export { createTotalsObject as n, calculateTotals as t };

package/dist/calculate-cost.d.ts

@@ -0,0 +1,74 @@
+import { c as SessionUsage, n as DailyUsage, s as MonthlyUsage, u as WeeklyUsage } from "./data-loader-0-AaQB5-.js";
+
+//#region src/_token-utils.d.ts
+
+/**
+ * @fileoverview Token calculation utilities
+ *
+ * This module provides shared utilities for calculating token totals
+ * across different token types. Used throughout the application to
+ * ensure consistent token counting logic.
+ */
+/**
+ * Token counts structure for raw usage data (uses InputTokens suffix)
+ */
+type TokenCounts = {
+  inputTokens: number;
+  outputTokens: number;
+  cacheCreationInputTokens: number;
+  cacheReadInputTokens: number;
+};
+/**
+ * Token counts structure for aggregated data (uses shorter names)
+ */
+type AggregatedTokenCounts = {
+  inputTokens: number;
+  outputTokens: number;
+  cacheCreationTokens: number;
+  cacheReadTokens: number;
+};
+/**
+ * Union type that supports both token count formats
+ */
+type AnyTokenCounts = TokenCounts | AggregatedTokenCounts;
+/**
+ * Calculates the total number of tokens across all token types
+ * Supports both raw usage data format and aggregated data format
+ * @param tokenCounts - Object containing counts for each token type
+ * @returns Total number of tokens
+ */
+declare function getTotalTokens(tokenCounts: AnyTokenCounts): number;
+//#endregion
+//#region src/calculate-cost.d.ts
+
+/**
+ * Alias for AggregatedTokenCounts from shared utilities
+ * @deprecated Use AggregatedTokenCounts from _token-utils.ts instead
+ */
+type TokenData = AggregatedTokenCounts;
+/**
+ * Token totals including cost information
+ */
+type TokenTotals = TokenData & {
+  totalCost: number;
+};
+/**
+ * Complete totals object with token counts, cost, and total token sum
+ */
+type TotalsObject = TokenTotals & {
+  totalTokens: number;
+};
+/**
+ * Calculates total token usage and cost across multiple usage data entries
+ * @param data - Array of daily, monthly, or session usage data
+ * @returns Aggregated token totals and cost
+ */
+declare function calculateTotals(data: Array<DailyUsage | MonthlyUsage | WeeklyUsage | SessionUsage>): TokenTotals;
+/**
+ * Creates a complete totals object by adding total token count to existing totals
+ * @param totals - Token totals with cost information
+ * @returns Complete totals object including total token sum
+ */
+declare function createTotalsObject(totals: TokenTotals): TotalsObject;
+//#endregion
+export { calculateTotals, createTotalsObject, getTotalTokens };

package/dist/calculate-cost.js

@@ -0,0 +1,3 @@
+import { z as getTotalTokens } from "./_types-BFL_bTNX.js";
+import { n as createTotalsObject, t as calculateTotals } from "./calculate-cost-CKH-OC_c.js";
+export { calculateTotals, createTotalsObject, getTotalTokens };