@rhombus-toolkit/type-guards 2.0.1 → 3.0.0

package/dist/bundle/index.d.ts

@@ -5,25 +5,54 @@ type Func<in Args extends readonly any[] = any[], out Return = any, in This = un
 /** The `GeneratorFunction` constructor. Named `…Ctor` so it does not shadow the lib interface of the same name. */
 declare const GeneratorFunctionCtor: GeneratorFunctionConstructor;
 declare const AsyncGeneratorFunctionCtor: AsyncGeneratorFunctionConstructor;
-declare function isArray(value: any): value is any[];
+/**
+ * Whether `value` carries `key` at all, whatever it holds.
+ *
+ * @remarks
+ * `K` is a type parameter rather than a plain `PropertyKey` so the narrowing names the key that was
+ * actually checked: a literal argument makes the result `Record<'foo', unknown>`, where a widened
+ * `PropertyKey` would collapse to an index signature that admits every other key too.
+ *
+ * `Object(value)` boxes primitives, since `in` demands an object where a property read would have
+ * boxed on its own. Testing the member's *value* instead would conflate absence with a falsy
+ * member — `''` carries `length`.
+ */
+declare function hasMember<K extends PropertyKey>(value: unknown, key: K): value is Record<K, unknown>;
+declare function isObject(value: any): value is object;
+declare function isReadonlyArray(value: any): value is readonly unknown[];
+declare function isArray(value: any): value is unknown[];
+declare function isUndefined(value: any): value is undefined;
 /** Whether `value` is anything other than `undefined` — `null` is a defined value, so it passes. Use {@link hasValue} to exclude both. */
-declare function isDefined<T>(p: T | undefined | null): p is T | null;
+declare function isDefined<T>(p: T | undefined): p is T;
 declare function hasValue<T>(p: T | null | undefined): p is T;
-declare function isFunction(value: any): value is Func;
+/**
+ * Whether `value` is callable.
+ *
+ * @remarks
+ * Takes no type arguments: `typeof` witnesses that something is callable and nothing about what it
+ * accepts or returns, so letting a caller name those would dress an unchecked assertion up as a
+ * guard — a caller who needs a signature should spell the cast out.
+ *
+ * `Func`'s permissive default is what the narrowing needs, rather than a stricter
+ * `Func<unknown[], unknown>`. Parameters are contravariant, so a concrete `Func<[T], U>` is not
+ * assignable to the stricter form; narrowing a `U | Func<[T], U>` by it cannot pick the function
+ * member and yields a call signature returning `unknown`, losing `U`.
+ */
+declare function isFunction(value: unknown): value is Func;
 /** CONTRACT. Whether `value` is thenable, whatever produced it. */
-declare function isPromiseLike(value: any): value is PromiseLike<any>;
+declare function isPromiseLike(value: any): value is PromiseLike<unknown>;
 /** PROTOTYPE. Whether `value` is a real `Promise`, so `catch`/`finally` are present. A thenable from another realm reads as {@link isPromiseLike} only. */
-declare function isPromise(value: any): value is Promise<any>;
+declare function isPromise(value: any): value is Promise<unknown>;
 /** CONTRACT. Whether `value` has a `next`. Sync and async iterators are indistinguishable by shape — use {@link isAsyncIteratorObject} or {@link isAsyncIterable} to tell them apart. */
-declare function isIterator(value: any): value is Iterator<any>;
+declare function isIterator(value: any): value is Iterator<unknown>;
 /** CONTRACT. Whether `value` yields an iterator when asked. Strings, arrays, `Map` and `Set` all pass. */
-declare function isIterable(value: any): value is Iterable<any>;
+declare function isIterable(value: any): value is Iterable<unknown>;
 /** CONTRACT. Whether `value` is an iterator that is also iterable, the shape a `for…of` accepts directly. */
-declare function isIterableIterator(value: any): value is IterableIterator<any>;
+declare function isIterableIterator(value: any): value is IterableIterator<unknown>;
 /** CONTRACT. Whether `value` yields an async iterator when asked. */
-declare function isAsyncIterable(value: any): value is AsyncIterable<any>;
+declare function isAsyncIterable(value: any): value is AsyncIterable<unknown>;
 /** CONTRACT. Whether `value` is an async iterator that is also async-iterable. */
-declare function isAsyncIterableIterator(value: any): value is AsyncIterableIterator<any>;
+declare function isAsyncIterableIterator(value: any): value is AsyncIterableIterator<unknown>;
 /**
  * PROTOTYPE. Whether `value` inherits `%IteratorPrototype%`, so the ES2025
  * iterator helpers (`map`, `filter`, `take`, `drop`, `toArray`, …) are present.
@@ -31,16 +60,16 @@ declare function isAsyncIterableIterator(value: any): value is AsyncIterableIter
  * @remarks
  * A hand-rolled `{ next() { … } }` is an {@link isIterator} but not this.
  */
-declare function isIteratorObject(value: any): value is IteratorObject<any, any, any>;
+declare function isIteratorObject(value: any): value is IteratorObject<unknown>;
 /** PROTOTYPE. The async counterpart of {@link isIteratorObject}. */
-declare function isAsyncIteratorObject(value: any): value is AsyncIteratorObject<any, any, any>;
+declare function isAsyncIteratorObject(value: any): value is AsyncIteratorObject<unknown>;
 /** PROTOTYPE. Whether `value` is a generator *object* — what calling a generator function returns, not the function itself. */
