@cult-frog/primitives 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Quin Partridge
+
+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,82 @@
+# @cult-frog/primitives
+
+Small, dependency-free TypeScript utilities for everyday code: type-narrowing predicates and common callback helpers.
+
+- **Type-safe.** Every predicate is a TypeScript type guard, so it narrows types in `if` statements and in `Array.prototype.filter`.
+- **Tree-shakeable.** It is ESM-only, has no side effects and no dependencies, so you only ship what you import.
+- **Predictable.** Edge cases like `NaN`, class instances and inherited properties are handled deliberately and documented.
+
+## Installation
+
+```sh
+pnpm add @cult-frog/primitives
+# or
+npm install @cult-frog/primitives
+```
+
+Requires Node.js 20.19 or later. The package is published as ES modules with bundled type declarations.
+
+## Usage
+
+```ts
+import { hasProperty, isNotNil, isNumber, isRecord, once } from '@cult-frog/primitives';
+
+// Remove null and undefined while keeping the array's element type.
+const ids = [1, null, 2, undefined].filter(isNotNil); // number[]
+
+// Safely read properties from unknown data.
+const data: unknown = JSON.parse(input);
+if (isRecord(data) && hasProperty(data, 'id') && isNumber(data.id)) {
+  console.log(data.id); // number
+}
+
+// Run expensive setup only once.
+const getClient = once(() => createClient());
+```
+
+## API
+
+### Predicates
+
+Every predicate is a type guard. Each `isX` check has an `isNotX` counterpart where the negation is useful for narrowing.
+
+| Function | Returns `true` when the value is |
+| --- | --- |
+| `isNil(value)` | `null` or `undefined` |
+| `isNotNil(value)` | neither `null` nor `undefined` |
+| `isNull(value)` | `null` |
+| `isNotNull(value)` | not `null` |
+| `isUndefined(value)` | `undefined` |
+| `isNotUndefined(value)` | not `undefined` |
+| `isNumber(value)` | a finite number |
+| `isString(value)` | a string primitive |
+| `isRecord(value)` | a plain object |
+| `isNotRecord(value)` | not a plain object |
+| `hasProperty(object, key)` | an object with `key` as its own property |
+
+Worth knowing:
+
+- **`isNumber`** rejects `NaN`, `Infinity` and `-Infinity`. It never coerces, so `'42'` is not a number.
+- **`isRecord`** accepts only object literals and `Object.create(null)` objects. Arrays, class instances and built-ins such as `Date` and `Map` are rejected, which makes it a safe first check on parsed JSON. Objects from another realm, such as an iframe, are also rejected.
+- **`hasProperty`** ignores inherited properties such as `toString`. The property it finds can still hold `undefined`.
+- **`isNotNil`** keeps falsy values such as `0`, `''` and `false`, unlike `filter(Boolean)`.
+
+### Callbacks
+
+| Function | Description |
+| --- | --- |
+| `noop()` | Does nothing and returns `undefined`. Use it as a default for optional callbacks. |
+| `identity(value)` | Returns `value` unchanged. Use it as a default transform. |
+| `constant(value)` | Returns a function that always returns `value`. |
+| `once(fn)` | Returns a function that calls `fn` at most once and caches its result. |
+
+How `once` behaves:
+
+- Calls after the first successful one return the cached result and ignore their arguments.
+- `this` is forwarded, so the wrapped function can be used as a method.
+- If `fn` throws, nothing is cached and the next call tries again.
+- When used on a shared prototype, `fn` runs once in total rather than once per instance.
+
+## License
+
+[MIT](./LICENSE) © Quin Partridge

package/dist/callbacks/constant.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Creates a function that always returns the given value.
+ *
+ * Useful when an API expects a callback or factory but you already have the value, e.g. a
+ * default provider or a stubbed dependency in tests.
+ *
+ * The same value is returned on every call; objects are not copied.
+ *
+ * @example
+ * ```ts
+ * const getDefaultName = constant('anonymous');
+ * getDefaultName(); // 'anonymous'
+ *
+ * const names = users.map((user) => user.name ?? getDefaultName());
+ * ```
+ *
+ * @param value - The value the returned function should produce.
+ * @returns A function that returns `value` every time it is called.
+ */
+export declare function constant<T>(value: T): () => T;
+//# sourceMappingURL=constant.d.ts.map

