Audit stream externs for Node 24 and Haxe 4

.github/workflows/main.yml

@@ -0,0 +1,100 @@
+name: CI
+
+on: [push, pull_request]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        haxe_ver: [4.0.5, 4.3.7, latest]
+
+    steps:
+    - uses: actions/checkout@v7
+
+    - uses: krdlab/setup-haxe@v2
+      with:
+        haxe-version: ${{ matrix.haxe_ver }}
+
+    - run: haxelib dev hxnodejs .
+      name: Set haxelib dev path
+
+    - run: |
+        haxe build.hxml
+        haxelib git dox https://github.com/HaxeFoundation/dox
+        haxe doc.hxml
+      name: Build
+
+    - name: Upload artifact
+      if: matrix.haxe_ver == 'latest'
+      uses: actions/upload-pages-artifact@v3
+      with:
+        path: ./bin/api
+
+  test:
+    strategy:
+      fail-fast: false
+      matrix:
+        haxe_ver: [4.3.7, latest]
+        runner: [ubuntu-latest, windows-latest, macos-latest]
+    runs-on: ${{ matrix.runner }}
+    steps:
+    - uses: actions/checkout@v7
+
+    - uses: krdlab/setup-haxe@v2
+      with:
+        haxe-version: ${{ matrix.haxe_ver }}
+
+    - uses: actions/setup-node@v4
+      if: matrix.runner == 'windows-latest'
+      with:
+        node-version: 24
+
+    - run: haxelib dev hxnodejs .
+      name: Set haxelib dev path
+
+    - name: Get Haxe commit SHA
+      id: haxe_sha
+      shell: bash
+      env:
+        GH_TOKEN: ${{ github.token }}
+      run: |
+        version=$(haxe --version)
+        echo "Haxe version: $version"
+        short_sha=${version##*+}
+        full_sha=$(gh api repos/HaxeFoundation/haxe/commits/$short_sha --jq '.sha')
+        echo "Commit SHA: $short_sha, Full SHA: $full_sha"
+        echo "sha=$full_sha" >> "$GITHUB_OUTPUT"
+
+    - uses: actions/checkout@v7
+      with:
+        repository: HaxeFoundation/haxe
+        path: haxe
+        ref: ${{ steps.haxe_sha.outputs.sha }}
+
+    - name: Test
+      shell: bash
+      run: |
+        if [[ "${{ matrix.runner }}" == "macos-latest" ]]; then
+          echo "" > sys/compile-fs.hxml
+        fi
+        haxe --run RunCi js
+      working-directory: haxe/tests
+
+  deploy:
+    needs: [build, test]
+    if: github.ref == 'refs/heads/master' && github.event_name == 'push'
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      pages: write
+      id-token: write
+
+    environment:
+      name: github-pages
+      url: ${{steps.deployment.outputs.page_url}}
+    steps:
+      - name: Deploy artifact
+        id: deployment
+        uses: actions/deploy-pages@v4
+

HOWTO.md

@@ -72,14 +72,14 @@ Node.js event emitters take strings as event names and don't check listener sign
 
 If you provide an instance of `Event<T>` abstract string type where an event name is expected in any `EventEmitter` method, then the listener type will be unified with `T` and thus provide type checking and inference for the listener function.
 
-We provide [@:enum abstract types](http://haxe.org/manual/types-abstract-enum.html) that enumerate possible event names for a given event emitter. They are implicitly castable to `Event<T>` and can be used for type-checking listener functions as described above. For each `EventEmitter` subclass, an `@:enum abstract` type must be created with a `Event` postfix in its name. For example, if we have a `Process` class which is an `EventEmitter`, it should have a pairing `ProcessEvent` type in its module, i.e.:
+We provide [enum abstract types](https://haxe.org/manual/types-abstract-enum.html) that enumerate possible event names for a given event emitter. They are implicitly castable to `Event<T>` and can be used for type-checking listener functions as described above. For each `EventEmitter` subclass, an `enum abstract` type must be created with a `Event` postfix in its name. For example, if we have a `Process` class which is an `EventEmitter`, it should have a pairing `ProcessEvent` type in its module, i.e.:
 
 ```haxe
 extern class Process extends EventEmitter {
     // ...
 }
 
-@:enum abstract ProcessEvent<T:haxe.Constraints.Function>(Event<T>) to Event<T> {
+enum abstract ProcessEvent<T:haxe.Constraints.Function>(Event<T>) to Event<T> {
     var Exit : ProcessEvent<Int->Void> = "exit";
 }
 ```
@@ -96,7 +96,7 @@ TODO (describe the difference of overloading/optional argument concepts and advi
 
 The whole idea of haxe externs is provide a fully type-checked access to external API. Considering that, we must avoid the need for use `Dynamic` type or `cast` and think of a way to properly express type restrictions.
 
-On the other hand, we want developers to be able to copy-paste node.js code into haxe with minimal modification and have it compiling. For that reason we have to weaken some typing restrictions, for example adding implicit cast `from String` for our `@:enum abstract` types.
+On the other hand, we want developers to be able to copy-paste node.js code into haxe with minimal modification and have it compiling. For that reason we have to weaken some typing restrictions, for example adding implicit cast `from String` for our `enum abstract` types.
 
 ### Multiple inheritance
 
@@ -147,12 +147,12 @@ If a type can be of 3 and more types, nested `EitherType` can be used.
 
 ### Constant enumeration
 
-If there's a finite set of posible values for a function argument or object field, [@:enum abstract types](http://haxe.org/manual/types-abstract-enum.html) are used to enumerate those values.
+If there's a finite set of posible values for a function argument or object field, [enum abstract types](https://haxe.org/manual/types-abstract-enum.html) are used to enumerate those values.
 
 Example:
 
 ```haxe
-@:enum abstract SymlinkType(String) from String to String {
+enum abstract SymlinkType(String) from String to String {
     var File = "file";
     var Dir = "dir";
     var Junction = "junction";
@@ -164,10 +164,10 @@ The `to` and `from` implicit cast must be added so user can use both enumeration
 Constant names are `UpperCamelCase` and their values are actual values expected by native API.
 
 
-Note that combined with `haxe.EitherType` (described above), `@:enum abstract`s can handle even complicated cases where a value can be of different types, e.g.
+Note that combined with `haxe.EitherType` (described above), `enum abstract`s can handle even complicated cases where a value can be of different types, e.g.
 
 ```haxe
-@:enum abstract ListeningEventAddressType(haxe.EitherType<Int,String>) to haxe.EitherType<Int,String> {
+enum abstract ListeningEventAddressType(haxe.EitherType<Int,String>) to haxe.EitherType<Int,String> {
 	var TCPv4 = 4;
 	var TCPv6 = 6;
 	var Unix = -1;
@@ -213,4 +213,4 @@ extern class NotSoDeprecated {
 
 ## Tricks and hints
 
-TODO (dealing with keywords, `untyped __js__`, inline methods and properties on extern classes)
+TODO (dealing with keywords, `js.Syntax.code`, inline methods and properties on extern classes)

ImportAll.hx

@@ -24,6 +24,10 @@ class ImportAll {
 				Context.getType(typePath);
 			}
 		}
+		#if haxe5
+		Context.onAfterInitMacros(() -> loop([]));
+		#else
 		loop([]);
+		#end
 	}
 }

README.md

@@ -2,12 +2,13 @@
 
 # Haxe Node.JS
 
-[![Build Status](https://badgen.net/travis/HaxeFoundation/hxnodejs?label=build)](https://travis-ci.org/HaxeFoundation/hxnodejs)
+[![Build Status](https://img.shields.io/github/actions/workflow/status/HaxeFoundation/hxnodejs/main.yml?branch=master&label=build)](https://github.com/HaxeFoundation/hxnodejs/actions/workflows/main.yml)
 [![Haxelib Version](https://badgen.net/haxelib/v/hxnodejs)](https://lib.haxe.org/p/hxnodejs)
 [![Haxelib Downloads](https://badgen.net/haxelib/d/hxnodejs?color=blue)](https://lib.haxe.org/p/hxnodejs)
 [![Haxelib License](https://badgen.net/haxelib/license/hxnodejs)](LICENSE.md)
 
-Extern type definitions for Node.JS. Haxe **3.4** or newer is required.
+Extern type definitions for Node.JS. Haxe **4.0** or newer is required.
+Targeted at **Node.js 24** Active LTS APIs (bindings may lag behind edge cases).
 
 Haxe-generated API documentation is available at http://haxefoundation.github.io/hxnodejs/js/Node.html.
 

examples/AssertThrows.hx

@@ -1,16 +1,17 @@
-#if haxe4
 import js.lib.Error;
 import js.lib.RegExp;
-#else
-import js.Error;
-import js.RegExp;
-#end
 import js.node.Assert;
 
 class AssertThrows {
 	static function main() {
 		Assert.throws(function() throw new Error("Wrong value"), Error);
 		Assert.throws(function() throw new Error("Wrong value"), new RegExp("value"));
-		Assert.throws(function() throw new Error("Wrong value"), function(err) return (Std.is(err, Error) && ~/value/.match(err.message)), "unexpected error");
+		Assert.throws(function() throw new Error("Wrong value"), function(err)
+			return switch Std.downcast(cast err, Error) {
+				case null: false;
+				case e: ~/value/.match(e.message);
+			},
+			"unexpected error"
+		);
 	}
 }

examples/StreamExample.hx

@@ -31,7 +31,8 @@ class StreamExample {
 				} catch (er:Error) {
 					// uh oh!  bad json!
 					res.statusCode = 400;
-					return res.end('error: ' + er.message);
+					res.end('error: ' + er.message);
+					return;
 				}
 
 				// write back something interesting to the user:

haxelib.json

@@ -4,7 +4,7 @@
     "description": "Extern definitions for node.js",
     "license": "MIT",
     "version": "12.2.0",
-    "releasenote": "Update some API, fix some deprecation warnings.",
+    "releasenote": "Node.js 24 Active LTS audit ongoing; Haxe 4.0+ only.",
     "classPath": "src",
     "contributors": ["nadako", "Simn", "Gama11", "HaxeFoundation"],
     "tags": ["js", "nodejs", "async", "net", "web", "extern"]