9.2.0 R.once TS type definition miss to context argument and its type (…

…#729)

* dsa

* chore@small

* prepare

* fix 726

* feat@fix

---------

Co-authored-by: Deyan Totev <[email protected]>

.github/README.md

@@ -10214,7 +10214,7 @@ This method is also known as P combinator.
 
 ```typescript
 
-once<T extends AnyFunction>(func: T): T
+once<T extends AnyFunction, C = unknown>(fn: T, context?: C): T
 ```
 
 It returns a function, which invokes only once `fn` function.
@@ -10235,7 +10235,7 @@ addOnce(1)
 <summary>All TypeScript definitions</summary>
 
 ```typescript
-once<T extends AnyFunction>(func: T): T;
+once<T extends AnyFunction, C = unknown>(fn: T, context?: C): T;
 ```
 
 </details>
@@ -10304,6 +10304,17 @@ test('happy path', () => {
   )).toBe(60)
   expect(addOneOnce(40)).toBe(60)
 })
+
+test('with context', () => {
+  const context = { name: 'fris' }
+  const getNameOnce = once(function (){
+    return this.name
+  }, context)
+
+  expect(getNameOnce()).toBe('fris')
+  expect(getNameOnce()).toBe('fris')
+  expect(getNameOnce()).toBe('fris')
+})
 ```
 
 </details>
@@ -10324,6 +10335,14 @@ describe('R.once', () => {
     const result = runOnce(1)
     result // $ExpectType number
   })
+  it('with context', () => {
+    const runOnce = once(function (this: any, x: number) {
+      return x + 2
+    })
+
+    const result = runOnce.call({}, 1)
+    result // $ExpectType number
+  })
 })
 ```
 
@@ -17067,13 +17086,17 @@ unless<T>(predicate: (x: T) => boolean, whenFalseFn: (x: T) => T): (x: T) => T;
 <summary><strong>R.unless</strong> source</summary>
 
 ```javascript
-export function unless(predicate, whenFalse){
-  if (arguments.length === 1){
-    return _whenFalse => unless(predicate, _whenFalse)
-  }
+import { curry } from './curry.js'
+
+function unlessFn(
+  predicate, whenFalseFn, input
+){
+  if (predicate(input)) return input
 
-  return input => predicate(input) ? input : whenFalse(input)
+  return whenFalseFn(input)
 }
+
+export const unless = curry(unlessFn)
 ```
 
 </details>
@@ -17097,6 +17120,11 @@ test('curried', () => {
   const safeIncCurried = unless(isNil)(inc)
   expect(safeIncCurried(null)).toBeNull()
 })
+
+test('with 3 inputs', () => {
+  let result = unless(x => x.startsWith('/'), x=> x.concat('/'), '/api')
+  expect(result).toBe('/api')
+})
 ```
 
 </details>
@@ -18502,9 +18530,16 @@ describe('R.zipWith', () => {
 
 ## ❯ CHANGELOG
 
+9.1.2
+
+- `R.once` TS type definition miss to context argument and its type - [Issue #728](https://github.com/selfrefactor/rambda/issues/728)
+
+- Fix implementation of `R.unless` function - https://github.com/selfrefactor/rambda/pull/726 
+
 9.1.1
 
 - Faster R.equals with Object.is short circuit - https://github.com/selfrefactor/rambda/pull/725
+
 - Fix R.cond transform is unary - https://github.com/selfrefactor/rambda/issues/720
 
 9.1.0

CHANGELOG.md

@@ -1,6 +1,13 @@
+9.1.2
+
+- `R.once` TS type definition miss to context argument and its type - [Issue #728](https://github.com/selfrefactor/rambda/issues/728)
+
+- Fix implementation of `R.unless` function - https://github.com/selfrefactor/rambda/pull/726 
+
 9.1.1
 
 - Faster R.equals with Object.is short circuit - https://github.com/selfrefactor/rambda/pull/725
+
 - Fix R.cond transform is unary - https://github.com/selfrefactor/rambda/issues/720
 
 9.1.0

README.md

@@ -9607,7 +9607,7 @@ This method is also known as P combinator.
 
 ```typescript
 
-once<T extends AnyFunction>(func: T): T
+once<T extends AnyFunction, C = unknown>(fn: T, context?: C): T
 ```
 
 It returns a function, which invokes only once `fn` function.
@@ -9619,7 +9619,7 @@ It returns a function, which invokes only once `fn` function.
 <summary>All TypeScript definitions</summary>
 
 ```typescript
