@helpers4/observable 2.0.1 → 2.0.3

package/README.md

@@ -14,6 +14,7 @@ A set of helpers for working with URLs.
 <!-- AUTOMATIC-METHODS -->
 - combine
 - combineLatest
+- isObservable
 <!-- /AUTOMATIC-METHODS -->
 
 ## See

package/lib/index.d.ts

@@ -38,4 +38,29 @@ declare function combineLatest<T extends Record<string, ObservableInput<unknown>
     [K in keyof T]: ObservedValueOf<T[K]>;
 }>;
 
-export { combine, combineLatest };
+/**
+ * This file is part of helpers4.
+ * Copyright (C) 2025 baxyz
+ * SPDX-License-Identifier: LGPL-3.0-or-later
+ */
+
+/**
+ * Checks if a value is an RxJS Observable or any compatible observable.
+ *
+ * Uses duck-typing: returns `true` for any object with both `.subscribe()` and
+ * `.pipe()` methods, covering `Observable`, `Subject`, `BehaviorSubject`,
+ * `ReplaySubject`, and any RxJS-compatible observable implementation.
+ *
+ * @param value - The value to check
+ * @returns `true` if value is observable-like
+ * @example
+ * import { Observable, Subject } from 'rxjs';
+ * isObservable(new Observable())  // => true
+ * isObservable(new Subject())     // => true
+ * isObservable(Promise.resolve()) // => false
+ * isObservable({})                // => false
+ * @since 2.0.3
+ */
+declare function isObservable(value: unknown): value is Observable<unknown>;
+
+export { combine, combineLatest, isObservable };

package/lib/index.js

@@ -96,6 +96,28 @@ function combineLatest(input) {
 	}
 }
 //#endregion
-export { combine, combineLatest };
+//#region helpers/observable/isObservable.ts
+/**
+* Checks if a value is an RxJS Observable or any compatible observable.
+*
+* Uses duck-typing: returns `true` for any object with both `.subscribe()` and
+* `.pipe()` methods, covering `Observable`, `Subject`, `BehaviorSubject`,
+* `ReplaySubject`, and any RxJS-compatible observable implementation.
+*
+* @param value - The value to check
+* @returns `true` if value is observable-like
+* @example
+* import { Observable, Subject } from 'rxjs';
+* isObservable(new Observable())  // => true
+* isObservable(new Subject())     // => true
+* isObservable(Promise.resolve()) // => false
+* isObservable({})                // => false
+* @since 2.0.3
+*/
+function isObservable(value) {
+	return value !== null && typeof value === "object" && typeof value["subscribe"] === "function" && typeof value["pipe"] === "function";
+}
+//#endregion
+export { combine, combineLatest, isObservable };
 
 //# sourceMappingURL=index.js.map

