ts-results-es

# 5.0.1 Fixed: - Fixed the regression introduced in 5.0.0 as part of the `AsyncResult.andThen` fix. The fix is completely reverted for now. # 5.0.0 Backwards incompatible: - Changed `Option` and `Result` iterator behavior such that iterating `Some` and `Ok` will instead produce only one result – the wrapped value. Previously the iteration depended on the type of the wrapped value (iteratable or not) and produced results obtained by iterating the wrapped values. For example: ``` const o: Option<number[]> = Some([1, 2, 3]) const rs = Array.from(o) // Previously: rs was [1, 2, 3] // Now: rs equals [[1, 2, 3]] ``` Iterating `None` and `Err` is not affected and continues to produce no results. - Removed the parameter spread variants of `Result.all` and `Result.any`. Both of these methods now only take a single array parameter (the array parameter has already been supported for a while). Fixed: - Fixed `Result.or` and `Result.orElse` method types to actually be callable and return reasonable types when called. - Attempted to fix `AsyncResult.andThen` to return the correct type when the provided callback always returns an `Ok`. This attempt has been (for now) reverted in 5.0.1 as it created other problems. - Fixed the `Result.partition` signature. Added: - `Option.unwrapOrElse` - `Result.unwrapOrElse` # 4.2.0 Added: - Added a non-spread (you can pass an array as a single parameter) variant of `Result.all` - Added a new `Result.partition` convenience method # 4.1.0 - A whole bunch of documentation changes - Introduced `AsyncResult` to allow composing results with asynchronous code - Introduced `AsyncOption` as well - Fixed `Option.any` behavior - Fixed an edge case in using `ts-results-es` in CommonJS projects # 4.0.0 - Improved the documentation - Fixed the rxjs-operators submodules type declarations for CommonJS code - Changed `Result.orElse()` and `Result.mapOrElse()` error-handling callback to take the error as an argument (consistent with the original Rust methods) Backwards incompatible: - A bunch of renames: - `Some.val` -> `Some.value` - `Result.val` -> `Ok.value` and `Err.error` - `Option.some` -> `Option.isSome()` - `Option.none` -> `Option.isNone()` - `Result.ok` -> `Result.isOk()` - `Result.err` -> `Result.isErr()` # 3.6.1 - Improved the documentation a little bit - Fixed rxjs-operators module imports, thanks to Jacob Nguyen # 3.6.0 - Added `or()` and `orElse()` methods to both `Option` and `Result` # 3.5.0 - Added `andThen()` documentation, thanks to Drew De Ponte - Added the `expectErr()` method to `Result`, thanks to TheDudeFromCI - Added `mapOr()` and `mapOrElse()` to both `Option` and `Result` # 3.4.0 - Fixed some type errors that prevented the package from being built with recent TypeScript versions - Fixed ESM compatibility so that client code can use named imports without resorting to workarounds (fixes https://github.com/vultix/ts-results/issues/37) # 3.3.0 Big thank you to [@petehunt](https://github.com/petehunt) for all his work adding stack traces to `Err`. - Added a `stack` property to all `Err` objects. Can be used to pull a stack trace - Added `toOption` and `toResult` methods for converting between `Option` and `Result` objects # v3.2.1 - Fix regression found in [Issue#24](https://github.com/vultix/ts-results/issues/24) # v3.2.0 - Fixes for Typescript 4.2 # v3.1.0 Big thank you to [@petehunt](https://github.com/petehunt) for all his work adding the `Option` type. ### New Features - Added new `Option<T>`, `Some<T>`, and `None` types! - You should feel at home if you're used to working with Rust: ```typescript import { Option, Some, None } from 'ts-results'; const optionalNum: Option<number> = Some(3).map((num) => num * 2); if (optionalNum.some) { console.log(optionalNum.val === 6); // prints `true` } const noneNum: Option<number> = None; if (noneNum.some) { // You'll never get in here } ``` - Added new `Option.isOption` and `Result.isResult` helper functions. ### Other Improvements - Got to 100% test coverage on all code! - Removed uses of `@ts-ignore` # v3.0.0 Huge shout out to [@Jack-Works](https://github.com/Jack-Works) for helping get this release out. Most of the work was his, and it would not have happened without him. ### New Features - `Ok<T>` and `Err<T>` are now callable without `new`! - No longer breaks when calling from node - Tree-shakable when using tools like rollup or webpack - Fully unit tested - Added these helper functions: - `Result.all(...)` - Same as `Results` from previous releases. Collects all `Ok` values, or returns the first `Err` value. - `Results.any(...)` - Returns the first `Ok` value, or all of the `Err` values. - `Result.wrap<T, E>(() => ...)` - Wraps an operation that may throw an error, uses try / catch to return a `Result<T, E>` - `Result.wrapAsync<T, E>(() => ...)` - Same as the above, but async - Deprecated `else` in favor of `unwrapOr` to prefer api parity with Rust # v2.0.1 ### New Features - **core:** Added `reaonly static EMPTY: Ok<void>;` to `Ok` class. - **core:** Added `reaonly static EMPTY: Err<void>;` to `Err` class. # v2.0.0 This release features a complete rewrite of most of the library with one focus in mind: simpler types. The entire library now consists of only the following: - Two classes: `Ok<T>` and `Err<E>`. - A `Result<T, E>` type that is a simple or type between the two classes. - A simple `Results` function that allows combining multiple results. ### New Features - **core:** much simpler Typescript types - **rxjs:** added new `filterResultOk` and `filterResultErr` operators - **rxjs:** added new `resultMapErrTo` operator ### Breaking Changes - **core:** `Err` and `Ok` now require `new`: - **Before:** `let result = Ok(value); let error = Err(message);` - **After:** `let result = new Ok(value); let error = new Err(message);` - **core:** `map` function broken into two functions: `map` and `mapErr` - **before**: `result.map(value => "new value", error => "new error")` - **after**: `result.map(value => "newValue").mapError(error => "newError")` - **rxjs:** `resultMap` operator broken into two operators: `resultMap` and `resultMapErr` - **before**: `obs.pipe(resultMap(value => "new value", error => "new error"))` - **after**: `result.pipe(resultMap(value => "newValue"), resultMapError(error => "newError"))`