package/dist/callbacks/constant.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constant.d.ts","sourceRoot":"","sources":["../../src/callbacks/constant.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,MAAM,CAAC,CAE7C"}

package/dist/callbacks/constant.js

@@ -0,0 +1,23 @@
+/**
+ * Creates a function that always returns the given value.
+ *
+ * Useful when an API expects a callback or factory but you already have the value, e.g. a
+ * default provider or a stubbed dependency in tests.
+ *
+ * The same value is returned on every call; objects are not copied.
+ *
+ * @example
+ * ```ts
+ * const getDefaultName = constant('anonymous');
+ * getDefaultName(); // 'anonymous'
+ *
+ * const names = users.map((user) => user.name ?? getDefaultName());
+ * ```
+ *
+ * @param value - The value the returned function should produce.
+ * @returns A function that returns `value` every time it is called.
+ */
+export function constant(value) {
+    return () => value;
+}
+//# sourceMappingURL=constant.js.map

package/dist/callbacks/constant.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constant.js","sourceRoot":"","sources":["../../src/callbacks/constant.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,UAAU,QAAQ,CAAI,KAAQ;IAClC,OAAO,GAAG,EAAE,CAAC,KAAK,CAAC;AACrB,CAAC"}

package/dist/callbacks/identity.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Returns the value it is given, unchanged.
+ *
+ * Useful as a default transform or a pass-through callback, so callers don't need to branch on
+ * whether a transform was provided.
+ *
+ * @example
+ * ```ts
+ * function formatAll<T>(items: T[], format: (item: T) => T = identity): T[] {
+ *   return items.map(format);
+ * }
+ *
+ * formatAll([1, 2, 3]); // [1, 2, 3]
+ * ```
+ *
+ * @param value - The value to return.
+ * @returns `value`, unchanged.
+ */
+export declare function identity<T>(value: T): T;
+//# sourceMappingURL=identity.d.ts.map

package/dist/callbacks/identity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"identity.d.ts","sourceRoot":"","sources":["../../src/callbacks/identity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,CAEvC"}

package/dist/callbacks/identity.js

@@ -0,0 +1,22 @@
+/**
+ * Returns the value it is given, unchanged.
+ *
+ * Useful as a default transform or a pass-through callback, so callers don't need to branch on
+ * whether a transform was provided.
+ *
+ * @example
+ * ```ts
+ * function formatAll<T>(items: T[], format: (item: T) => T = identity): T[] {
+ *   return items.map(format);
+ * }
+ *
+ * formatAll([1, 2, 3]); // [1, 2, 3]
+ * ```
+ *
+ * @param value - The value to return.
+ * @returns `value`, unchanged.
+ */
+export function identity(value) {
+    return value;
+}
+//# sourceMappingURL=identity.js.map

package/dist/callbacks/identity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"identity.js","sourceRoot":"","sources":["../../src/callbacks/identity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,UAAU,QAAQ,CAAI,KAAQ;IAClC,OAAO,KAAK,CAAC;AACf,CAAC"}

package/dist/callbacks/index.d.ts

@@ -0,0 +1,5 @@
+export * from './constant.js';
+export * from './identity.js';
+export * from './noop.js';
+export * from './once.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/callbacks/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/callbacks/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,cAAc,WAAW,CAAC;AAC1B,cAAc,WAAW,CAAC"}

package/dist/callbacks/index.js

@@ -0,0 +1,5 @@
+export * from './constant.js';
+export * from './identity.js';
+export * from './noop.js';
+export * from './once.js';
+//# sourceMappingURL=index.js.map

