rambda 10.0.0 → 10.1.0

package/CHANGELOG.md

@@ -1,6 +1,16 @@
-10.0.0
+10.1.0
+
+- Add `R.assertType` and `R.convertToType` methods
+
+- Fix issue with exports in old Node.js versions - [Discussion #768](https://github.com/selfrefactor/rambda/discussions/768)
+
+- Fix `deno` release as it was not possible for users to import version `10.0.0`
 
-CHANGELOG - 10.0.0
+10.0.1
+
+- Fix issue with `R.unwind`/`R.pick` typings - [Issue #766](https://github.com/selfrefactor/rambda/issues/766)
+
+10.0.0
 
 This is major revamp of `Rambda` library:
 
@@ -196,7 +206,7 @@ const result = piped(
 
 9.4.1
 
-- Fix bug with `R.differenceWith` when two arrays has same length - [Issue #750](https://github.com/selfrefactor/rambda/issues/757)
+- Fix bug with `R.differenceWith` when two arrays has same length - [Issue #757](https://github.com/selfrefactor/rambda/issues/757)
 
 - Allow path input to not be transformed when string numbers are there - [Issue #750](https://github.com/selfrefactor/rambda/issues/750)
 

package/README.md

@@ -1021,6 +1021,103 @@ it('R.ascend', () => {
 
 [![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#ascend)
 
+### assertType
+
+```typescript
+
+assertType<T, U extends T>(fn: (x: T) => x is U) : (x: T) => U
+```
+
+It helps to make sure that input is from specific type. Similar to `R.convertToType`, but it actually checks the type of the input value. If `fn` input returns falsy value, then the function will throw an error.
+
+<details>
+
+<summary>All TypeScript definitions</summary>
+
+```typescript
+assertType<T, U extends T>(fn: (x: T) => x is U) : (x: T) => U;
+```
+
+</details>
+
+<details>
+
+<summary><strong>R.assertType</strong> source</summary>
+
+```javascript
+export function assertType(fn) {
+  return (x) => {
+    if (fn(x)) {
+      return x
+    }
+    throw new Error('type assertion failed in R.assertType')
+  }
+}
+```
+
+</details>
+
+<details>
+
+<summary><strong>Tests</strong></summary>
+
+```javascript
+import { assertType } from './assertType.js'
+import { pipe } from './pipe.js'
+
+test('happy', () => {
+  const result = pipe(
+		[1, 2, 3],
+		assertType((x) => x.length === 3),
+	)
+	expect(result).toEqual([1, 2, 3])
+})
+
+test('throw', () => {
+	expect(() => {
+		pipe(
+			[1, 2, 3],
+			assertType((x) => x.length === 4),
+		)
+	}).toThrow('type assertion failed in R.assertType')
+})
+```
+
+</details>
+
+<details>
+
+<summary><strong>TypeScript</strong> test</summary>
+
+```typescript
+import { pipe, assertType } from 'rambda'
+
+type Book = {
+	title: string
+	year: number
+}
+
+type BookToRead = Book & {
+	bookmarkFlag: boolean
+}
+
+function isBookToRead(book: Book): book is BookToRead {
+	return (book as BookToRead).bookmarkFlag !== undefined 
+}
+
+it('R.assertType', () => {
+	const result = pipe(
+		{ title: 'Book1', year: 2020, bookmarkFlag: true },
+		assertType(isBookToRead),
+	)
+	result // $ExpectType BookToRead
+})
+```
+
+</details>
+
+[![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#assertType)
+
 ### checkObjectWithSpec
 
 ```typescript
@@ -1429,6 +1526,63 @@ it('R.concat', () => {
 
 [![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#concat)
 
+### convertToType
+
+```typescript
+
+convertToType<T>(x: unknown) : T
+```
+
+It helps to convert a value to a specific type.
+It is useful when you have to overcome TypeScript's type inference.
+
+<details>
+
+<summary>All TypeScript definitions</summary>
+
+```typescript
+convertToType<T>(x: unknown) : T;
+```
+
+</details>
+
+<details>
+
+<summary><strong>R.convertToType</strong> source</summary>
+
+```javascript
+export function convertToType(x) {
+  return x
+}
+```
+
+</details>
+
+<details>
+
+<summary><strong>TypeScript</strong> test</summary>
+
+```typescript
+import { convertToType, pipe } from 'rambda'
+
+const list = [1, 2, 3]
+
+it('R.convertToType', () => {
+  const result = pipe(list, 
+		convertToType<string[]>,
+		x => {
+			x // $ExpectType string[]
+			return x 
+		}
+	)
+  result // $ExpectType string[]
+})
+```
+
+</details>
+
+[![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#convertToType)
+
 ### count
 
 ```typescript
@@ -7808,10 +7962,7 @@ const expected = [
 
 ```typescript
 pick<K extends PropertyKey>(propsToPick: K[]): <T>(input: T) => MergeTypes<Pick<T, Exclude<keyof T, Exclude<keyof T, K>>>>;
-pick<
-	S extends string,
-	K extends PickStringToPickPath<K>
->(propsToPick: S): <T>(input: T) => MergeTypes<Pick<T, Exclude<keyof T, Exclude<keyof T, K>>>>;
+pick<S extends string>(propsToPick: S): <T>(input: T) => MergeTypes<Pick<T, Exclude<keyof T, Exclude<keyof T, ElementOf<PickStringToPickPath<S>>>>>>;
 ```
 
 </details>
@@ -8222,6 +8373,7 @@ function assertType<T, U extends T>(fn: (x: T) => x is U) {
 function convertToType<T>() {
   return <U>(x: U) => x as unknown as T
 }
+// const convertToType = <T>(x: unknown)=> x as unknown as T
 
 function tapFn<T, U>(
   transformFn: (x: T) => U,
@@ -12156,7 +12308,7 @@ describe('R.unless', () => {
 
 ```typescript
 
-unwind<S extends string>(prop: S): <T>(obj: T) => MergeTypes<Omit<T, S> & { [K in S]: T[S][number] }>
+unwind<S extends string>(prop: S): <T extends Record<S, readonly any[]>>(obj: T) => Array<MergeTypes<Omit<T, S> & { [K in S]: T[S][number] }>>
 ```
 
 It takes an object and a property name. The method will return a list of objects, where each object is a shallow copy of the input object, but with the property array unwound.
@@ -12178,7 +12330,7 @@ const expected = [{a:1, b:2}, {a:1, b:3}]
 <summary>All TypeScript definitions</summary>
 
 ```typescript
-unwind<S extends string>(prop: S): <T>(obj: T) => MergeTypes<Omit<T, S> & { [K in S]: T[S][number] }>;
+unwind<S extends string>(prop: S): <T extends Record<S, readonly any[]>>(obj: T) => Array<MergeTypes<Omit<T, S> & { [K in S]: T[S][number] }>>;
 ```
 
 </details>
@@ -12246,12 +12398,12 @@ const obj = {
 
 describe('R.unwind', () => {
   it('happy', () => {
-    const result = unwind('b')(obj)
+    const [result] = unwind('b')(obj)
     result.a // $ExpectType number
     result.b // $ExpectType number
   })
   it('inside pipe', () => {
-    const result = pipe(obj, unwind('b'))
+    const [result] = pipe(obj, unwind('b'))
     result.a // $ExpectType number
     result.b // $ExpectType number
   })
@@ -12708,9 +12860,19 @@ describe('R.zipWith', () => {
 
 ## ❯ CHANGELOG
 
-10.0.0
+10.1.0
+
+- Add `R.assertType` and `R.convertToType` methods
+
+- Fix issue with exports in old Node.js versions - [Discussion #768](https://github.com/selfrefactor/rambda/discussions/768)
+
+- Fix `deno` release as it was not possible for users to import version `10.0.0`
 
-CHANGELOG - 10.0.0
+10.0.1
+
+- Fix issue with `R.unwind`/`R.pick` typings - [Issue #766](https://github.com/selfrefactor/rambda/issues/766)
+
+10.0.0
 
 This is major revamp of `Rambda` library:
 
@@ -12906,7 +13068,7 @@ const result = piped(
 
 9.4.1
 
-- Fix bug with `R.differenceWith` when two arrays has same length - [Issue #750](https://github.com/selfrefactor/rambda/issues/757)
+- Fix bug with `R.differenceWith` when two arrays has same length - [Issue #757](https://github.com/selfrefactor/rambda/issues/757)
 
 - Allow path input to not be transformed when string numbers are there - [Issue #750](https://github.com/selfrefactor/rambda/issues/750)
 

package/dist/rambda.cjs

@@ -115,6 +115,15 @@ function ascend(getFunction) {
 }
 }
 
+function assertType(fn) {
+  return (x) => {
+    if (fn(x)) {
+      return x
+    }
+    throw new Error('type assertion failed in R.assertType')
+  }
+}
+
 function checkObjectWithSpec(conditions) {
   return input => {
     let shouldProceed = true;
@@ -190,6 +199,10 @@ function concat(x) {
   return y => (typeof x === 'string' ? `${x}${y}` : [...x, ...y])
 }
 
+function convertToType(x) {
+  return x
+}
+
 function count(predicate) {
   return list => {
     if (!isArray(list)) {
@@ -1787,10 +1800,12 @@ exports.any = any;
 exports.anyPass = anyPass;
 exports.append = append;
 exports.ascend = ascend;
+exports.assertType = assertType;
 exports.checkObjectWithSpec = checkObjectWithSpec;
 exports.compact = compact;
 exports.complement = complement;
 exports.concat = concat;
+exports.convertToType = convertToType;
 exports.count = count;
 exports.countBy = countBy;
 exports.createCompareFunction = createCompareFunction;

package/dist/rambda.js

@@ -113,6 +113,15 @@ function ascend(getFunction) {
 }
 }
 
+function assertType(fn) {
+  return (x) => {
+    if (fn(x)) {
+      return x
+    }
+    throw new Error('type assertion failed in R.assertType')
+  }
+}
+
 function checkObjectWithSpec(conditions) {
   return input => {
     let shouldProceed = true;
@@ -188,6 +197,10 @@ function concat(x) {
   return y => (typeof x === 'string' ? `${x}${y}` : [...x, ...y])
 }
 
+function convertToType(x) {
+  return x
+}
+
 function count(predicate) {
   return list => {
     if (!isArray(list)) {
@@ -1773,4 +1786,4 @@ function zipWith(fn, x) {
     )
 }
 
-export { _arity, _includes, _indexOf, _lastIndexOf, addProp, addPropToObjects, all, allPass, any, anyPass, append, ascend, checkObjectWithSpec, compact, complement, concat, count, countBy, createCompareFunction, createObjectFromKeys, defaultTo, descend, drop, dropLast, dropLastWhile, dropWhile, eqBy, eqProps, equals, equalsFn, evolve, excludes, filter, filterObject, find, findIndex, findLast, findLastIndex, findNth, flatMap, flatten, flattenObject, flattenObjectHelper, groupBy, groupByFallback, head, includes, indexOf, init, innerJoin, interpolate, intersection, intersperse, join, last, lastIndexOf, map, mapAsync, mapFn, mapKeys, mapObject, mapObjectAsync, mapParallelAsync, match, maxBy, merge, mergeTypes, minBy, modifyItemAtIndex, modifyProp, none, objOf, objectIncludes, omit, partition, partitionObject, path, pathSatisfies, permutations, pick, pipe, pipeAsync, pluck, prepend, prop, propEq, propOr, propSatisfies, range, reduce, reject, rejectObject, replace, shuffle, sort, sortBy, sortByDescending, sortByFn, sortByPath, sortByPathDescending, sortObject, sortWith, split, splitEvery, symmetricDifference, tail, take, takeLast, takeLastWhile, takeWhile, tap, test, transformFlatObject, tryCatch, type, union, uniq, uniqBy, uniqWith, unless, unwind, update, when, zip, zipWith };
+export { _arity, _includes, _indexOf, _lastIndexOf, addProp, addPropToObjects, all, allPass, any, anyPass, append, ascend, assertType, checkObjectWithSpec, compact, complement, concat, convertToType, count, countBy, createCompareFunction, createObjectFromKeys, defaultTo, descend, drop, dropLast, dropLastWhile, dropWhile, eqBy, eqProps, equals, equalsFn, evolve, excludes, filter, filterObject, find, findIndex, findLast, findLastIndex, findNth, flatMap, flatten, flattenObject, flattenObjectHelper, groupBy, groupByFallback, head, includes, indexOf, init, innerJoin, interpolate, intersection, intersperse, join, last, lastIndexOf, map, mapAsync, mapFn, mapKeys, mapObject, mapObjectAsync, mapParallelAsync, match, maxBy, merge, mergeTypes, minBy, modifyItemAtIndex, modifyProp, none, objOf, objectIncludes, omit, partition, partitionObject, path, pathSatisfies, permutations, pick, pipe, pipeAsync, pluck, prepend, prop, propEq, propOr, propSatisfies, range, reduce, reject, rejectObject, replace, shuffle, sort, sortBy, sortByDescending, sortByFn, sortByPath, sortByPathDescending, sortObject, sortWith, split, splitEvery, symmetricDifference, tail, take, takeLast, takeLastWhile, takeWhile, tap, test, transformFlatObject, tryCatch, type, union, uniq, uniqBy, uniqWith, unless, unwind, update, when, zip, zipWith };

package/dist/rambda.umd.js

@@ -119,6 +119,15 @@
   }
   }
 
+  function assertType(fn) {
+    return (x) => {
+      if (fn(x)) {
+        return x
+      }
+      throw new Error('type assertion failed in R.assertType')
+    }
+  }
+
   function checkObjectWithSpec(conditions) {
     return input => {
       let shouldProceed = true;
@@ -194,6 +203,10 @@
     return y => (typeof x === 'string' ? `${x}${y}` : [...x, ...y])
   }
 
+  function convertToType(x) {
+    return x
+  }
+
   function count(predicate) {
     return list => {
       if (!isArray(list)) {
@@ -1791,10 +1804,12 @@
   exports.anyPass = anyPass;
   exports.append = append;
   exports.ascend = ascend;
+  exports.assertType = assertType;
   exports.checkObjectWithSpec = checkObjectWithSpec;
   exports.compact = compact;
   exports.complement = complement;
   exports.concat = concat;
+  exports.convertToType = convertToType;
   exports.count = count;
   exports.countBy = countBy;
   exports.createCompareFunction = createCompareFunction;