rambda 10.0.1 → 10.2.0

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+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`
+
 10.0.1
 
 - Fix issue with `R.unwind`/`R.pick` typings - [Issue #766](https://github.com/selfrefactor/rambda/issues/766)

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
@@ -6560,6 +6714,135 @@ test('when index is out of bounds', () => {
 
 [![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#modifyItemAtIndex)
 
+### modifyPath
+
+```typescript
+
+modifyPath<U, T>(path: [], fn: (value: U) => T): (obj: U) => T
+```
+
+It changes a property of object on the base of provided path and transformer function.
+
+```javascript
+const result = R.modifyPath('a.b.c', x=> x+1, {a:{b: {c:1}}})
+// => {a:{b: {c:2}}}
+```
+
+<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20result%20%3D%20R.modifyPath('a.b.c'%2C%20x%3D%3E%20x%2B1%2C%20%7Ba%3A%7Bb%3A%20%7Bc%3A1%7D%7D%7D)%0A%2F%2F%20%3D%3E%20%7Ba%3A%7Bb%3A%20%7Bc%3A2%7D%7D%7D">Try this <strong>R.modifyPath</strong> example in Rambda REPL</a>
+
+<details>
+
+<summary>All TypeScript definitions</summary>
+
+```typescript
+modifyPath<U, T>(path: [], fn: (value: U) => T): (obj: U) => T;
+modifyPath<
+  K0 extends keyof U,
+  U,
+  T
+>(path: [K0], fn: (value: U[K0]) => T): (obj: U) => DeepModify<[K0], U, T>;
+modifyPath<
+  K0 extends string & keyof U,
+  U,
+  T
+>(path: `${K0}`, fn: (value: U[K0]) => T): (obj: U) => DeepModify<[K0], U, T>;
+modifyPath<
+  K0 extends keyof U,
+  K1 extends keyof U[K0],
+  U,
+  T
+>(path: [K0, K1], fn: (value: U[K0][K1]) => T): (obj: U) => DeepModify<[K0, K1], U, T>;
+...
+...
+```
+
+</details>
+
+<details>
+
+<summary><strong>R.modifyPath</strong> source</summary>
+
+```javascript
+import { createPath } from './_internals/createPath.js'
+import { path as pathModule } from './path.js'
+
+function assoc(prop, newValue) {
+  return obj => Object.assign({}, obj, { [prop]: newValue })
+}
+
+function modifyPathFn(pathInput, fn, obj) {
+  const path = createPath(pathInput)
+  if (path.length === 1) {
+    return {
+      ...obj,
+      [path[0]]: fn(obj[path[0]]),
+    }
+  }
+  if (pathModule(path)(obj) === undefined) {
+    return obj
+  }
+
+  const val = modifyPathFn(Array.prototype.slice.call(path, 1), fn, obj[path[0]])
+  if (val === obj[path[0]]) {
+    return obj
+  }
+
+  return assoc(path[0], val)(obj)
+}
+
+export function modifyPath(pathInput, fn) {
+  return obj => modifyPathFn(pathInput, fn, obj)
+}
+```
+
+</details>
+
+<details>
+
+<summary><strong>Tests</strong></summary>
+
+```javascript
+import { modifyPath } from './modifyPath.js'
+
+test('happy', () => {
+  const result = modifyPath('a.b.c', x => x + 1)({ a: { b: { c: 1 } } })
+  expect(result).toEqual({ a: { b: { c: 2 } } })
+})
+```
+
+</details>
+
+<details>
+
+<summary><strong>TypeScript</strong> test</summary>
+
+```typescript
+import { modifyPath, pipe } from 'rambda'
+
+const obj = { a: { b: { c: 1 } } }
+
+describe('R.modifyPath', () => {
+  it('array path', () => {
+    const result = pipe(
+      obj,
+      modifyPath(['a', 'b', 'c'], (x: number) => String(x)),
+    )
+    result.a.b.c // $ExpectType string
+  })
+  it('string path', () => {
+    const result = pipe(
+      obj,
+      modifyPath('a.b.c', (x: number) => String(x)),
+    )
+    result.a.b.c // $ExpectType string
+  })
+})
+```
+
+</details>
+
+[![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#modifyPath)
+
 ### modifyProp
 
 ```typescript
