@settlemint/sdk-utils 2.3.2-pr6cb5dd2e → 2.3.2-pr74f654b5

package/dist/index.d.ts

@@ -1,122 +1,4 @@
-/**
- * Attempts to parse a JSON string into a typed value, returning a default value if parsing fails.
- *
- * @param value - The JSON string to parse
- * @param defaultValue - The value to return if parsing fails or results in null/undefined
- * @returns The parsed JSON value as type T, or the default value if parsing fails
- *
- * @example
- * import { tryParseJson } from "@settlemint/sdk-utils";
- *
- * const config = tryParseJson<{ port: number }>(
- *   '{"port": 3000}',
- *   { port: 8080 }
- * );
- * // Returns: { port: 3000 }
- *
- * const invalid = tryParseJson<string[]>(
- *   'invalid json',
- *   []
- * );
- * // Returns: []
- */
-declare function tryParseJson<T>(value: string, defaultValue?: T | null): T | null;
-/**
- * Extracts a JSON object from a string.
- *
- * @param value - The string to extract the JSON object from
- * @returns The parsed JSON object, or null if no JSON object is found
- * @throws {Error} If the input string is too long (longer than 5000 characters)
- * @example
- * import { extractJsonObject } from "@settlemint/sdk-utils";
- *
- * const json = extractJsonObject<{ port: number }>(
- *   'port info: {"port": 3000}',
- * );
- * // Returns: { port: 3000 }
- */
-declare function extractJsonObject<T>(value: string): T | null;
-/**
- * Converts a value to a JSON stringifiable format.
- *
- * @param value - The value to convert
- * @returns The JSON stringifiable value
- *
- * @example
- * import { makeJsonStringifiable } from "@settlemint/sdk-utils";
- *
- * const json = makeJsonStringifiable<{ amount: bigint }>({ amount: BigInt(1000) });
- * // Returns: '{"amount":"1000"}'
- */
-declare function makeJsonStringifiable<T>(value: unknown): T;
-
-/**
- * Retry a function when it fails.
- * @param fn - The function to retry.
- * @param maxRetries - The maximum number of retries.
- * @param initialSleepTime - The initial time to sleep between exponential backoff retries.
- * @param stopOnError - The function to stop on error.
- * @returns The result of the function or undefined if it fails.
- * @example
- * import { retryWhenFailed } from "@settlemint/sdk-utils";
- * import { readFile } from "node:fs/promises";
- *
- * const result = await retryWhenFailed(() => readFile("/path/to/file.txt"), 3, 1_000);
- */
-declare function retryWhenFailed<T>(fn: () => Promise<T>, maxRetries?: number, initialSleepTime?: number, stopOnError?: (error: Error) => boolean): Promise<T>;
-
-/**
- * Capitalizes the first letter of a string.
- *
- * @param val - The string to capitalize
- * @returns The input string with its first letter capitalized
- *
- * @example
- * import { capitalizeFirstLetter } from "@settlemint/sdk-utils";
- *
- * const capitalized = capitalizeFirstLetter("hello");
- * // Returns: "Hello"
- */
-declare function capitalizeFirstLetter(val: string): string;
-/**
- * Converts a camelCase string to a human-readable string.
- *
- * @param s - The camelCase string to convert
- * @returns The human-readable string
- *
- * @example
- * import { camelCaseToWords } from "@settlemint/sdk-utils";
- *
- * const words = camelCaseToWords("camelCaseString");
- * // Returns: "Camel Case String"
- */
-declare function camelCaseToWords(s: string): string;
-/**
- * Replaces underscores and hyphens with spaces.
- *
- * @param s - The string to replace underscores and hyphens with spaces
- * @returns The input string with underscores and hyphens replaced with spaces
- *
- * @example
- * import { replaceUnderscoresAndHyphensWithSpaces } from "@settlemint/sdk-utils";
- *
- * const result = replaceUnderscoresAndHyphensWithSpaces("Already_Spaced-Second");
- * // Returns: "Already Spaced Second"
- */
-declare function replaceUnderscoresAndHyphensWithSpaces(s: string): string;
-/**
- * Truncates a string to a maximum length and appends "..." if it is longer.
- *
- * @param value - The string to truncate
- * @param maxLength - The maximum length of the string
- * @returns The truncated string or the original string if it is shorter than the maximum length
- *
- * @example
- * import { truncate } from "@settlemint/sdk-utils";
- *
- * const truncated = truncate("Hello, world!", 10);
- * // Returns: "Hello, wor..."
- */
-declare function truncate(value: string, maxLength: number): string;
-
-export { camelCaseToWords, capitalizeFirstLetter, extractJsonObject, makeJsonStringifiable, replaceUnderscoresAndHyphensWithSpaces, retryWhenFailed, truncate, tryParseJson };
+export * from "./json.js";
+export * from "./retry.js";
+export * from "./string.js";
+export * from "./url.js";