package/dist/callbacks/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/callbacks/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,cAAc,WAAW,CAAC;AAC1B,cAAc,WAAW,CAAC"}

package/dist/callbacks/noop.d.ts

@@ -0,0 +1,16 @@
+/**
+ * A function that does nothing and returns `undefined`.
+ *
+ * Useful as a default for optional callbacks, so callers can invoke them without checking
+ * whether one was provided. Using a shared `noop` also makes intent clearer than an inline
+ * `() => {}`.
+ *
+ * @example
+ * ```ts
+ * function load(onProgress: (percent: number) => void = noop) {
+ *   onProgress(50);
+ * }
+ * ```
+ */
+export declare function noop(): void;
+//# sourceMappingURL=noop.d.ts.map

package/dist/callbacks/noop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"noop.d.ts","sourceRoot":"","sources":["../../src/callbacks/noop.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,wBAAgB,IAAI,IAAI,IAAI,CAE3B"}

package/dist/callbacks/noop.js

@@ -0,0 +1,18 @@
+/**
+ * A function that does nothing and returns `undefined`.
+ *
+ * Useful as a default for optional callbacks, so callers can invoke them without checking
+ * whether one was provided. Using a shared `noop` also makes intent clearer than an inline
+ * `() => {}`.
+ *
+ * @example
+ * ```ts
+ * function load(onProgress: (percent: number) => void = noop) {
+ *   onProgress(50);
+ * }
+ * ```
+ */
+export function noop() {
+    return;
+}
+//# sourceMappingURL=noop.js.map

package/dist/callbacks/noop.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"noop.js","sourceRoot":"","sources":["../../src/callbacks/noop.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,IAAI;IAClB,OAAO;AACT,CAAC"}

package/dist/callbacks/once.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Wraps a function so it runs at most once. Later calls return the result of the first call.
+ *
+ * Useful for lazy initialisation and for guarding side effects that must only happen once,
+ * such as setup, teardown or one-time warnings.
+ *
+ * - Arguments passed after the first successful call are ignored.
+ * - `this` is forwarded to `fn`, so the wrapper can be used as a method.
+ * - If `fn` throws, nothing is cached and the next call tries again.
+ * - After a successful call the reference to `fn` is released.
+ * - When used as a method on a shared prototype, `fn` runs once in total, not once per instance.
+ *
+ * @example
+ * ```ts
+ * const init = once(() => {
+ *   console.log('initialising');
+ *   return createClient();
+ * });
+ *
+ * init(); // logs 'initialising' and returns the client
+ * init(); // returns the same client without logging
+ * ```
+ *
+ * @param fn - The function to wrap.
+ * @returns A function with the same signature as `fn` that only invokes it once.
+ */
+export declare function once<This, Args extends unknown[], R>(fn: (this: This, ...args: Args) => R): (this: This, ...args: Args) => R;
+//# sourceMappingURL=once.d.ts.map

package/dist/callbacks/once.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"once.d.ts","sourceRoot":"","sources":["../../src/callbacks/once.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,IAAI,CAAC,IAAI,EAAE,IAAI,SAAS,OAAO,EAAE,EAAE,CAAC,EAClD,EAAE,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,IAAI,EAAE,IAAI,KAAK,CAAC,GACnC,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,IAAI,EAAE,IAAI,KAAK,CAAC,CAYlC"}

package/dist/callbacks/once.js

@@ -0,0 +1,38 @@
+/**
+ * Wraps a function so it runs at most once. Later calls return the result of the first call.
+ *
+ * Useful for lazy initialisation and for guarding side effects that must only happen once,
+ * such as setup, teardown or one-time warnings.
+ *
+ * - Arguments passed after the first successful call are ignored.
+ * - `this` is forwarded to `fn`, so the wrapper can be used as a method.
+ * - If `fn` throws, nothing is cached and the next call tries again.
+ * - After a successful call the reference to `fn` is released.
+ * - When used as a method on a shared prototype, `fn` runs once in total, not once per instance.
+ *
+ * @example
+ * ```ts
+ * const init = once(() => {
+ *   console.log('initialising');
+ *   return createClient();
+ * });
+ *
+ * init(); // logs 'initialising' and returns the client
+ * init(); // returns the same client without logging
+ * ```
+ *
+ * @param fn - The function to wrap.
+ * @returns A function with the same signature as `fn` that only invokes it once.
+ */
+export function once(fn) {
+    let pending = fn;
+    let result;
+    return function (...args) {
+        if (pending) {
+            result = pending.apply(this, args);
+            pending = undefined;
+        }
+        return result;
+    };
+}
+//# sourceMappingURL=once.js.map

