ts-data-forge 14.6.0 → 14.6.2

package/dist/guard/is-record.mjs

@@ -1,7 +1,90 @@
 import { isNonNullObject } from './is-non-null-object.mjs';
-
-const isRecord = (u) => isNonNullObject(u) && !Array.isArray(u);
-const isMutableRecord = isRecord;
-
-export { isMutableRecord, isRecord };
-//# sourceMappingURL=is-record.mjs.map
+/**
+ * Type guard that checks if a value is a record — a non-null, non-array
+ * object — and narrows it to `UnknownRecord` (= `ReadonlyRecord<string,
+ * unknown>`).
+ *
+ * This function is designed to be combined with {@link hasKey} to probe
+ * values of type `unknown` (e.g. parsed JSON, caught errors, external data)
+ * in a type-safe way: `if (isRecord(u) && hasKey(u, 'some-key')) { ... }`.
+ *
+ * **Type Narrowing Behavior:**
+ *
+ * - Narrows `unknown` to `UnknownRecord` (= `ReadonlyRecord<string, unknown>`)
+ * - Excludes `null`, `undefined`, primitives, and functions
+ * - Excludes arrays: arrays have no string index signature, so they are not
+ *   assignable to `UnknownRecord`; admitting them at runtime would be
+ *   inconsistent with the narrowed type
+ * - Returns `true` for every other non-null object, including dictionary
+ *   objects created with `Object.create(null)` and instances such as `Date`,
+ *   `RegExp`, `Map`, `Set`, `Error`, and user-defined classes
+ *
+ * **Why non-plain objects are included:** since every property of
+ * `UnknownRecord` is typed `unknown`, reading properties from any object
+ * through this narrowing is type-safe, and `hasKey` (backed by
+ * `Object.hasOwn`) answers own-property questions correctly on any object
+ * (e.g. `Map` entries are not own properties, so `hasKey` correctly returns
+ * `false` for them). Restricting the guard to plain objects would require
+ * prototype checks that misjudge cross-realm objects and would prevent
+ * probing useful instances such as `Error` subclasses.
+ *
+ * **Implementation:** `isNonNullObject(u) && !Array.isArray(u)`.
+ *
+ * @example
+ *
+ * ```ts
+ * const entries: readonly unknown[] = [
+ *   { id: 1 },
+ *   [1, 2],
+ *   'str',
+ *   0,
+ *   null,
+ * ] as const;
+ *
+ * const records = entries.filter(isRecord);
+ *
+ * assert.deepStrictEqual(records, [{ id: 1 }]);
+ * ```
+ *
+ * @param u - The value to check
+ * @returns `true` if `u` is a non-null, non-array object, `false` otherwise.
+ *   When `true`, TypeScript narrows the type to `UnknownRecord`.
+ * @see {@link isNonNullObject} - For checking any non-null object (includes arrays)
+ * @see {@link hasKey} - For checking if a record has specific keys
+ */
+export const isRecord = (u) => isNonNullObject(u) && !Array.isArray(u);
+/**
+ * Type guard that checks if a value is a mutable record.
+ *
+ * This function has the same runtime behavior as {@link isRecord} (non-null,
+ * non-array object check), but narrows the type to `MutableRecord<string,
+ * unknown>`, which is useful when you need to add or overwrite properties on
+ * the narrowed object.
+ *
+ * **Type Narrowing Behavior:**
+ *
+ * - Narrows `unknown` to `MutableRecord<string, unknown>`
+ * - Excludes `null`, `undefined`, primitives, functions, and arrays
+ * - Returns `true` for every other non-null object (see {@link isRecord} for
+ *   details on non-plain objects such as `Date`, `Map`, and `Set`)
+ *
+ * **Implementation:** This is a type alias for {@link isRecord}.
+ *
+ * @example
+ *
+ * ```ts
+ * const obj: unknown = { foo: 1 } as const;
+ *
+ * if (isMutableRecord(obj)) {
+ *   obj['bar'] = 2; // Safe: obj is now known to be a mutable record
+ * }
+ * ```
+ *
+ * @param u - The value to check
+ * @returns `true` if `u` is a non-null, non-array object, `false` otherwise.
+ *   When `true`, TypeScript narrows the type to `MutableRecord<string,
+ *   unknown>`.
+ * @see {@link isRecord} - For the underlying implementation and more details
+ */
+export const isMutableRecord = isRecord;
+//# sourceMappingURL=is-record.mjs.map

