ccusage 0.3.1 → 0.3.2

package/dist/calculate-cost.d.ts

@@ -1,5 +1,4 @@
-import { DailyUsage, SessionUsage } from "./data-loader-Ds_vUoR2.js";
-import "valibot";
+import { DailyUsage, SessionUsage } from "./data-loader-ToqWI8hT.js";
 
 //#region types.d.ts
 

package/dist/{data-loader-Dh4y6ICb.js → data-loader-D64xoJ7s.js}

@@ -3,7 +3,6 @@ import { readFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import path from "node:path";
 import path$1, { posix } from "path";
-import * as v from "valibot";
 
 //#region rolldown:runtime
 var __create = Object.create;
@@ -510,13 +509,13 @@ var require_walker = __commonJS({ "node_modules/fdir/dist/api/walker.js"(exports
 		if (k2 === void 0) k2 = k;
 		o[k2] = m[k];
 	});
-	var __setModuleDefault = void 0 && (void 0).__setModuleDefault || (Object.create ? function(o, v$1) {
+	var __setModuleDefault = void 0 && (void 0).__setModuleDefault || (Object.create ? function(o, v) {
 		Object.defineProperty(o, "default", {
 			enumerable: true,
-			value: v$1
+			value: v
 		});
-	} : function(o, v$1) {
-		o["default"] = v$1;
+	} : function(o, v) {
+		o["default"] = v;
 	});
 	var __importStar = void 0 && (void 0).__importStar || function() {
 		var ownKeys = function(o) {
@@ -1218,7 +1217,7 @@ var require_parse = __commonJS({ "node_modules/picomatch/lib/parse.js"(exports,
 		try {
 			new RegExp(value);
 		} catch (ex) {
-			return args.map((v$1) => utils$2.escapeRegex(v$1)).join("..");
+			return args.map((v) => utils$2.escapeRegex(v)).join("..");
 		}
 		return value;
 	};
@@ -2109,9 +2108,9 @@ var require_picomatch$1 = __commonJS({ "node_modules/picomatch/lib/picomatch.js"
 		if (glob$1 === "" || typeof glob$1 !== "string" && !isState) throw new TypeError("Expected pattern to be a non-empty string");
 		const opts = options || {};
 		const posix$1 = opts.windows;
-		const regex = isState ? picomatch$2.compileRe(glob$1, options) : picomatch$2.makeRe(glob$1, options, false, true);
-		const state = regex.state;
-		delete regex.state;
+		const regex$1 = isState ? picomatch$2.compileRe(glob$1, options) : picomatch$2.makeRe(glob$1, options, false, true);
+		const state = regex$1.state;
+		delete regex$1.state;
 		let isIgnored = () => false;
 		if (opts.ignore) {
 			const ignoreOpts = {
@@ -2123,14 +2122,14 @@ var require_picomatch$1 = __commonJS({ "node_modules/picomatch/lib/picomatch.js"
 			isIgnored = picomatch$2(opts.ignore, ignoreOpts, returnState);
 		}
 		const matcher = (input, returnObject = false) => {
-			const { isMatch, match, output } = picomatch$2.test(input, regex, options, {
+			const { isMatch, match, output } = picomatch$2.test(input, regex$1, options, {
 				glob: glob$1,
 				posix: posix$1
 			});
 			const result = {
 				glob: glob$1,
 				state,
-				regex,
+				regex: regex$1,
 				posix: posix$1,
 				input,
 				output,
@@ -2169,7 +2168,7 @@ var require_picomatch$1 = __commonJS({ "node_modules/picomatch/lib/picomatch.js"
 	* @return {Object} Returns an object with matching info.
 	* @api public
 	*/
-	picomatch$2.test = (input, regex, options, { glob: glob$1, posix: posix$1 } = {}) => {
+	picomatch$2.test = (input, regex$1, options, { glob: glob$1, posix: posix$1 } = {}) => {
 		if (typeof input !== "string") throw new TypeError("Expected input to be a string");
 		if (input === "") return {
 			isMatch: false,
@@ -2183,8 +2182,8 @@ var require_picomatch$1 = __commonJS({ "node_modules/picomatch/lib/picomatch.js"
 			output = format ? format(input) : input;
 			match = output === glob$1;
 		}
-		if (match === false || opts.capture === true) if (opts.matchBase === true || opts.basename === true) match = picomatch$2.matchBase(input, regex, options, posix$1);
-		else match = regex.exec(output);
+		if (match === false || opts.capture === true) if (opts.matchBase === true || opts.basename === true) match = picomatch$2.matchBase(input, regex$1, options, posix$1);
+		else match = regex$1.exec(output);
 		return {
 			isMatch: Boolean(match),
 			match,
@@ -2205,8 +2204,8 @@ var require_picomatch$1 = __commonJS({ "node_modules/picomatch/lib/picomatch.js"
 	* @api public
 	*/
 	picomatch$2.matchBase = (input, glob$1, options) => {
-		const regex = glob$1 instanceof RegExp ? glob$1 : picomatch$2.makeRe(glob$1, options);
-		return regex.test(utils$1.basename(input));
+		const regex$1 = glob$1 instanceof RegExp ? glob$1 : picomatch$2.makeRe(glob$1, options);
+		return regex$1.test(utils$1.basename(input));
 	};
 	/**
 	* Returns true if **any** of the given glob `patterns` match the specified `string`.
@@ -2290,9 +2289,9 @@ var require_picomatch$1 = __commonJS({ "node_modules/picomatch/lib/picomatch.js"
 		const append = opts.contains ? "" : "$";
 		let source = `${prepend}(?:${state.output})${append}`;
 		if (state && state.negated === true) source = `^(?!${source}).*$`;
-		const regex = picomatch$2.toRegex(source, options);
-		if (returnState === true) regex.state = state;
-		return regex;
+		const regex$1 = picomatch$2.toRegex(source, options);
+		if (returnState === true) regex$1.state = state;
+		return regex$1;
 	};
 	/**
 	* Create a regular expression from a parsed glob pattern.
@@ -2572,14 +2571,14 @@ function getPartialMatcher(patterns, options) {
 		if (inputParts[0] === ".." && ONLY_PARENT_DIRECTORIES.test(input)) return true;
 		for (let i = 0; i < patterns.length; i++) {
 			const patternParts = patternsParts[i];
-			const regex = regexes[i];
+			const regex$1 = regexes[i];
 			const inputPatternCount = inputParts.length;
 			const minParts = Math.min(inputPatternCount, patternParts.length);
 			let j = 0;
 			while (j < minParts) {
 				const part = patternParts[j];
 				if (part.includes("/")) return true;
-				const match = regex[j].test(inputParts[j]);
+				const match = regex$1[j].test(inputParts[j]);
 				if (!match) break;
 				if (part === "**") return true;
 				j++;
@@ -2767,36 +2766,432 @@ async function glob(patternsOrOptions, options) {
 	return crawl(opts, cwd, false);
 }
 
+//#endregion
+//#region node_modules/valibot/dist/index.js
+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 _isValidObjectKey(object2, key) {
+	return Object.hasOwn(object2, key) && key !== "__proto__" && key !== "prototype" && key !== "constructor";
+}
+/* @__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 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 getFallback(schema, dataset, config2) {
+	return typeof schema.fallback === "function" ? schema.fallback(dataset, config2) : schema.fallback;
+}
+/* @__NO_SIDE_EFFECTS__ */
+function getDefault(schema, dataset, config2) {
+	return typeof schema.default === "function" ? schema.default(dataset, config2) : schema.default;
+}
+/* @__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 record(key, value2, message2) {
+	return {
+		kind: "schema",
+		type: "record",
+		reference: record,
+		expects: "Object",
+		async: false,
+		key,
+		value: value2,
+		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 entryKey in input) if (/* @__PURE__ */ _isValidObjectKey(input, entryKey)) {
+					const entryValue = input[entryKey];
+					const keyDataset = this.key["~run"]({ value: entryKey }, config2);
+					if (keyDataset.issues) {
+						const pathItem = {
+							type: "object",
+							origin: "key",
+							input,
+							key: entryKey,
+							value: entryValue
+						};
+						for (const issue of keyDataset.issues) {
+							issue.path = [pathItem];
+							dataset.issues?.push(issue);
+						}
+						if (!dataset.issues) dataset.issues = keyDataset.issues;
+						if (config2.abortEarly) {
+							dataset.typed = false;
+							break;
+						}
+					}
+					const valueDataset = this.value["~run"]({ value: entryValue }, config2);
+					if (valueDataset.issues) {
+						const pathItem = {
+							type: "object",
+							origin: "value",
+							input,
+							key: entryKey,
+							value: entryValue
+						};
+						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 (!keyDataset.typed || !valueDataset.typed) dataset.typed = false;
+					if (keyDataset.typed) dataset.value[keyDataset.value] = valueDataset.value;
+				}
+			} else _addIssue(this, "type", dataset, config2);
+			return dataset;
+		}
+	};
+}
+/* @__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;
+		}
+	};
+}
+/* @__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
+	};
+}
+
 //#endregion
 //#region data-loader.ts
 const getDefaultClaudePath = () => path.join(homedir(), ".claude");
-const UsageDataSchema = v.object({
-	timestamp: v.string(),
-	message: v.object({ usage: v.object({
-		input_tokens: v.number(),
-		output_tokens: v.number(),
-		cache_creation_input_tokens: v.optional(v.number()),
-		cache_read_input_tokens: v.optional(v.number())
+const UsageDataSchema = object({
+	timestamp: string(),
+	message: object({ usage: object({
+		input_tokens: number(),
+		output_tokens: number(),
+		cache_creation_input_tokens: optional(number()),
+		cache_read_input_tokens: optional(number())
 	}) }),
-	costUSD: v.number()
+	costUSD: number()
 });
-const DailyUsageSchema = v.object({
-	date: v.string(),
-	inputTokens: v.number(),
-	outputTokens: v.number(),
-	cacheCreationTokens: v.number(),
-	cacheReadTokens: v.number(),
-	totalCost: v.number()
+const DailyUsageSchema = object({
+	date: string(),
+	inputTokens: number(),
+	outputTokens: number(),
+	cacheCreationTokens: number(),
+	cacheReadTokens: number(),
+	totalCost: number()
 });
-const SessionUsageSchema = v.object({
-	sessionId: v.string(),
-	projectPath: v.string(),
-	inputTokens: v.number(),
-	outputTokens: v.number(),
-	cacheCreationTokens: v.number(),
-	cacheReadTokens: v.number(),
-	totalCost: v.number(),
-	lastActivity: v.string()
+const SessionUsageSchema = object({
+	sessionId: string(),
+	projectPath: string(),
+	inputTokens: number(),
+	outputTokens: number(),
+	cacheCreationTokens: number(),
+	cacheReadTokens: number(),
+	totalCost: number(),
+	lastActivity: string()
 });
 const formatDate = (dateStr) => {
 	const date = new Date(dateStr);
@@ -2819,7 +3214,7 @@ async function loadUsageData(options) {
 		const lines = content.trim().split("\n").filter((line) => line.length > 0);
 		for (const line of lines) try {
 			const parsed = JSON.parse(line);
-			const result = v.safeParse(UsageDataSchema, parsed);
+			const result = safeParse(UsageDataSchema, parsed);
 			if (!result.success) continue;
 			const data = result.output;
 			const date = formatDate(data.timestamp);
@@ -2867,7 +3262,7 @@ async function loadSessionData(options) {
 		let lastTimestamp = "";
 		for (const line of lines) try {
 			const parsed = JSON.parse(line);
-			const result = v.safeParse(UsageDataSchema, parsed);
+			const result = safeParse(UsageDataSchema, parsed);
 			if (!result.success) continue;
 			const data = result.output;
 			const key = `${projectPath}/${sessionId}`;
@@ -2904,4 +3299,4 @@ async function loadSessionData(options) {
 }
 
 //#endregion
-export { DailyUsageSchema, SessionUsageSchema, UsageDataSchema, __commonJS, __require, __toESM, formatDate, getDefaultClaudePath, loadSessionData, loadUsageData };
+export { DailyUsageSchema, SessionUsageSchema, UsageDataSchema, __commonJS, __require, __toESM, boolean, formatDate, getDefaultClaudePath, loadSessionData, loadUsageData, number, object, optional, pipe, record, regex, safeParse, string, union };