v6.3.1 - fix 6.0.0 regressions breaking event-emitted-grouped

Author: balupton

.github/workflows/bevry.yml

@@ -66,7 +66,7 @@ jobs:
       - run: npm run our:compile
       - run: npm run our:meta
       - name: publish to npm
-        uses: bevry-actions/[email protected].5
+        uses: bevry-actions/[email protected].6
         with:
           npmAuthToken: ${{ secrets.NPM_AUTH_TOKEN }}
           npmBranchTag: ':next'

HISTORY.md

@@ -1,5 +1,10 @@
 # History
 
+## v6.3.1 2023 December 29
+
+-   Fixed v6.0.0+ breaking compatibility with `event-emitter-grouped`; we once again export `bind` and `define`, and return the bounded function with `define`
+-   Thank you to the sponsors: [Andrew Nesbitt](https://nesbitt.io), [Balsa](https://balsa.com), [Codecov](https://codecov.io), [Poonacha Medappa](https://poonachamedappa.com), [Rob Morris](https://github.com/Rob-Morris), [Sentry](https://sentry.io), [Syntax](https://syntax.fm)
+
 ## v6.3.0 2023 December 29
 
 -   Updated dependencies, [base files](https://github.com/bevry/base), and [editions](https://editions.bevry.me) using [boundation](https://github.com/bevry/boundation)

README.md

@@ -90,27 +90,27 @@ equal(boundedFunction.unbounded, myFunction, 'unbounded was correct')
 ### [Deno](https://deno.land "Deno is a secure runtime for JavaScript and TypeScript, it is an alternative for Node.js")
 
 ``` typescript
-import * as pkg from 'https://unpkg.com/unbounded@^6.3.0/edition-deno/index.ts'
+import * as pkg from 'https://unpkg.com/unbounded@^6.3.1/edition-deno/index.ts'
 ```
 ### [Skypack](https://www.skypack.dev "Skypack is a JavaScript Delivery Network for modern web apps")
 
 ``` html
 <script type="module">
-    import * as pkg from '//cdn.skypack.dev/unbounded@^6.3.0'
+    import * as pkg from '//cdn.skypack.dev/unbounded@^6.3.1'
 </script>
 ```
 ### [unpkg](https://unpkg.com "unpkg is a fast, global content delivery network for everything on npm")
 
 ``` html
 <script type="module">
-    import * as pkg from '//unpkg.com/unbounded@^6.3.0'
+    import * as pkg from '//unpkg.com/unbounded@^6.3.1'
 </script>
 ```
 ### [jspm](https://jspm.io "Native ES Modules CDN")
 
 ``` html
 <script type="module">
-    import * as pkg from '//dev.jspm.io/[email protected].0'
+    import * as pkg from '//dev.jspm.io/[email protected].1'
 </script>
 ```
 ### [Editions](https://editions.bevry.me "Editions are the best way to produce and consume packages you care about.")

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "unbounded",
-  "version": "6.3.0",
+  "version": "6.3.1",
   "license": "Artistic-2.0",
   "description": "Function.prototype.bind replacement that provides an `unbounded` hidden property on the returned bounded function, that contains the original unbounded function",
   "homepage": "https://github.com/bevry/unbounded",
@@ -246,7 +246,7 @@
     "eslint-config-bevry": "^5.3.0",
     "eslint-config-prettier": "^9.1.0",
     "eslint-plugin-prettier": "^5.1.2",
-    "kava": "^7.6.0",
+    "kava": "^7.7.0",
     "make-deno-edition": "^2.2.0",
     "prettier": "^3.1.1",
     "projectz": "^4.1.1",

package.json

@@ -1,17 +1,20 @@
-const bind = Function.prototype.bind
-
 declare global {
 	interface Function {
 		/** The original function, before any binding. */
 		unbounded?: this
 	}
 }
 
+/** The original native bind function, before {@link patch} wraps it. */
+export const bind = Function.prototype.bind
+
 /**
  * Attach the `unbounded` property on the `bounded` function.
  * If `unbounded.unbounded` already exists, then it is used instead, to ensure that the `unbounded` property is always the original function.
+ * @param bounded the bounded function
+ * @param unbounded the original function, before any binding
  */
-function define<T extends Function>(bounded: T, unbounded: T): void {
+export function define<T extends Function>(bounded: T, unbounded: T): T {
 	if (bounded.unbounded !== unbounded) {
 		Object.defineProperty(bounded, 'unbounded', {
 			value: unbounded.unbounded || unbounded,
@@ -20,16 +23,25 @@ function define<T extends Function>(bounded: T, unbounded: T): void {
 			writable: false,
 		})
 	}
+	return bounded
 }
 
 /**
  * Alternative to `Function.prototype.bind` that sets the `unbounded` property on the bounded function.
  * Types of this are not intelligent, as using the intelligent bind types causes this/unknown incompatibility. This is not important however, as the masquerading binder of {@link patch} has the intelligent types.
+ * @example `a.bind(context, arg1, arg2)` is equivalent to `binder.call(a, context, arg1, arg2)`
+ * @param this the function that will be bounded
+ * @param newThis the new `this` context to attach to the bounded function
+ * @param prefilledArguments the arguments to prefill the bounded function with
  */
-export function binder(this: Function, thisArg: any, ...argArray: any[]): any {
-	const bounded = bind.call(this, thisArg, ...argArray)
-	define(bounded, this)
-	return bounded
+export function binder(
+	this: Function,
+	newThis: any,
+	...prefilledArguments: any[]
+): any {
+	const unbounded = this
+	const bounded = bind.call(unbounded, newThis, ...prefilledArguments)
+	return define(bounded, unbounded)
 }
 
 /** Patch the native `Function.prototype.bind` so that it sets the `unbounded` property on the bounded function. */

source/index.ts

@@ -1,4 +1,4 @@
-import * as unbounded from './index.js'
+import { binder, define, patch } from './index.js'
 import { equal } from 'assert-helpers'
 import kava from 'kava'
 
@@ -7,6 +7,14 @@ interface Context {
 }
 
 kava.suite('unbounded', function (suite, test) {
+	test('define works', function () {
+		const a = function () {}
+		const b = function () {}
+		const c = function () {}
+		define(b, c)
+		define(a, b)
+		equal(a.unbounded, c, 'unbounded was correct')
+	})
 	test('binder works', function () {
 		const context: Context = {
 			str: 'a',
@@ -16,22 +24,22 @@ kava.suite('unbounded', function (suite, test) {
 			return this.str
 		}
 
-		const b = unbounded.binder.call(a, context)
+		const b = binder.call(a, context)
 		equal(b.unbounded, a, 'unbounded was correct')
 		equal(b(), context.str, 'context was correct')
 		equal(context.str, 'a', 'context was correct')
 		equal(b('b'), context.str, 'context was correct')
 		equal(context.str, 'b', 'context was correct')
 
-		const c = unbounded.binder.call(a, context, 'c')
+		const c = binder.call(a, context, 'c')
 		equal(c.unbounded, a, 'unbounded was correct')
 		equal(c(), context.str, 'context was correct')
 		equal(context.str, 'c', 'context was correct')
 
 		equal(b.unbounded, a, 'unbounded was correct')
 	})
 	test('patch works', function () {
-		unbounded.patch()
+		patch()
 		const context: Context = {
 			str: 'a',
 		}