@dloizides/utils 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,24 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [1.0.0] - 2024-01-27
+
+### Added
+
+- Initial release
+- Type guards:
+  - `isValueDefined` - Check if value is not null or undefined
+  - `isNotEmptyArray` - Check if value is a non-empty array
+  - `isNotEmptyString` - Check if value is a non-empty string (after trim)
+  - `isNullOrUndefined` - Check if value is null or undefined
+  - `isEmptyArray` - Check if value is an empty array
+  - `isEmptyString` - Check if value is empty or whitespace only
+- Assertions:
+  - `assertDefined` - Assert that value is defined (throws if null/undefined)
+- Full TypeScript support with type narrowing
+- ESM and CommonJS module support
+- 100% test coverage

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 dloizides
+
+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,95 @@
+# @dloizides/utils
+
+> Type-safe utility functions for TypeScript projects
+
+[![npm version](https://badge.fury.io/js/@baseclient%2Futils.svg)](https://www.npmjs.com/package/@dloizides/utils)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Installation
+
+```bash
+npm install @dloizides/utils
+# or
+yarn add @dloizides/utils
+# or
+pnpm add @dloizides/utils
+```
+
+## Features
+
+- **Type Guards**: `isValueDefined`, `isNotEmptyArray`, `isNotEmptyString`, `isNullOrUndefined`, `isEmptyArray`, `isEmptyString`
+- **Assertions**: `assertDefined`
+- **Zero Dependencies**: No runtime dependencies
+- **Tree-shakeable**: Only import what you need
+- **TypeScript First**: Full type inference and narrowing
+
+## Usage
+
+### Type Guards
+
+```typescript
+import { isValueDefined, isNotEmptyArray, isNotEmptyString } from '@dloizides/utils';
+
+// isValueDefined - Check if value is not null or undefined
+const user = getUserOrNull();
+if (isValueDefined(user)) {
+  console.log(user.name); // TypeScript knows user is defined
+}
+
+// isNotEmptyArray - Check if array has elements
+const items = getItems();
+if (isNotEmptyArray(items)) {
+  console.log(items[0]); // Safe to access first element
+}
+
+// isNotEmptyString - Check if string has content
+const input = formData.get('name');
+if (isNotEmptyString(input)) {
+  saveUser(input); // String is guaranteed to have content
+}
+```
+
+### Assertions
+
+```typescript
+import { assertDefined } from '@dloizides/utils';
+
+function processUser(user: User | null) {
+  assertDefined(user, 'User is required');
+  // user is now narrowed to User
+  return user.name.toUpperCase();
+}
+```
+
+### Subpath Imports
+
+```typescript
+// Import only guards
+import { isValueDefined } from '@dloizides/utils/guards';
+
+// Import only assertions
+import { assertDefined } from '@dloizides/utils/assertions';
+```
+
+## API Reference
+
+### Type Guards
+
+| Function | Description |
+|----------|-------------|
+| `isValueDefined<T>(value)` | Returns `true` if value is not `null` or `undefined` |
+| `isNotEmptyArray<T>(value)` | Returns `true` if value is an array with length > 0 |
+| `isNotEmptyString(value)` | Returns `true` if value is a non-empty string (after trim) |
+| `isNullOrUndefined(value)` | Returns `true` if value is `null` or `undefined` |
+| `isEmptyArray(value)` | Returns `true` if value is an empty array |
+| `isEmptyString(value)` | Returns `true` if value is empty or whitespace only |
+
+### Assertions
+
+| Function | Description |
+|----------|-------------|
+| `assertDefined<T>(value, message?)` | Throws if value is `null` or `undefined` |
+
+## License
+
+MIT

package/dist/assertions/index.d.mts

@@ -0,0 +1 @@
+export { a as assertDefined } from '../index-DmagV9KM.mjs';

package/dist/assertions/index.d.ts

@@ -0,0 +1 @@
+export { a as assertDefined } from '../index-DmagV9KM.js';

package/dist/assertions/index.js

@@ -0,0 +1,12 @@
+'use strict';
+
+// src/assertions/assertDefined.ts
+function assertDefined(value, message) {
+  if (value === void 0 || value === null) {
+    throw new Error(message ?? "Value must be defined");
+  }
+}
+
+exports.assertDefined = assertDefined;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/assertions/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/assertions/assertDefined.ts"],"names":[],"mappings":";;;AAgBO,SAAS,aAAA,CACd,OACA,OAAA,EACoB;AACpB,EAAA,IAAI,KAAA,KAAU,MAAA,IAAa,KAAA,KAAU,IAAA,EAAM;AACzC,IAAA,MAAM,IAAI,KAAA,CAAM,OAAA,IAAW,uBAAuB,CAAA;AAAA,EACpD;AACF","file":"index.js","sourcesContent":["/**\r\n * Asserts that a value is defined (not null or undefined).\r\n * Throws an error if the value is null or undefined.\r\n *\r\n * @param value - The value to assert\r\n * @param message - Optional error message\r\n * @throws Error if value is null or undefined\r\n *\r\n * @example\r\n * ```typescript\r\n * const user = getUser(); // User | null\r\n * assertDefined(user, 'User must exist');\r\n * // user is now narrowed to User\r\n * console.log(user.name);\r\n * ```\r\n */\r\nexport function assertDefined<T>(\r\n  value: T | null | undefined,\r\n  message?: string\r\n): asserts value is T {\r\n  if (value === undefined || value === null) {\r\n    throw new Error(message ?? 'Value must be defined');\r\n  }\r\n}\r\n"]}

package/dist/assertions/index.mjs

@@ -0,0 +1,10 @@
+// src/assertions/assertDefined.ts
+function assertDefined(value, message) {
+  if (value === void 0 || value === null) {
+    throw new Error(message ?? "Value must be defined");
+  }
+}
+
+export { assertDefined };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map

package/dist/assertions/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/assertions/assertDefined.ts"],"names":[],"mappings":";AAgBO,SAAS,aAAA,CACd,OACA,OAAA,EACoB;AACpB,EAAA,IAAI,KAAA,KAAU,MAAA,IAAa,KAAA,KAAU,IAAA,EAAM;AACzC,IAAA,MAAM,IAAI,KAAA,CAAM,OAAA,IAAW,uBAAuB,CAAA;AAAA,EACpD;AACF","file":"index.mjs","sourcesContent":["/**\r\n * Asserts that a value is defined (not null or undefined).\r\n * Throws an error if the value is null or undefined.\r\n *\r\n * @param value - The value to assert\r\n * @param message - Optional error message\r\n * @throws Error if value is null or undefined\r\n *\r\n * @example\r\n * ```typescript\r\n * const user = getUser(); // User | null\r\n * assertDefined(user, 'User must exist');\r\n * // user is now narrowed to User\r\n * console.log(user.name);\r\n * ```\r\n */\r\nexport function assertDefined<T>(\r\n  value: T | null | undefined,\r\n  message?: string\r\n): asserts value is T {\r\n  if (value === undefined || value === null) {\r\n    throw new Error(message ?? 'Value must be defined');\r\n  }\r\n}\r\n"]}

package/dist/guards/index.d.mts

@@ -0,0 +1 @@
+export { a as isEmptyArray, b as isEmptyString, c as isNotEmptyArray, d as isNotEmptyString, e as isNullOrUndefined, f as isValueDefined } from '../index-Dge_3DNw.mjs';

package/dist/guards/index.d.ts

@@ -0,0 +1 @@
+export { a as isEmptyArray, b as isEmptyString, c as isNotEmptyArray, d as isNotEmptyString, e as isNullOrUndefined, f as isValueDefined } from '../index-Dge_3DNw.js';

package/dist/guards/index.js

@@ -0,0 +1,40 @@
+'use strict';
+
+// src/guards/isValueDefined.ts
+function isValueDefined(value) {
+  return value !== void 0 && value !== null;
+}
+
+// src/guards/isNotEmptyArray.ts
+function isNotEmptyArray(value) {
+  return Array.isArray(value) && value.length > 0;
+}
+
+// src/guards/isNotEmptyString.ts
+function isNotEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+
+// src/guards/isNullOrUndefined.ts
+function isNullOrUndefined(value) {
+  return value === void 0 || value === null;
+}
+
+// src/guards/isEmptyArray.ts
+function isEmptyArray(value) {
+  return Array.isArray(value) && value.length === 0;
+}
+
+// src/guards/isEmptyString.ts
+function isEmptyString(value) {
+  return typeof value === "string" && value.trim().length === 0;
+}
+
+exports.isEmptyArray = isEmptyArray;
+exports.isEmptyString = isEmptyString;
+exports.isNotEmptyArray = isNotEmptyArray;
+exports.isNotEmptyString = isNotEmptyString;
+exports.isNullOrUndefined = isNullOrUndefined;
+exports.isValueDefined = isValueDefined;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/guards/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/guards/isValueDefined.ts","../../src/guards/isNotEmptyArray.ts","../../src/guards/isNotEmptyString.ts","../../src/guards/isNullOrUndefined.ts","../../src/guards/isEmptyArray.ts","../../src/guards/isEmptyString.ts"],"names":[],"mappings":";;;AAeO,SAAS,eAAkB,KAAA,EAAyC;AACzE,EAAA,OAAO,KAAA,KAAU,UAAa,KAAA,KAAU,IAAA;AAC1C;;;ACFO,SAAS,gBACd,KAAA,EACqD;AACrD,EAAA,OAAO,KAAA,CAAM,OAAA,CAAQ,KAAK,CAAA,IAAK,MAAM,MAAA,GAAS,CAAA;AAChD;;;ACLO,SAAS,iBAAiB,KAAA,EAAmD;AAClF,EAAA,OAAO,OAAO,KAAA,KAAU,QAAA,IAAY,KAAA,CAAM,IAAA,GAAO,MAAA,GAAS,CAAA;AAC5D;;;ACDO,SAAS,kBAAkB,KAAA,EAA2C;AAC3E,EAAA,OAAO,KAAA,KAAU,UAAa,KAAA,KAAU,IAAA;AAC1C;;;ACHO,SAAS,aACd,KAAA,EACgD;AAChD,EAAA,OAAO,KAAA,CAAM,OAAA,CAAQ,KAAK,CAAA,IAAK,MAAM,MAAA,KAAW,CAAA;AAClD;;;ACHO,SAAS,cAAc,KAAA,EAA2C;AACvE,EAAA,OAAO,OAAO,KAAA,KAAU,QAAA,IAAY,KAAA,CAAM,IAAA,GAAO,MAAA,KAAW,CAAA;AAC9D","file":"index.js","sourcesContent":["/**\r\n * Type guard that checks if a value is neither null nor undefined.\r\n *\r\n * @param value - The value to check\r\n * @returns True if the value is defined (not null and not undefined)\r\n *\r\n * @example\r\n * ```typescript\r\n * const value: string | null | undefined = getValue();\r\n * if (isValueDefined(value)) {\r\n *   // value is narrowed to string\r\n *   console.log(value.length);\r\n * }\r\n * ```\r\n */\r\nexport function isValueDefined<T>(value: T | null | undefined): value is T {\r\n  return value !== undefined && value !== null;\r\n}\r\n","/**\r\n * Type guard that checks if a value is a non-empty array.\r\n *\r\n * @param value - The value to check\r\n * @returns True if the value is an array with at least one element\r\n *\r\n * @example\r\n * ```typescript\r\n * const items: string[] | undefined = getItems();\r\n * if (isNotEmptyArray(items)) {\r\n *   // items is narrowed to string[] with at least one element\r\n *   console.log(items[0]); // Safe to access\r\n * }\r\n * ```\r\n */\r\nexport function isNotEmptyArray<T>(\r\n  value: readonly T[] | null | undefined\r\n): value is readonly T[] & { readonly length: number } {\r\n  return Array.isArray(value) && value.length > 0;\r\n}\r\n","/**\r\n * Checks if a value is a non-empty string (after trimming whitespace).\r\n *\r\n * @param value - The value to check\r\n * @returns True if the value is a string with non-whitespace content\r\n *\r\n * @example\r\n * ```typescript\r\n * isNotEmptyString('hello');     // true\r\n * isNotEmptyString('  ');        // false\r\n * isNotEmptyString('');          // false\r\n * isNotEmptyString(undefined);   // false\r\n * ```\r\n */\r\nexport function isNotEmptyString(value: string | null | undefined): value is string {\r\n  return typeof value === 'string' && value.trim().length > 0;\r\n}\r\n","/**\r\n * Type guard that checks if a value is null or undefined.\r\n *\r\n * @param value - The value to check\r\n * @returns True if the value is null or undefined\r\n *\r\n * @example\r\n * ```typescript\r\n * const value: string | null | undefined = getValue();\r\n * if (isNullOrUndefined(value)) {\r\n *   // value is narrowed to null | undefined\r\n *   console.log('Value is not set');\r\n * }\r\n * ```\r\n */\r\nexport function isNullOrUndefined(value: unknown): value is null | undefined {\r\n  return value === undefined || value === null;\r\n}\r\n","/**\r\n * Type guard that checks if a value is an empty array.\r\n *\r\n * @param value - The value to check\r\n * @returns True if the value is an array with zero elements\r\n *\r\n * @example\r\n * ```typescript\r\n * const items: string[] = getItems();\r\n * if (isEmptyArray(items)) {\r\n *   console.log('No items found');\r\n * }\r\n * ```\r\n */\r\nexport function isEmptyArray<T>(\r\n  value: readonly T[] | null | undefined\r\n): value is readonly T[] & { readonly length: 0 } {\r\n  return Array.isArray(value) && value.length === 0;\r\n}\r\n","/**\r\n * Checks if a value is an empty string or contains only whitespace.\r\n *\r\n * @param value - The value to check\r\n * @returns True if the value is an empty string or whitespace-only\r\n *\r\n * @example\r\n * ```typescript\r\n * isEmptyString('');          // true\r\n * isEmptyString('  ');        // true\r\n * isEmptyString('hello');     // false\r\n * isEmptyString(undefined);   // false (not a string)\r\n * isEmptyString(null);        // false (not a string)\r\n * ```\r\n */\r\nexport function isEmptyString(value: string | null | undefined): boolean {\r\n  return typeof value === 'string' && value.trim().length === 0;\r\n}\r\n"]}

package/dist/guards/index.mjs

@@ -0,0 +1,33 @@
+// src/guards/isValueDefined.ts
+function isValueDefined(value) {
+  return value !== void 0 && value !== null;
+}
+
+// src/guards/isNotEmptyArray.ts
+function isNotEmptyArray(value) {
+  return Array.isArray(value) && value.length > 0;
+}
+
+// src/guards/isNotEmptyString.ts
+function isNotEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+
+// src/guards/isNullOrUndefined.ts
+function isNullOrUndefined(value) {
+  return value === void 0 || value === null;
+}
+
+// src/guards/isEmptyArray.ts
+function isEmptyArray(value) {
+  return Array.isArray(value) && value.length === 0;
+}
+
+// src/guards/isEmptyString.ts
+function isEmptyString(value) {
+  return typeof value === "string" && value.trim().length === 0;
+}
+
+export { isEmptyArray, isEmptyString, isNotEmptyArray, isNotEmptyString, isNullOrUndefined, isValueDefined };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map

package/dist/guards/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/guards/isValueDefined.ts","../../src/guards/isNotEmptyArray.ts","../../src/guards/isNotEmptyString.ts","../../src/guards/isNullOrUndefined.ts","../../src/guards/isEmptyArray.ts","../../src/guards/isEmptyString.ts"],"names":[],"mappings":";AAeO,SAAS,eAAkB,KAAA,EAAyC;AACzE,EAAA,OAAO,KAAA,KAAU,UAAa,KAAA,KAAU,IAAA;AAC1C;;;ACFO,SAAS,gBACd,KAAA,EACqD;AACrD,EAAA,OAAO,KAAA,CAAM,OAAA,CAAQ,KAAK,CAAA,IAAK,MAAM,MAAA,GAAS,CAAA;AAChD;;;ACLO,SAAS,iBAAiB,KAAA,EAAmD;AAClF,EAAA,OAAO,OAAO,KAAA,KAAU,QAAA,IAAY,KAAA,CAAM,IAAA,GAAO,MAAA,GAAS,CAAA;AAC5D;;;ACDO,SAAS,kBAAkB,KAAA,EAA2C;AAC3E,EAAA,OAAO,KAAA,KAAU,UAAa,KAAA,KAAU,IAAA;AAC1C;;;ACHO,SAAS,aACd,KAAA,EACgD;AAChD,EAAA,OAAO,KAAA,CAAM,OAAA,CAAQ,KAAK,CAAA,IAAK,MAAM,MAAA,KAAW,CAAA;AAClD;;;ACHO,SAAS,cAAc,KAAA,EAA2C;AACvE,EAAA,OAAO,OAAO,KAAA,KAAU,QAAA,IAAY,KAAA,CAAM,IAAA,GAAO,MAAA,KAAW,CAAA;AAC9D","file":"index.mjs","sourcesContent":["/**\r\n * Type guard that checks if a value is neither null nor undefined.\r\n *\r\n * @param value - The value to check\r\n * @returns True if the value is defined (not null and not undefined)\r\n *\r\n * @example\r\n * ```typescript\r\n * const value: string | null | undefined = getValue();\r\n * if (isValueDefined(value)) {\r\n *   // value is narrowed to string\r\n *   console.log(value.length);\r\n * }\r\n * ```\r\n */\r\nexport function isValueDefined<T>(value: T | null | undefined): value is T {\r\n  return value !== undefined && value !== null;\r\n}\r\n","/**\r\n * Type guard that checks if a value is a non-empty array.\r\n *\r\n * @param value - The value to check\r\n * @returns True if the value is an array with at least one element\r\n *\r\n * @example\r\n * ```typescript\r\n * const items: string[] | undefined = getItems();\r\n * if (isNotEmptyArray(items)) {\r\n *   // items is narrowed to string[] with at least one element\r\n *   console.log(items[0]); // Safe to access\r\n * }\r\n * ```\r\n */\r\nexport function isNotEmptyArray<T>(\r\n  value: readonly T[] | null | undefined\r\n): value is readonly T[] & { readonly length: number } {\r\n  return Array.isArray(value) && value.length > 0;\r\n}\r\n","/**\r\n * Checks if a value is a non-empty string (after trimming whitespace).\r\n *\r\n * @param value - The value to check\r\n * @returns True if the value is a string with non-whitespace content\r\n *\r\n * @example\r\n * ```typescript\r\n * isNotEmptyString('hello');     // true\r\n * isNotEmptyString('  ');        // false\r\n * isNotEmptyString('');          // false\r\n * isNotEmptyString(undefined);   // false\r\n * ```\r\n */\r\nexport function isNotEmptyString(value: string | null | undefined): value is string {\r\n  return typeof value === 'string' && value.trim().length > 0;\r\n}\r\n","/**\r\n * Type guard that checks if a value is null or undefined.\r\n *\r\n * @param value - The value to check\r\n * @returns True if the value is null or undefined\r\n *\r\n * @example\r\n * ```typescript\r\n * const value: string | null | undefined = getValue();\r\n * if (isNullOrUndefined(value)) {\r\n *   // value is narrowed to null | undefined\r\n *   console.log('Value is not set');\r\n * }\r\n * ```\r\n */\r\nexport function isNullOrUndefined(value: unknown): value is null | undefined {\r\n  return value === undefined || value === null;\r\n}\r\n","/**\r\n * Type guard that checks if a value is an empty array.\r\n *\r\n * @param value - The value to check\r\n * @returns True if the value is an array with zero elements\r\n *\r\n * @example\r\n * ```typescript\r\n * const items: string[] = getItems();\r\n * if (isEmptyArray(items)) {\r\n *   console.log('No items found');\r\n * }\r\n * ```\r\n */\r\nexport function isEmptyArray<T>(\r\n  value: readonly T[] | null | undefined\r\n): value is readonly T[] & { readonly length: 0 } {\r\n  return Array.isArray(value) && value.length === 0;\r\n}\r\n","/**\r\n * Checks if a value is an empty string or contains only whitespace.\r\n *\r\n * @param value - The value to check\r\n * @returns True if the value is an empty string or whitespace-only\r\n *\r\n * @example\r\n * ```typescript\r\n * isEmptyString('');          // true\r\n * isEmptyString('  ');        // true\r\n * isEmptyString('hello');     // false\r\n * isEmptyString(undefined);   // false (not a string)\r\n * isEmptyString(null);        // false (not a string)\r\n * ```\r\n */\r\nexport function isEmptyString(value: string | null | undefined): boolean {\r\n  return typeof value === 'string' && value.trim().length === 0;\r\n}\r\n"]}

package/dist/index-Dge_3DNw.d.mts

@@ -0,0 +1,115 @@
+/**
+ * Type guard that checks if a value is neither null nor undefined.
+ *
+ * @param value - The value to check
+ * @returns True if the value is defined (not null and not undefined)
+ *
+ * @example
+ * ```typescript
+ * const value: string | null | undefined = getValue();
+ * if (isValueDefined(value)) {
+ *   // value is narrowed to string
+ *   console.log(value.length);
+ * }
+ * ```
+ */
+declare function isValueDefined<T>(value: T | null | undefined): value is T;
+
+/**
+ * Type guard that checks if a value is a non-empty array.
+ *
+ * @param value - The value to check
+ * @returns True if the value is an array with at least one element
+ *
+ * @example
+ * ```typescript
+ * const items: string[] | undefined = getItems();
+ * if (isNotEmptyArray(items)) {
+ *   // items is narrowed to string[] with at least one element
+ *   console.log(items[0]); // Safe to access
+ * }
+ * ```
+ */
+declare function isNotEmptyArray<T>(value: readonly T[] | null | undefined): value is readonly T[] & {
+    readonly length: number;
+};
+
+/**
+ * Checks if a value is a non-empty string (after trimming whitespace).
+ *
+ * @param value - The value to check
+ * @returns True if the value is a string with non-whitespace content
+ *
+ * @example
+ * ```typescript
+ * isNotEmptyString('hello');     // true
+ * isNotEmptyString('  ');        // false
+ * isNotEmptyString('');          // false
+ * isNotEmptyString(undefined);   // false
+ * ```
+ */
+declare function isNotEmptyString(value: string | null | undefined): value is string;
+
+/**
+ * Type guard that checks if a value is null or undefined.
+ *
+ * @param value - The value to check
+ * @returns True if the value is null or undefined
+ *
+ * @example
+ * ```typescript
+ * const value: string | null | undefined = getValue();
+ * if (isNullOrUndefined(value)) {
+ *   // value is narrowed to null | undefined
+ *   console.log('Value is not set');
+ * }
+ * ```
+ */
+declare function isNullOrUndefined(value: unknown): value is null | undefined;
+
+/**
+ * Type guard that checks if a value is an empty array.
+ *
+ * @param value - The value to check
+ * @returns True if the value is an array with zero elements
+ *
+ * @example
+ * ```typescript
+ * const items: string[] = getItems();
+ * if (isEmptyArray(items)) {
+ *   console.log('No items found');
+ * }
+ * ```
+ */
+declare function isEmptyArray<T>(value: readonly T[] | null | undefined): value is readonly T[] & {
+    readonly length: 0;
+};
+
+/**
+ * Checks if a value is an empty string or contains only whitespace.
+ *
+ * @param value - The value to check
+ * @returns True if the value is an empty string or whitespace-only
+ *
+ * @example
+ * ```typescript
+ * isEmptyString('');          // true
+ * isEmptyString('  ');        // true
+ * isEmptyString('hello');     // false
+ * isEmptyString(undefined);   // false (not a string)
+ * isEmptyString(null);        // false (not a string)
+ * ```
+ */
+declare function isEmptyString(value: string | null | undefined): boolean;
+
+declare const index_isEmptyArray: typeof isEmptyArray;
+declare const index_isEmptyString: typeof isEmptyString;
+declare const index_isNotEmptyArray: typeof isNotEmptyArray;
+declare const index_isNotEmptyString: typeof isNotEmptyString;
+declare const index_isNullOrUndefined: typeof isNullOrUndefined;
+declare const index_isValueDefined: typeof isValueDefined;
+declare namespace index {
+  export { index_isEmptyArray as isEmptyArray, index_isEmptyString as isEmptyString, index_isNotEmptyArray as isNotEmptyArray, index_isNotEmptyString as isNotEmptyString, index_isNullOrUndefined as isNullOrUndefined, index_isValueDefined as isValueDefined };
+}
+
+export { isEmptyArray as a, isEmptyString as b, isNotEmptyArray as c, isNotEmptyString as d, isNullOrUndefined as e, isValueDefined as f, index as i };

package/dist/index-Dge_3DNw.d.ts

@@ -0,0 +1,115 @@
+/**
+ * Type guard that checks if a value is neither null nor undefined.
+ *
+ * @param value - The value to check
+ * @returns True if the value is defined (not null and not undefined)
+ *
+ * @example
+ * ```typescript
+ * const value: string | null | undefined = getValue();
+ * if (isValueDefined(value)) {
+ *   // value is narrowed to string
+ *   console.log(value.length);
+ * }
+ * ```
+ */
+declare function isValueDefined<T>(value: T | null | undefined): value is T;
+
+/**
+ * Type guard that checks if a value is a non-empty array.
+ *
+ * @param value - The value to check
+ * @returns True if the value is an array with at least one element
+ *
+ * @example
+ * ```typescript
+ * const items: string[] | undefined = getItems();
+ * if (isNotEmptyArray(items)) {
+ *   // items is narrowed to string[] with at least one element
+ *   console.log(items[0]); // Safe to access
+ * }
+ * ```
+ */
+declare function isNotEmptyArray<T>(value: readonly T[] | null | undefined): value is readonly T[] & {
+    readonly length: number;
+};
+
+/**
+ * Checks if a value is a non-empty string (after trimming whitespace).
+ *
+ * @param value - The value to check
+ * @returns True if the value is a string with non-whitespace content
+ *
+ * @example
+ * ```typescript
+ * isNotEmptyString('hello');     // true
+ * isNotEmptyString('  ');        // false
+ * isNotEmptyString('');          // false
+ * isNotEmptyString(undefined);   // false
+ * ```
+ */
+declare function isNotEmptyString(value: string | null | undefined): value is string;
+
+/**
+ * Type guard that checks if a value is null or undefined.
+ *
+ * @param value - The value to check
+ * @returns True if the value is null or undefined
+ *
+ * @example
+ * ```typescript
+ * const value: string | null | undefined = getValue();
+ * if (isNullOrUndefined(value)) {
+ *   // value is narrowed to null | undefined
+ *   console.log('Value is not set');
+ * }
+ * ```
+ */
+declare function isNullOrUndefined(value: unknown): value is null | undefined;
+
+/**
+ * Type guard that checks if a value is an empty array.
+ *
+ * @param value - The value to check
+ * @returns True if the value is an array with zero elements
+ *
+ * @example
+ * ```typescript
+ * const items: string[] = getItems();
+ * if (isEmptyArray(items)) {
+ *   console.log('No items found');
+ * }
+ * ```
+ */
+declare function isEmptyArray<T>(value: readonly T[] | null | undefined): value is readonly T[] & {
+    readonly length: 0;
+};
+
+/**
+ * Checks if a value is an empty string or contains only whitespace.
+ *
+ * @param value - The value to check
+ * @returns True if the value is an empty string or whitespace-only
+ *
+ * @example
+ * ```typescript
+ * isEmptyString('');          // true
+ * isEmptyString('  ');        // true
+ * isEmptyString('hello');     // false
+ * isEmptyString(undefined);   // false (not a string)
+ * isEmptyString(null);        // false (not a string)
+ * ```
+ */
+declare function isEmptyString(value: string | null | undefined): boolean;
+
+declare const index_isEmptyArray: typeof isEmptyArray;
+declare const index_isEmptyString: typeof isEmptyString;
+declare const index_isNotEmptyArray: typeof isNotEmptyArray;
+declare const index_isNotEmptyString: typeof isNotEmptyString;
+declare const index_isNullOrUndefined: typeof isNullOrUndefined;
+declare const index_isValueDefined: typeof isValueDefined;
+declare namespace index {
+  export { index_isEmptyArray as isEmptyArray, index_isEmptyString as isEmptyString, index_isNotEmptyArray as isNotEmptyArray, index_isNotEmptyString as isNotEmptyString, index_isNullOrUndefined as isNullOrUndefined, index_isValueDefined as isValueDefined };
+}
+
+export { isEmptyArray as a, isEmptyString as b, isNotEmptyArray as c, isNotEmptyString as d, isNullOrUndefined as e, isValueDefined as f, index as i };

package/dist/index-DmagV9KM.d.mts

@@ -0,0 +1,24 @@
+/**
+ * Asserts that a value is defined (not null or undefined).
+ * Throws an error if the value is null or undefined.
+ *
+ * @param value - The value to assert
+ * @param message - Optional error message
+ * @throws Error if value is null or undefined
+ *
+ * @example
+ * ```typescript
+ * const user = getUser(); // User | null
+ * assertDefined(user, 'User must exist');
+ * // user is now narrowed to User
+ * console.log(user.name);
+ * ```
+ */
+declare function assertDefined<T>(value: T | null | undefined, message?: string): asserts value is T;
+
+declare const index_assertDefined: typeof assertDefined;
+declare namespace index {
+  export { index_assertDefined as assertDefined };
+}
+
+export { assertDefined as a, index as i };

package/dist/index-DmagV9KM.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Asserts that a value is defined (not null or undefined).
+ * Throws an error if the value is null or undefined.
+ *
+ * @param value - The value to assert
+ * @param message - Optional error message
+ * @throws Error if value is null or undefined
+ *
+ * @example
+ * ```typescript
+ * const user = getUser(); // User | null
+ * assertDefined(user, 'User must exist');
+ * // user is now narrowed to User
+ * console.log(user.name);
+ * ```
+ */
+declare function assertDefined<T>(value: T | null | undefined, message?: string): asserts value is T;
+
+declare const index_assertDefined: typeof assertDefined;
+declare namespace index {
+  export { index_assertDefined as assertDefined };
+}
+
+export { assertDefined as a, index as i };

package/dist/index.d.mts

@@ -0,0 +1,2 @@
+export { i as guards, a as isEmptyArray, b as isEmptyString, c as isNotEmptyArray, d as isNotEmptyString, e as isNullOrUndefined, f as isValueDefined } from './index-Dge_3DNw.mjs';
+export { a as assertDefined, i as assertions } from './index-DmagV9KM.mjs';

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { i as guards, a as isEmptyArray, b as isEmptyString, c as isNotEmptyArray, d as isNotEmptyString, e as isNullOrUndefined, f as isValueDefined } from './index-Dge_3DNw.js';
+export { a as assertDefined, i as assertions } from './index-DmagV9KM.js';

package/dist/index.js

@@ -0,0 +1,73 @@
+'use strict';
+
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/guards/isValueDefined.ts
+function isValueDefined(value) {
+  return value !== void 0 && value !== null;
+}
+
+// src/guards/isNotEmptyArray.ts
+function isNotEmptyArray(value) {
+  return Array.isArray(value) && value.length > 0;
+}
+
+// src/guards/isNotEmptyString.ts
+function isNotEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+
+// src/guards/isNullOrUndefined.ts
+function isNullOrUndefined(value) {
+  return value === void 0 || value === null;
+}
+
+// src/guards/isEmptyArray.ts
+function isEmptyArray(value) {
+  return Array.isArray(value) && value.length === 0;
+}
+
+// src/guards/isEmptyString.ts
+function isEmptyString(value) {
+  return typeof value === "string" && value.trim().length === 0;
+}
+
+// src/assertions/assertDefined.ts
+function assertDefined(value, message) {
+  if (value === void 0 || value === null) {
+    throw new Error(message ?? "Value must be defined");
+  }
+}
+
+// src/guards/index.ts
+var guards_exports = {};
+__export(guards_exports, {
+  isEmptyArray: () => isEmptyArray,
+  isEmptyString: () => isEmptyString,
+  isNotEmptyArray: () => isNotEmptyArray,
+  isNotEmptyString: () => isNotEmptyString,
+  isNullOrUndefined: () => isNullOrUndefined,
+  isValueDefined: () => isValueDefined
+});
+
+// src/assertions/index.ts
+var assertions_exports = {};
+__export(assertions_exports, {
+  assertDefined: () => assertDefined
+});
+
+exports.assertDefined = assertDefined;
+exports.assertions = assertions_exports;
+exports.guards = guards_exports;
+exports.isEmptyArray = isEmptyArray;
+exports.isEmptyString = isEmptyString;
+exports.isNotEmptyArray = isNotEmptyArray;
+exports.isNotEmptyString = isNotEmptyString;
+exports.isNullOrUndefined = isNullOrUndefined;
+exports.isValueDefined = isValueDefined;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/guards/isValueDefined.ts","../src/guards/isNotEmptyArray.ts","../src/guards/isNotEmptyString.ts","../src/guards/isNullOrUndefined.ts","../src/guards/isEmptyArray.ts","../src/guards/isEmptyString.ts","../src/assertions/assertDefined.ts","../src/guards/index.ts","../src/assertions/index.ts"],"names":[],"mappings":";;;;;;;;;AAeO,SAAS,eAAkB,KAAA,EAAyC;AACzE,EAAA,OAAO,KAAA,KAAU,UAAa,KAAA,KAAU,IAAA;AAC1C;;;ACFO,SAAS,gBACd,KAAA,EACqD;AACrD,EAAA,OAAO,KAAA,CAAM,OAAA,CAAQ,KAAK,CAAA,IAAK,MAAM,MAAA,GAAS,CAAA;AAChD;;;ACLO,SAAS,iBAAiB,KAAA,EAAmD;AAClF,EAAA,OAAO,OAAO,KAAA,KAAU,QAAA,IAAY,KAAA,CAAM,IAAA,GAAO,MAAA,GAAS,CAAA;AAC5D;;;ACDO,SAAS,kBAAkB,KAAA,EAA2C;AAC3E,EAAA,OAAO,KAAA,KAAU,UAAa,KAAA,KAAU,IAAA;AAC1C;;;ACHO,SAAS,aACd,KAAA,EACgD;AAChD,EAAA,OAAO,KAAA,CAAM,OAAA,CAAQ,KAAK,CAAA,IAAK,MAAM,MAAA,KAAW,CAAA;AAClD;;;ACHO,SAAS,cAAc,KAAA,EAA2C;AACvE,EAAA,OAAO,OAAO,KAAA,KAAU,QAAA,IAAY,KAAA,CAAM,IAAA,GAAO,MAAA,KAAW,CAAA;AAC9D;;;ACDO,SAAS,aAAA,CACd,OACA,OAAA,EACoB;AACpB,EAAA,IAAI,KAAA,KAAU,MAAA,IAAa,KAAA,KAAU,IAAA,EAAM;AACzC,IAAA,MAAM,IAAI,KAAA,CAAM,OAAA,IAAW,uBAAuB,CAAA;AAAA,EACpD;AACF;;;ACvBA,IAAA,cAAA,GAAA;AAAA,QAAA,CAAA,cAAA,EAAA;AAAA,EAAA,YAAA,EAAA,MAAA,YAAA;AAAA,EAAA,aAAA,EAAA,MAAA,aAAA;AAAA,EAAA,eAAA,EAAA,MAAA,eAAA;AAAA,EAAA,gBAAA,EAAA,MAAA,gBAAA;AAAA,EAAA,iBAAA,EAAA,MAAA,iBAAA;AAAA,EAAA,cAAA,EAAA,MAAA;AAAA,CAAA,CAAA;;;ACAA,IAAA,kBAAA,GAAA;AAAA,QAAA,CAAA,kBAAA,EAAA;AAAA,EAAA,aAAA,EAAA,MAAA;AAAA,CAAA,CAAA","file":"index.js","sourcesContent":["/**\r\n * Type guard that checks if a value is neither null nor undefined.\r\n *\r\n * @param value - The value to check\r\n * @returns True if the value is defined (not null and not undefined)\r\n *\r\n * @example\r\n * ```typescript\r\n * const value: string | null | undefined = getValue();\r\n * if (isValueDefined(value)) {\r\n *   // value is narrowed to string\r\n *   console.log(value.length);\r\n * }\r\n * ```\r\n */\r\nexport function isValueDefined<T>(value: T | null | undefined): value is T {\r\n  return value !== undefined && value !== null;\r\n}\r\n","/**\r\n * Type guard that checks if a value is a non-empty array.\r\n *\r\n * @param value - The value to check\r\n * @returns True if the value is an array with at least one element\r\n *\r\n * @example\r\n * ```typescript\r\n * const items: string[] | undefined = getItems();\r\n * if (isNotEmptyArray(items)) {\r\n *   // items is narrowed to string[] with at least one element\r\n *   console.log(items[0]); // Safe to access\r\n * }\r\n * ```\r\n */\r\nexport function isNotEmptyArray<T>(\r\n  value: readonly T[] | null | undefined\r\n): value is readonly T[] & { readonly length: number } {\r\n  return Array.isArray(value) && value.length > 0;\r\n}\r\n","/**\r\n * Checks if a value is a non-empty string (after trimming whitespace).\r\n *\r\n * @param value - The value to check\r\n * @returns True if the value is a string with non-whitespace content\r\n *\r\n * @example\r\n * ```typescript\r\n * isNotEmptyString('hello');     // true\r\n * isNotEmptyString('  ');        // false\r\n * isNotEmptyString('');          // false\r\n * isNotEmptyString(undefined);   // false\r\n * ```\r\n */\r\nexport function isNotEmptyString(value: string | null | undefined): value is string {\r\n  return typeof value === 'string' && value.trim().length > 0;\r\n}\r\n","/**\r\n * Type guard that checks if a value is null or undefined.\r\n *\r\n * @param value - The value to check\r\n * @returns True if the value is null or undefined\r\n *\r\n * @example\r\n * ```typescript\r\n * const value: string | null | undefined = getValue();\r\n * if (isNullOrUndefined(value)) {\r\n *   // value is narrowed to null | undefined\r\n *   console.log('Value is not set');\r\n * }\r\n * ```\r\n */\r\nexport function isNullOrUndefined(value: unknown): value is null | undefined {\r\n  return value === undefined || value === null;\r\n}\r\n","/**\r\n * Type guard that checks if a value is an empty array.\r\n *\r\n * @param value - The value to check\r\n * @returns True if the value is an array with zero elements\r\n *\r\n * @example\r\n * ```typescript\r\n * const items: string[] = getItems();\r\n * if (isEmptyArray(items)) {\r\n *   console.log('No items found');\r\n * }\r\n * ```\r\n */\r\nexport function isEmptyArray<T>(\r\n  value: readonly T[] | null | undefined\r\n): value is readonly T[] & { readonly length: 0 } {\r\n  return Array.isArray(value) && value.length === 0;\r\n}\r\n","/**\r\n * Checks if a value is an empty string or contains only whitespace.\r\n *\r\n * @param value - The value to check\r\n * @returns True if the value is an empty string or whitespace-only\r\n *\r\n * @example\r\n * ```typescript\r\n * isEmptyString('');          // true\r\n * isEmptyString('  ');        // true\r\n * isEmptyString('hello');     // false\r\n * isEmptyString(undefined);   // false (not a string)\r\n * isEmptyString(null);        // false (not a string)\r\n * ```\r\n */\r\nexport function isEmptyString(value: string | null | undefined): boolean {\r\n  return typeof value === 'string' && value.trim().length === 0;\r\n}\r\n","/**\r\n * Asserts that a value is defined (not null or undefined).\r\n * Throws an error if the value is null or undefined.\r\n *\r\n * @param value - The value to assert\r\n * @param message - Optional error message\r\n * @throws Error if value is null or undefined\r\n *\r\n * @example\r\n * ```typescript\r\n * const user = getUser(); // User | null\r\n * assertDefined(user, 'User must exist');\r\n * // user is now narrowed to User\r\n * console.log(user.name);\r\n * ```\r\n */\r\nexport function assertDefined<T>(\r\n  value: T | null | undefined,\r\n  message?: string\r\n): asserts value is T {\r\n  if (value === undefined || value === null) {\r\n    throw new Error(message ?? 'Value must be defined');\r\n  }\r\n}\r\n","export { isValueDefined } from './isValueDefined';\r\nexport { isNotEmptyArray } from './isNotEmptyArray';\r\nexport { isNotEmptyString } from './isNotEmptyString';\r\nexport { isNullOrUndefined } from './isNullOrUndefined';\r\nexport { isEmptyArray } from './isEmptyArray';\r\nexport { isEmptyString } from './isEmptyString';\r\n","export { assertDefined } from './assertDefined';\r\n"]}

package/dist/index.mjs

@@ -0,0 +1,63 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/guards/isValueDefined.ts
+function isValueDefined(value) {
+  return value !== void 0 && value !== null;
+}
+
+// src/guards/isNotEmptyArray.ts
+function isNotEmptyArray(value) {
+  return Array.isArray(value) && value.length > 0;
+}
+
+// src/guards/isNotEmptyString.ts
+function isNotEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+
+// src/guards/isNullOrUndefined.ts
+function isNullOrUndefined(value) {
+  return value === void 0 || value === null;
+}
+
+// src/guards/isEmptyArray.ts
+function isEmptyArray(value) {
+  return Array.isArray(value) && value.length === 0;
+}
+
+// src/guards/isEmptyString.ts
+function isEmptyString(value) {
+  return typeof value === "string" && value.trim().length === 0;
+}
+
+// src/assertions/assertDefined.ts
+function assertDefined(value, message) {
+  if (value === void 0 || value === null) {
+    throw new Error(message ?? "Value must be defined");
+  }
+}
+
+// src/guards/index.ts
+var guards_exports = {};
+__export(guards_exports, {
+  isEmptyArray: () => isEmptyArray,
+  isEmptyString: () => isEmptyString,
+  isNotEmptyArray: () => isNotEmptyArray,
+  isNotEmptyString: () => isNotEmptyString,
+  isNullOrUndefined: () => isNullOrUndefined,
+  isValueDefined: () => isValueDefined
+});
+
+// src/assertions/index.ts
+var assertions_exports = {};
+__export(assertions_exports, {
+  assertDefined: () => assertDefined
+});
+
+export { assertDefined, assertions_exports as assertions, guards_exports as guards, isEmptyArray, isEmptyString, isNotEmptyArray, isNotEmptyString, isNullOrUndefined, isValueDefined };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/guards/isValueDefined.ts","../src/guards/isNotEmptyArray.ts","../src/guards/isNotEmptyString.ts","../src/guards/isNullOrUndefined.ts","../src/guards/isEmptyArray.ts","../src/guards/isEmptyString.ts","../src/assertions/assertDefined.ts","../src/guards/index.ts","../src/assertions/index.ts"],"names":[],"mappings":";;;;;;;AAeO,SAAS,eAAkB,KAAA,EAAyC;AACzE,EAAA,OAAO,KAAA,KAAU,UAAa,KAAA,KAAU,IAAA;AAC1C;;;ACFO,SAAS,gBACd,KAAA,EACqD;AACrD,EAAA,OAAO,KAAA,CAAM,OAAA,CAAQ,KAAK,CAAA,IAAK,MAAM,MAAA,GAAS,CAAA;AAChD;;;ACLO,SAAS,iBAAiB,KAAA,EAAmD;AAClF,EAAA,OAAO,OAAO,KAAA,KAAU,QAAA,IAAY,KAAA,CAAM,IAAA,GAAO,MAAA,GAAS,CAAA;AAC5D;;;ACDO,SAAS,kBAAkB,KAAA,EAA2C;AAC3E,EAAA,OAAO,KAAA,KAAU,UAAa,KAAA,KAAU,IAAA;AAC1C;;;ACHO,SAAS,aACd,KAAA,EACgD;AAChD,EAAA,OAAO,KAAA,CAAM,OAAA,CAAQ,KAAK,CAAA,IAAK,MAAM,MAAA,KAAW,CAAA;AAClD;;;ACHO,SAAS,cAAc,KAAA,EAA2C;AACvE,EAAA,OAAO,OAAO,KAAA,KAAU,QAAA,IAAY,KAAA,CAAM,IAAA,GAAO,MAAA,KAAW,CAAA;AAC9D;;;ACDO,SAAS,aAAA,CACd,OACA,OAAA,EACoB;AACpB,EAAA,IAAI,KAAA,KAAU,MAAA,IAAa,KAAA,KAAU,IAAA,EAAM;AACzC,IAAA,MAAM,IAAI,KAAA,CAAM,OAAA,IAAW,uBAAuB,CAAA;AAAA,EACpD;AACF;;;ACvBA,IAAA,cAAA,GAAA;AAAA,QAAA,CAAA,cAAA,EAAA;AAAA,EAAA,YAAA,EAAA,MAAA,YAAA;AAAA,EAAA,aAAA,EAAA,MAAA,aAAA;AAAA,EAAA,eAAA,EAAA,MAAA,eAAA;AAAA,EAAA,gBAAA,EAAA,MAAA,gBAAA;AAAA,EAAA,iBAAA,EAAA,MAAA,iBAAA;AAAA,EAAA,cAAA,EAAA,MAAA;AAAA,CAAA,CAAA;;;ACAA,IAAA,kBAAA,GAAA;AAAA,QAAA,CAAA,kBAAA,EAAA;AAAA,EAAA,aAAA,EAAA,MAAA;AAAA,CAAA,CAAA","file":"index.mjs","sourcesContent":["/**\r\n * Type guard that checks if a value is neither null nor undefined.\r\n *\r\n * @param value - The value to check\r\n * @returns True if the value is defined (not null and not undefined)\r\n *\r\n * @example\r\n * ```typescript\r\n * const value: string | null | undefined = getValue();\r\n * if (isValueDefined(value)) {\r\n *   // value is narrowed to string\r\n *   console.log(value.length);\r\n * }\r\n * ```\r\n */\r\nexport function isValueDefined<T>(value: T | null | undefined): value is T {\r\n  return value !== undefined && value !== null;\r\n}\r\n","/**\r\n * Type guard that checks if a value is a non-empty array.\r\n *\r\n * @param value - The value to check\r\n * @returns True if the value is an array with at least one element\r\n *\r\n * @example\r\n * ```typescript\r\n * const items: string[] | undefined = getItems();\r\n * if (isNotEmptyArray(items)) {\r\n *   // items is narrowed to string[] with at least one element\r\n *   console.log(items[0]); // Safe to access\r\n * }\r\n * ```\r\n */\r\nexport function isNotEmptyArray<T>(\r\n  value: readonly T[] | null | undefined\r\n): value is readonly T[] & { readonly length: number } {\r\n  return Array.isArray(value) && value.length > 0;\r\n}\r\n","/**\r\n * Checks if a value is a non-empty string (after trimming whitespace).\r\n *\r\n * @param value - The value to check\r\n * @returns True if the value is a string with non-whitespace content\r\n *\r\n * @example\r\n * ```typescript\r\n * isNotEmptyString('hello');     // true\r\n * isNotEmptyString('  ');        // false\r\n * isNotEmptyString('');          // false\r\n * isNotEmptyString(undefined);   // false\r\n * ```\r\n */\r\nexport function isNotEmptyString(value: string | null | undefined): value is string {\r\n  return typeof value === 'string' && value.trim().length > 0;\r\n}\r\n","/**\r\n * Type guard that checks if a value is null or undefined.\r\n *\r\n * @param value - The value to check\r\n * @returns True if the value is null or undefined\r\n *\r\n * @example\r\n * ```typescript\r\n * const value: string | null | undefined = getValue();\r\n * if (isNullOrUndefined(value)) {\r\n *   // value is narrowed to null | undefined\r\n *   console.log('Value is not set');\r\n * }\r\n * ```\r\n */\r\nexport function isNullOrUndefined(value: unknown): value is null | undefined {\r\n  return value === undefined || value === null;\r\n}\r\n","/**\r\n * Type guard that checks if a value is an empty array.\r\n *\r\n * @param value - The value to check\r\n * @returns True if the value is an array with zero elements\r\n *\r\n * @example\r\n * ```typescript\r\n * const items: string[] = getItems();\r\n * if (isEmptyArray(items)) {\r\n *   console.log('No items found');\r\n * }\r\n * ```\r\n */\r\nexport function isEmptyArray<T>(\r\n  value: readonly T[] | null | undefined\r\n): value is readonly T[] & { readonly length: 0 } {\r\n  return Array.isArray(value) && value.length === 0;\r\n}\r\n","/**\r\n * Checks if a value is an empty string or contains only whitespace.\r\n *\r\n * @param value - The value to check\r\n * @returns True if the value is an empty string or whitespace-only\r\n *\r\n * @example\r\n * ```typescript\r\n * isEmptyString('');          // true\r\n * isEmptyString('  ');        // true\r\n * isEmptyString('hello');     // false\r\n * isEmptyString(undefined);   // false (not a string)\r\n * isEmptyString(null);        // false (not a string)\r\n * ```\r\n */\r\nexport function isEmptyString(value: string | null | undefined): boolean {\r\n  return typeof value === 'string' && value.trim().length === 0;\r\n}\r\n","/**\r\n * Asserts that a value is defined (not null or undefined).\r\n * Throws an error if the value is null or undefined.\r\n *\r\n * @param value - The value to assert\r\n * @param message - Optional error message\r\n * @throws Error if value is null or undefined\r\n *\r\n * @example\r\n * ```typescript\r\n * const user = getUser(); // User | null\r\n * assertDefined(user, 'User must exist');\r\n * // user is now narrowed to User\r\n * console.log(user.name);\r\n * ```\r\n */\r\nexport function assertDefined<T>(\r\n  value: T | null | undefined,\r\n  message?: string\r\n): asserts value is T {\r\n  if (value === undefined || value === null) {\r\n    throw new Error(message ?? 'Value must be defined');\r\n  }\r\n}\r\n","export { isValueDefined } from './isValueDefined';\r\nexport { isNotEmptyArray } from './isNotEmptyArray';\r\nexport { isNotEmptyString } from './isNotEmptyString';\r\nexport { isNullOrUndefined } from './isNullOrUndefined';\r\nexport { isEmptyArray } from './isEmptyArray';\r\nexport { isEmptyString } from './isEmptyString';\r\n","export { assertDefined } from './assertDefined';\r\n"]}

package/package.json

@@ -0,0 +1,93 @@
+{
+  "name": "@dloizides/utils",
+  "version": "1.0.0",
+  "description": "Type-safe utility functions for TypeScript projects",
+  "keywords": [
+    "typescript",
+    "utilities",
+    "type-guards",
+    "validation"
+  ],
+  "author": "dloizides",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/openmindednewby/utils.git"
+  },
+  "homepage": "https://github.com/openmindednewby/utils#readme",
+  "bugs": {
+    "url": "https://github.com/openmindednewby/utils/issues"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "require": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      }
+    },
+    "./guards": {
+      "require": {
+        "types": "./dist/guards/index.d.ts",
+        "default": "./dist/guards/index.js"
+      },
+      "import": {
+        "types": "./dist/guards/index.d.mts",
+        "default": "./dist/guards/index.mjs"
+      }
+    },
+    "./assertions": {
+      "require": {
+        "types": "./dist/assertions/index.d.ts",
+        "default": "./dist/assertions/index.js"
+      },
+      "import": {
+        "types": "./dist/assertions/index.d.mts",
+        "default": "./dist/assertions/index.mjs"
+      }
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "sideEffects": false,
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "build:watch": "tsup --watch",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "lint": "eslint src --ext .ts",
+    "lint:fix": "eslint src --ext .ts --fix",
+    "typecheck": "tsc --noEmit",
+    "clean": "rimraf dist",
+    "prepublishOnly": "npm run clean && npm run build && npm run test",
+    "version": "npm run build",
+    "postversion": "git push && git push --tags"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.0",
+    "@types/node": "^20.0.0",
+    "@typescript-eslint/eslint-plugin": "^7.0.0",
+    "@typescript-eslint/parser": "^7.0.0",
+    "eslint": "^8.57.0",
+    "jest": "^29.7.0",
+    "rimraf": "^5.0.0",
+    "ts-jest": "^29.1.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.4.0"
+  },
+  "peerDependencies": {},
+  "dependencies": {}
+}