-once<T extends AnyFunction>(func: T): T;
+once<T extends AnyFunction, C = unknown>(fn: T, context?: C): T;
 ```
 
 </details>
@@ -9688,6 +9688,17 @@ test('happy path', () => {
   )).toBe(60)
   expect(addOneOnce(40)).toBe(60)
 })
+
+test('with context', () => {
+  const context = { name: 'fris' }
+  const getNameOnce = once(function (){
+    return this.name
+  }, context)
+
+  expect(getNameOnce()).toBe('fris')
+  expect(getNameOnce()).toBe('fris')
+  expect(getNameOnce()).toBe('fris')
+})
 ```
 
 </details>
@@ -9708,6 +9719,14 @@ describe('R.once', () => {
     const result = runOnce(1)
     result // $ExpectType number
   })
+  it('with context', () => {
+    const runOnce = once(function (this: any, x: number) {
+      return x + 2
+    })
+
+    const result = runOnce.call({}, 1)
+    result // $ExpectType number
+  })
 })
 ```
 
@@ -15876,13 +15895,17 @@ unless<T>(predicate: (x: T) => boolean, whenFalseFn: (x: T) => T): (x: T) => T;
 <summary><strong>R.unless</strong> source</summary>
 
 ```javascript
-export function unless(predicate, whenFalse){
-  if (arguments.length === 1){
-    return _whenFalse => unless(predicate, _whenFalse)
-  }
+import { curry } from './curry.js'
+
+function unlessFn(
+  predicate, whenFalseFn, input
+){
+  if (predicate(input)) return input
 
-  return input => predicate(input) ? input : whenFalse(input)
+  return whenFalseFn(input)
 }
+
+export const unless = curry(unlessFn)
 ```
 
 </details>
@@ -15906,6 +15929,11 @@ test('curried', () => {
   const safeIncCurried = unless(isNil)(inc)
   expect(safeIncCurried(null)).toBeNull()
 })
+
+test('with 3 inputs', () => {
+  let result = unless(x => x.startsWith('/'), x=> x.concat('/'), '/api')
+  expect(result).toBe('/api')
+})
 ```
 
 </details>
@@ -17192,9 +17220,16 @@ describe('R.zipWith', () => {
 
 ## ❯ CHANGELOG
 
+9.1.2
+
+- `R.once` TS type definition miss to context argument and its type - [Issue #728](https://github.com/selfrefactor/rambda/issues/728)
+
+- Fix implementation of `R.unless` function - https://github.com/selfrefactor/rambda/pull/726 
+
 9.1.1
 
 - Faster R.equals with Object.is short circuit - https://github.com/selfrefactor/rambda/pull/725
+
 - Fix R.cond transform is unary - https://github.com/selfrefactor/rambda/issues/720
 
 9.1.0

dist/rambda.js

@@ -2380,12 +2380,11 @@ function uniqWith(predicate, list) {
   return willReturn;
 }
 
-function unless(predicate, whenFalse) {
-  if (arguments.length === 1) {
-    return _whenFalse => unless(predicate, _whenFalse);
-  }
-  return input => predicate(input) ? input : whenFalse(input);
+function unlessFn(predicate, whenFalseFn, input) {
+  if (predicate(input)) return input;
+  return whenFalseFn(input);
 }
+const unless = curry(unlessFn);
 
 function unnest(list) {
   return list.reduce((acc, item) => {

docs/README.md

@@ -9607,7 +9607,7 @@ This method is also known as P combinator.
 
 ```typescript
 
-once<T extends AnyFunction>(func: T): T
+once<T extends AnyFunction, C = unknown>(fn: T, context?: C): T
 ```
 
 It returns a function, which invokes only once `fn` function.
@@ -9619,7 +9619,7 @@ It returns a function, which invokes only once `fn` function.
 <summary>All TypeScript definitions</summary>
 
 ```typescript
-once<T extends AnyFunction>(func: T): T;
+once<T extends AnyFunction, C = unknown>(fn: T, context?: C): T;
 ```
 
 </details>
@@ -9688,6 +9688,17 @@ test('happy path', () => {
   )).toBe(60)
   expect(addOneOnce(40)).toBe(60)
 })
+
+test('with context', () => {
+  const context = { name: 'fris' }
+  const getNameOnce = once(function (){
+    return this.name
+  }, context)
+
+  expect(getNameOnce()).toBe('fris')
+  expect(getNameOnce()).toBe('fris')
+  expect(getNameOnce()).toBe('fris')
+})
 ```
 
 </details>
@@ -9708,6 +9719,14 @@ describe('R.once', () => {
     const result = runOnce(1)
     result // $ExpectType number
   })
+  it('with context', () => {
+    const runOnce = once(function (this: any, x: number) {
+      return x + 2
+    })
+
+    const result = runOnce.call({}, 1)
+    result // $ExpectType number
+  })
 })
 ```
 
@@ -15876,13 +15895,17 @@ unless<T>(predicate: (x: T) => boolean, whenFalseFn: (x: T) => T): (x: T) => T;
 <summary><strong>R.unless</strong> source</summary>
 
 ```javascript
-export function unless(predicate, whenFalse){
-  if (arguments.length === 1){
-    return _whenFalse => unless(predicate, _whenFalse)
-  }
+import { curry } from './curry.js'
+
+function unlessFn(
+  predicate, whenFalseFn, input
+){
+  if (predicate(input)) return input
 
-  return input => predicate(input) ? input : whenFalse(input)
+  return whenFalseFn(input)
 }
+
+export const unless = curry(unlessFn)
 ```
 
 </details>
@@ -15906,6 +15929,11 @@ test('curried', () => {
   const safeIncCurried = unless(isNil)(inc)
   expect(safeIncCurried(null)).toBeNull()
 })
+
+test('with 3 inputs', () => {
+  let result = unless(x => x.startsWith('/'), x=> x.concat('/'), '/api')
+  expect(result).toBe('/api')
+})
 ```
 
 </details>
@@ -17192,9 +17220,16 @@ describe('R.zipWith', () => {
 
 ## ❯ CHANGELOG
 
+9.1.2
+
+- `R.once` TS type definition miss to context argument and its type - [Issue #728](https://github.com/selfrefactor/rambda/issues/728)
+
+- Fix implementation of `R.unless` function - https://github.com/selfrefactor/rambda/pull/726 
+
 9.1.1
 
 - Faster R.equals with Object.is short circuit - https://github.com/selfrefactor/rambda/pull/725
+
 - Fix R.cond transform is unary - https://github.com/selfrefactor/rambda/issues/720
 
 9.1.0

files/index.d.ts

@@ -2754,7 +2754,7 @@ Notes:
 
 */
 // @SINGLE_MARKER
-export function once<T extends AnyFunction>(func: T): T;
+export function once<T extends AnyFunction, C = unknown>(fn: T, context?: C): T;
 
 /*
 Method: omit
@@ -6981,6 +6981,8 @@ Notes:
 // @SINGLE_MARKER
 export function mapToObject<T, U extends object>(fn: (input: T) => U|false, list: readonly T[]): U;
 export function mapToObject<T, U extends object>(fn: (input: T) => U|false): (list: readonly T[]) => U;
+export function mapToObject<T, U>(fn: (input: T) => object|false, list: T[]): U;
+export function mapToObject<T, U>(fn: (input: T) => object|false): (list: T[]) => U;
 
 /*
 Method: mapToObjectAsync
@@ -7001,6 +7003,8 @@ Notes:
 // @SINGLE_MARKER
 export function mapToObjectAsync<T, U extends object>(fn: (input: T) => Promise<U|false>, list: readonly T[]): Promise<U>;
 export function mapToObjectAsync<T, U extends object>(fn: (input: T) => Promise<U|false>): (list: readonly T[]) => Promise<U>;
+export function mapToObjectAsync<T, U>(fn: (input: T) => Promise<Output[keyof Output]|false>, list: T[]): Promise<U>;
+export function mapToObjectAsync<T, U>(fn: (input: T) => Promise<Output[keyof Output]|false>): (list: T[]) => Promise<U>;
 
 /*
 Method: mapKeys

immutable.d.ts

@@ -1167,7 +1167,7 @@ export function on<T, U, R>(binaryFn: (a: U, b: U) => R, unaryFn: (value: T) =>
 /**
  * It returns a function, which invokes only once `fn` function.
  */
-export function once<T extends AnyFunction>(func: T): T;
+export function once<T extends AnyFunction, C = unknown>(fn: T, context?: C): T;
 
 /**
  * Logical OR

index.d.ts

@@ -1167,7 +1167,7 @@ export function on<T, U, R>(binaryFn: (a: U, b: U) => R, unaryFn: (value: T) =>
 /**
  * It returns a function, which invokes only once `fn` function.
  */
-export function once<T extends AnyFunction>(func: T): T;
+export function once<T extends AnyFunction, C = unknown>(fn: T, context?: C): T;
 
 /**
  * Logical OR

package.json

@@ -32,6 +32,7 @@
     "test:all": "jest source/*.spec.js -u --bail=false",
     "test:ci": "jest source/*.spec.js --coverage --no-cache -w 1",
     "test:typings": "dtslint --localTs ./node_modules/typescript/lib --expectOnly ./source",
+    "test:ts": "yarn test:typings",
     "ts": "yarn test:typings",
     "usedby": "cd ../rambda-scripts && yarn usedby",
     "x": "yarn populatedocs:x && yarn populatereadme:x && yarn immutable:x"