@@ -8219,7 +8502,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
+// const convertToType = <T>(x: unknown)=> x as unknown as T
 
 function tapFn<T, U>(
   transformFn: (x: T) => U,
@@ -12706,6 +12989,14 @@ describe('R.zipWith', () => {
 
 ## ❯ CHANGELOG
 
+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`
+
 10.0.1
 
 - Fix issue with `R.unwind`/`R.pick` typings - [Issue #766](https://github.com/selfrefactor/rambda/issues/766)

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)) {
@@ -997,6 +1010,66 @@ function modifyItemAtIndex(index, replaceFn) {
   }
 }
 
+function createPath(path, delimiter = '.') {
+  return typeof path === 'string'
+    ? path.split(delimiter).map(x => (Number.isInteger(Number(x)) ? Number(x) : x))
+    : path
+}
+
+function path(pathInput) {
+	return (obj)  => {
+		if (!obj) {
+			return undefined
+		}
+		let willReturn = obj;
+		let counter = 0;
+	
+		const pathArrValue = createPath(pathInput);
+	
+		while (counter < pathArrValue.length) {
+			if (willReturn === null || willReturn === undefined) {
+				return undefined
+			}
+			if (willReturn[pathArrValue[counter]] === null) {
+				return undefined
+			}
+	
+			willReturn = willReturn[pathArrValue[counter]];
+			counter++;
+		}
+	
+		return willReturn
+	}
+}
+
+function assoc(prop, newValue) {
+  return obj => Object.assign({}, obj, { [prop]: newValue })
+}
+
+function modifyPathFn(pathInput, fn, obj) {
+  const path$1 = createPath(pathInput);
+  if (path$1.length === 1) {
+    return {
+      ...obj,
+      [path$1[0]]: fn(obj[path$1[0]]),
+    }
+  }
+  if (path(path$1)(obj) === undefined) {
+    return obj
+  }
+
+  const val = modifyPathFn(Array.prototype.slice.call(path$1, 1), fn, obj[path$1[0]]);
+  if (val === obj[path$1[0]]) {
+    return obj
+  }
+
+  return assoc(path$1[0], val)(obj)
+}
+
+function modifyPath(pathInput, fn) {
+  return obj => modifyPathFn(pathInput, fn, obj)
+}
+
 function update(index, newValue) {
   return list => {
     const clone = cloneList(list);
@@ -1052,12 +1125,6 @@ function objectIncludes(condition) {
   }
 }
 
-function createPath(path, delimiter = '.') {
-  return typeof path === 'string'
-    ? path.split(delimiter).map(x => (Number.isInteger(Number(x)) ? Number(x) : x))
-    : path
-}
-
 function _includes(x, list) {
   let index = -1;
   const { length } = list;
@@ -1124,32 +1191,6 @@ function partitionObject(predicate) {
 }
 }
 
-function path(pathInput) {
-	return (obj)  => {
-		if (!obj) {
-			return undefined
-		}
-		let willReturn = obj;
-		let counter = 0;
-	
-		const pathArrValue = createPath(pathInput);
-	
-		while (counter < pathArrValue.length) {
-			if (willReturn === null || willReturn === undefined) {
-				return undefined
-			}
-			if (willReturn[pathArrValue[counter]] === null) {
-				return undefined
-			}
-	
-			willReturn = willReturn[pathArrValue[counter]];
-			counter++;
-		}
-	
-		return willReturn
-	}
-}
-
 function pathSatisfies(fn, pathInput) {
   return obj => Boolean(fn(path(pathInput)(obj)))
 }
@@ -1787,10 +1828,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;
@@ -1844,6 +1887,7 @@ exports.merge = merge;
 exports.mergeTypes = mergeTypes;
 exports.minBy = minBy;
 exports.modifyItemAtIndex = modifyItemAtIndex;
+exports.modifyPath = modifyPath;
 exports.modifyProp = modifyProp;
 exports.none = none;
 exports.objOf = objOf;

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)) {
@@ -995,6 +1008,66 @@ function modifyItemAtIndex(index, replaceFn) {
   }
 }
 
+function createPath(path, delimiter = '.') {
+  return typeof path === 'string'
+    ? path.split(delimiter).map(x => (Number.isInteger(Number(x)) ? Number(x) : x))
+    : path
+}
+
+function path(pathInput) {
+	return (obj)  => {
+		if (!obj) {
+			return undefined
+		}
+		let willReturn = obj;
+		let counter = 0;
+	
+		const pathArrValue = createPath(pathInput);
+	
+		while (counter < pathArrValue.length) {
+			if (willReturn === null || willReturn === undefined) {
+				return undefined
+			}
+			if (willReturn[pathArrValue[counter]] === null) {
+				return undefined
+			}
+	
+			willReturn = willReturn[pathArrValue[counter]];
+			counter++;
+		}
+	
+		return willReturn
+	}
+}
+
+function assoc(prop, newValue) {
+  return obj => Object.assign({}, obj, { [prop]: newValue })
+}
+
+function modifyPathFn(pathInput, fn, obj) {
+  const path$1 = createPath(pathInput);
+  if (path$1.length === 1) {
+    return {
+      ...obj,
+      [path$1[0]]: fn(obj[path$1[0]]),
+    }
+  }
+  if (path(path$1)(obj) === undefined) {
+    return obj
+  }
+
+  const val = modifyPathFn(Array.prototype.slice.call(path$1, 1), fn, obj[path$1[0]]);
+  if (val === obj[path$1[0]]) {
+    return obj
+  }
+
+  return assoc(path$1[0], val)(obj)
+}
+
+function modifyPath(pathInput, fn) {
+  return obj => modifyPathFn(pathInput, fn, obj)
+}
+
 function update(index, newValue) {
   return list => {
     const clone = cloneList(list);
@@ -1050,12 +1123,6 @@ function objectIncludes(condition) {
   }
 }
 
-function createPath(path, delimiter = '.') {
-  return typeof path === 'string'
-    ? path.split(delimiter).map(x => (Number.isInteger(Number(x)) ? Number(x) : x))
-    : path
-}
-
 function _includes(x, list) {
   let index = -1;
   const { length } = list;
@@ -1122,32 +1189,6 @@ function partitionObject(predicate) {
 }
 }
 
-function path(pathInput) {
-	return (obj)  => {
-		if (!obj) {
-			return undefined
-		}
-		let willReturn = obj;
-		let counter = 0;
-	
-		const pathArrValue = createPath(pathInput);
-	
-		while (counter < pathArrValue.length) {
-			if (willReturn === null || willReturn === undefined) {
-				return undefined
-			}
-			if (willReturn[pathArrValue[counter]] === null) {
-				return undefined
-			}
-	
-			willReturn = willReturn[pathArrValue[counter]];
-			counter++;
-		}
-	
-		return willReturn
-	}
-}
-
 function pathSatisfies(fn, pathInput) {
   return obj => Boolean(fn(path(pathInput)(obj)))
 }
@@ -1773,4 +1814,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, modifyPath, 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 };