xantiagoma 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Santiago Montoya
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,41 @@
+# xantiagoma
+
+Personal utilities by [Santiago Montoya](https://github.com/xantiagoma).
+
+## Install
+
+```bash
+npm install xantiagoma
+```
+
+## `tryCatch` / `tryCatchSync`
+
+Convert promises or sync functions into `[data, error]` tuples — no `try/catch` needed.
+
+```ts
+import { tryCatch, tryCatchSync } from "xantiagoma";
+
+// Async
+const [user, error] = await tryCatch(fetch("/api/me").then((r) => r.json()));
+if (error) {
+  // handle error
+}
+
+// With async function
+const [data, err] = await tryCatch(async () => {
+  const res = await fetch("/api/data");
+  return res.json();
+});
+
+// Sync
+const [parsed, parseErr] = tryCatchSync(() => JSON.parse(rawString));
+```
+
+## See Also
+
+- [drizzle-cursor](https://github.com/xantiagoma/drizzle-cursor) — Cursor-based pagination for Drizzle ORM
+- [drizzle-audit](https://github.com/xantiagoma/drizzle-audit) — Configurable audit logging for Drizzle ORM
+
+## License
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,68 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/try-catch.ts
+/**
+* Convert a promise (or promise factory) into a tuple result: `[data, error]`.
+*
+* This is handy when you want to avoid `try/catch` at the call site.
+*
+* @example With a promise
+* ```ts
+* const [user, error] = await tryCatch(fetch("/api/me").then((r) => r.json()));
+*
+* if (error) {
+*   // handle error
+* } else {
+*   // use user
+* }
+* ```
+*
+* @example With a function (captures sync throws too)
+* ```ts
+* const [data, error] = await tryCatch(async () => {
+*   if (Math.random() > 0.5) {
+*     throw new Error("boom");
+*   }
+*   return 123;
+* });
+*
+* if (!error) {
+*   // data === 123
+* }
+* ```
+*/
+async function tryCatch(promise) {
+	try {
+		return [await (typeof promise === "function" ? promise() : promise), null];
+	} catch (error) {
+		return [null, error];
+	}
+}
+/**
+* Convert a sync function call into a tuple result: `[data, error]`.
+*
+* This is the sync equivalent of `tryCatch` and is handy when you want to avoid
+* `try/catch` at the call site.
+*
+* @example
+* ```ts
+* const [value, error] = tryCatchSync(() => JSON.parse('{"ok":true}'));
+*
+* if (error) {
+*   // handle error
+* } else {
+*   // value.ok === true
+* }
+* ```
+*/
+function tryCatchSync(fn) {
+	try {
+		return [fn(), null];
+	} catch (error) {
+		return [null, error];
+	}
+}
+//#endregion
+exports.tryCatch = tryCatch;
+exports.tryCatchSync = tryCatchSync;
+
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":[],"sources":["../src/try-catch.ts"],"sourcesContent":["type MaybePromise<T> = T | Promise<T>;\ntype Result<T, E = Error> = [T, null] | [null, E];\n\n/**\n * Convert a promise (or promise factory) into a tuple result: `[data, error]`.\n *\n * This is handy when you want to avoid `try/catch` at the call site.\n *\n * @example With a promise\n * ```ts\n * const [user, error] = await tryCatch(fetch(\"/api/me\").then((r) => r.json()));\n *\n * if (error) {\n *   // handle error\n * } else {\n *   // use user\n * }\n * ```\n *\n * @example With a function (captures sync throws too)\n * ```ts\n * const [data, error] = await tryCatch(async () => {\n *   if (Math.random() > 0.5) {\n *     throw new Error(\"boom\");\n *   }\n *   return 123;\n * });\n *\n * if (!error) {\n *   // data === 123\n * }\n * ```\n */\nexport async function tryCatch<T, E = Error>(\n  promise: PromiseLike<T> | (() => MaybePromise<T>),\n): Promise<Result<T, E>> {\n  try {\n    const data = await (typeof promise === \"function\" ? promise() : promise);\n    return [data, null];\n  } catch (error) {\n    return [null, error as E];\n  }\n}\n\n/**\n * Convert a sync function call into a tuple result: `[data, error]`.\n *\n * This is the sync equivalent of `tryCatch` and is handy when you want to avoid\n * `try/catch` at the call site.\n *\n * @example\n * ```ts\n * const [value, error] = tryCatchSync(() => JSON.parse('{\"ok\":true}'));\n *\n * if (error) {\n *   // handle error\n * } else {\n *   // value.ok === true\n * }\n * ```\n */\nexport function tryCatchSync<T, E = Error>(fn: () => T): Result<T, E> {\n  try {\n    return [fn(), null];\n  } catch (error) {\n    return [null, error as E];\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCA,eAAsB,SACpB,SACuB;CACvB,IAAI;EAEF,OAAO,CAAC,OADY,OAAO,YAAY,aAAa,SAAS,GAAG,UAClD,KAAK;UACZ,OAAO;EACd,OAAO,CAAC,MAAM,MAAW;;;;;;;;;;;;;;;;;;;;AAqB7B,SAAgB,aAA2B,IAA2B;CACpE,IAAI;EACF,OAAO,CAAC,IAAI,EAAE,KAAK;UACZ,OAAO;EACd,OAAO,CAAC,MAAM,MAAW"}

package/dist/index.d.cts

@@ -0,0 +1,55 @@
+//#region src/try-catch.d.ts
+type MaybePromise<T> = T | Promise<T>;
+type Result<T, E = Error> = [T, null] | [null, E];
+/**
+ * Convert a promise (or promise factory) into a tuple result: `[data, error]`.
+ *
+ * This is handy when you want to avoid `try/catch` at the call site.
+ *
+ * @example With a promise
+ * ```ts
+ * const [user, error] = await tryCatch(fetch("/api/me").then((r) => r.json()));
+ *
+ * if (error) {
+ *   // handle error
+ * } else {
+ *   // use user
+ * }
+ * ```
+ *
+ * @example With a function (captures sync throws too)
+ * ```ts
+ * const [data, error] = await tryCatch(async () => {
+ *   if (Math.random() > 0.5) {
+ *     throw new Error("boom");
+ *   }
+ *   return 123;
+ * });
+ *
+ * if (!error) {
+ *   // data === 123
+ * }
+ * ```
+ */
+declare function tryCatch<T, E = Error>(promise: PromiseLike<T> | (() => MaybePromise<T>)): Promise<Result<T, E>>;
+/**
+ * Convert a sync function call into a tuple result: `[data, error]`.
+ *
+ * This is the sync equivalent of `tryCatch` and is handy when you want to avoid
+ * `try/catch` at the call site.
+ *
+ * @example
+ * ```ts
+ * const [value, error] = tryCatchSync(() => JSON.parse('{"ok":true}'));
+ *
+ * if (error) {
+ *   // handle error
+ * } else {
+ *   // value.ok === true
+ * }
+ * ```
+ */
+declare function tryCatchSync<T, E = Error>(fn: () => T): Result<T, E>;
+//#endregion
+export { tryCatch, tryCatchSync };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.mts

@@ -0,0 +1,55 @@
+//#region src/try-catch.d.ts
+type MaybePromise<T> = T | Promise<T>;
+type Result<T, E = Error> = [T, null] | [null, E];
+/**
+ * Convert a promise (or promise factory) into a tuple result: `[data, error]`.
+ *
+ * This is handy when you want to avoid `try/catch` at the call site.
+ *
+ * @example With a promise
+ * ```ts
+ * const [user, error] = await tryCatch(fetch("/api/me").then((r) => r.json()));
+ *
+ * if (error) {
+ *   // handle error
+ * } else {
+ *   // use user
+ * }
+ * ```
+ *
+ * @example With a function (captures sync throws too)
+ * ```ts
+ * const [data, error] = await tryCatch(async () => {
+ *   if (Math.random() > 0.5) {
+ *     throw new Error("boom");
+ *   }
+ *   return 123;
+ * });
+ *
+ * if (!error) {
+ *   // data === 123
+ * }
+ * ```
+ */
+declare function tryCatch<T, E = Error>(promise: PromiseLike<T> | (() => MaybePromise<T>)): Promise<Result<T, E>>;
+/**
+ * Convert a sync function call into a tuple result: `[data, error]`.
+ *
+ * This is the sync equivalent of `tryCatch` and is handy when you want to avoid
+ * `try/catch` at the call site.
+ *
+ * @example
+ * ```ts
+ * const [value, error] = tryCatchSync(() => JSON.parse('{"ok":true}'));
+ *
+ * if (error) {
+ *   // handle error
+ * } else {
+ *   // value.ok === true
+ * }
+ * ```
+ */
+declare function tryCatchSync<T, E = Error>(fn: () => T): Result<T, E>;
+//#endregion
+export { tryCatch, tryCatchSync };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.mjs

@@ -0,0 +1,66 @@
+//#region src/try-catch.ts
+/**
+* Convert a promise (or promise factory) into a tuple result: `[data, error]`.
+*
+* This is handy when you want to avoid `try/catch` at the call site.
+*
+* @example With a promise
+* ```ts
+* const [user, error] = await tryCatch(fetch("/api/me").then((r) => r.json()));
+*
+* if (error) {
+*   // handle error
+* } else {
+*   // use user
+* }
+* ```
+*
+* @example With a function (captures sync throws too)
+* ```ts
+* const [data, error] = await tryCatch(async () => {
+*   if (Math.random() > 0.5) {
+*     throw new Error("boom");
+*   }
+*   return 123;
+* });
+*
+* if (!error) {
+*   // data === 123
+* }
+* ```
+*/
+async function tryCatch(promise) {
+	try {
+		return [await (typeof promise === "function" ? promise() : promise), null];
+	} catch (error) {
+		return [null, error];
+	}
+}
+/**
+* Convert a sync function call into a tuple result: `[data, error]`.
+*
+* This is the sync equivalent of `tryCatch` and is handy when you want to avoid
+* `try/catch` at the call site.
+*
+* @example
+* ```ts
+* const [value, error] = tryCatchSync(() => JSON.parse('{"ok":true}'));
+*
+* if (error) {
+*   // handle error
+* } else {
+*   // value.ok === true
+* }
+* ```
+*/
+function tryCatchSync(fn) {
+	try {
+		return [fn(), null];
+	} catch (error) {
+		return [null, error];
+	}
+}
+//#endregion
+export { tryCatch, tryCatchSync };
+
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/try-catch.ts"],"sourcesContent":["type MaybePromise<T> = T | Promise<T>;\ntype Result<T, E = Error> = [T, null] | [null, E];\n\n/**\n * Convert a promise (or promise factory) into a tuple result: `[data, error]`.\n *\n * This is handy when you want to avoid `try/catch` at the call site.\n *\n * @example With a promise\n * ```ts\n * const [user, error] = await tryCatch(fetch(\"/api/me\").then((r) => r.json()));\n *\n * if (error) {\n *   // handle error\n * } else {\n *   // use user\n * }\n * ```\n *\n * @example With a function (captures sync throws too)\n * ```ts\n * const [data, error] = await tryCatch(async () => {\n *   if (Math.random() > 0.5) {\n *     throw new Error(\"boom\");\n *   }\n *   return 123;\n * });\n *\n * if (!error) {\n *   // data === 123\n * }\n * ```\n */\nexport async function tryCatch<T, E = Error>(\n  promise: PromiseLike<T> | (() => MaybePromise<T>),\n): Promise<Result<T, E>> {\n  try {\n    const data = await (typeof promise === \"function\" ? promise() : promise);\n    return [data, null];\n  } catch (error) {\n    return [null, error as E];\n  }\n}\n\n/**\n * Convert a sync function call into a tuple result: `[data, error]`.\n *\n * This is the sync equivalent of `tryCatch` and is handy when you want to avoid\n * `try/catch` at the call site.\n *\n * @example\n * ```ts\n * const [value, error] = tryCatchSync(() => JSON.parse('{\"ok\":true}'));\n *\n * if (error) {\n *   // handle error\n * } else {\n *   // value.ok === true\n * }\n * ```\n */\nexport function tryCatchSync<T, E = Error>(fn: () => T): Result<T, E> {\n  try {\n    return [fn(), null];\n  } catch (error) {\n    return [null, error as E];\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCA,eAAsB,SACpB,SACuB;CACvB,IAAI;EAEF,OAAO,CAAC,OADY,OAAO,YAAY,aAAa,SAAS,GAAG,UAClD,KAAK;UACZ,OAAO;EACd,OAAO,CAAC,MAAM,MAAW;;;;;;;;;;;;;;;;;;;;AAqB7B,SAAgB,aAA2B,IAA2B;CACpE,IAAI;EACF,OAAO,CAAC,IAAI,EAAE,KAAK;UACZ,OAAO;EACd,OAAO,CAAC,MAAM,MAAW"}

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "xantiagoma",
+  "version": "0.0.1",
+  "description": "Santiago Montoya's utilities and tools",
+  "keywords": [
+    "xantiagoma",
+    "utilities"
+  ],
+  "homepage": "https://github.com/xantiagoma/xantiagoma-lib#readme",
+  "bugs": {
+    "url": "https://github.com/xantiagoma/xantiagoma-lib/issues"
+  },
+  "license": "MIT",
+  "author": "Santiago Montoya <xantiagoma@gmail.com>",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/xantiagoma/xantiagoma-lib.git"
+  },
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "main": "dist/index.cjs",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.mts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "vp pack",
+    "test": "vp test run",
+    "lint": "vp lint",
+    "format": "vp fmt",
+    "check": "vp lint && vp fmt --check && tsc --noEmit",
+    "release": "changelogen --release --push"
+  },
+  "devDependencies": {
+    "changelogen": "^0.6.2",
+    "vite-plus": "^0.1.22"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  }
+}