@helpers4/observable 2.0.0-alpha.10 → 2.0.0-alpha.14

package/lib/index.d.ts

@@ -34,7 +34,7 @@ declare function combine<T, U, R>(source1: Observable<T>, source2: Observable<U>
  */
 
 declare function combineLatest<A extends readonly unknown[]>(sources: readonly [...ObservableInputTuple<A>]): Observable<A>;
-declare function combineLatest<T extends Record<string, ObservableInput<any>>>(sourcesObject: T): Observable<{
+declare function combineLatest<T extends Record<string, ObservableInput<unknown>>>(sourcesObject: T): Observable<{
     [K in keyof T]: ObservedValueOf<T[K]>;
 }>;
 

package/lib/index.js

@@ -26,6 +26,35 @@ function combine(source1, source2, map$1, options) {
 	else return combineLatest$1([source1, source2]).pipe(map(map$1));
 }
 //#endregion
+//#region helpers/type/isDefined.ts
+/**
+* Checks if a value is defined (not undefined nor null).
+* This is the inverse of {@link isNullish}.
+*
+* Use as a type-safe filter callback to remove `null`/`undefined` from arrays.
+*
+* @param value - The value to check
+* @returns True if value is not undefined nor null
+* @example
+* isDefined(42)        // => true
+* isDefined('')        // => true (empty string is defined)
+* isDefined(null)      // => false
+* isDefined(undefined) // => false
+*
+* @example
+* // Type-safe alternative to filter out null/undefined
+* const items: (string | null | undefined)[] = ['a', null, 'b', undefined];
+* const result = items.filter(isDefined);
+* // => ['a', 'b'] with type string[]
+*
+* @see {@link isNullish} for the inverse check
+* @see {@link isTruthy} to also filter out `0`, `""`, `false`, and `NaN`
+* @since 2.0.0
+*/
+function isDefined(value) {
+	return value !== void 0 && value !== null;
+}
+//#endregion
 //#region helpers/observable/combineLatest.ts
 /**
 * This file is part of helpers4.
@@ -59,9 +88,12 @@ function combine(source1, source2, map$1, options) {
 */
 function combineLatest(input) {
 	if (Array.isArray(input)) {
-		input = input.filter((a) => !!a);
-		return input.length ? combineLatest$1(...input) : of([]);
-	} else return Object.entries(input).filter(([_, v]) => !!v).length ? combineLatest$1(input) : of({});
+		const filtered = input.filter(isDefined);
+		return filtered.length ? combineLatest$1(filtered) : of([]);
+	} else {
+		const filtered = Object.fromEntries(Object.entries(input).filter(([_, v]) => isDefined(v)));
+		return Object.keys(filtered).length ? combineLatest$1(filtered) : of({});
+	}
 }
 //#endregion
 export { combine, combineLatest };

package/lib/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../../../helpers/observable/combine.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\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\";\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<any>>>(\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: any): any {\n  if (Array.isArray(input)) {\n    input = input.filter((a) => !!a);\n    return input.length ? combineLatestOperator(...input) : of([]);\n  } else {\n    return Object.entries(input).filter(([_, v]) => !!v).length\n      ? combineLatestOperator(input)\n      : of({});\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAsCA,SAAgB,QACd,SACA,SACA,OACA,SACe;AACf,KAAI,SAAS,aACX,QAAO,gBAAsB,CAAC,SAAS,QAAQ,CAAC,CAAC,KAC/C,QAAQ,cACR,IAAY,MAAI,CACjB;KAED,QAAO,gBAAsB,CAAC,SAAS,QAAQ,CAAC,CAAC,KAAK,IAAY,MAAI,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACI3E,SAAgB,cAAc,OAAiB;AAC7C,KAAI,MAAM,QAAQ,MAAM,EAAE;AACxB,UAAQ,MAAM,QAAQ,MAAM,CAAC,CAAC,EAAE;AAChC,SAAO,MAAM,SAAS,gBAAsB,GAAG,MAAM,GAAG,GAAG,EAAE,CAAC;OAE9D,QAAO,OAAO,QAAQ,MAAM,CAAC,QAAQ,CAAC,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC,SACjD,gBAAsB,MAAM,GAC5B,GAAG,EAAE,CAAC"}
+{"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;AACf,KAAI,SAAS,aACX,QAAO,gBAAsB,CAAC,SAAS,QAAQ,CAAC,CAAC,KAC/C,QAAQ,cACR,IAAY,MAAI,CACjB;KAED,QAAO,gBAAsB,CAAC,SAAS,QAAQ,CAAC,CAAC,KAAK,IAAY,MAAI,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;AClB3E,SAAgB,UAAa,OAA6B;AACxD,QAAO,UAAU,KAAA,KAAa,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACsB1C,SAAgB,cAAc,OAA4G;AACxI,KAAI,MAAM,QAAQ,MAAM,EAAE;EACxB,MAAM,WAAW,MAAM,OAAO,UAAU;AACxC,SAAO,SAAS,SAAS,gBAAsB,SAAS,GAAG,GAAG,EAAE,CAAC;QAC5D;EACL,MAAM,WAAW,OAAO,YACtB,OAAO,QAAQ,MAAM,CAAC,QAAQ,CAAC,GAAG,OAAO,UAAU,EAAE,CAAC,CACvD;AACD,SAAO,OAAO,KAAK,SAAS,CAAC,SACzB,gBAAsB,SAAS,GAC/B,GAAG,EAAE,CAAC"}