-declare function isGenerator(value: any): value is Generator<any, any, any>;
+declare function isGenerator(value: any): value is Generator<unknown>;
 /** PROTOTYPE. Whether `value` is an async generator object. Never true for a sync generator — the two have distinct intrinsics. */
-declare function isAsyncGenerator(value: any): value is AsyncGenerator<any, any, any>;
+declare function isAsyncGenerator(value: any): value is AsyncGenerator<unknown>;
 /** PROTOTYPE. Whether `value` is a generator *function* — the thing you call to get a generator. */
 declare function isGeneratorFunction(value: any): value is GeneratorFunction;
 /** PROTOTYPE. Whether `value` is an async generator function. */
 declare function isAsyncGeneratorFunction(value: any): value is AsyncGeneratorFunction;
 
-export { AsyncGeneratorFunctionCtor, GeneratorFunctionCtor, assertNever, hasValue, isArray, isAsyncGenerator, isAsyncGeneratorFunction, isAsyncIterable, isAsyncIterableIterator, isAsyncIteratorObject, isDefined, isFunction, isGenerator, isGeneratorFunction, isIterable, isIterableIterator, isIterator, isIteratorObject, isPromise, isPromiseLike };
+export { AsyncGeneratorFunctionCtor, GeneratorFunctionCtor, assertNever, hasMember, hasValue, isArray, isAsyncGenerator, isAsyncGeneratorFunction, isAsyncIterable, isAsyncIterableIterator, isAsyncIteratorObject, isDefined, isFunction, isGenerator, isGeneratorFunction, isIterable, isIterableIterator, isIterator, isIteratorObject, isObject, isPromise, isPromiseLike, isReadonlyArray, isUndefined };

package/dist/bundle/index.js

@@ -25,17 +25,26 @@ function inheritsFrom(value, prototype) {
   return false;
 }
 function hasMethod(value, key) {
-  if (value === null || value === undefined) {
-    return false;
-  }
-  return typeof value[key] === "function";
+  return hasMember(value, key) && isFunction(value[key]);
+}
+function hasMember(value, key) {
+  return hasValue(value) && key in Object(value);
 }
 function typeTag(value) {
   return Object.prototype.toString.call(value).slice(8, -1);
 }
+function isObject(value) {
+  return hasValue(value) && typeof value === "object";
+}
+function isReadonlyArray(value) {
+  return isArray(value);
+}
 function isArray(value) {
   return Array.isArray(value);
 }
+function isUndefined(value) {
+  return value === undefined;
+}
 function isDefined(p) {
   return p !== undefined;
 }
@@ -46,22 +55,22 @@ function isFunction(value) {
   return typeof value === "function";
 }
 function isPromiseLike(value) {
-  return isPromise(value) || typeTag(value) === "Promise" || hasMethod(value, "then");
+  return isPromise(value) || hasMethod(value, "then");
 }
 function isPromise(value) {
-  return value instanceof Promise;
+  return isObject(value) && value instanceof Promise;
 }
 function isIterator(value) {
   return hasMethod(value, "next");
 }
 function isIterable(value) {
-  return hasMethod(value, Symbol.iterator);
+  return isFunction(value?.[Symbol.iterator]);
 }
 function isIterableIterator(value) {
-  return isIterator(value) && isIterable(value);
+  return isDefined(value) && isIterator(value) && isIterable(value);
 }
 function isAsyncIterable(value) {
-  return hasMethod(value, Symbol.asyncIterator);
+  return isFunction(value?.[Symbol.asyncIterator]);
 }
 function isAsyncIterableIterator(value) {
   return isIterator(value) && isAsyncIterable(value);
@@ -91,24 +100,28 @@ function isAsyncGeneratorFunction(value) {
   return Object.getPrototypeOf(value) === AsyncGeneratorFunctionPrototype || typeTag(value) === "AsyncGeneratorFunction";
 }
 export {
-  isPromiseLike,
-  isPromise,
-  isIteratorObject,
-  isIterator,
-  isIterableIterator,
-  isIterable,
-  isGeneratorFunction,
-  isGenerator,
-  isFunction,
-  isDefined,
-  isAsyncIteratorObject,
-  isAsyncIterableIterator,
-  isAsyncIterable,
-  isAsyncGeneratorFunction,
-  isAsyncGenerator,
-  isArray,
-  hasValue,
-  assertNever,
+  AsyncGeneratorFunctionCtor,
   GeneratorFunctionCtor,
-  AsyncGeneratorFunctionCtor
+  assertNever,
+  hasMember,
+  hasValue,
+  isArray,
+  isAsyncGenerator,
+  isAsyncGeneratorFunction,
+  isAsyncIterable,
+  isAsyncIterableIterator,
+  isAsyncIteratorObject,
+  isDefined,
+  isFunction,
+  isGenerator,
+  isGeneratorFunction,
+  isIterable,
+  isIterableIterator,
+  isIterator,
+  isIteratorObject,
+  isObject,
+  isPromise,
+  isPromiseLike,
+  isReadonlyArray,
+  isUndefined
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rhombus-toolkit/type-guards",
-  "version": "2.0.1",
+  "version": "3.0.0",
   "description": "",
   "repository": {
     "type": "git",
@@ -24,7 +24,7 @@
   "keywords": [],
   "author": "Thomas Butler",
   "dependencies": {
-    "@rhombus-toolkit/types": "1.0.1"
+    "@rhombus-toolkit/types": "1.0.0"
   },
   "devDependencies": {},
   "publishConfig": {