@pcg/predicates 1.0.0-alpha.1

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+# @pcg/predicates
+
+## 1.0.0-alpha.1
+
+### Minor Changes
+
+- Initial release of predicates package with type checking utilities

package/dist/index.d.ts

@@ -0,0 +1,111 @@
+import { Entries } from "type-fest";
+
+//#region src/basic.d.ts
+
+/**
+ * Checks if the given parameter is callable (a function).
+ * @param {unknown} fn - The function to check.
+ * @returns {boolean} Returns true if `fn` is a function, false otherwise.
+ * @example
+ * isCallable(() => {});  // Returns true
+ * isCallable('Hello');  // Returns false
+ */
+declare const isCallable: (fn: unknown) => fn is (...args: any[]) => any;
+/**
+ * Checks if the given value is a string.
+ * @param {unknown} val - The value to check.
+ * @returns {boolean} Returns true if `val` is a string, false otherwise.
+ * @example
+ * isString('Hello');  // Returns true
+ * isString(123);  // Returns false
+ */
+declare const isString: (val: unknown) => val is string;
+/**
+ * Checks if the given value is a number.
+ * @param {unknown} val - The value to check.
+ * @returns {boolean} Returns true if `val` is a number, false otherwise.
+ * @example
+ * isNumber(123);  // Returns true
+ * isNumber('Hello');  // Returns false
+ */
+declare const isNumber: (val: unknown) => val is number;
+/**
+ * Checks if a given value can be used as an index (a non-negative integer).
+ * @param {unknown} value - The value to check.
+ * @returns {boolean} Returns true if `value` can be used as an index, false otherwise.
+ * @example
+ * isIndex(2);  // Returns true
+ * isIndex('2');  // Returns true
+ * isIndex(-1);  // Returns false
+ */
+declare const isIndex: (value: unknown) => value is number;
+/**
+ * Checks if the given value is null or undefined.
+ * @param {unknown} value - The value to check.
+ * @returns {boolean} Returns true if `value` is null or undefined, false otherwise.
+ * @example
+ * isNullOrUndefined(null);  // Returns true
+ * isNullOrUndefined(undefined);  // Returns true
+ * isNullOrUndefined('Hello');  // Returns false
+ */
+declare const isNullOrUndefined: (value: unknown) => value is undefined | null;
+//#endregion
+//#region src/containers.d.ts
+/**
+ * Checks if the given value is an empty array.
+ * @param {unknown} arr - The array to check.
+ * @returns {boolean} Returns true if `arr` is an empty array, false otherwise.
+ * @example
+ * isEmptyArray([]);  // Returns true
+ * isEmptyArray([1, 2, 3]);  // Returns false
+ */
+declare const isEmptyArray: (arr: unknown) => boolean;
+/**
+ * Gets the keys of the given object.
+ * @param {T} arr - The object to get the keys from.
+ * @returns {Array<keyof T>} Returns an array of keys of the given object.
+ * @example
+ * keysOf({ a: 1, b: 2 });  // Returns ['a', 'b']
+ */
+declare const keysOf: <T>(arr: T) => (keyof T)[];
+/**
+ * Gets the entries of the given object.
+ * @param {T} arr - The object to get the entries from.
+ * @returns {Entries<T>} Returns an array of entries of the given object.
+ * @example
+ * entriesOf({ a: 1, b: 2 });  // Returns [['a', 1], ['b', 2]]
+ */
+declare const entriesOf: <T>(arr: T) => Entries<T>;
+/**
+ * Checks if the given value is an object (not an array).
+ * @param {unknown} obj - The value to check.
+ * @returns {boolean} Returns true if `obj` is an object, false otherwise.
+ * @example
+ * isObject({ a: 1 });  // Returns true
+ * isObject([1, 2, 3]);  // Returns false
+ */
+declare const isObject: (obj: unknown) => obj is Record<string, unknown>;
+/**
+ * Checks if the given value is a container (an object or an array).
+ * @param {unknown} value - The value to check.
+ * @returns {boolean} Returns true if `value` is a container, false otherwise.
+ * @example
+ * isContainerValue({ a: 1 });  // Returns true
+ * isContainerValue([1, 2, 3]);  // Returns true
+ * isContainerValue('Hello');  // Returns false
+ */
+declare const isContainerValue: (value: unknown) => value is Record<string, unknown>;
+/**
+ * Checks if the given value is an empty container (an empty object or array).
+ * @param {unknown} value - The value to check.
+ * @returns {boolean} Returns true if `value` is an empty container, false otherwise.
+ * @example
+ * isEmptyContainer({});  // Returns true
+ * isEmptyContainer([]);  // Returns true
+ * isEmptyContainer({ a: 1 });  // Returns false
+ * isEmptyContainer([1, 2, 3]);  // Returns false
+ */
+declare const isEmptyContainer: (value: unknown) => boolean;
+//#endregion
+export { entriesOf, isCallable, isContainerValue, isEmptyArray, isEmptyContainer, isIndex, isNullOrUndefined, isNumber, isObject, isString, keysOf };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,123 @@
+//#region src/basic.ts
+/**
+* Checks if the given parameter is callable (a function).
+* @param {unknown} fn - The function to check.
+* @returns {boolean} Returns true if `fn` is a function, false otherwise.
+* @example
+* isCallable(() => {});  // Returns true
+* isCallable('Hello');  // Returns false
+*/
+const isCallable = (fn) => {
+	return typeof fn === "function";
+};
+/**
+* Checks if the given value is a string.
+* @param {unknown} val - The value to check.
+* @returns {boolean} Returns true if `val` is a string, false otherwise.
+* @example
+* isString('Hello');  // Returns true
+* isString(123);  // Returns false
+*/
+const isString = (val) => typeof val === "string";
+/**
+* Checks if the given value is a number.
+* @param {unknown} val - The value to check.
+* @returns {boolean} Returns true if `val` is a number, false otherwise.
+* @example
+* isNumber(123);  // Returns true
+* isNumber('Hello');  // Returns false
+*/
+const isNumber = (val) => typeof val === "number";
+/**
+* Checks if a given value can be used as an index (a non-negative integer).
+* @param {unknown} value - The value to check.
+* @returns {boolean} Returns true if `value` can be used as an index, false otherwise.
+* @example
+* isIndex(2);  // Returns true
+* isIndex('2');  // Returns true
+* isIndex(-1);  // Returns false
+*/
+const isIndex = (value) => {
+	return (isNumber(value) || isString(value)) && Number(value) >= 0;
+};
+/**
+* Checks if the given value is null or undefined.
+* @param {unknown} value - The value to check.
+* @returns {boolean} Returns true if `value` is null or undefined, false otherwise.
+* @example
+* isNullOrUndefined(null);  // Returns true
+* isNullOrUndefined(undefined);  // Returns true
+* isNullOrUndefined('Hello');  // Returns false
+*/
+const isNullOrUndefined = (value) => {
+	return value === null || value === void 0;
+};
+
+//#endregion
+//#region src/containers.ts
+/**
+* Checks if the given value is an empty array.
+* @param {unknown} arr - The array to check.
+* @returns {boolean} Returns true if `arr` is an empty array, false otherwise.
+* @example
+* isEmptyArray([]);  // Returns true
+* isEmptyArray([1, 2, 3]);  // Returns false
+*/
+const isEmptyArray = (arr) => {
+	return Array.isArray(arr) && arr.length === 0;
+};
+/**
+* Gets the keys of the given object.
+* @param {T} arr - The object to get the keys from.
+* @returns {Array<keyof T>} Returns an array of keys of the given object.
+* @example
+* keysOf({ a: 1, b: 2 });  // Returns ['a', 'b']
+*/
+const keysOf = (arr) => Object.keys(arr);
+/**
+* Gets the entries of the given object.
+* @param {T} arr - The object to get the entries from.
+* @returns {Entries<T>} Returns an array of entries of the given object.
+* @example
+* entriesOf({ a: 1, b: 2 });  // Returns [['a', 1], ['b', 2]]
+*/
+const entriesOf = (arr) => Object.entries(arr);
+/**
+* Checks if the given value is an object (not an array).
+* @param {unknown} obj - The value to check.
+* @returns {boolean} Returns true if `obj` is an object, false otherwise.
+* @example
+* isObject({ a: 1 });  // Returns true
+* isObject([1, 2, 3]);  // Returns false
+*/
+const isObject = (obj) => obj !== null && !!obj && typeof obj === "object" && !Array.isArray(obj);
+/**
+* Checks if the given value is a container (an object or an array).
+* @param {unknown} value - The value to check.
+* @returns {boolean} Returns true if `value` is a container, false otherwise.
+* @example
+* isContainerValue({ a: 1 });  // Returns true
+* isContainerValue([1, 2, 3]);  // Returns true
+* isContainerValue('Hello');  // Returns false
+*/
+const isContainerValue = (value) => {
+	return isObject(value) || Array.isArray(value);
+};
+/**
+* Checks if the given value is an empty container (an empty object or array).
+* @param {unknown} value - The value to check.
+* @returns {boolean} Returns true if `value` is an empty container, false otherwise.
+* @example
+* isEmptyContainer({});  // Returns true
+* isEmptyContainer([]);  // Returns true
+* isEmptyContainer({ a: 1 });  // Returns false
+* isEmptyContainer([1, 2, 3]);  // Returns false
+*/
+const isEmptyContainer = (value) => {
+	if (Array.isArray(value)) return value.length === 0;
+	return isObject(value) && Object.keys(value).length === 0;
+};
+
+//#endregion
+export { entriesOf, isCallable, isContainerValue, isEmptyArray, isEmptyContainer, isIndex, isNullOrUndefined, isNumber, isObject, isString, keysOf };
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../src/basic.ts","../src/containers.ts"],"sourcesContent":["/**\n * Checks if the given parameter is callable (a function).\n * @param {unknown} fn - The function to check.\n * @returns {boolean} Returns true if `fn` is a function, false otherwise.\n * @example\n * isCallable(() => {});  // Returns true\n * isCallable('Hello');  // Returns false\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport const isCallable = (fn: unknown): fn is (...args: any[]) => any => {\n  return typeof fn === 'function';\n};\n\n/**\n * Checks if the given value is a string.\n * @param {unknown} val - The value to check.\n * @returns {boolean} Returns true if `val` is a string, false otherwise.\n * @example\n * isString('Hello');  // Returns true\n * isString(123);  // Returns false\n */\nexport const isString = (val: unknown): val is string => typeof val === 'string';\n\n/**\n * Checks if the given value is a number.\n * @param {unknown} val - The value to check.\n * @returns {boolean} Returns true if `val` is a number, false otherwise.\n * @example\n * isNumber(123);  // Returns true\n * isNumber('Hello');  // Returns false\n */\nexport const isNumber = (val: unknown): val is number => typeof val === 'number';\n\n/**\n * Checks if a given value can be used as an index (a non-negative integer).\n * @param {unknown} value - The value to check.\n * @returns {boolean} Returns true if `value` can be used as an index, false otherwise.\n * @example\n * isIndex(2);  // Returns true\n * isIndex('2');  // Returns true\n * isIndex(-1);  // Returns false\n */\nexport const isIndex = (value: unknown): value is number => {\n  return (isNumber(value) || isString(value)) && Number(value) >= 0;\n};\n\n/**\n * Checks if the given value is null or undefined.\n * @param {unknown} value - The value to check.\n * @returns {boolean} Returns true if `value` is null or undefined, false otherwise.\n * @example\n * isNullOrUndefined(null);  // Returns true\n * isNullOrUndefined(undefined);  // Returns true\n * isNullOrUndefined('Hello');  // Returns false\n */\nexport const isNullOrUndefined = (value: unknown): value is undefined | null => {\n  return value === null || value === undefined;\n};\n","// https://github.com/logaretm/vee-validate/blob/main/packages/shared/utils.ts\n// https://github.com/logaretm/vee-validate/blob/main/packages/vee-validate/src/utils/assertions.ts\n\nimport type { Entries } from 'type-fest';\n\n/**\n * Checks if the given value is an empty array.\n * @param {unknown} arr - The array to check.\n * @returns {boolean} Returns true if `arr` is an empty array, false otherwise.\n * @example\n * isEmptyArray([]);  // Returns true\n * isEmptyArray([1, 2, 3]);  // Returns false\n */\nexport const isEmptyArray = (arr: unknown): boolean => {\n  return Array.isArray(arr) && arr.length === 0;\n};\n\n/**\n * Gets the keys of the given object.\n * @param {T} arr - The object to get the keys from.\n * @returns {Array<keyof T>} Returns an array of keys of the given object.\n * @example\n * keysOf({ a: 1, b: 2 });  // Returns ['a', 'b']\n */\nexport const keysOf = <T>(arr: T) => Object.keys(arr as unknown[]) as (keyof T)[];\n\n/**\n * Gets the entries of the given object.\n * @param {T} arr - The object to get the entries from.\n * @returns {Entries<T>} Returns an array of entries of the given object.\n * @example\n * entriesOf({ a: 1, b: 2 });  // Returns [['a', 1], ['b', 2]]\n */\nexport const entriesOf = <T>(arr: T) => Object.entries(arr as unknown[]) as Entries<T>;\n\n/**\n * Checks if the given value is an object (not an array).\n * @param {unknown} obj - The value to check.\n * @returns {boolean} Returns true if `obj` is an object, false otherwise.\n * @example\n * isObject({ a: 1 });  // Returns true\n * isObject([1, 2, 3]);  // Returns false\n */\nexport const isObject = (obj: unknown): obj is Record<string, unknown> =>\n  obj !== null && !!obj && typeof obj === 'object' && !Array.isArray(obj);\n\n/**\n * Checks if the given value is a container (an object or an array).\n * @param {unknown} value - The value to check.\n * @returns {boolean} Returns true if `value` is a container, false otherwise.\n * @example\n * isContainerValue({ a: 1 });  // Returns true\n * isContainerValue([1, 2, 3]);  // Returns true\n * isContainerValue('Hello');  // Returns false\n */\nexport const isContainerValue = (value: unknown): value is Record<string, unknown> => {\n  return isObject(value) || Array.isArray(value);\n};\n\n/**\n * Checks if the given value is an empty container (an empty object or array).\n * @param {unknown} value - The value to check.\n * @returns {boolean} Returns true if `value` is an empty container, false otherwise.\n * @example\n * isEmptyContainer({});  // Returns true\n * isEmptyContainer([]);  // Returns true\n * isEmptyContainer({ a: 1 });  // Returns false\n * isEmptyContainer([1, 2, 3]);  // Returns false\n */\nexport const isEmptyContainer = (value: unknown): boolean => {\n  if (Array.isArray(value)) {\n    return value.length === 0;\n  }\n\n  return isObject(value) && Object.keys(value).length === 0;\n};\n"],"mappings":";;;;;;;;;AASA,MAAa,cAAc,OAA+C;AACxE,QAAO,OAAO,OAAO;;;;;;;;;;AAWvB,MAAa,YAAY,QAAgC,OAAO,QAAQ;;;;;;;;;AAUxE,MAAa,YAAY,QAAgC,OAAO,QAAQ;;;;;;;;;;AAWxE,MAAa,WAAW,UAAoC;AAC1D,SAAQ,SAAS,MAAM,IAAI,SAAS,MAAM,KAAK,OAAO,MAAM,IAAI;;;;;;;;;;;AAYlE,MAAa,qBAAqB,UAA8C;AAC9E,QAAO,UAAU,QAAQ,UAAU;;;;;;;;;;;;;AC3CrC,MAAa,gBAAgB,QAA0B;AACrD,QAAO,MAAM,QAAQ,IAAI,IAAI,IAAI,WAAW;;;;;;;;;AAU9C,MAAa,UAAa,QAAW,OAAO,KAAK,IAAiB;;;;;;;;AASlE,MAAa,aAAgB,QAAW,OAAO,QAAQ,IAAiB;;;;;;;;;AAUxE,MAAa,YAAY,QACvB,QAAQ,QAAQ,CAAC,CAAC,OAAO,OAAO,QAAQ,YAAY,CAAC,MAAM,QAAQ,IAAI;;;;;;;;;;AAWzE,MAAa,oBAAoB,UAAqD;AACpF,QAAO,SAAS,MAAM,IAAI,MAAM,QAAQ,MAAM;;;;;;;;;;;;AAahD,MAAa,oBAAoB,UAA4B;AAC3D,KAAI,MAAM,QAAQ,MAAM,CACtB,QAAO,MAAM,WAAW;AAG1B,QAAO,SAAS,MAAM,IAAI,OAAO,KAAK,MAAM,CAAC,WAAW"}