package/llms.txt

@@ -0,0 +1,122 @@
+# @helpers4/observable
+
+> Tree-shakable TypeScript utility functions for the `observable` domain.
+> Package: `@helpers4/observable` — Version: 2.0.0-alpha.14
+> License: LGPL-3.0-or-later
+
+## Installation
+
+```sh
+npm install @helpers4/observable
+# or
+pnpm add @helpers4/observable
+```
+
+## Usage
+
+```typescript
+import { combine, combineLatest } from '@helpers4/observable';
+```
+
+## Functions
+
+| Function | Description |
+|---|---|
+| `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 |
+
+---
+
+## API Reference
+
+### `combine`
+
+Combine two observables with a map function and an optional pre-treatment.
+
+Note: you can use the pre-treatment to add a filter, a distinctUntilChanged,
+any other operator that can be used in a pipe, or even an `UntilDestroy`
+operator.
+
+```typescript
+import { combine } from '@helpers4/observable';
+
+combine<T, U, R>(source1: Observable<T>, source2: Observable<U>, map: function, options?: combineOptions<T, U>): Observable<R>
+```
+
+**Parameters:**
+
+- `source1: Observable<T>` — first source of data
+- `source2: Observable<U>` — second source of data
+- `map: function` — way to combine data
+- `options?: combineOptions<T, U>` — options for the combineLatest operator
+
+**Returns:** `Observable<R>` — an observable that emits the result of the map function
+
+**Examples:**
+
+*Combine two observables with a map*
+
+Combines the latest values of two observables using a mapping function.
+
+```typescript
+combine(of(1), of(2), ([a, b]) => a + b)
+// emits 3
+```
+
+---
+
+### `combineLatest`
+
+Combines multiple Observables to create an Observable whose values are
+calculated from the latest values of each of its input Observables.
+
+This method relies on combineLatestOperator of rxjs.
+
+The main difference with combineLatestOperator is in case of empty parameters.
+If the parameter is empty (empty array or empty object), the result will be
+also empty.
+
+ATTENTION: this version doesn't support `scheduler` nor `mapper` as last
+argument like in combineLatestOperator.
+
+```typescript
+import { combineLatest } from '@helpers4/observable';
+
+combineLatest<A extends readonly unknown[]>(sources: readonly [ObservableInputTuple<A>]): Observable<A>
+```
+
+**Parameters:**
+
+- `sources: readonly [ObservableInputTuple<A>]`
+
+```typescript
+import { combineLatest } from '@helpers4/observable';
+
+combineLatest<T extends Record<string, ObservableInput<unknown>>>(sourcesObject: T): Observable<mapped>
+```
+
+**Parameters:**
+
+- `sourcesObject: T`
+
+**Examples:**
+
+*Combine array of observables*
+
+Combines an array of observables into one that emits arrays of their latest values.
+
+```typescript
+combineLatest([of(1), of(2), of(3)])
+// emits [1, 2, 3]
+```
+
+*Handle empty array*
+
+Returns an observable that emits an empty array when given no sources.
+
+```typescript
+combineLatest([])
+// emits []
+```
+
+---

package/meta/api.json

@@ -1,6 +1,6 @@
 {
   "category": "observable",
-  "version": "2.0.0-alpha.10",
+  "version": "2.0.0-alpha.14",
   "functions": [
     {
       "name": "combine",
@@ -88,7 +88,7 @@
           ]
         },
         {
-          "signature": "combineLatest<T extends Record<string, ObservableInput<any>>>(sourcesObject: T): Observable<mapped>",
+          "signature": "combineLatest<T extends Record<string, ObservableInput<unknown>>>(sourcesObject: T): Observable<mapped>",
           "description": "",
           "params": [
             {
@@ -104,7 +104,7 @@
           "typeParameters": [
             {
               "name": "T",
-              "constraint": "Record<string, ObservableInput<any>>"
+              "constraint": "Record<string, ObservableInput<unknown>>"
             }
           ]
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@helpers4/observable",
-  "version": "2.0.0-alpha.10",
+  "version": "2.0.0-alpha.14",
   "description": "A set of helpers in TS/JS, compatible with tree-shaking, for observable.",
   "author": "baxyz <baxy@etik.com>",
   "license": "LGPL-3.0",
@@ -21,6 +21,7 @@
     "./meta/api.json": "./meta/api.json",
     "./meta/examples.json": "./meta/examples.json",
     "./meta/licenses.json": "./meta/licenses.json",
+    "./llms.txt": "./llms.txt",
     "./package.json": "./package.json"
   },
   "keywords": [
@@ -34,6 +35,7 @@
     "lib/index.d.ts",
     "lib/index.js.map",
     "meta/",
+    "llms.txt",
     "LICENSE.md",
     "package.json",
     "README.md"
@@ -42,6 +44,6 @@
     "node": ">=18.0.0"
   },
   "peerDependencies": {
-    "rxjs": "^7.8.2"
+    "rxjs": "^7.0.0"
   }
 }