package/dist/callbacks/once.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"once.js","sourceRoot":"","sources":["../../src/callbacks/once.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,UAAU,IAAI,CAClB,EAAoC;IAEpC,IAAI,OAAO,GAAmD,EAAE,CAAC;IACjE,IAAI,MAAS,CAAC;IAEd,OAAO,UAAsB,GAAG,IAAU;QACxC,IAAI,OAAO,EAAE,CAAC;YACZ,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;YACnC,OAAO,GAAG,SAAS,CAAC;QACtB,CAAC;QAED,OAAO,MAAM,CAAC;IAChB,CAAC,CAAC;AACJ,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './callbacks/index.js';
+export * from './predicates/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC"}

package/dist/index.js

@@ -0,0 +1,3 @@
+export * from './callbacks/index.js';
+export * from './predicates/index.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC"}

package/dist/predicates/index.d.ts

@@ -0,0 +1,7 @@
+export * from './nil.js';
+export * from './null.js';
+export * from './number.js';
+export * from './record.js';
+export * from './string.js';
+export * from './undefined.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/predicates/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/predicates/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC"}

package/dist/predicates/index.js

@@ -0,0 +1,7 @@
+export * from './nil.js';
+export * from './null.js';
+export * from './number.js';
+export * from './record.js';
+export * from './string.js';
+export * from './undefined.js';
+//# sourceMappingURL=index.js.map

package/dist/predicates/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/predicates/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC"}

package/dist/predicates/nil.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Checks if a value is `null` or `undefined`.
+ *
+ * @example
+ * ```ts
+ * isNil(null); // true
+ * isNil(undefined); // true
+ * isNil(0); // false
+ * isNil(''); // false
+ * ```
+ *
+ * @param value - The value to check.
+ * @returns `true` if `value` is `null` or `undefined`, otherwise `false`.
+ */
+export declare function isNil<T>(value: T | null | undefined): value is null | undefined;
+/**
+ * Checks if a value is neither `null` nor `undefined`, narrowing it to its non-nullable type.
+ *
+ * Unlike a truthiness check, falsy values such as `0`, `''` and `false` are kept.
+ *
+ * @example
+ * ```ts
+ * const values = [1, null, 0, undefined, 2];
+ * const present = values.filter(isNotNil); // number[]: [1, 0, 2]
+ * ```
+ *
+ * @param value - The value to check.
+ * @returns `true` if `value` is not `null` or `undefined`, otherwise `false`.
+ */
+export declare function isNotNil<T>(value: T | null | undefined): value is T;
+//# sourceMappingURL=nil.d.ts.map

package/dist/predicates/nil.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nil.d.ts","sourceRoot":"","sources":["../../src/predicates/nil.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI,GAAG,SAAS,GAAG,KAAK,IAAI,IAAI,GAAG,SAAS,CAE/E;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI,GAAG,SAAS,GAAG,KAAK,IAAI,CAAC,CAEnE"}

package/dist/predicates/nil.js

@@ -0,0 +1,35 @@
+/**
+ * Checks if a value is `null` or `undefined`.
+ *
+ * @example
+ * ```ts
+ * isNil(null); // true
+ * isNil(undefined); // true
+ * isNil(0); // false
+ * isNil(''); // false
+ * ```
+ *
+ * @param value - The value to check.
+ * @returns `true` if `value` is `null` or `undefined`, otherwise `false`.
+ */
+export function isNil(value) {
+    return value == null;
+}
+/**
+ * Checks if a value is neither `null` nor `undefined`, narrowing it to its non-nullable type.
+ *
+ * Unlike a truthiness check, falsy values such as `0`, `''` and `false` are kept.
+ *
+ * @example
+ * ```ts
+ * const values = [1, null, 0, undefined, 2];
+ * const present = values.filter(isNotNil); // number[]: [1, 0, 2]
+ * ```
+ *
+ * @param value - The value to check.
+ * @returns `true` if `value` is not `null` or `undefined`, otherwise `false`.
+ */
+export function isNotNil(value) {
+    return value != null;
+}
+//# sourceMappingURL=nil.js.map

package/dist/predicates/nil.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nil.js","sourceRoot":"","sources":["../../src/predicates/nil.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,KAAK,CAAI,KAA2B;IAClD,OAAO,KAAK,IAAI,IAAI,CAAC;AACvB,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,QAAQ,CAAI,KAA2B;IACrD,OAAO,KAAK,IAAI,IAAI,CAAC;AACvB,CAAC"}

package/dist/predicates/null.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Checks if a value is `null`. `undefined` is not considered `null`; use {@link isNil} to check
+ * for both.
+ *
+ * @example
+ * ```ts
+ * isNull(null); // true
+ * isNull(undefined); // false
+ * ```
+ *
+ * @param value - The value to check.
+ * @returns `true` if `value` is `null`, otherwise `false`.
+ */
+export declare function isNull<T>(value: T | null): value is null;
+/**
+ * Checks if a value is not `null`, narrowing `null` out of its type. `undefined` passes this
+ * check; use {@link isNotNil} to exclude both.
+ *
+ * @example
+ * ```ts
+ * const rows: (Row | null)[] = await fetchRows();
+ * const found = rows.filter(isNotNull); // Row[]
+ * ```
+ *
+ * @param value - The value to check.
+ * @returns `true` if `value` is not `null`, otherwise `false`.
+ */
+export declare function isNotNull<T>(value: T | null): value is T;
+//# sourceMappingURL=null.d.ts.map

package/dist/predicates/null.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"null.d.ts","sourceRoot":"","sources":["../../src/predicates/null.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI,GAAG,KAAK,IAAI,IAAI,CAExD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI,GAAG,KAAK,IAAI,CAAC,CAExD"}

package/dist/predicates/null.js

@@ -0,0 +1,33 @@
+/**
+ * Checks if a value is `null`. `undefined` is not considered `null`; use {@link isNil} to check
+ * for both.
+ *
+ * @example
+ * ```ts
+ * isNull(null); // true
+ * isNull(undefined); // false
+ * ```
+ *
+ * @param value - The value to check.
+ * @returns `true` if `value` is `null`, otherwise `false`.
+ */
+export function isNull(value) {
+    return value === null;
+}
+/**
+ * Checks if a value is not `null`, narrowing `null` out of its type. `undefined` passes this
+ * check; use {@link isNotNil} to exclude both.
+ *
+ * @example
+ * ```ts
+ * const rows: (Row | null)[] = await fetchRows();
+ * const found = rows.filter(isNotNull); // Row[]
+ * ```
+ *
+ * @param value - The value to check.
+ * @returns `true` if `value` is not `null`, otherwise `false`.
+ */
+export function isNotNull(value) {
+    return value !== null;
+}
+//# sourceMappingURL=null.js.map

package/dist/predicates/null.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"null.js","sourceRoot":"","sources":["../../src/predicates/null.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,MAAM,CAAI,KAAe;IACvC,OAAO,KAAK,KAAK,IAAI,CAAC;AACxB,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,SAAS,CAAI,KAAe;IAC1C,OAAO,KAAK,KAAK,IAAI,CAAC;AACxB,CAAC"}

package/dist/predicates/number.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Checks if a value is a finite number.
+ *
+ * `NaN`, `Infinity` and `-Infinity` are rejected, as are numeric strings such as `'42'`; no
+ * coercion is performed.
+ *
+ * @example
+ * ```ts
+ * isNumber(42); // true
+ * isNumber(-1.5); // true
+ * isNumber(NaN); // false
+ * isNumber(Infinity); // false
+ * isNumber('42'); // false
+ * ```
+ *
+ * @param value - The value to check.
+ * @returns `true` if `value` is a finite number, otherwise `false`.
+ */
+export declare function isNumber(value: unknown): value is number;
+//# sourceMappingURL=number.d.ts.map

package/dist/predicates/number.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"number.d.ts","sourceRoot":"","sources":["../../src/predicates/number.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAExD"}

package/dist/predicates/number.js

@@ -0,0 +1,22 @@
+/**
+ * Checks if a value is a finite number.
+ *
+ * `NaN`, `Infinity` and `-Infinity` are rejected, as are numeric strings such as `'42'`; no
+ * coercion is performed.
+ *
+ * @example
+ * ```ts
+ * isNumber(42); // true
+ * isNumber(-1.5); // true
+ * isNumber(NaN); // false
+ * isNumber(Infinity); // false
+ * isNumber('42'); // false
+ * ```
+ *
+ * @param value - The value to check.
+ * @returns `true` if `value` is a finite number, otherwise `false`.
+ */
+export function isNumber(value) {
+    return Number.isFinite(value);
+}
+//# sourceMappingURL=number.js.map

package/dist/predicates/number.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"number.js","sourceRoot":"","sources":["../../src/predicates/number.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,UAAU,QAAQ,CAAC,KAAc;IACrC,OAAO,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;AAChC,CAAC"}

package/dist/predicates/record.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Checks if a value is a plain object, i.e. an object literal or an object created with
+ * `Object.create(null)`.
+ *
+ * Arrays, class instances and built-ins such as `Date`, `Map` and `RegExp` are rejected. This
+ * makes it suitable for validating parsed data such as JSON before reading its properties.
+ *
+ * Objects created in another realm (an iframe or a Node `vm` context) are also rejected, because
+ * their prototype is a different `Object.prototype`.
+ *
+ * @example
+ * ```ts
+ * isRecord({ id: 1 }); // true
+ * isRecord(Object.create(null)); // true
+ * isRecord([]); // false
+ * isRecord(new Date()); // false
+ * isRecord(null); // false
+ * ```
+ *
+ * @param value - The value to check.
+ * @returns `true` if `value` is a plain object, otherwise `false`.
+ */
+export declare function isRecord(value: unknown): value is Record<PropertyKey, unknown>;
+/**
+ * Checks if a value is not a plain object. This is the inverse of {@link isRecord}.
+ *
+ * @example
+ * ```ts
+ * isNotRecord(new Date()); // true
+ * isNotRecord([]); // true
+ * isNotRecord({ id: 1 }); // false
+ * ```
+ *
+ * @param value - The value to check.
+ * @returns `true` if `value` is not a plain object, otherwise `false`.
+ */
+export declare function isNotRecord<T>(value: T): value is Exclude<T, Record<PropertyKey, unknown>>;
+/**
+ * Checks if an object has the given key as its own property, narrowing the object so the
+ * property can be read.
+ *
+ * Inherited properties are not counted, so keys such as `toString` do not match. The property
+ * may still hold `undefined`.
+ *
+ * @example
+ * ```ts
+ * const data: unknown = JSON.parse(input);
+ *
+ * if (isRecord(data) && hasProperty(data, 'id') && isNumber(data.id)) {
+ *   data.id; // number
+ * }
+ * ```
+ *
+ * @param value - The object to check.
+ * @param key - The property key to look for.
+ * @returns `true` if `value` has `key` as an own property, otherwise `false`.
+ */
+export declare function hasProperty<K extends PropertyKey>(value: object, key: K): value is Record<K, unknown>;
+//# sourceMappingURL=record.d.ts.map