package/lib/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../../../helpers/observable/combine.ts","../../../helpers/type/isDefined.ts","../../../helpers/observable/combineLatest.ts"],"sourcesContent":["/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\n/*\n * This program is under the terms of the GNU Lesser General Public License version 3\n * The full license information can be found in LICENSE in the root directory of this project.\n */\nimport {\n  Observable,\n  OperatorFunction,\n  combineLatest as combineLatestOperator,\n  map as mapOperator,\n} from \"rxjs\";\n\n\ntype combineOptions<T, U> = {\n  readonly preTreatment?: OperatorFunction<readonly [T, U], readonly [T, U]>;\n};\n\n/**\n * Combine two observables with a map function and an optional pre-treatment.\n *\n * Note: you can use the pre-treatment to add a filter, a distinctUntilChanged,\n * any other operator that can be used in a pipe, or even an `UntilDestroy`\n * operator.\n *\n * @param source1 first source of data\n * @param source2 second source of data\n * @param map way to combine data\n * @param options options for the combineLatest operator\n * @returns an observable that emits the result of the map function\n * @see combineLatestOperator\n * @see mapOperator\n * @since 1.0.0\n */\nexport function combine<T, U, R>(\n  source1: Observable<T>,\n  source2: Observable<U>,\n  map: (c: readonly [T, U]) => R,\n  options?: combineOptions<T, U>\n): Observable<R> {\n  if (options?.preTreatment) {\n    return combineLatestOperator([source1, source2]).pipe(\n      options.preTreatment,\n      mapOperator(map)\n    );\n  } else {\n    return combineLatestOperator([source1, source2]).pipe(mapOperator(map));\n  }\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\nimport type { Maybe } from './Maybe';\n\n/**\n * Checks if a value is defined (not undefined nor null).\n * This is the inverse of {@link isNullish}.\n *\n * Use as a type-safe filter callback to remove `null`/`undefined` from arrays.\n *\n * @param value - The value to check\n * @returns True if value is not undefined nor null\n * @example\n * isDefined(42)        // => true\n * isDefined('')        // => true (empty string is defined)\n * isDefined(null)      // => false\n * isDefined(undefined) // => false\n *\n * @example\n * // Type-safe alternative to filter out null/undefined\n * const items: (string | null | undefined)[] = ['a', null, 'b', undefined];\n * const result = items.filter(isDefined);\n * // => ['a', 'b'] with type string[]\n *\n * @see {@link isNullish} for the inverse check\n * @see {@link isTruthy} to also filter out `0`, `\"\"`, `false`, and `NaN`\n * @since 2.0.0\n */\nexport function isDefined<T>(value: Maybe<T>): value is T {\n  return value !== undefined && value !== null;\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\n/*\n * This program is under the terms of the GNU Lesser General Public License version 3\n * The full license information can be found in LICENSE in the root directory of this project.\n */\nimport {\n  Observable,\n  ObservableInput,\n  ObservableInputTuple,\n  ObservedValueOf,\n  combineLatest as combineLatestOperator,\n  of,\n} from \"rxjs\";\nimport { isDefined } from '../type/isDefined';\n\n// combineLatest([a, b, c])\nexport function combineLatest<A extends readonly unknown[]>(\n  sources: readonly [...ObservableInputTuple<A>]\n): Observable<A>;\n\n// combineLatest({a, b, c})\nexport function combineLatest<T extends Record<string, ObservableInput<unknown>>>(\n  sourcesObject: T\n): Observable<{ [K in keyof T]: ObservedValueOf<T[K]> }>;\n\n/**\n * Combines multiple Observables to create an Observable whose values are\n * calculated from the latest values of each of its input Observables.\n *\n * This method relies on {@link combineLatestOperator} of rxjs.\n *\n * The main difference with {@link combineLatestOperator} is in case of empty parameters.\n * If the parameter is empty (empty array or empty object), the result will be\n * also empty.\n *\n * ATTENTION: this version doesn't support `scheduler` nor `mapper` as last\n * argument like in {@link combineLatestOperator}.\n *\n * @see {@link combineLatestOperator}\n * @see {@link combineLatestAll}\n * @see {@link merge}\n * @see {@link withLatestFrom}\n *\n * @param {ObservableInput} [observables] An array of input Observables to combine with each other.\n * An array of Observables must be given as the first argument.\n * @returns {Observable} An Observable of projected values from the most recent\n * values from each input Observable, or an array of the most recent values from\n * each input Observable.\n * @since 1.0.0\n */\nexport function combineLatest(input: readonly ObservableInput<unknown>[] | Record<string, ObservableInput<unknown>>): Observable<unknown> {\n  if (Array.isArray(input)) {\n    const filtered = input.filter(isDefined);\n    return filtered.length ? combineLatestOperator(filtered) : of([]);\n  } else {\n    const filtered = Object.fromEntries(\n      Object.entries(input).filter(([_, v]) => isDefined(v)),\n    );\n    return Object.keys(filtered).length\n      ? combineLatestOperator(filtered)\n      : of({});\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAsCA,SAAgB,QACd,SACA,SACA,OACA,SACe;CACf,IAAI,SAAS,cACX,OAAO,gBAAsB,CAAC,SAAS,OAAO,CAAC,EAAE,KAC/C,QAAQ,cACR,IAAY,KAAG,CACjB;MAEA,OAAO,gBAAsB,CAAC,SAAS,OAAO,CAAC,EAAE,KAAK,IAAY,KAAG,CAAC;AAE1E;;;;;;;;;;;;;;;;;;;;;;;;;;;ACpBA,SAAgB,UAAa,OAA6B;CACxD,OAAO,UAAU,KAAA,KAAa,UAAU;AAC1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACqBA,SAAgB,cAAc,OAA4G;CACxI,IAAI,MAAM,QAAQ,KAAK,GAAG;EACxB,MAAM,WAAW,MAAM,OAAO,SAAS;EACvC,OAAO,SAAS,SAAS,gBAAsB,QAAQ,IAAI,GAAG,CAAC,CAAC;CAClE,OAAO;EACL,MAAM,WAAW,OAAO,YACtB,OAAO,QAAQ,KAAK,EAAE,QAAQ,CAAC,GAAG,OAAO,UAAU,CAAC,CAAC,CACvD;EACA,OAAO,OAAO,KAAK,QAAQ,EAAE,SACzB,gBAAsB,QAAQ,IAC9B,GAAG,CAAC,CAAC;CACX;AACF"}
+{"version":3,"file":"index.js","names":[],"sources":["../../../helpers/observable/combine.ts","../../../helpers/type/isDefined.ts","../../../helpers/observable/combineLatest.ts","../../../helpers/observable/isObservable.ts"],"sourcesContent":["/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\n/*\n * This program is under the terms of the GNU Lesser General Public License version 3\n * The full license information can be found in LICENSE in the root directory of this project.\n */\nimport {\n  Observable,\n  OperatorFunction,\n  combineLatest as combineLatestOperator,\n  map as mapOperator,\n} from \"rxjs\";\n\n\ntype combineOptions<T, U> = {\n  readonly preTreatment?: OperatorFunction<readonly [T, U], readonly [T, U]>;\n};\n\n/**\n * Combine two observables with a map function and an optional pre-treatment.\n *\n * Note: you can use the pre-treatment to add a filter, a distinctUntilChanged,\n * any other operator that can be used in a pipe, or even an `UntilDestroy`\n * operator.\n *\n * @param source1 first source of data\n * @param source2 second source of data\n * @param map way to combine data\n * @param options options for the combineLatest operator\n * @returns an observable that emits the result of the map function\n * @see combineLatestOperator\n * @see mapOperator\n * @since 1.0.0\n */\nexport function combine<T, U, R>(\n  source1: Observable<T>,\n  source2: Observable<U>,\n  map: (c: readonly [T, U]) => R,\n  options?: combineOptions<T, U>\n): Observable<R> {\n  if (options?.preTreatment) {\n    return combineLatestOperator([source1, source2]).pipe(\n      options.preTreatment,\n      mapOperator(map)\n    );\n  } else {\n    return combineLatestOperator([source1, source2]).pipe(mapOperator(map));\n  }\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\nimport type { Maybe } from './Maybe';\n\n/**\n * Checks if a value is defined (not undefined nor null).\n * This is the inverse of {@link isNullish}.\n *\n * Use as a type-safe filter callback to remove `null`/`undefined` from arrays.\n *\n * @param value - The value to check\n * @returns True if value is not undefined nor null\n * @example\n * isDefined(42)        // => true\n * isDefined('')        // => true (empty string is defined)\n * isDefined(null)      // => false\n * isDefined(undefined) // => false\n *\n * @example\n * // Type-safe alternative to filter out null/undefined\n * const items: (string | null | undefined)[] = ['a', null, 'b', undefined];\n * const result = items.filter(isDefined);\n * // => ['a', 'b'] with type string[]\n *\n * @see {@link isNullish} for the inverse check\n * @see {@link isTruthy} to also filter out `0`, `\"\"`, `false`, and `NaN`\n * @since 2.0.0\n */\nexport function isDefined<T>(value: Maybe<T>): value is T {\n  return value !== undefined && value !== null;\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\n/*\n * This program is under the terms of the GNU Lesser General Public License version 3\n * The full license information can be found in LICENSE in the root directory of this project.\n */\nimport {\n  Observable,\n  ObservableInput,\n  ObservableInputTuple,\n  ObservedValueOf,\n  combineLatest as combineLatestOperator,\n  of,\n} from \"rxjs\";\nimport { isDefined } from '../type/isDefined';\n\n// combineLatest([a, b, c])\nexport function combineLatest<A extends readonly unknown[]>(\n  sources: readonly [...ObservableInputTuple<A>]\n): Observable<A>;\n\n// combineLatest({a, b, c})\nexport function combineLatest<T extends Record<string, ObservableInput<unknown>>>(\n  sourcesObject: T\n): Observable<{ [K in keyof T]: ObservedValueOf<T[K]> }>;\n\n/**\n * Combines multiple Observables to create an Observable whose values are\n * calculated from the latest values of each of its input Observables.\n *\n * This method relies on {@link combineLatestOperator} of rxjs.\n *\n * The main difference with {@link combineLatestOperator} is in case of empty parameters.\n * If the parameter is empty (empty array or empty object), the result will be\n * also empty.\n *\n * ATTENTION: this version doesn't support `scheduler` nor `mapper` as last\n * argument like in {@link combineLatestOperator}.\n *\n * @see {@link combineLatestOperator}\n * @see {@link combineLatestAll}\n * @see {@link merge}\n * @see {@link withLatestFrom}\n *\n * @param {ObservableInput} [observables] An array of input Observables to combine with each other.\n * An array of Observables must be given as the first argument.\n * @returns {Observable} An Observable of projected values from the most recent\n * values from each input Observable, or an array of the most recent values from\n * each input Observable.\n * @since 1.0.0\n */\nexport function combineLatest(input: readonly ObservableInput<unknown>[] | Record<string, ObservableInput<unknown>>): Observable<unknown> {\n  if (Array.isArray(input)) {\n    const filtered = input.filter(isDefined);\n    return filtered.length ? combineLatestOperator(filtered) : of([]);\n  } else {\n    const filtered = Object.fromEntries(\n      Object.entries(input).filter(([_, v]) => isDefined(v)),\n    );\n    return Object.keys(filtered).length\n      ? combineLatestOperator(filtered)\n      : of({});\n  }\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\nimport type { Observable } from 'rxjs';\n\n/**\n * Checks if a value is an RxJS Observable or any compatible observable.\n *\n * Uses duck-typing: returns `true` for any object with both `.subscribe()` and\n * `.pipe()` methods, covering `Observable`, `Subject`, `BehaviorSubject`,\n * `ReplaySubject`, and any RxJS-compatible observable implementation.\n *\n * @param value - The value to check\n * @returns `true` if value is observable-like\n * @example\n * import { Observable, Subject } from 'rxjs';\n * isObservable(new Observable())  // => true\n * isObservable(new Subject())     // => true\n * isObservable(Promise.resolve()) // => false\n * isObservable({})                // => false\n * @since 2.0.3\n */\nexport function isObservable(value: unknown): value is Observable<unknown> {\n  return (\n    // Intentionally `object`-only, unlike `isPromiseLike` (see type/isPromiseLike.ts):\n    // a callable function exposing `.subscribe()`/`.pipe()` would be an unusual,\n    // contrived observable shape.\n    value !== null &&\n    typeof value === 'object' &&\n    typeof (value as Record<string, unknown>)['subscribe'] === 'function' &&\n    typeof (value as Record<string, unknown>)['pipe'] === 'function'\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAsCA,SAAgB,QACd,SACA,SACA,OACA,SACe;CACf,IAAI,SAAS,cACX,OAAO,gBAAsB,CAAC,SAAS,OAAO,CAAC,EAAE,KAC/C,QAAQ,cACR,IAAY,KAAG,CACjB;MAEA,OAAO,gBAAsB,CAAC,SAAS,OAAO,CAAC,EAAE,KAAK,IAAY,KAAG,CAAC;AAE1E;;;;;;;;;;;;;;;;;;;;;;;;;;;ACpBA,SAAgB,UAAa,OAA6B;CACxD,OAAO,UAAU,KAAA,KAAa,UAAU;AAC1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACqBA,SAAgB,cAAc,OAA4G;CACxI,IAAI,MAAM,QAAQ,KAAK,GAAG;EACxB,MAAM,WAAW,MAAM,OAAO,SAAS;EACvC,OAAO,SAAS,SAAS,gBAAsB,QAAQ,IAAI,GAAG,CAAC,CAAC;CAClE,OAAO;EACL,MAAM,WAAW,OAAO,YACtB,OAAO,QAAQ,KAAK,EAAE,QAAQ,CAAC,GAAG,OAAO,UAAU,CAAC,CAAC,CACvD;EACA,OAAO,OAAO,KAAK,QAAQ,EAAE,SACzB,gBAAsB,QAAQ,IAC9B,GAAG,CAAC,CAAC;CACX;AACF;;;;;;;;;;;;;;;;;;;;AC1CA,SAAgB,aAAa,OAA8C;CACzE,OAIE,UAAU,QACV,OAAO,UAAU,YACjB,OAAQ,MAAkC,iBAAiB,cAC3D,OAAQ,MAAkC,YAAY;AAE1D"}

package/llms.txt

@@ -1,7 +1,7 @@
 # @helpers4/observable
 
 > Tree-shakable TypeScript utility functions for the `observable` domain.
-> Package: `@helpers4/observable` — Version: 2.0.1
+> Package: `@helpers4/observable` — Version: 2.0.3
 > License: LGPL-3.0-or-later
 
 ## Installation
@@ -15,7 +15,7 @@ pnpm add @helpers4/observable
 ## Usage
 
 ```typescript
-import { combine, combineLatest } from '@helpers4/observable';
+import { combine, combineLatest, isObservable } from '@helpers4/observable';
 ```
 
 ## Functions
@@ -24,6 +24,7 @@ import { combine, combineLatest } from '@helpers4/observable';
 |---|---|
 | `combine` | Combine two observables with a map function and an optional pre-treatment.  Note: you can use the pr |
 | `combineLatest` | Combines multiple Observables to create an Observable whose values are calculated from the latest va |
+| `isObservable` | Checks if a value is an RxJS Observable or any compatible observable.  Uses duck-typing: returns `tr |
 
 ---
 
@@ -120,3 +121,50 @@ combineLatest([])
 ```
 
 ---
+
+### `isObservable`
+
+Checks if a value is an RxJS Observable or any compatible observable.
+
+Uses duck-typing: returns `true` for any object with both `.subscribe()` and
+`.pipe()` methods, covering `Observable`, `Subject`, `BehaviorSubject`,
+`ReplaySubject`, and any RxJS-compatible observable implementation.
+
+```typescript
+import { isObservable } from '@helpers4/observable';
+
+isObservable(value: unknown): value is Observable<unknown>
+```
+
+**Parameters:**
+
+- `value: unknown` — The value to check
+
+**Returns:** `value is Observable<unknown>` — `true` if value is observable-like
+
+**Examples:**
+
+*Detect an RxJS Observable or Subject*
+
+Returns true for Observable, Subject, BehaviorSubject, and any duck-typed observable.
+
+```typescript
+import { Observable, Subject } from 'rxjs';
+isObservable(new Observable())  // => true
+isObservable(new Subject())     // => true
+isObservable(Promise.resolve()) // => false
+isObservable({})                // => false
+```
+
+*Accept either an Observable or a plain value*
+
+Use as a guard to normalize inputs that may be Observables or raw values.
+
+```typescript
+import { Observable, of } from 'rxjs';
+function toObservable<T>(value: T | Observable<T>): Observable<T> {
+  return isObservable(value) ? value : of(value);
+}
+```
+
+---

package/meta/api.json

@@ -1,6 +1,6 @@
 {
   "category": "observable",
-  "version": "2.0.1",
+  "version": "2.0.3",
   "functions": [
     {
       "name": "combine",
@@ -122,6 +122,42 @@
         }
       ],
       "sourceFile": "combineLatest.ts"
+    },
+    {
+      "name": "isObservable",
+      "kind": "function",
+      "description": "Checks if a value is an RxJS Observable or any compatible observable.\n\nUses duck-typing: returns `true` for any object with both `.subscribe()` and\n`.pipe()` methods, covering `Observable`, `Subject`, `BehaviorSubject`,\n`ReplaySubject`, and any RxJS-compatible observable implementation.",
+      "since": "2.0.3",
+      "signatures": [
+        {
+          "signature": "isObservable(value: unknown): value is Observable<unknown>",
+          "description": "Checks if a value is an RxJS Observable or any compatible observable.\n\nUses duck-typing: returns `true` for any object with both `.subscribe()` and\n`.pipe()` methods, covering `Observable`, `Subject`, `BehaviorSubject`,\n`ReplaySubject`, and any RxJS-compatible observable implementation.",
+          "params": [
+            {
+              "name": "value",
+              "type": "unknown",
+              "description": "The value to check"
+            }
+          ],
+          "returns": {
+            "type": "value is Observable<unknown>",
+            "description": "`true` if value is observable-like"
+          }
+        }
+      ],
+      "examples": [
+        {
+          "title": "Detect an RxJS Observable or Subject",
+          "description": "Returns true for Observable, Subject, BehaviorSubject, and any duck-typed observable.",
+          "code": "import { Observable, Subject } from 'rxjs';\nisObservable(new Observable())  // => true\nisObservable(new Subject())     // => true\nisObservable(Promise.resolve()) // => false\nisObservable({})                // => false"
+        },
+        {
+          "title": "Accept either an Observable or a plain value",
+          "description": "Use as a guard to normalize inputs that may be Observables or raw values.",
+          "code": "import { Observable, of } from 'rxjs';\nfunction toObservable<T>(value: T | Observable<T>): Observable<T> {\n  return isObservable(value) ? value : of(value);\n}"
+        }
+      ],
+      "sourceFile": "isObservable.ts"
     }
   ]
 }

