@tsukilabs/nil-ffi 0.7.1 → 0.7.2

package/dist/error.d.ts

@@ -1,15 +1,20 @@
 import { Option } from '@tb-dev/utils';
-import { ffi_Status } from '@tsukilabs/nil-bindings';
+import { ffi_Response, ffi_Status } from '@tsukilabs/nil-bindings';
 export interface FfiErrorOptions extends ErrorOptions {
     readonly status?: Option<ffi_Status>;
 }
-export declare class FfiError extends Error {
-    readonly name = "FfiError";
+export declare class NilError extends Error {
+    readonly name = "NilError";
     readonly status: ffi_Status;
     constructor(message: Option<string>, options?: FfiErrorOptions);
-    static fromStatus(status: ffi_Status): FfiError;
+    static fromStatus(status: ffi_Status): NilError;
 }
 export declare class HandleClosedError extends Error {
     readonly name = "HandleClosedError";
     constructor(options?: ErrorOptions);
 }
+export declare class UnknownResponseError extends Error {
+    readonly name = "UnknownResponseError";
+    readonly response: ffi_Response;
+    constructor(response: ffi_Response, options?: ErrorOptions);
+}

package/dist/index.d.ts

@@ -1,22 +1,25 @@
 import { definitions } from './def';
 import { Option } from '@tb-dev/utils';
+import { GetRemoteWorldsResponse } from '@tsukilabs/nil-bindings';
 import * as ffi from "node:ffi";
 export * from './def';
 export * from './error';
 export type Handle = ffi.DynamicLibraryResult<typeof definitions>;
 export declare const VERSION: string;
+export declare const USER_AGENT: string;
 export declare class Nil implements Disposable {
     private readonly handle;
     readonly functions: Handle["functions"];
     private readonly queue;
     private disposed;
-    constructor(dll: string);
+    private constructor();
+    static init(dll: string): Promise<Nil>;
     [Symbol.dispose](): void;
     close(): void;
     getClientVersion(): Promise<string>;
     getFfiVersion(): Promise<string>;
-    getRemoteWorldLimit(): Promise<GetRemoteWorldLimitResponse>;
-    getRemoteWorldLimitPerUser(): Promise<GetRemoteWorldLimitPerUserResponse>;
+    getRemoteWorldLimit(): Promise<number>;
+    getRemoteWorldLimitPerUser(): Promise<number>;
     getRemoteWorlds(): Promise<GetRemoteWorldsResponse>;
     getUserAgent(): Promise<string>;
     getWorld(): Promise<Option<string>>;

package/dist/index.js

@@ -1,8 +1,11 @@
 import * as ffi from "node:ffi";
+import { EventEmitter } from "node:events";
 import { isNil } from "es-toolkit/predicate";
 import * as process from "node:process";
 import { ffi_Status } from "@tsukilabs/nil-bindings";
 //#region src/request.ts
+//! Copyright (C) Call of Nil contributors
+//! SPDX-License-Identifier: AGPL-3.0-only
 var RequestId = class {
 	#current = 0;
 	next() {
@@ -12,6 +15,8 @@ var RequestId = class {
 };
 //#endregion
 //#region src/ptr.ts
+//! Copyright (C) Call of Nil contributors
+//! SPDX-License-Identifier: AGPL-3.0-only
 function allocBuffer(size) {
 	return Buffer.alloc(size ?? pointerSize());
 }
@@ -25,7 +30,9 @@ function pointerSize() {
 }
 //#endregion
 //#region src/error.ts
-var FfiError = class FfiError extends Error {
+//! Copyright (C) Call of Nil contributors
+//! SPDX-License-Identifier: AGPL-3.0-only
+var NilError = class NilError extends Error {
 	constructor(message, options) {
 		const status = options?.status ?? ffi_Status.ERR_UNKNOWN;
 		if (!message && status !== ffi_Status.OK) {
@@ -36,11 +43,11 @@ var FfiError = class FfiError extends Error {
 		}
 		message ??= "ERR_UNKNOWN";
 		super(message, options);
-		this.name = "FfiError";
+		this.name = "NilError";
 		this.status = status;
 	}
 	static fromStatus(status) {
-		return new FfiError(null, { status });
+		return new NilError(null, { status });
 	}
 };
 var HandleClosedError = class extends Error {
@@ -49,8 +56,25 @@ var HandleClosedError = class extends Error {
 		this.name = "HandleClosedError";
 	}
 };
+var UnknownResponseError = class extends Error {
+	constructor(response, options) {
+		super(`got unknown response with id ${response.id}`, options);
+		this.name = "UnknownResponseError";
+		this.response = response;
+	}
+};
 //#endregion
 //#region src/queue.ts
+//! Copyright (C) Call of Nil contributors
+//! SPDX-License-Identifier: AGPL-3.0-only
+var QueueEmitter = class extends EventEmitter {
+	emit(event, ...args) {
+		return super.emit(event, ...args);
+	}
+	on(event, listener) {
+		return super.on(event, listener);
+	}
+};
 var Queue = class Queue {
 	static {
 		this.POLL_INTERVAL = 16;
@@ -58,81 +82,101 @@ var Queue = class Queue {
 	static {
 		this.LIMIT_PER_TICK = 200;
 	}
-	constructor(handle) {
-		this.pending = /* @__PURE__ */ new Map();
+	constructor(handle, options) {
 		this.disposed = false;
+		this.emitter = new QueueEmitter();
 		this.requestId = new RequestId();
+		this.pendingRequests = /* @__PURE__ */ new Map();
 		this.functions = handle.functions;
+		this.errorHandler = options?.onError ?? console.error;
+		this.emitter.on("error", this.errorHandler);
+		this.emitter.on("response", this.onResponse.bind(this));
+		this.timer = setTimeout(() => this.drain(), 0);
 	}
 	[Symbol.dispose]() {
 		if (this.disposed) return;
 		this.disposed = true;
 		this.rejectAll(new HandleClosedError());
+		this.emitter.removeAllListeners();
 	}
 	request(start) {
 		if (this.disposed) return Promise.reject(new HandleClosedError());
 		const requestId = this.requestId.next();
 		return new Promise((resolve, reject) => {
-			this.pending.set(requestId, {
+			this.pendingRequests.set(requestId, {
 				resolve,
 				reject
 			});
 			try {
 				start(requestId);
 			} catch (err) {
-				this.pending.delete(requestId);
+				this.pendingRequests.delete(requestId);
 				reject(err);
-				return;
 			}
-			this.startPolling();
 		});
 	}
-	startPolling() {
-		if (isNil(this.timer) && !this.disposed) this.timer = setTimeout(() => this.poll(), 0);
-	}
-	poll() {
-		this.timer = null;
-		if (!this.disposed && this.pending.size > 0) try {
-			for (let i = 0; i < Queue.LIMIT_PER_TICK; i++) if (!this.pollOnce()) break;
+	drain() {
+		if (this.disposed) return;
+		this.clearTimeout();
+		try {
+			for (let i = 0; i < Queue.LIMIT_PER_TICK; i++) if (!this.poll()) break;
 		} catch (err) {
-			this.rejectAll(err);
-			return;
+			this.emitter.emit("error", err);
 		}
-		if (!this.disposed && this.pending.size > 0) this.timer = setTimeout(() => this.poll(), Queue.POLL_INTERVAL);
+		this.timer = setTimeout(() => this.drain(), Queue.POLL_INTERVAL);
 	}
-	pollOnce() {
+	poll() {
 		const out = allocBuffer();
 		const status = this.functions.nil_ffi_poll(out);
 		if (status === ffi_Status.ERR_NOTHING_TO_POLL) return false;
-		if (status !== ffi_Status.OK) throw FfiError.fromStatus(status);
+		if (status !== ffi_Status.OK) throw NilError.fromStatus(status);
 		const ptr = readBufferPtr(out);
-		if (ptr === 0n) throw new Error("unexpected null pointer");
-		let json;
+		if (ptr === 0n) throw new Error("failed to poll: unexpected null pointer");
 		try {
-			json = ffi.toString(ptr);
+			const json = ffi.toString(ptr) ?? "";
+			const entry = JSON.parse(json);
+			this.dispatch(entry);
 		} finally {
 			this.functions.nil_ffi_free_str(ptr);
 		}
-		const entry = JSON.parse(json);
-		const response = JSON.parse(entry.json_str);
-		const pending = this.pending.get(response.id);
-		if (!pending) return true;
-		this.pending.delete(response.id);
-		if (response.kind === "ok") pending.resolve(response.data);
-		else pending.reject(new FfiError(response.error, { status: response.status }));
 		return true;
 	}
+	dispatch(entry) {
+		switch (entry.kind) {
+			case "response": {
+				const response = JSON.parse(entry.json_str);
+				this.emitter.emit("response", response);
+				break;
+			}
+		}
+	}
 	rejectAll(error) {
+		this.clearTimeout();
+		this.pendingRequests.values().forEach(({ reject }) => reject(error));
+		this.pendingRequests.clear();
+	}
+	clearTimeout() {
 		if (!isNil(this.timer)) {
 			clearTimeout(this.timer);
 			this.timer = null;
 		}
-		for (const { reject } of this.pending.values()) reject(error);
-		this.pending.clear();
+	}
+	onResponse(response) {
+		const pending = this.pendingRequests.get(response.id);
+		if (pending) {
+			this.pendingRequests.delete(response.id);
+			if (response.kind === "ok") pending.resolve(response.data);
+			else {
+				const { status, error } = response;
+				pending.reject(new NilError(error, { status }));
+			}
+		} else this.emitter.emit("error", new UnknownResponseError(response));
 	}
 };
 //#endregion
 //#region src/def.ts
+//! Copyright (C) Call of Nil contributors
+//! SPDX-License-Identifier: AGPL-3.0-only
 var definitions = {
 	nil_ffi_free_str: {
 		arguments: [ffi.types.POINTER],
@@ -680,19 +724,23 @@ var definitions = {
 	}
 };
 //#endregion
-//#region package.json
-var version = "0.7.1";
-//#endregion
 //#region src/index.ts
-var VERSION = version;
-var Nil = class {
+//! Copyright (C) Call of Nil contributors
+//! SPDX-License-Identifier: AGPL-3.0-only
+var VERSION = "0.7.2";
+var USER_AGENT = `nil-ffi-node/${VERSION}`;
+var Nil = class Nil {
 	constructor(dll) {
 		this.disposed = false;
 		if (!dll.endsWith(ffi.suffix)) dll = `${dll}.${ffi.suffix}`;
 		this.handle = ffi.dlopen(dll, definitions);
 		this.functions = this.handle.functions;
 		this.queue = new Queue(this.handle);
-		this.setUserAgent(`nil-ffi-node/${version}`).catch(console.error);
+	}
+	static async init(dll) {
+		const nil = new Nil(dll);
+		await nil.setUserAgent(USER_AGENT);
+		return nil;
 	}
 	[Symbol.dispose]() {
 		this.close();
@@ -758,4 +806,4 @@ var Nil = class {
 	}
 };
 //#endregion
-export { FfiError, HandleClosedError, Nil, VERSION, definitions };
+export { HandleClosedError, Nil, NilError, USER_AGENT, UnknownResponseError, VERSION, definitions };

package/dist/queue.d.ts

@@ -1,20 +1,29 @@
 import { Handle } from '.';
+import { Option } from '@tb-dev/utils';
 import { ffi_RequestId } from '@tsukilabs/nil-bindings';
-type RequestFn = (requestId: ffi_RequestId) => void;
 export declare class Queue implements Disposable {
     private static readonly POLL_INTERVAL;
     private static readonly LIMIT_PER_TICK;
-    readonly functions: Handle["functions"];
-    private timer;
-    private readonly pending;
     private disposed;
+    private readonly functions;
+    private readonly emitter;
     private readonly requestId;
-    constructor(handle: Handle);
+    private readonly pendingRequests;
+    private timer;
+    private readonly errorHandler;
+    constructor(handle: Handle, options?: QueueOptions);
     [Symbol.dispose](): void;
     request<T = unknown>(start: RequestFn): Promise<T>;
-    private startPolling;
+    private drain;
     private poll;
-    private pollOnce;
+    private dispatch;
     private rejectAll;
+    private clearTimeout;
+    private onResponse;
+}
+type RequestFn = (requestId: ffi_RequestId) => void;
+type ErrorHandler = (error: unknown) => void;
+export interface QueueOptions {
+    onError?: Option<ErrorHandler>;
 }
 export {};

package/dist/request.d.ts

@@ -1,4 +1,5 @@
+import { ffi_RequestId } from '@tsukilabs/nil-bindings';
 export declare class RequestId {
     #private;
-    next(): number;
+    next(): ffi_RequestId;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tsukilabs/nil-ffi",
-  "version": "0.7.1",
+  "version": "0.7.2",
   "type": "module",
   "packageManager": "pnpm@11.17.0",
   "license": "AGPL-3.0-only",