package/dist/index.js

@@ -0,0 +1,7 @@
+export * from "./json.js"
+
+export * from "./retry.js"
+
+export * from "./string.js"
+
+export * from "./url.js"

package/dist/json.cjs

@@ -0,0 +1,83 @@
+
+//#region src/json.ts
+/**
+* Attempts to parse a JSON string into a typed value, returning a default value if parsing fails.
+*
+* @param value - The JSON string to parse
+* @param defaultValue - The value to return if parsing fails or results in null/undefined
+* @returns The parsed JSON value as type T, or the default value if parsing fails
+*
+* @example
+* import { tryParseJson } from "@settlemint/sdk-utils";
+*
+* const config = tryParseJson<{ port: number }>(
+*   '{"port": 3000}',
+*   { port: 8080 }
+* );
+* // Returns: { port: 3000 }
+*
+* const invalid = tryParseJson<string[]>(
+*   'invalid json',
+*   []
+* );
+* // Returns: []
+*/
+function tryParseJson(value, defaultValue = null) {
+	try {
+		const parsed = JSON.parse(value);
+		if (parsed === undefined || parsed === null) {
+			return defaultValue;
+		}
+		return parsed;
+	} catch (err) {
+		return defaultValue;
+	}
+}
+/**
+* Extracts a JSON object from a string.
+*
+* @param value - The string to extract the JSON object from
+* @returns The parsed JSON object, or null if no JSON object is found
+* @throws {Error} If the input string is too long (longer than 5000 characters)
+* @example
+* import { extractJsonObject } from "@settlemint/sdk-utils";
+*
+* const json = extractJsonObject<{ port: number }>(
+*   'port info: {"port": 3000}',
+* );
+* // Returns: { port: 3000 }
+*/
+function extractJsonObject(value) {
+	if (value.length > 5e3) {
+		throw new Error("Input too long");
+	}
+	const result = /\{([\s\S]*)\}/.exec(value);
+	if (!result) {
+		return null;
+	}
+	return tryParseJson(result[0]);
+}
+/**
+* Converts a value to a JSON stringifiable format.
+*
+* @param value - The value to convert
+* @returns The JSON stringifiable value
+*
+* @example
+* import { makeJsonStringifiable } from "@settlemint/sdk-utils";
+*
+* const json = makeJsonStringifiable<{ amount: bigint }>({ amount: BigInt(1000) });
+* // Returns: '{"amount":"1000"}'
+*/
+function makeJsonStringifiable(value) {
+	if (value === undefined || value === null) {
+		return value;
+	}
+	return tryParseJson(JSON.stringify(value, (_, value$1) => typeof value$1 === "bigint" ? value$1.toString() : value$1));
+}
+
+//#endregion
+exports.extractJsonObject = extractJsonObject;
+exports.makeJsonStringifiable = makeJsonStringifiable;
+exports.tryParseJson = tryParseJson;
+//# sourceMappingURL=json.cjs.map