package/meta/examples.json

@@ -25,6 +25,21 @@
           "code": "combineLatest([])\n// emits []"
         }
       ]
+    },
+    {
+      "name": "isObservable",
+      "examples": [
+        {
+          "title": "Detect an RxJS Observable or Subject",
+          "description": "Returns true for Observable, Subject, BehaviorSubject, and any duck-typed observable.",
+          "code": "import { Observable, Subject } from 'rxjs';\nisObservable(new Observable())  // => true\nisObservable(new Subject())     // => true\nisObservable(Promise.resolve()) // => false\nisObservable({})                // => false"
+        },
+        {
+          "title": "Accept either an Observable or a plain value",
+          "description": "Use as a guard to normalize inputs that may be Observables or raw values.",
+          "code": "import { Observable, of } from 'rxjs';\nfunction toObservable<T>(value: T | Observable<T>): Observable<T> {\n  return isObservable(value) ? value : of(value);\n}"
+        }
+      ]
     }
   ]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@helpers4/observable",
-  "version": "2.0.1",
+  "version": "2.0.3",
   "description": "A set of helpers in TS/JS, compatible with tree-shaking, for observable.",
   "author": "baxyz <baxy@etik.com>",
   "license": "LGPL-3.0",
@@ -28,7 +28,8 @@
     "helpers",
     "observable",
     "combine",
-    "combineLatest"
+    "combineLatest",
+    "isObservable"
   ],
   "files": [
     "lib/index.js",