package/eslint.config.cjs

@@ -0,0 +1,14 @@
+//
+// @pkg 📦 DeepVision ESLint Config [NestJS]
+// @version 📍 1.0.0
+// @author 🐳 DeepVision Team <code@deepvision.team>
+//
+// Documentation reference: https://eslint.org/docs/user-guide/configuring/
+// ESLint versions: https://eslint.org/blog/
+//
+// eslint-disable-next-line @typescript-eslint/no-require-imports, node/no-unpublished-require
+const deep = require('@deepvision/eslint-plugin');
+
+module.exports = [
+  ...deep.default.configs.node,
+];

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@pcg/predicates",
+  "version": "1.0.0-alpha.1",
+  "description": "Type predicate utilities and assertions",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "dependencies": {
+    "type-fest": "^4.41.0"
+  },
+  "devDependencies": {
+    "@vitest/ui": "^3.2.4",
+    "vitest": "^3.2.4"
+  },
+  "scripts": {
+    "dev": "tsdown --watch",
+    "build": "tsdown",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "eslint \"src/**/*.ts\""
+  }
+}

package/src/basic.ts

@@ -0,0 +1,58 @@
+/**
+ * Checks if the given parameter is callable (a function).
+ * @param {unknown} fn - The function to check.
+ * @returns {boolean} Returns true if `fn` is a function, false otherwise.
+ * @example
+ * isCallable(() => {});  // Returns true
+ * isCallable('Hello');  // Returns false
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const isCallable = (fn: unknown): fn is (...args: any[]) => any => {
+  return typeof fn === 'function';
+};
+
+/**
+ * Checks if the given value is a string.
+ * @param {unknown} val - The value to check.
+ * @returns {boolean} Returns true if `val` is a string, false otherwise.
+ * @example
+ * isString('Hello');  // Returns true
+ * isString(123);  // Returns false
+ */
+export const isString = (val: unknown): val is string => typeof val === 'string';
+
+/**
+ * Checks if the given value is a number.
+ * @param {unknown} val - The value to check.
+ * @returns {boolean} Returns true if `val` is a number, false otherwise.
+ * @example
+ * isNumber(123);  // Returns true
+ * isNumber('Hello');  // Returns false
+ */
+export const isNumber = (val: unknown): val is number => typeof val === 'number';
+
+/**
+ * Checks if a given value can be used as an index (a non-negative integer).
+ * @param {unknown} value - The value to check.
+ * @returns {boolean} Returns true if `value` can be used as an index, false otherwise.
+ * @example
+ * isIndex(2);  // Returns true
+ * isIndex('2');  // Returns true
+ * isIndex(-1);  // Returns false
+ */
+export const isIndex = (value: unknown): value is number => {
+  return (isNumber(value) || isString(value)) && Number(value) >= 0;
+};
+
+/**
+ * Checks if the given value is null or undefined.
+ * @param {unknown} value - The value to check.
+ * @returns {boolean} Returns true if `value` is null or undefined, false otherwise.
+ * @example
+ * isNullOrUndefined(null);  // Returns true
+ * isNullOrUndefined(undefined);  // Returns true
+ * isNullOrUndefined('Hello');  // Returns false
+ */
+export const isNullOrUndefined = (value: unknown): value is undefined | null => {
+  return value === null || value === undefined;
+};