package/dist/json.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.cjs","names":["value: string","defaultValue: T | null","value: unknown","value"],"sources":["../src/json.ts"],"sourcesContent":["/**\n * Attempts to parse a JSON string into a typed value, returning a default value if parsing fails.\n *\n * @param value - The JSON string to parse\n * @param defaultValue - The value to return if parsing fails or results in null/undefined\n * @returns The parsed JSON value as type T, or the default value if parsing fails\n *\n * @example\n * import { tryParseJson } from \"@settlemint/sdk-utils\";\n *\n * const config = tryParseJson<{ port: number }>(\n *   '{\"port\": 3000}',\n *   { port: 8080 }\n * );\n * // Returns: { port: 3000 }\n *\n * const invalid = tryParseJson<string[]>(\n *   'invalid json',\n *   []\n * );\n * // Returns: []\n */\nexport function tryParseJson<T>(value: string, defaultValue: T | null = null): T | null {\n  try {\n    const parsed = JSON.parse(value) as T;\n    if (parsed === undefined || parsed === null) {\n      return defaultValue;\n    }\n    return parsed;\n  } catch (err) {\n    // Invalid json\n    return defaultValue;\n  }\n}\n\n/**\n * Extracts a JSON object from a string.\n *\n * @param value - The string to extract the JSON object from\n * @returns The parsed JSON object, or null if no JSON object is found\n * @throws {Error} If the input string is too long (longer than 5000 characters)\n * @example\n * import { extractJsonObject } from \"@settlemint/sdk-utils\";\n *\n * const json = extractJsonObject<{ port: number }>(\n *   'port info: {\"port\": 3000}',\n * );\n * // Returns: { port: 3000 }\n */\nexport function extractJsonObject<T>(value: string): T | null {\n  if (value.length > 5000) {\n    throw new Error(\"Input too long\");\n  }\n  const result = /\\{([\\s\\S]*)\\}/.exec(value);\n  if (!result) {\n    return null;\n  }\n  return tryParseJson<T>(result[0]);\n}\n\n/**\n * Converts a value to a JSON stringifiable format.\n *\n * @param value - The value to convert\n * @returns The JSON stringifiable value\n *\n * @example\n * import { makeJsonStringifiable } from \"@settlemint/sdk-utils\";\n *\n * const json = makeJsonStringifiable<{ amount: bigint }>({ amount: BigInt(1000) });\n * // Returns: '{\"amount\":\"1000\"}'\n */\nexport function makeJsonStringifiable<T>(value: unknown): T {\n  if (value === undefined || value === null) {\n    return value as T;\n  }\n  return tryParseJson<T>(\n    JSON.stringify(\n      value,\n      (_, value) => (typeof value === \"bigint\" ? value.toString() : value), // return everything else unchanged\n    ),\n  ) as T;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAsBA,SAAgB,aAAgBA,OAAeC,eAAyB,MAAgB;AACtF,KAAI;EACF,MAAM,SAAS,KAAK,MAAM,MAAM;AAChC,MAAI,WAAW,aAAa,WAAW,MAAM;AAC3C,UAAO;EACR;AACD,SAAO;CACR,SAAQ,KAAK;AAEZ,SAAO;CACR;AACF;;;;;;;;;;;;;;;AAgBD,SAAgB,kBAAqBD,OAAyB;AAC5D,KAAI,MAAM,SAAS,KAAM;AACvB,QAAM,IAAI,MAAM;CACjB;CACD,MAAM,SAAS,gBAAgB,KAAK,MAAM;AAC1C,MAAK,QAAQ;AACX,SAAO;CACR;AACD,QAAO,aAAgB,OAAO,GAAG;AAClC;;;;;;;;;;;;;AAcD,SAAgB,sBAAyBE,OAAmB;AAC1D,KAAI,UAAU,aAAa,UAAU,MAAM;AACzC,SAAO;CACR;AACD,QAAO,aACL,KAAK,UACH,OACA,CAAC,GAAGC,mBAAkBA,YAAU,WAAW,QAAM,UAAU,GAAGA,QAC/D,CACF;AACF"}

package/dist/json.d.cts

@@ -0,0 +1,56 @@
+//#region src/json.d.ts
+/**
+ * Attempts to parse a JSON string into a typed value, returning a default value if parsing fails.
+ *
+ * @param value - The JSON string to parse
+ * @param defaultValue - The value to return if parsing fails or results in null/undefined
+ * @returns The parsed JSON value as type T, or the default value if parsing fails
+ *
+ * @example
+ * import { tryParseJson } from "@settlemint/sdk-utils";
+ *
+ * const config = tryParseJson<{ port: number }>(
+ *   '{"port": 3000}',
+ *   { port: 8080 }
+ * );
+ * // Returns: { port: 3000 }
+ *
+ * const invalid = tryParseJson<string[]>(
+ *   'invalid json',
+ *   []
+ * );
+ * // Returns: []
+ */
+declare function tryParseJson<T>(value: string, defaultValue?: T | null): T | null;
+/**
+ * Extracts a JSON object from a string.
+ *
+ * @param value - The string to extract the JSON object from
+ * @returns The parsed JSON object, or null if no JSON object is found
+ * @throws {Error} If the input string is too long (longer than 5000 characters)
+ * @example
+ * import { extractJsonObject } from "@settlemint/sdk-utils";
+ *
+ * const json = extractJsonObject<{ port: number }>(
+ *   'port info: {"port": 3000}',
+ * );
+ * // Returns: { port: 3000 }
+ */
+declare function extractJsonObject<T>(value: string): T | null;
+/**
+ * Converts a value to a JSON stringifiable format.
+ *
+ * @param value - The value to convert
+ * @returns The JSON stringifiable value
+ *
+ * @example
+ * import { makeJsonStringifiable } from "@settlemint/sdk-utils";
+ *
+ * const json = makeJsonStringifiable<{ amount: bigint }>({ amount: BigInt(1000) });
+ * // Returns: '{"amount":"1000"}'
+ */
+declare function makeJsonStringifiable<T>(value: unknown): T;
+
+//#endregion
+export { extractJsonObject, makeJsonStringifiable, tryParseJson };
+//# sourceMappingURL=json.d.cts.map

package/dist/json.d.ts

@@ -0,0 +1,56 @@
+//#region src/json.d.ts
+/**
+ * Attempts to parse a JSON string into a typed value, returning a default value if parsing fails.
+ *
+ * @param value - The JSON string to parse
+ * @param defaultValue - The value to return if parsing fails or results in null/undefined
+ * @returns The parsed JSON value as type T, or the default value if parsing fails
+ *
+ * @example
+ * import { tryParseJson } from "@settlemint/sdk-utils";
+ *
+ * const config = tryParseJson<{ port: number }>(
+ *   '{"port": 3000}',
+ *   { port: 8080 }
+ * );
+ * // Returns: { port: 3000 }
+ *
+ * const invalid = tryParseJson<string[]>(
+ *   'invalid json',
+ *   []
+ * );
+ * // Returns: []
+ */
+declare function tryParseJson<T>(value: string, defaultValue?: T | null): T | null;
+/**
+ * Extracts a JSON object from a string.
+ *
+ * @param value - The string to extract the JSON object from
+ * @returns The parsed JSON object, or null if no JSON object is found
+ * @throws {Error} If the input string is too long (longer than 5000 characters)
+ * @example
+ * import { extractJsonObject } from "@settlemint/sdk-utils";
+ *
+ * const json = extractJsonObject<{ port: number }>(
+ *   'port info: {"port": 3000}',
+ * );
+ * // Returns: { port: 3000 }
+ */
+declare function extractJsonObject<T>(value: string): T | null;
+/**
+ * Converts a value to a JSON stringifiable format.
+ *
+ * @param value - The value to convert
+ * @returns The JSON stringifiable value
+ *
+ * @example
+ * import { makeJsonStringifiable } from "@settlemint/sdk-utils";
+ *
+ * const json = makeJsonStringifiable<{ amount: bigint }>({ amount: BigInt(1000) });
+ * // Returns: '{"amount":"1000"}'
+ */
+declare function makeJsonStringifiable<T>(value: unknown): T;
+
+//#endregion
+export { extractJsonObject, makeJsonStringifiable, tryParseJson };
+//# sourceMappingURL=json.d.ts.map

package/dist/json.js

@@ -0,0 +1,80 @@
+//#region src/json.ts
+/**
+* Attempts to parse a JSON string into a typed value, returning a default value if parsing fails.
+*
+* @param value - The JSON string to parse
+* @param defaultValue - The value to return if parsing fails or results in null/undefined
+* @returns The parsed JSON value as type T, or the default value if parsing fails
+*
+* @example
+* import { tryParseJson } from "@settlemint/sdk-utils";
+*
+* const config = tryParseJson<{ port: number }>(
+*   '{"port": 3000}',
+*   { port: 8080 }
+* );
+* // Returns: { port: 3000 }
+*
+* const invalid = tryParseJson<string[]>(
+*   'invalid json',
+*   []
+* );
+* // Returns: []
+*/
+function tryParseJson(value, defaultValue = null) {
+	try {
+		const parsed = JSON.parse(value);
+		if (parsed === undefined || parsed === null) {
+			return defaultValue;
+		}
+		return parsed;
+	} catch (err) {
+		return defaultValue;
+	}
+}
+/**
+* Extracts a JSON object from a string.
+*
+* @param value - The string to extract the JSON object from
+* @returns The parsed JSON object, or null if no JSON object is found
+* @throws {Error} If the input string is too long (longer than 5000 characters)
+* @example
+* import { extractJsonObject } from "@settlemint/sdk-utils";
+*
+* const json = extractJsonObject<{ port: number }>(
+*   'port info: {"port": 3000}',
+* );
+* // Returns: { port: 3000 }
+*/
+function extractJsonObject(value) {
+	if (value.length > 5e3) {
+		throw new Error("Input too long");
+	}
+	const result = /\{([\s\S]*)\}/.exec(value);
+	if (!result) {
+		return null;
+	}
+	return tryParseJson(result[0]);
+}
+/**
+* Converts a value to a JSON stringifiable format.
+*
+* @param value - The value to convert
+* @returns The JSON stringifiable value
+*
+* @example
+* import { makeJsonStringifiable } from "@settlemint/sdk-utils";
+*
+* const json = makeJsonStringifiable<{ amount: bigint }>({ amount: BigInt(1000) });
+* // Returns: '{"amount":"1000"}'
+*/
+function makeJsonStringifiable(value) {
+	if (value === undefined || value === null) {
+		return value;
+	}
+	return tryParseJson(JSON.stringify(value, (_, value$1) => typeof value$1 === "bigint" ? value$1.toString() : value$1));
+}
+
+//#endregion
+export { extractJsonObject, makeJsonStringifiable, tryParseJson };
+//# sourceMappingURL=json.js.map

package/dist/json.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.js","names":["value: string","defaultValue: T | null","value: unknown","value"],"sources":["../src/json.ts"],"sourcesContent":["/**\n * Attempts to parse a JSON string into a typed value, returning a default value if parsing fails.\n *\n * @param value - The JSON string to parse\n * @param defaultValue - The value to return if parsing fails or results in null/undefined\n * @returns The parsed JSON value as type T, or the default value if parsing fails\n *\n * @example\n * import { tryParseJson } from \"@settlemint/sdk-utils\";\n *\n * const config = tryParseJson<{ port: number }>(\n *   '{\"port\": 3000}',\n *   { port: 8080 }\n * );\n * // Returns: { port: 3000 }\n *\n * const invalid = tryParseJson<string[]>(\n *   'invalid json',\n *   []\n * );\n * // Returns: []\n */\nexport function tryParseJson<T>(value: string, defaultValue: T | null = null): T | null {\n  try {\n    const parsed = JSON.parse(value) as T;\n    if (parsed === undefined || parsed === null) {\n      return defaultValue;\n    }\n    return parsed;\n  } catch (err) {\n    // Invalid json\n    return defaultValue;\n  }\n}\n\n/**\n * Extracts a JSON object from a string.\n *\n * @param value - The string to extract the JSON object from\n * @returns The parsed JSON object, or null if no JSON object is found\n * @throws {Error} If the input string is too long (longer than 5000 characters)\n * @example\n * import { extractJsonObject } from \"@settlemint/sdk-utils\";\n *\n * const json = extractJsonObject<{ port: number }>(\n *   'port info: {\"port\": 3000}',\n * );\n * // Returns: { port: 3000 }\n */\nexport function extractJsonObject<T>(value: string): T | null {\n  if (value.length > 5000) {\n    throw new Error(\"Input too long\");\n  }\n  const result = /\\{([\\s\\S]*)\\}/.exec(value);\n  if (!result) {\n    return null;\n  }\n  return tryParseJson<T>(result[0]);\n}\n\n/**\n * Converts a value to a JSON stringifiable format.\n *\n * @param value - The value to convert\n * @returns The JSON stringifiable value\n *\n * @example\n * import { makeJsonStringifiable } from \"@settlemint/sdk-utils\";\n *\n * const json = makeJsonStringifiable<{ amount: bigint }>({ amount: BigInt(1000) });\n * // Returns: '{\"amount\":\"1000\"}'\n */\nexport function makeJsonStringifiable<T>(value: unknown): T {\n  if (value === undefined || value === null) {\n    return value as T;\n  }\n  return tryParseJson<T>(\n    JSON.stringify(\n      value,\n      (_, value) => (typeof value === \"bigint\" ? value.toString() : value), // return everything else unchanged\n    ),\n  ) as T;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAsBA,SAAgB,aAAgBA,OAAeC,eAAyB,MAAgB;AACtF,KAAI;EACF,MAAM,SAAS,KAAK,MAAM,MAAM;AAChC,MAAI,WAAW,aAAa,WAAW,MAAM;AAC3C,UAAO;EACR;AACD,SAAO;CACR,SAAQ,KAAK;AAEZ,SAAO;CACR;AACF;;;;;;;;;;;;;;;AAgBD,SAAgB,kBAAqBD,OAAyB;AAC5D,KAAI,MAAM,SAAS,KAAM;AACvB,QAAM,IAAI,MAAM;CACjB;CACD,MAAM,SAAS,gBAAgB,KAAK,MAAM;AAC1C,MAAK,QAAQ;AACX,SAAO;CACR;AACD,QAAO,aAAgB,OAAO,GAAG;AAClC;;;;;;;;;;;;;AAcD,SAAgB,sBAAyBE,OAAmB;AAC1D,KAAI,UAAU,aAAa,UAAU,MAAM;AACzC,SAAO;CACR;AACD,QAAO,aACL,KAAK,UACH,OACA,CAAC,GAAGC,mBAAkBA,YAAU,WAAW,QAAM,UAAU,GAAGA,QAC/D,CACF;AACF"}

package/dist/logging.cjs

@@ -1,152 +1,45 @@
-"use strict";
+//#region rolldown:runtime
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
 var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
 };
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
 
-// src/logging.ts
-var logging_exports = {};
-__export(logging_exports, {
-  createLogger: () => createLogger,
-  maskTokens: () => maskTokens,
-  requestLogger: () => requestLogger
-});
-module.exports = __toCommonJS(logging_exports);
-
-// src/logging/mask-tokens.ts
-var maskTokens = (output) => {
-  return output.replace(/sm_(pat|aat|sat)_[0-9a-zA-Z]+/g, "***");
-};
+//#endregion
+const src_logging_logger_js = __toESM(require("./logging/logger.js"));
+const src_logging_request_logger_js = __toESM(require("./logging/request-logger.js"));
+const src_logging_mask_tokens_js = __toESM(require("./logging/mask-tokens.js"));
 
-// src/logging/logger.ts
-function createLogger(options = {}) {
-  const { level = "warn", prefix = "" } = options;
-  const logLevels = {
-    debug: 0,
-    info: 1,
-    warn: 2,
-    error: 3,
-    none: 4
-  };
-  const currentLevelValue = logLevels[level];
-  const formatArgs = (args) => {
-    if (args.length === 0 || args.every((arg) => arg === void 0 || arg === null)) {
-      return "";
-    }
-    const formatted = args.map((arg) => {
-      if (arg instanceof Error) {
-        return `
-${arg.stack || arg.message}`;
-      }
-      if (typeof arg === "object" && arg !== null) {
-        return `
-${JSON.stringify(arg, null, 2)}`;
-      }
-      return ` ${String(arg)}`;
-    }).join("");
-    return `, args:${formatted}`;
-  };
-  const shouldLog = (level2) => {
-    return logLevels[level2] >= currentLevelValue;
-  };
-  return {
-    debug: (message, ...args) => {
-      if (shouldLog("debug")) {
-        console.debug(`\x1B[32m${prefix}[DEBUG] ${maskTokens(message)}${maskTokens(formatArgs(args))}\x1B[0m`);
-      }
-    },
-    info: (message, ...args) => {
-      if (shouldLog("info")) {
-        console.info(`\x1B[34m${prefix}[INFO] ${maskTokens(message)}${maskTokens(formatArgs(args))}\x1B[0m`);
-      }
-    },
-    warn: (message, ...args) => {
-      if (shouldLog("warn")) {
-        console.warn(`\x1B[33m${prefix}[WARN] ${maskTokens(message)}${maskTokens(formatArgs(args))}\x1B[0m`);
-      }
-    },
-    error: (message, ...args) => {
-      if (shouldLog("error")) {
-        console.error(`\x1B[31m${prefix}[ERROR] ${maskTokens(message)}${maskTokens(formatArgs(args))}\x1B[0m`);
-      }
-    }
-  };
-}
-var logger = createLogger();
-
-// src/string.ts
-function truncate(value, maxLength) {
-  if (value.length <= maxLength) {
-    return value;
+Object.defineProperty(exports, 'createLogger', {
+  enumerable: true,
+  get: function () {
+    return src_logging_logger_js.createLogger;
   }
-  return `${value.slice(0, maxLength)}...`;
-}
-
-// src/logging/request-logger.ts
-var WARNING_THRESHOLD = 500;
-var TRUNCATE_LENGTH = 50;
-function requestLogger(logger2, name, fn) {
-  return async (...args) => {
-    const start = Date.now();
-    try {
-      return await fn(...args);
-    } finally {
-      const end = Date.now();
-      const duration = end - start;
-      const body = extractInfoFromBody(args[1]?.body ?? "{}");
-      const message = `${name} path: ${args[0]}, took ${formatDuration(duration)}`;
-      if (duration > WARNING_THRESHOLD) {
-        logger2.warn(message, body);
-      } else {
-        logger2.info(message, body);
-      }
-    }
-  };
-}
-function formatDuration(duration) {
-  return duration < 1e3 ? `${duration}ms` : `${(duration / 1e3).toFixed(3)}s`;
-}
-function extractInfoFromBody(body) {
-  try {
-    const parsedBody = typeof body === "string" ? JSON.parse(body) : body;
-    if (parsedBody === null || parsedBody === void 0 || Object.keys(parsedBody).length === 0) {
-      return null;
-    }
-    const dataToKeep = {};
-    if ("query" in parsedBody) {
-      dataToKeep.query = truncate(parsedBody.query, TRUNCATE_LENGTH);
-    }
-    if ("variables" in parsedBody) {
-      dataToKeep.variables = truncate(JSON.stringify(parsedBody.variables), TRUNCATE_LENGTH);
-    }
-    if ("operationName" in parsedBody) {
-      dataToKeep.operationName = truncate(parsedBody.operationName, TRUNCATE_LENGTH);
-    }
-    if (Object.keys(dataToKeep).length > 0) {
-      return JSON.stringify(dataToKeep);
-    }
-    return truncate(JSON.stringify(parsedBody || "{}"), TRUNCATE_LENGTH);
-  } catch {
-    return "{}";
+});
+Object.defineProperty(exports, 'maskTokens', {
+  enumerable: true,
+  get: function () {
+    return src_logging_mask_tokens_js.maskTokens;
   }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  createLogger,
-  maskTokens,
-  requestLogger
 });
-//# sourceMappingURL=logging.cjs.map
+Object.defineProperty(exports, 'requestLogger', {
+  enumerable: true,
+  get: function () {
+    return src_logging_request_logger_js.requestLogger;
+  }
+});