package/dist/guard/is-record.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"is-record.mjs","sources":["../../src/guard/is-record.mts"],"sourcesContent":["import { type MutableRecord, type UnknownRecord } from 'ts-type-forge';\nimport { isNonNullObject } from './is-non-null-object.mjs';\n\n/**\n * Type guard that checks if a value is a record — a non-null, non-array\n * object — and narrows it to `UnknownRecord` (= `ReadonlyRecord<string,\n * unknown>`).\n *\n * This function is designed to be combined with {@link hasKey} to probe\n * values of type `unknown` (e.g. parsed JSON, caught errors, external data)\n * in a type-safe way: `if (isRecord(u) && hasKey(u, 'some-key')) { ... }`.\n *\n * **Type Narrowing Behavior:**\n *\n * - Narrows `unknown` to `UnknownRecord` (= `ReadonlyRecord<string, unknown>`)\n * - Excludes `null`, `undefined`, primitives, and functions\n * - Excludes arrays: arrays have no string index signature, so they are not\n *   assignable to `UnknownRecord`; admitting them at runtime would be\n *   inconsistent with the narrowed type\n * - Returns `true` for every other non-null object, including dictionary\n *   objects created with `Object.create(null)` and instances such as `Date`,\n *   `RegExp`, `Map`, `Set`, `Error`, and user-defined classes\n *\n * **Why non-plain objects are included:** since every property of\n * `UnknownRecord` is typed `unknown`, reading properties from any object\n * through this narrowing is type-safe, and `hasKey` (backed by\n * `Object.hasOwn`) answers own-property questions correctly on any object\n * (e.g. `Map` entries are not own properties, so `hasKey` correctly returns\n * `false` for them). Restricting the guard to plain objects would require\n * prototype checks that misjudge cross-realm objects and would prevent\n * probing useful instances such as `Error` subclasses.\n *\n * **Implementation:** `isNonNullObject(u) && !Array.isArray(u)`.\n *\n * @example\n *\n * ```ts\n * const entries: readonly unknown[] = [\n *   { id: 1 },\n *   [1, 2],\n *   'str',\n *   0,\n *   null,\n * ] as const;\n *\n * const records = entries.filter(isRecord);\n *\n * assert.deepStrictEqual(records, [{ id: 1 }]);\n * ```\n *\n * @param u - The value to check\n * @returns `true` if `u` is a non-null, non-array object, `false` otherwise.\n *   When `true`, TypeScript narrows the type to `UnknownRecord`.\n * @see {@link isNonNullObject} - For checking any non-null object (includes arrays)\n * @see {@link hasKey} - For checking if a record has specific keys\n */\nexport const isRecord = (u: unknown): u is UnknownRecord =>\n  isNonNullObject(u) && !Array.isArray(u);\n\n/**\n * Type guard that checks if a value is a mutable record.\n *\n * This function has the same runtime behavior as {@link isRecord} (non-null,\n * non-array object check), but narrows the type to `MutableRecord<string,\n * unknown>`, which is useful when you need to add or overwrite properties on\n * the narrowed object.\n *\n * **Type Narrowing Behavior:**\n *\n * - Narrows `unknown` to `MutableRecord<string, unknown>`\n * - Excludes `null`, `undefined`, primitives, functions, and arrays\n * - Returns `true` for every other non-null object (see {@link isRecord} for\n *   details on non-plain objects such as `Date`, `Map`, and `Set`)\n *\n * **Implementation:** This is a type alias for {@link isRecord}.\n *\n * @example\n *\n * ```ts\n * const obj: unknown = { foo: 1 } as const;\n *\n * if (isMutableRecord(obj)) {\n *   obj['bar'] = 2; // Safe: obj is now known to be a mutable record\n * }\n * ```\n *\n * @param u - The value to check\n * @returns `true` if `u` is a non-null, non-array object, `false` otherwise.\n *   When `true`, TypeScript narrows the type to `MutableRecord<string,\n *   unknown>`.\n * @see {@link isRecord} - For the underlying implementation and more details\n */\nexport const isMutableRecord: (\n  u: unknown,\n) => u is MutableRecord<string, unknown> = isRecord;\n"],"names":[],"mappings":";;AAwDO,MAAM,QAAA,GAAW,CAAC,CAAA,KACvB,eAAA,CAAgB,CAAC,CAAA,IAAK,CAAC,KAAA,CAAM,OAAA,CAAQ,CAAC;AAmCjC,MAAM,eAAA,GAE8B;;;;"}
+{"version":3,"file":"is-record.mjs","sourceRoot":"","sources":["../../src/guard/is-record.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAE3D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,CAAC,CAAU,EAAsB,EAAE,CACzD,eAAe,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;AAE1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,MAAM,CAAC,MAAM,eAAe,GAEe,QAAQ,CAAC"}

package/dist/guard/is-type.mjs

@@ -1,19 +1,404 @@
-const isUndefined = (u) => u === void 0;
-const isNotUndefined = (u) => u !== void 0;
-const isBoolean = (u) => typeof u === "boolean";
-const isNotBoolean = (u) => typeof u !== "boolean";
-const isNumber = (u) => typeof u === "number";
-const isNotNumber = (u) => typeof u !== "number";
-const isBigint = (u) => typeof u === "bigint";
-const isNotBigint = (u) => typeof u !== "bigint";
-const isString = (u) => typeof u === "string";
-const isNotString = (u) => typeof u !== "string";
-const isSymbol = (u) => typeof u === "symbol";
-const isNotSymbol = (u) => typeof u !== "symbol";
-const isNull = (u) => u === null;
-const isNotNull = (u) => u !== null;
-const isNullish = (u) => u == null;
-const isNonNullish = (u) => u != null;
-
-export { isBigint, isBoolean, isNonNullish, isNotBigint, isNotBoolean, isNotNull, isNotNumber, isNotString, isNotSymbol, isNotUndefined, isNull, isNullish, isNumber, isString, isSymbol, isUndefined };
-//# sourceMappingURL=is-type.mjs.map
+/**
+ * Type guard that checks if a value is `undefined`.
+ *
+ * **Type Narrowing Behavior:**
+ *
+ * - Narrows the input type to `undefined` when `true`
+ * - Useful for explicit undefined checks
+ *
+ * @example
+ *
+ * ```ts
+ * const values: readonly (number | undefined)[] = [1, undefined, 2] as const;
+ *
+ * const undefinedValues = values.filter(isUndefined);
+ *
+ * assert.deepStrictEqual(undefinedValues, [undefined]);
+ * ```
+ *
+ * @param u - The value to check
+ * @returns `true` if `u` is `undefined`, `false` otherwise. When `true`,
+ *   TypeScript narrows the type to `undefined`.
+ */
+export const isUndefined = (u) => u === undefined;
+/**
+ * Type guard that checks if a value is not `undefined`.
+ *
+ * **Type Narrowing Behavior:**
+ *
+ * - Excludes `undefined` from the input type when `true`
+ * - Preserves all other types in the union
+ * - Commonly used to filter out undefined values
+ *
+ * @example
+ *
+ * ```ts
+ * const values: readonly (number | undefined)[] = [1, undefined, 2] as const;
+ *
+ * const definedValues = values.filter(isNotUndefined);
+ *
+ * assert.deepStrictEqual(definedValues, [1, 2]);
+ * ```
+ *
+ * @template T - The type of the input value
+ * @param u - The value to check
+ * @returns `true` if `u` is not `undefined`, `false` otherwise. When `true`,
+ *   TypeScript excludes `undefined` from the type.
+ */
+export const isNotUndefined = (u) => u !== undefined;
+/**
+ * Type guard that checks if a value is a boolean.
+ *
+ * **Type Narrowing Behavior:**
+ *
+ * - Narrows `unknown` to `boolean` when `true`
+ * - Preserves literal boolean types (`true | false`)
+ *
+ * @example
+ *
+ * ```ts
+ * const flags: readonly unknown[] = [true, 'no', false] as const;
+ *
+ * const booleans = flags.filter(isBoolean);
+ *
+ * assert.deepStrictEqual(booleans, [true, false]);
+ * ```
+ *
+ * @param u - The value to check
+ * @returns `true` if `u` is a boolean, `false` otherwise. When `true`,
+ *   TypeScript narrows the type to `boolean`.
+ */
+export const isBoolean = (u) => typeof u === 'boolean';
+/**
+ * Type guard that checks if a value is not a boolean.
+ *
+ * **Type Narrowing Behavior:**
+ *
+ * - Excludes `boolean` from the input type when `true`
+ * - Preserves all other types in the union
+ *
+ * @example
+ *
+ * ```ts
+ * const flags: readonly unknown[] = [true, 'no', false] as const;
+ *
+ * const nonBooleans = flags.filter(isNotBoolean);
+ *
+ * assert.deepStrictEqual(nonBooleans, ['no']);
+ * ```
+ *
+ * @template T - The type of the input value
+ * @param u - The value to check
+ * @returns `true` if `u` is not a boolean, `false` otherwise. When `true`,
+ *   TypeScript excludes `boolean` from the type.
+ */
+export const isNotBoolean = (u) => typeof u !== 'boolean';
+/**
+ * Type guard that checks if a value is a number.
+ *
+ * **Type Narrowing Behavior:**
+ *
+ * - Narrows `unknown` to `number` when `true`
+ * - Includes `NaN`, `Infinity`, and `-Infinity` as valid numbers
+ * - Preserves literal number types when possible
+ *
+ * @example
+ *
+ * ```ts
+ * const mixed: readonly unknown[] = [1, '2', 3] as const;
+ *
+ * const numbers = mixed.filter(isNumber);
+ *
+ * assert.deepStrictEqual(numbers, [1, 3]);
+ * ```
+ *
+ * @param u - The value to check
+ * @returns `true` if `u` is a number, `false` otherwise. When `true`,
+ *   TypeScript narrows the type to `number`.
+ */
+export const isNumber = (u) => typeof u === 'number';
+/**
+ * Type guard that checks if a value is not a number.
+ *
+ * **Type Narrowing Behavior:**
+ *
+ * - Excludes `number` from the input type when `true`
+ * - Preserves all other types in the union
+ *
+ * @example
+ *
+ * ```ts
+ * const mixed: readonly unknown[] = [1, '2', 3] as const;
+ *
+ * const nonNumbers = mixed.filter(isNotNumber);
+ *
+ * assert.deepStrictEqual(nonNumbers, ['2']);
+ * ```
+ *
+ * @template T - The type of the input value
+ * @param u - The value to check
+ * @returns `true` if `u` is not a number, `false` otherwise. When `true`,
+ *   TypeScript excludes `number` from the type.
+ */
+export const isNotNumber = (u) => typeof u !== 'number';
+/**
+ * Type guard that checks if a value is a bigint.
+ *
+ * **Type Narrowing Behavior:**
+ *
+ * - Narrows `unknown` to `bigint` when `true`
+ * - Identifies values created with `BigInt()` constructor or `n` suffix
+ *
+ * @example
+ *
+ * ```ts
+ * const values: readonly unknown[] = [1n, 2, 3n] as const;
+ *
+ * const bigints = values.filter(isBigint);
+ *
+ * assert.deepStrictEqual(bigints, [1n, 3n]);
+ * ```
+ *
+ * @param u - The value to check
+ * @returns `true` if `u` is a bigint, `false` otherwise. When `true`,
+ *   TypeScript narrows the type to `bigint`.
+ */
+export const isBigint = (u) => typeof u === 'bigint';
+/**
+ * Type guard that checks if a value is not a bigint.
+ *
+ * **Type Narrowing Behavior:**
+ *
+ * - Excludes `bigint` from the input type when `true`
+ * - Preserves all other types in the union
+ *
+ * @example
+ *
+ * ```ts
+ * const values: readonly unknown[] = [1n, 2, 3n] as const;
+ *
+ * const nonBigints = values.filter(isNotBigint);
+ *
+ * assert.deepStrictEqual(nonBigints, [2]);
+ * ```
+ *
+ * @template T - The type of the input value
+ * @param u - The value to check
+ * @returns `true` if `u` is not a bigint, `false` otherwise. When `true`,
+ *   TypeScript excludes `bigint` from the type.
+ */
+export const isNotBigint = (u) => typeof u !== 'bigint';
+/**
+ * Type guard that checks if a value is a string.
+ *
+ * **Type Narrowing Behavior:**
+ *
+ * - Narrows `unknown` to `string` when `true`
+ * - Preserves literal string types when possible
+ * - Includes empty strings
+ *
+ * @example
+ *
+ * ```ts
+ * const values: readonly unknown[] = ['Ada', 42, 'Lovelace'] as const;
+ *
+ * const strings = values.filter(isString);
+ *
+ * assert.deepStrictEqual(strings, ['Ada', 'Lovelace']);
+ * ```
+ *
+ * @param u - The value to check
+ * @returns `true` if `u` is a string, `false` otherwise. When `true`,
+ *   TypeScript narrows the type to `string`.
+ */
+export const isString = (u) => typeof u === 'string';
+/**
+ * Type guard that checks if a value is not a string.
+ *
+ * **Type Narrowing Behavior:**
+ *
+ * - Excludes `string` from the input type when `true`
+ * - Preserves all other types in the union
+ *
+ * @example
+ *
+ * ```ts
+ * const values: readonly unknown[] = ['Ada', 42, 'Lovelace'] as const;
+ *
+ * const nonStrings = values.filter(isNotString);
+ *
+ * assert.deepStrictEqual(nonStrings, [42]);
+ * ```
+ *
+ * @template T - The type of the input value
+ * @param u - The value to check
+ * @returns `true` if `u` is not a string, `false` otherwise. When `true`,
+ *   TypeScript excludes `string` from the type.
+ */
+export const isNotString = (u) => typeof u !== 'string';
+/**
+ * Type guard that checks if a value is a symbol.
+ *
+ * **Type Narrowing Behavior:**
+ *
+ * - Narrows `unknown` to `symbol` when `true`
+ * - Identifies values created with `Symbol()` constructor
+ *
+ * @example
+ *
+ * ```ts
+ * const id = Symbol('id');
+ *
+ * const shared = Symbol.for('shared');
+ *
+ * const tokens: readonly unknown[] = [id, 'shared', shared] as const;
+ *
+ * const symbols = tokens.filter(isSymbol);
+ *
+ * assert.deepStrictEqual(symbols, [id, shared]);
+ * ```
+ *
+ * @param u - The value to check
+ * @returns `true` if `u` is a symbol, `false` otherwise. When `true`,
+ *   TypeScript narrows the type to `symbol`.
+ */
+export const isSymbol = (u) => typeof u === 'symbol';
+/**
+ * Type guard that checks if a value is not a symbol.
+ *
+ * **Type Narrowing Behavior:**
+ *
+ * - Excludes `symbol` from the input type when `true`
+ * - Preserves all other types in the union
+ *
+ * @example
+ *
+ * ```ts
+ * const id = Symbol('id');
+ *
+ * const tokens: readonly unknown[] = [id, 'shared'] as const;
+ *
+ * const nonSymbols = tokens.filter(isNotSymbol);
+ *
+ * assert.deepStrictEqual(nonSymbols, ['shared']);
+ * ```
+ *
+ * @template T - The type of the input value
+ * @param u - The value to check
+ * @returns `true` if `u` is not a symbol, `false` otherwise. When `true`,
+ *   TypeScript excludes `symbol` from the type.
+ */
+export const isNotSymbol = (u) => typeof u !== 'symbol';
+/**
+ * Type guard that checks if a value is `null`.
+ *
+ * **Type Narrowing Behavior:**
+ *
+ * - Narrows the input type to `null` when `true`
+ * - Useful for explicit null checks
+ *
+ * @example
+ *
+ * ```ts
+ * const values: readonly (number | null)[] = [null, 5] as const;
+ *
+ * const nullValues = values.filter(isNull);
+ *
+ * assert.deepStrictEqual(nullValues, [null]);
+ * ```
+ *
+ * @param u - The value to check
+ * @returns `true` if `u` is `null`, `false` otherwise. When `true`, TypeScript
+ *   narrows the type to `null`.
+ */
+export const isNull = (u) => u === null;
+/**
+ * Type guard that checks if a value is not `null`.
+ *
+ * **Type Narrowing Behavior:**
+ *
+ * - Excludes `null` from the input type when `true`
+ * - Preserves all other types including `undefined`
+ * - Commonly used to filter out null values
+ *
+ * @example
+ *
+ * ```ts
+ * const values: readonly (number | null)[] = [null, 5] as const;
+ *
+ * const nonNullValues = values.filter(isNotNull);
+ *
+ * assert.deepStrictEqual(nonNullValues, [5]);
+ * ```
+ *
+ * @template T - The type of the input value (which could be `null`)
+ * @param u - The value to check
+ * @returns `true` if `u` is not `null`, `false` otherwise. When `true`,
+ *   TypeScript excludes `null` from the type.
+ */
+export const isNotNull = (u) => u !== null;
+/**
+ * Type guard that checks if a value is `null` or `undefined` (nullish).
+ *
+ * This function uses the loose equality operator (`==`) to check for both
+ * `null` and `undefined` in a single comparison, which is the standard
+ * JavaScript idiom for nullish checks.
+ *
+ * **Type Narrowing Behavior:**
+ *
+ * - Narrows the input type to `null | undefined` when `true`
+ * - Useful for checking if a value is "nullish" (either null or undefined)
+ *
+ * @example
+ *
+ * ```ts
+ * const values: readonly (string | null | undefined)[] = [
+ *   'Ada',
+ *   null,
+ *   undefined,
+ * ] as const;
+ *
+ * const nullishValues = values.filter(isNullish);
+ *
+ * assert.deepStrictEqual(nullishValues, [null, undefined]);
+ * ```
+ *
+ * @param u - The value to check
+ * @returns `true` if `u` is `null` or `undefined`, `false` otherwise. When
+ *   `true`, TypeScript narrows the type to `null | undefined`.
+ */
+export const isNullish = (u) => u == null;
+/**
+ * Type guard that checks if a value is not `null` or `undefined` (non-nullish).
+ *
+ * This function uses the loose inequality operator (`!=`) to check that a value
+ * is neither `null` nor `undefined` in a single comparison. This is equivalent
+ * to TypeScript's `NonNullable<T>` utility type.
+ *
+ * **Type Narrowing Behavior:**
+ *
+ * - Excludes both `null` and `undefined` from the input type when `true`
+ * - Equivalent to applying TypeScript's `NonNullable<T>` utility type
+ * - Commonly used to filter out nullish values from arrays
+ *
+ * @example
+ *
+ * ```ts
+ * const values: readonly (string | null | undefined)[] = [
+ *   'Ada',
+ *   null,
+ *   undefined,
+ * ] as const;
+ *
+ * const definedValues = values.filter(isNonNullish);
+ *
+ * assert.deepStrictEqual(definedValues, ['Ada']);
+ * ```
+ *
+ * @template T - The type of the input value
+ * @param u - The value to check
+ * @returns `true` if `u` is not `null` and not `undefined`, `false` otherwise.
+ *   When `true`, TypeScript narrows the type to `NonNullable<T>`.
+ */
+export const isNonNullish = (u) => u != null;
+//# sourceMappingURL=is-type.mjs.map

package/dist/guard/is-type.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"is-type.mjs","sources":["../../src/guard/is-type.mts"],"sourcesContent":["import { type RelaxedExclude } from 'ts-type-forge';\n\n/**\n * Type guard that checks if a value is `undefined`.\n *\n * **Type Narrowing Behavior:**\n *\n * - Narrows the input type to `undefined` when `true`\n * - Useful for explicit undefined checks\n *\n * @example\n *\n * ```ts\n * const values: readonly (number | undefined)[] = [1, undefined, 2] as const;\n *\n * const undefinedValues = values.filter(isUndefined);\n *\n * assert.deepStrictEqual(undefinedValues, [undefined]);\n * ```\n *\n * @param u - The value to check\n * @returns `true` if `u` is `undefined`, `false` otherwise. When `true`,\n *   TypeScript narrows the type to `undefined`.\n */\nexport const isUndefined = (u: unknown): u is undefined => u === undefined;\n\n/**\n * Type guard that checks if a value is not `undefined`.\n *\n * **Type Narrowing Behavior:**\n *\n * - Excludes `undefined` from the input type when `true`\n * - Preserves all other types in the union\n * - Commonly used to filter out undefined values\n *\n * @example\n *\n * ```ts\n * const values: readonly (number | undefined)[] = [1, undefined, 2] as const;\n *\n * const definedValues = values.filter(isNotUndefined);\n *\n * assert.deepStrictEqual(definedValues, [1, 2]);\n * ```\n *\n * @template T - The type of the input value\n * @param u - The value to check\n * @returns `true` if `u` is not `undefined`, `false` otherwise. When `true`,\n *   TypeScript excludes `undefined` from the type.\n */\nexport const isNotUndefined = <T,>(u: T): u is RelaxedExclude<T, undefined> =>\n  u !== undefined;\n\n/**\n * Type guard that checks if a value is a boolean.\n *\n * **Type Narrowing Behavior:**\n *\n * - Narrows `unknown` to `boolean` when `true`\n * - Preserves literal boolean types (`true | false`)\n *\n * @example\n *\n * ```ts\n * const flags: readonly unknown[] = [true, 'no', false] as const;\n *\n * const booleans = flags.filter(isBoolean);\n *\n * assert.deepStrictEqual(booleans, [true, false]);\n * ```\n *\n * @param u - The value to check\n * @returns `true` if `u` is a boolean, `false` otherwise. When `true`,\n *   TypeScript narrows the type to `boolean`.\n */\nexport const isBoolean = (u: unknown): u is boolean => typeof u === 'boolean';\n\n/**\n * Type guard that checks if a value is not a boolean.\n *\n * **Type Narrowing Behavior:**\n *\n * - Excludes `boolean` from the input type when `true`\n * - Preserves all other types in the union\n *\n * @example\n *\n * ```ts\n * const flags: readonly unknown[] = [true, 'no', false] as const;\n *\n * const nonBooleans = flags.filter(isNotBoolean);\n *\n * assert.deepStrictEqual(nonBooleans, ['no']);\n * ```\n *\n * @template T - The type of the input value\n * @param u - The value to check\n * @returns `true` if `u` is not a boolean, `false` otherwise. When `true`,\n *   TypeScript excludes `boolean` from the type.\n */\nexport const isNotBoolean = <T,>(u: T): u is RelaxedExclude<T, boolean> =>\n  typeof u !== 'boolean';\n\n/**\n * Type guard that checks if a value is a number.\n *\n * **Type Narrowing Behavior:**\n *\n * - Narrows `unknown` to `number` when `true`\n * - Includes `NaN`, `Infinity`, and `-Infinity` as valid numbers\n * - Preserves literal number types when possible\n *\n * @example\n *\n * ```ts\n * const mixed: readonly unknown[] = [1, '2', 3] as const;\n *\n * const numbers = mixed.filter(isNumber);\n *\n * assert.deepStrictEqual(numbers, [1, 3]);\n * ```\n *\n * @param u - The value to check\n * @returns `true` if `u` is a number, `false` otherwise. When `true`,\n *   TypeScript narrows the type to `number`.\n */\nexport const isNumber = (u: unknown): u is number => typeof u === 'number';\n\n/**\n * Type guard that checks if a value is not a number.\n *\n * **Type Narrowing Behavior:**\n *\n * - Excludes `number` from the input type when `true`\n * - Preserves all other types in the union\n *\n * @example\n *\n * ```ts\n * const mixed: readonly unknown[] = [1, '2', 3] as const;\n *\n * const nonNumbers = mixed.filter(isNotNumber);\n *\n * assert.deepStrictEqual(nonNumbers, ['2']);\n * ```\n *\n * @template T - The type of the input value\n * @param u - The value to check\n * @returns `true` if `u` is not a number, `false` otherwise. When `true`,\n *   TypeScript excludes `number` from the type.\n */\nexport const isNotNumber = <T,>(u: T): u is RelaxedExclude<T, number> =>\n  typeof u !== 'number';\n\n/**\n * Type guard that checks if a value is a bigint.\n *\n * **Type Narrowing Behavior:**\n *\n * - Narrows `unknown` to `bigint` when `true`\n * - Identifies values created with `BigInt()` constructor or `n` suffix\n *\n * @example\n *\n * ```ts\n * const values: readonly unknown[] = [1n, 2, 3n] as const;\n *\n * const bigints = values.filter(isBigint);\n *\n * assert.deepStrictEqual(bigints, [1n, 3n]);\n * ```\n *\n * @param u - The value to check\n * @returns `true` if `u` is a bigint, `false` otherwise. When `true`,\n *   TypeScript narrows the type to `bigint`.\n */\nexport const isBigint = (u: unknown): u is bigint => typeof u === 'bigint';\n\n/**\n * Type guard that checks if a value is not a bigint.\n *\n * **Type Narrowing Behavior:**\n *\n * - Excludes `bigint` from the input type when `true`\n * - Preserves all other types in the union\n *\n * @example\n *\n * ```ts\n * const values: readonly unknown[] = [1n, 2, 3n] as const;\n *\n * const nonBigints = values.filter(isNotBigint);\n *\n * assert.deepStrictEqual(nonBigints, [2]);\n * ```\n *\n * @template T - The type of the input value\n * @param u - The value to check\n * @returns `true` if `u` is not a bigint, `false` otherwise. When `true`,\n *   TypeScript excludes `bigint` from the type.\n */\nexport const isNotBigint = <T,>(u: T): u is RelaxedExclude<T, bigint> =>\n  typeof u !== 'bigint';\n\n/**\n * Type guard that checks if a value is a string.\n *\n * **Type Narrowing Behavior:**\n *\n * - Narrows `unknown` to `string` when `true`\n * - Preserves literal string types when possible\n * - Includes empty strings\n *\n * @example\n *\n * ```ts\n * const values: readonly unknown[] = ['Ada', 42, 'Lovelace'] as const;\n *\n * const strings = values.filter(isString);\n *\n * assert.deepStrictEqual(strings, ['Ada', 'Lovelace']);\n * ```\n *\n * @param u - The value to check\n * @returns `true` if `u` is a string, `false` otherwise. When `true`,\n *   TypeScript narrows the type to `string`.\n */\nexport const isString = (u: unknown): u is string => typeof u === 'string';\n\n/**\n * Type guard that checks if a value is not a string.\n *\n * **Type Narrowing Behavior:**\n *\n * - Excludes `string` from the input type when `true`\n * - Preserves all other types in the union\n *\n * @example\n *\n * ```ts\n * const values: readonly unknown[] = ['Ada', 42, 'Lovelace'] as const;\n *\n * const nonStrings = values.filter(isNotString);\n *\n * assert.deepStrictEqual(nonStrings, [42]);\n * ```\n *\n * @template T - The type of the input value\n * @param u - The value to check\n * @returns `true` if `u` is not a string, `false` otherwise. When `true`,\n *   TypeScript excludes `string` from the type.\n */\nexport const isNotString = <T,>(u: T): u is RelaxedExclude<T, string> =>\n  typeof u !== 'string';\n\n/**\n * Type guard that checks if a value is a symbol.\n *\n * **Type Narrowing Behavior:**\n *\n * - Narrows `unknown` to `symbol` when `true`\n * - Identifies values created with `Symbol()` constructor\n *\n * @example\n *\n * ```ts\n * const id = Symbol('id');\n *\n * const shared = Symbol.for('shared');\n *\n * const tokens: readonly unknown[] = [id, 'shared', shared] as const;\n *\n * const symbols = tokens.filter(isSymbol);\n *\n * assert.deepStrictEqual(symbols, [id, shared]);\n * ```\n *\n * @param u - The value to check\n * @returns `true` if `u` is a symbol, `false` otherwise. When `true`,\n *   TypeScript narrows the type to `symbol`.\n */\nexport const isSymbol = (u: unknown): u is symbol => typeof u === 'symbol';\n\n/**\n * Type guard that checks if a value is not a symbol.\n *\n * **Type Narrowing Behavior:**\n *\n * - Excludes `symbol` from the input type when `true`\n * - Preserves all other types in the union\n *\n * @example\n *\n * ```ts\n * const id = Symbol('id');\n *\n * const tokens: readonly unknown[] = [id, 'shared'] as const;\n *\n * const nonSymbols = tokens.filter(isNotSymbol);\n *\n * assert.deepStrictEqual(nonSymbols, ['shared']);\n * ```\n *\n * @template T - The type of the input value\n * @param u - The value to check\n * @returns `true` if `u` is not a symbol, `false` otherwise. When `true`,\n *   TypeScript excludes `symbol` from the type.\n */\nexport const isNotSymbol = <T,>(u: T): u is RelaxedExclude<T, symbol> =>\n  typeof u !== 'symbol';\n\n/**\n * Type guard that checks if a value is `null`.\n *\n * **Type Narrowing Behavior:**\n *\n * - Narrows the input type to `null` when `true`\n * - Useful for explicit null checks\n *\n * @example\n *\n * ```ts\n * const values: readonly (number | null)[] = [null, 5] as const;\n *\n * const nullValues = values.filter(isNull);\n *\n * assert.deepStrictEqual(nullValues, [null]);\n * ```\n *\n * @param u - The value to check\n * @returns `true` if `u` is `null`, `false` otherwise. When `true`, TypeScript\n *   narrows the type to `null`.\n */\nexport const isNull = (u: unknown): u is null => u === null;\n\n/**\n * Type guard that checks if a value is not `null`.\n *\n * **Type Narrowing Behavior:**\n *\n * - Excludes `null` from the input type when `true`\n * - Preserves all other types including `undefined`\n * - Commonly used to filter out null values\n *\n * @example\n *\n * ```ts\n * const values: readonly (number | null)[] = [null, 5] as const;\n *\n * const nonNullValues = values.filter(isNotNull);\n *\n * assert.deepStrictEqual(nonNullValues, [5]);\n * ```\n *\n * @template T - The type of the input value (which could be `null`)\n * @param u - The value to check\n * @returns `true` if `u` is not `null`, `false` otherwise. When `true`,\n *   TypeScript excludes `null` from the type.\n */\nexport const isNotNull = <T,>(u: T | null): u is T => u !== null;\n\n/**\n * Type guard that checks if a value is `null` or `undefined` (nullish).\n *\n * This function uses the loose equality operator (`==`) to check for both\n * `null` and `undefined` in a single comparison, which is the standard\n * JavaScript idiom for nullish checks.\n *\n * **Type Narrowing Behavior:**\n *\n * - Narrows the input type to `null | undefined` when `true`\n * - Useful for checking if a value is \"nullish\" (either null or undefined)\n *\n * @example\n *\n * ```ts\n * const values: readonly (string | null | undefined)[] = [\n *   'Ada',\n *   null,\n *   undefined,\n * ] as const;\n *\n * const nullishValues = values.filter(isNullish);\n *\n * assert.deepStrictEqual(nullishValues, [null, undefined]);\n * ```\n *\n * @param u - The value to check\n * @returns `true` if `u` is `null` or `undefined`, `false` otherwise. When\n *   `true`, TypeScript narrows the type to `null | undefined`.\n */\nexport const isNullish = (u: unknown): u is null | undefined => u == null;\n\n/**\n * Type guard that checks if a value is not `null` or `undefined` (non-nullish).\n *\n * This function uses the loose inequality operator (`!=`) to check that a value\n * is neither `null` nor `undefined` in a single comparison. This is equivalent\n * to TypeScript's `NonNullable<T>` utility type.\n *\n * **Type Narrowing Behavior:**\n *\n * - Excludes both `null` and `undefined` from the input type when `true`\n * - Equivalent to applying TypeScript's `NonNullable<T>` utility type\n * - Commonly used to filter out nullish values from arrays\n *\n * @example\n *\n * ```ts\n * const values: readonly (string | null | undefined)[] = [\n *   'Ada',\n *   null,\n *   undefined,\n * ] as const;\n *\n * const definedValues = values.filter(isNonNullish);\n *\n * assert.deepStrictEqual(definedValues, ['Ada']);\n * ```\n *\n * @template T - The type of the input value\n * @param u - The value to check\n * @returns `true` if `u` is not `null` and not `undefined`, `false` otherwise.\n *   When `true`, TypeScript narrows the type to `NonNullable<T>`.\n */\nexport const isNonNullish = <T,>(u: T): u is NonNullable<T> => u != null;\n"],"names":[],"mappings":"AAwBO,MAAM,WAAA,GAAc,CAAC,CAAA,KAA+B,CAAA,KAAM;AA0B1D,MAAM,cAAA,GAAiB,CAAK,CAAA,KACjC,CAAA,KAAM;AAwBD,MAAM,SAAA,GAAY,CAAC,CAAA,KAA6B,OAAO,CAAA,KAAM;AAyB7D,MAAM,YAAA,GAAe,CAAK,CAAA,KAC/B,OAAO,CAAA,KAAM;AAyBR,MAAM,QAAA,GAAW,CAAC,CAAA,KAA4B,OAAO,CAAA,KAAM;AAyB3D,MAAM,WAAA,GAAc,CAAK,CAAA,KAC9B,OAAO,CAAA,KAAM;AAwBR,MAAM,QAAA,GAAW,CAAC,CAAA,KAA4B,OAAO,CAAA,KAAM;AAyB3D,MAAM,WAAA,GAAc,CAAK,CAAA,KAC9B,OAAO,CAAA,KAAM;AAyBR,MAAM,QAAA,GAAW,CAAC,CAAA,KAA4B,OAAO,CAAA,KAAM;AAyB3D,MAAM,WAAA,GAAc,CAAK,CAAA,KAC9B,OAAO,CAAA,KAAM;AA4BR,MAAM,QAAA,GAAW,CAAC,CAAA,KAA4B,OAAO,CAAA,KAAM;AA2B3D,MAAM,WAAA,GAAc,CAAK,CAAA,KAC9B,OAAO,CAAA,KAAM;AAwBR,MAAM,MAAA,GAAS,CAAC,CAAA,KAA0B,CAAA,KAAM;AA0BhD,MAAM,SAAA,GAAY,CAAK,CAAA,KAAwB,CAAA,KAAM;AAgCrD,MAAM,SAAA,GAAY,CAAC,CAAA,KAAsC,CAAA,IAAK;AAkC9D,MAAM,YAAA,GAAe,CAAK,CAAA,KAA8B,CAAA,IAAK;;;;"}
+{"version":3,"file":"is-type.mjs","sourceRoot":"","sources":["../../src/guard/is-type.mts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,CAAU,EAAkB,EAAE,CAAC,CAAC,KAAK,SAAS,CAAC;AAE3E;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,CAAK,CAAI,EAAqC,EAAE,CAC5E,CAAC,KAAK,SAAS,CAAC;AAElB;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,CAAC,CAAU,EAAgB,EAAE,CAAC,OAAO,CAAC,KAAK,SAAS,CAAC;AAE9E;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,CAAK,CAAI,EAAmC,EAAE,CACxE,OAAO,CAAC,KAAK,SAAS,CAAC;AAEzB;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,CAAC,CAAU,EAAe,EAAE,CAAC,OAAO,CAAC,KAAK,QAAQ,CAAC;AAE3E;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,CAAK,CAAI,EAAkC,EAAE,CACtE,OAAO,CAAC,KAAK,QAAQ,CAAC;AAExB;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,CAAC,CAAU,EAAe,EAAE,CAAC,OAAO,CAAC,KAAK,QAAQ,CAAC;AAE3E;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,CAAK,CAAI,EAAkC,EAAE,CACtE,OAAO,CAAC,KAAK,QAAQ,CAAC;AAExB;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,CAAC,CAAU,EAAe,EAAE,CAAC,OAAO,CAAC,KAAK,QAAQ,CAAC;AAE3E;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,CAAK,CAAI,EAAkC,EAAE,CACtE,OAAO,CAAC,KAAK,QAAQ,CAAC;AAExB;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,CAAC,CAAU,EAAe,EAAE,CAAC,OAAO,CAAC,KAAK,QAAQ,CAAC;AAE3E;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,CAAK,CAAI,EAAkC,EAAE,CACtE,OAAO,CAAC,KAAK,QAAQ,CAAC;AAExB;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG,CAAC,CAAU,EAAa,EAAE,CAAC,CAAC,KAAK,IAAI,CAAC;AAE5D;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,CAAK,CAAW,EAAU,EAAE,CAAC,CAAC,KAAK,IAAI,CAAC;AAEjE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,CAAC,CAAU,EAAyB,EAAE,CAAC,CAAC,IAAI,IAAI,CAAC;AAE1E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,CAAK,CAAI,EAAuB,EAAE,CAAC,CAAC,IAAI,IAAI,CAAC"}

package/dist/guard/key-is-in.mjs

@@ -1,4 +1,42 @@
-const keyIsIn = (key, obj) => Object.hasOwn(obj, key);
-
-export { keyIsIn };
-//# sourceMappingURL=key-is-in.mjs.map
+/**
+ * Type guard that checks if a key exists as an own property in an object.
+ *
+ * This function is similar to `hasKey()` but with reversed parameter order and
+ * different type narrowing behavior. While `hasKey()` narrows the object type,
+ * `keyIsIn()` narrows the key type to be a valid key of the given object.
+ *
+ * **Type Narrowing Behavior:**
+ *
+ * - Narrows the key type to be a key that exists in the object (`K & keyof R`)
+ * - Useful when you have a dynamic key and want to ensure it's valid for a
+ *   specific object
+ * - The object type remains unchanged
+ *
+ * **Implementation:** Uses `Object.hasOwn()` to check for own properties (not
+ * inherited).
+ *
+ * @example
+ *
+ * ```ts
+ * const user = { id: 1, name: 'Ada' } as const;
+ *
+ * const maybeKey: string = 'name';
+ *
+ * if (keyIsIn(maybeKey, user)) {
+ *   assert.isTrue(user[maybeKey] === 'Ada');
+ * } else {
+ *   assert.fail();
+ * }
+ * ```
+ *
+ * @template K - The type of the key to check, must extend PropertyKey (string |
+ *   number | symbol)
+ * @template R - The type of the record (object), must extend UnknownRecord
+ * @param key - The key to check for
+ * @param obj - The object to check within
+ * @returns `true` if `key` is an own property of `obj`, `false` otherwise. When
+ *   `true`, TypeScript narrows the key type to be a valid key of the object.
+ * @see {@link hasKey} - Similar function that narrows the object type instead of the key type
+ */
+export const keyIsIn = (key, obj) => Object.hasOwn(obj, key);
+//# sourceMappingURL=key-is-in.mjs.map

package/dist/guard/key-is-in.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"key-is-in.mjs","sources":["../../src/guard/key-is-in.mts"],"sourcesContent":["import { type UnknownRecord } from 'ts-type-forge';\n\n/**\n * Type guard that checks if a key exists as an own property in an object.\n *\n * This function is similar to `hasKey()` but with reversed parameter order and\n * different type narrowing behavior. While `hasKey()` narrows the object type,\n * `keyIsIn()` narrows the key type to be a valid key of the given object.\n *\n * **Type Narrowing Behavior:**\n *\n * - Narrows the key type to be a key that exists in the object (`K & keyof R`)\n * - Useful when you have a dynamic key and want to ensure it's valid for a\n *   specific object\n * - The object type remains unchanged\n *\n * **Implementation:** Uses `Object.hasOwn()` to check for own properties (not\n * inherited).\n *\n * @example\n *\n * ```ts\n * const user = { id: 1, name: 'Ada' } as const;\n *\n * const maybeKey: string = 'name';\n *\n * if (keyIsIn(maybeKey, user)) {\n *   assert.isTrue(user[maybeKey] === 'Ada');\n * } else {\n *   assert.fail();\n * }\n * ```\n *\n * @template K - The type of the key to check, must extend PropertyKey (string |\n *   number | symbol)\n * @template R - The type of the record (object), must extend UnknownRecord\n * @param key - The key to check for\n * @param obj - The object to check within\n * @returns `true` if `key` is an own property of `obj`, `false` otherwise. When\n *   `true`, TypeScript narrows the key type to be a valid key of the object.\n * @see {@link hasKey} - Similar function that narrows the object type instead of the key type\n */\nexport const keyIsIn = <\n  const K extends PropertyKey,\n  const R extends UnknownRecord,\n>(\n  key: K,\n  obj: R,\n): key is K & keyof typeof obj => Object.hasOwn(obj, key);\n"],"names":[],"mappings":"AA0CO,MAAM,UAAU,CAIrB,GAAA,EACA,QACgC,MAAA,CAAO,MAAA,CAAO,KAAK,GAAG;;;;"}
+{"version":3,"file":"key-is-in.mjs","sourceRoot":"","sources":["../../src/guard/key-is-in.mts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG,CAIrB,GAAM,EACN,GAAM,EACuB,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC"}