package/src/containers.ts

@@ -0,0 +1,76 @@
+// https://github.com/logaretm/vee-validate/blob/main/packages/shared/utils.ts
+// https://github.com/logaretm/vee-validate/blob/main/packages/vee-validate/src/utils/assertions.ts
+
+import type { Entries } from 'type-fest';
+
+/**
+ * Checks if the given value is an empty array.
+ * @param {unknown} arr - The array to check.
+ * @returns {boolean} Returns true if `arr` is an empty array, false otherwise.
+ * @example
+ * isEmptyArray([]);  // Returns true
+ * isEmptyArray([1, 2, 3]);  // Returns false
+ */
+export const isEmptyArray = (arr: unknown): boolean => {
+  return Array.isArray(arr) && arr.length === 0;
+};
+
+/**
+ * Gets the keys of the given object.
+ * @param {T} arr - The object to get the keys from.
+ * @returns {Array<keyof T>} Returns an array of keys of the given object.
+ * @example
+ * keysOf({ a: 1, b: 2 });  // Returns ['a', 'b']
+ */
+export const keysOf = <T>(arr: T) => Object.keys(arr as unknown[]) as (keyof T)[];
+
+/**
+ * Gets the entries of the given object.
+ * @param {T} arr - The object to get the entries from.
+ * @returns {Entries<T>} Returns an array of entries of the given object.
+ * @example
+ * entriesOf({ a: 1, b: 2 });  // Returns [['a', 1], ['b', 2]]
+ */
+export const entriesOf = <T>(arr: T) => Object.entries(arr as unknown[]) as Entries<T>;
+
+/**
+ * Checks if the given value is an object (not an array).
+ * @param {unknown} obj - The value to check.
+ * @returns {boolean} Returns true if `obj` is an object, false otherwise.
+ * @example
+ * isObject({ a: 1 });  // Returns true
+ * isObject([1, 2, 3]);  // Returns false
+ */
+export const isObject = (obj: unknown): obj is Record<string, unknown> =>
+  obj !== null && !!obj && typeof obj === 'object' && !Array.isArray(obj);
+
+/**
+ * Checks if the given value is a container (an object or an array).
+ * @param {unknown} value - The value to check.
+ * @returns {boolean} Returns true if `value` is a container, false otherwise.
+ * @example
+ * isContainerValue({ a: 1 });  // Returns true
+ * isContainerValue([1, 2, 3]);  // Returns true
+ * isContainerValue('Hello');  // Returns false
+ */
+export const isContainerValue = (value: unknown): value is Record<string, unknown> => {
+  return isObject(value) || Array.isArray(value);
+};
+
+/**
+ * Checks if the given value is an empty container (an empty object or array).
+ * @param {unknown} value - The value to check.
+ * @returns {boolean} Returns true if `value` is an empty container, false otherwise.
+ * @example
+ * isEmptyContainer({});  // Returns true
+ * isEmptyContainer([]);  // Returns true
+ * isEmptyContainer({ a: 1 });  // Returns false
+ * isEmptyContainer([1, 2, 3]);  // Returns false
+ */
+export const isEmptyContainer = (value: unknown): boolean => {
+  if (Array.isArray(value)) {
+    return value.length === 0;
+  }
+
+  return isObject(value) && Object.keys(value).length === 0;
+};

package/src/index.ts

@@ -0,0 +1,2 @@
+export * from './basic.js';
+export * from './containers.js';

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "moduleResolution": "bundler",
+  },
+  "include": ["src/**/*.ts", "tests/**/*.ts"],
+  "exclude": ["node_modules", "dist"],
+}

package/tsconfig.lib.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "moduleResolution": "bundler",
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules", "dist"],
+}

package/tsdown.config.ts

@@ -0,0 +1,11 @@
+import { defineConfig } from 'tsdown';
+
+export default defineConfig({
+  entry: ['src/index.ts'],
+  tsconfig: './tsconfig.lib.json',
+  outDir: 'dist',
+  dts: true,
+  clean: true,
+  sourcemap: true,
+  format: 'esm',
+});

package/vitest.config.ts

@@ -0,0 +1,19 @@
+// / <reference types="vitest" />
+// eslint-disable-next-line node/no-unpublished-import
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    environment: 'node',
+    include: ['tests/**/*.test.ts'],
+    globals: true,
+    typecheck: {
+      tsconfig: './tsconfig.json',
+    },
+  },
+  resolve: {
+    alias: {
+      '@': new URL('./src', import.meta.url).pathname,
+    },
+  },
+});