@irpclib/irpc 1.0.0-beta.19 → 1.0.0-beta.20

package/dist/call.d.ts

@@ -1,4 +1,4 @@
-import { IRPCPayload } from "./types.js";
+import { IRPCPayload, IRPCStatus } from "./types.js";
 
 //#region src/call.d.ts
 
@@ -8,23 +8,41 @@ import { IRPCPayload } from "./types.js";
  */
 declare class IRPCCall {
   payload: IRPCPayload;
-  resolver: (value: unknown) => void;
-  rejector: (reason?: Error) => void;
+  private resolver;
+  private rejector;
   timeout?: number | undefined;
   /**
    * Unique identifier for this RPC call, generated using shortId().
    */
   id: string;
+  /**
+   * The status of the RPC call, indicating whether it is pending, resolved, or rejected.
+   */
+  status: IRPCStatus;
   /**
    * Flag indicating whether this call has been resolved or rejected.
    * Prevents multiple resolutions of the same call.
    */
   resolved: boolean;
+  /**
+   * The timestamp when the RPC call was started.
+   */
+  startedAt: number;
+  /**
+   * The timestamp when the RPC call was finished.
+   */
+  finishedAt?: number;
+  /**
+   * The value returned by the RPC call.
+   */
+  value?: unknown;
+  error?: Error;
   /**
    * Creates a new IRPCCall instance.
    * @param payload - The RPC payload containing method and parameters
    * @param resolver - Function to resolve the associated promise with a value
    * @param rejector - Function to reject the associated promise with an error
+   * @param timeout - Optional timeout value in milliseconds
    */
   constructor(payload: IRPCPayload, resolver: (value: unknown) => void, rejector: (reason?: Error) => void, timeout?: number | undefined);
   /**

package/dist/call.js

@@ -1,3 +1,4 @@
+import { IRPC_STATUS } from "./enum.js";
 import { uuid } from "./uuid.js";
 
 //#region src/call.ts
@@ -11,15 +12,33 @@ var IRPCCall = class {
 	*/
 	id = uuid();
 	/**
+	* The status of the RPC call, indicating whether it is pending, resolved, or rejected.
+	*/
+	status = IRPC_STATUS.PENDING;
+	/**
 	* Flag indicating whether this call has been resolved or rejected.
 	* Prevents multiple resolutions of the same call.
 	*/
 	resolved = false;
 	/**
+	* The timestamp when the RPC call was started.
+	*/
+	startedAt = Date.now();
+	/**
+	* The timestamp when the RPC call was finished.
+	*/
+	finishedAt;
+	/**
+	* The value returned by the RPC call.
+	*/
+	value;
+	error;
+	/**
 	* Creates a new IRPCCall instance.
 	* @param payload - The RPC payload containing method and parameters
 	* @param resolver - Function to resolve the associated promise with a value
 	* @param rejector - Function to reject the associated promise with an error
+	* @param timeout - Optional timeout value in milliseconds
 	*/
 	constructor(payload, resolver, rejector, timeout) {
 		this.payload = payload;
@@ -34,7 +53,10 @@ var IRPCCall = class {
 	*/
 	resolve(value) {
 		if (this.resolved) return;
+		this.value = value;
+		this.status = IRPC_STATUS.SUCCESS;
 		this.resolved = true;
+		this.finishedAt = Date.now();
 		this.resolver(value);
 	}
 	/**
@@ -44,7 +66,10 @@ var IRPCCall = class {
 	*/
 	reject(reason) {
 		if (this.resolved) return;
+		this.error = reason;
+		this.status = IRPC_STATUS.ERROR;
 		this.resolved = true;
+		this.finishedAt = Date.now();
 		this.rejector(reason);
 	}
 };

package/dist/enum.d.ts

@@ -0,0 +1,34 @@
+//#region src/enum.d.ts
+declare const IRPC_PACKET_TYPE: {
+  readonly CALL: "call";
+  readonly EVENT: "event";
+  readonly ANSWER: "answer";
+  readonly REQUEST: "request";
+  readonly RESPONSE: "response";
+};
+declare const IRPC_DATA_TYPE: {
+  readonly ARRAY: "array";
+  readonly OBJECT: "object";
+  readonly READABLE: "readable";
+  readonly WRITABLE: "writable";
+  readonly PRIMITIVE: "primitive";
+};
+declare const IRPC_EVENT_TYPE: {
+  readonly OBJECT_SET: "set";
+  readonly OBJECT_DELETE: "delete";
+  readonly ARRAY_PUSH: "push";
+  readonly ARRAY_POP: "pop";
+  readonly ARRAY_SHIFT: "shift";
+  readonly ARRAY_UNSHIFT: "unshift";
+  readonly ARRAY_SPLICE: "splice";
+  readonly ARRAY_REVERSE: "reverse";
+  readonly ARRAY_COPY_WITHIN: "copyWithin";
+};
+declare const IRPC_STATUS: {
+  readonly IDLE: "idle";
+  readonly ERROR: "error";
+  readonly PENDING: "pending";
+  readonly SUCCESS: "success";
+};
+//#endregion
+export { IRPC_DATA_TYPE, IRPC_EVENT_TYPE, IRPC_PACKET_TYPE, IRPC_STATUS };

package/dist/enum.js

@@ -0,0 +1,35 @@
+//#region src/enum.ts
+const IRPC_PACKET_TYPE = {
+	CALL: "call",
+	EVENT: "event",
+	ANSWER: "answer",
+	REQUEST: "request",
+	RESPONSE: "response"
+};
+const IRPC_DATA_TYPE = {
+	ARRAY: "array",
+	OBJECT: "object",
+	READABLE: "readable",
+	WRITABLE: "writable",
+	PRIMITIVE: "primitive"
+};
+const IRPC_EVENT_TYPE = {
+	OBJECT_SET: "set",
+	OBJECT_DELETE: "delete",
+	ARRAY_PUSH: "push",
+	ARRAY_POP: "pop",
+	ARRAY_SHIFT: "shift",
+	ARRAY_UNSHIFT: "unshift",
+	ARRAY_SPLICE: "splice",
+	ARRAY_REVERSE: "reverse",
+	ARRAY_COPY_WITHIN: "copyWithin"
+};
+const IRPC_STATUS = {
+	IDLE: "idle",
+	ERROR: "error",
+	PENDING: "pending",
+	SUCCESS: "success"
+};
+
+//#endregion
+export { IRPC_DATA_TYPE, IRPC_EVENT_TYPE, IRPC_PACKET_TYPE, IRPC_STATUS };

package/dist/index.d.ts

@@ -1,9 +1,10 @@
 import { IRPCCacheEntry, IRPCCacher } from "./cache.js";
+import { IRPC_DATA_TYPE, IRPC_EVENT_TYPE, IRPC_PACKET_TYPE, IRPC_STATUS } from "./enum.js";
 import { ERROR_CODE, ERROR_MESSAGE, ErrorCode } from "./error.js";
 import { IRPCTransport } from "./transport.js";
-import { IRPCArraySchema, IRPCCache, IRPCCaches, IRPCContext, IRPCContextProvider, IRPCData, IRPCDataSchema, IRPCError, IRPCHandler, IRPCInit, IRPCInputs, IRPCModule, IRPCObject, IRPCObjectSchema, IRPCOutput, IRPCPackageConfig, IRPCPackageInfo, IRPCParseResult, IRPCPayload, IRPCPrimitive, IRPCPrimitiveSchema, IRPCRequest, IRPCResponse, IRPCSchema, IRPCSpec, IRPCSpecStore, IRPCStubStore, TransportConfig } from "./types.js";
+import { IRPCArraySchema, IRPCCache, IRPCContext, IRPCContextProvider, IRPCData, IRPCDataSchema, IRPCDataType, IRPCError, IRPCEventType, IRPCHandler, IRPCInit, IRPCInputs, IRPCObject, IRPCObjectSchema, IRPCOutput, IRPCPackageConfig, IRPCPackageInfo, IRPCPacket, IRPCPacketAnswer, IRPCPacketCall, IRPCPacketData, IRPCPacketEvent, IRPCPacketType, IRPCParseResult, IRPCPayload, IRPCPrimitive, IRPCPrimitiveSchema, IRPCReadable, IRPCRequest, IRPCResponse, IRPCSchema, IRPCSpec, IRPCSpecStore, IRPCStatus, IRPCStubStore, TransportConfig } from "./types.js";
 import { IRPCCall } from "./call.js";
 import { createContext, getContext, setContext, setContextProvider, withContext } from "./context.js";
 import { IRPCPackage, createPackage } from "./module.js";
 import { IRPCResolver } from "./resolver.js";
-export { ERROR_CODE, ERROR_MESSAGE, ErrorCode, IRPCArraySchema, IRPCCache, IRPCCacheEntry, IRPCCacher, IRPCCaches, IRPCCall, IRPCContext, IRPCContextProvider, IRPCData, IRPCDataSchema, IRPCError, IRPCHandler, IRPCInit, IRPCInputs, IRPCModule, IRPCObject, IRPCObjectSchema, IRPCOutput, IRPCPackage, IRPCPackageConfig, IRPCPackageInfo, IRPCParseResult, IRPCPayload, IRPCPrimitive, IRPCPrimitiveSchema, IRPCRequest, IRPCResolver, IRPCResponse, IRPCSchema, IRPCSpec, IRPCSpecStore, IRPCStubStore, IRPCTransport, TransportConfig, createContext, createPackage, getContext, setContext, setContextProvider, withContext };
+export { ERROR_CODE, ERROR_MESSAGE, ErrorCode, IRPCArraySchema, IRPCCache, IRPCCacheEntry, IRPCCacher, IRPCCall, IRPCContext, IRPCContextProvider, IRPCData, IRPCDataSchema, IRPCDataType, IRPCError, IRPCEventType, IRPCHandler, IRPCInit, IRPCInputs, IRPCObject, IRPCObjectSchema, IRPCOutput, IRPCPackage, IRPCPackageConfig, IRPCPackageInfo, IRPCPacket, IRPCPacketAnswer, IRPCPacketCall, IRPCPacketData, IRPCPacketEvent, IRPCPacketType, IRPCParseResult, IRPCPayload, IRPCPrimitive, IRPCPrimitiveSchema, IRPCReadable, IRPCRequest, IRPCResolver, IRPCResponse, IRPCSchema, IRPCSpec, IRPCSpecStore, IRPCStatus, IRPCStubStore, IRPCTransport, IRPC_DATA_TYPE, IRPC_EVENT_TYPE, IRPC_PACKET_TYPE, IRPC_STATUS, TransportConfig, createContext, createPackage, getContext, setContext, setContextProvider, withContext };

package/dist/index.js

@@ -1,4 +1,5 @@
 import { IRPCCacher } from "./cache.js";
+import { IRPC_DATA_TYPE, IRPC_EVENT_TYPE, IRPC_PACKET_TYPE, IRPC_STATUS } from "./enum.js";
 import { IRPCCall } from "./call.js";
 import { createContext, getContext, setContext, setContextProvider, withContext } from "./context.js";
 import { ERROR_CODE, ERROR_MESSAGE } from "./error.js";
@@ -6,4 +7,4 @@ import { IRPCTransport } from "./transport.js";
 import { IRPCPackage, createPackage } from "./module.js";
 import { IRPCResolver } from "./resolver.js";
 
-export { ERROR_CODE, ERROR_MESSAGE, IRPCCacher, IRPCCall, IRPCPackage, IRPCResolver, IRPCTransport, createContext, createPackage, getContext, setContext, setContextProvider, withContext };
+export { ERROR_CODE, ERROR_MESSAGE, IRPCCacher, IRPCCall, IRPCPackage, IRPCResolver, IRPCTransport, IRPC_DATA_TYPE, IRPC_EVENT_TYPE, IRPC_PACKET_TYPE, IRPC_STATUS, createContext, createPackage, getContext, setContext, setContextProvider, withContext };

package/dist/module.js

@@ -72,20 +72,24 @@ var IRPCPackage = class {
 	declare(init) {
 		if (this.specs.has(init.name)) throw new Error(`IRPC ${init.name} already exists.`);
 		const spec = { ...init };
+		const calls = /* @__PURE__ */ new Map();
 		const caches = new IRPCCacher();
 		const timeout = spec.timeout ?? this.config.timeout;
 		const stub = (async (...args) => {
-			if (typeof spec.handler === "function") return spec.handler(...args);
-			if (!this.transport) throw new Error(ERROR_MESSAGE[ERROR_CODE.TRANSPORT_MISSING]);
-			if (spec.maxAge) {
-				const key = JSON.stringify(args);
-				const cache = caches.get(key);
-				if (cache) return cache.value;
-				const data = await this.transport.call(spec, args, timeout);
-				caches.set(key, data, spec.maxAge);
+			if (!this.transport && typeof spec.handler !== "function") throw new Error(ERROR_MESSAGE[ERROR_CODE.TRANSPORT_MISSING]);
+			const callKey = JSON.stringify(args);
+			const cached = caches.get(callKey);
+			if (cached) return cached.value;
+			if (spec.coalesce !== false && calls.has(callKey)) return calls.get(callKey);
+			const call = typeof spec.handler === "function" ? spec.handler(...args) : this.transport.call(spec, args, timeout);
+			calls.set(callKey, call);
+			try {
+				const data = await call;
+				if (spec.maxAge) caches.set(callKey, data, spec.maxAge);
 				return data;
+			} finally {
+				calls.delete(callKey);
 			}
-			return await this.transport.call(spec, args, timeout);
 		});
 		this.specs.set(init.name, spec);
 		this.stubs.set(stub, spec);

package/dist/state.d.ts

@@ -0,0 +1,19 @@
+import { IRPCReadable, IRPCStatus } from "./types.js";
+import * as _anchorlib_core0 from "@anchorlib/core";
+import { StateSubscriber } from "@anchorlib/core";
+
+//#region src/state.d.ts
+declare class RemoteState<T> {
+  #private;
+  get data(): T;
+  set data(data: T);
+  get error(): Error | undefined;
+  set error(error: Error | undefined);
+  get status(): IRPCStatus;
+  set status(status: IRPCStatus);
+  constructor(init: T);
+  subscribe(handler: StateSubscriber<IRPCReadable<T>>): _anchorlib_core0.StateUnsubscribe;
+  destroy(): void;
+}
+//#endregion
+export { RemoteState };

package/dist/state.js

@@ -0,0 +1,41 @@
+import { IRPC_STATUS } from "./enum.js";
+import { anchor, mutable, subscribe } from "@anchorlib/core";
+
+//#region src/state.ts
+var RemoteState = class {
+	#state;
+	get data() {
+		return this.#state.data;
+	}
+	set data(data) {
+		this.#state.data = data;
+	}
+	get error() {
+		return this.#state.error;
+	}
+	set error(error) {
+		this.#state.error = error;
+	}
+	get status() {
+		return this.#state.status;
+	}
+	set status(status) {
+		this.#state.status = status;
+	}
+	constructor(init) {
+		this.#state = mutable({
+			data: mutable(init),
+			error: void 0,
+			status: IRPC_STATUS.IDLE
+		});
+	}
+	subscribe(handler) {
+		return subscribe(this.#state, handler);
+	}
+	destroy() {
+		anchor.destroy(this.#state);
+	}
+};
+
+//#endregion
+export { RemoteState };

package/dist/transport.js

@@ -50,10 +50,18 @@ var IRPCTransport = class {
 	* @param call - The RPC call to schedule.
 	*/
 	schedule(call) {
-		if (!this.queue.size) setTimeout(() => {
-			this.dispatch(Array.from(this.queue));
+		const { debounce } = this.config ?? {};
+		if (debounce === false) {
+			this.dispatch([call]).finally(() => {});
+			return;
+		}
+		const timeout = typeof debounce === "number" && !Number.isNaN(debounce) ? debounce : 0;
+		const dispatch = () => {
+			this.dispatch(Array.from(this.queue)).finally(() => {});
 			this.queue.clear();
-		}, this.config?.debounce ?? 0);
+		};
+		if (!this.queue.size) if (timeout === 0) queueMicrotask(dispatch);
+		else setTimeout(dispatch, timeout);
 		this.queue.add(call);
 	}
 	/**

package/dist/types.d.ts

@@ -1,3 +1,4 @@
+import { IRPC_DATA_TYPE, IRPC_EVENT_TYPE, IRPC_PACKET_TYPE, IRPC_STATUS } from "./enum.js";
 import { ErrorCode } from "./error.js";
 import { IRPCTransport } from "./transport.js";
 import { ZodArray, ZodBoolean, ZodNull, ZodNumber, ZodObject, ZodSafeParseResult, ZodString, ZodUndefined } from "zod/v4";
@@ -14,6 +15,37 @@ type IRPCStubStore = WeakMap<IRPCHandler, IRPCSpec<IRPCInputs, IRPCOutput>>;
  * Used to keep track of available RPC hosts by their names.
  */
 type IRPCSpecStore = Map<string, IRPCSpec<IRPCInputs, IRPCOutput>>;
+type IRPCStatus = (typeof IRPC_STATUS)[keyof typeof IRPC_STATUS];
+type IRPCDataType = (typeof IRPC_DATA_TYPE)[keyof typeof IRPC_DATA_TYPE];
+type IRPCPacketType = (typeof IRPC_PACKET_TYPE)[keyof typeof IRPC_PACKET_TYPE];
+type IRPCEventType = (typeof IRPC_EVENT_TYPE)[keyof typeof IRPC_EVENT_TYPE];
+type IRPCPacket = {
+  id: string;
+  name: string;
+  type: IRPCPacketType;
+  dispatchAt?: number;
+  receivedAt?: number;
+};
+type IRPCPacketData = {
+  type: IRPCDataType;
+  value: IRPCData;
+};
+type IRPCPacketCall = IRPCPacket & {
+  args: IRPCData[];
+};
+type IRPCPacketAnswer = IRPCPacket & {
+  data?: IRPCPacketData;
+  error?: IRPCError;
+};
+type IRPCPacketEvent = IRPCPacket & {
+  data: IRPCPacketData;
+  event: IRPCEventType;
+};
+interface IRPCReadable<T> {
+  data: T;
+  error: Error | undefined;
+  status: IRPCStatus;
+}
 /**
  * Represents primitive data types that can be used in IRPC communications.
  * Includes string, number, boolean, null, and undefined.
@@ -74,15 +106,6 @@ type IRPCPackageConfig = IRPCPackageInfo & {
   timeout?: number;
   transport?: IRPCTransport;
 };
-/**
- * Defines an RPC module which extends a namespace with execution capabilities.
- */
-type IRPCModule = IRPCPackageInfo & {
-  /** Optional timeout for RPC calls */
-  timeout?: number;
-  /** Optional transport mechanism for RPC communications */
-  transport?: IRPCTransport;
-};
 /**
  * Represents the payload of an RPC call with its name and arguments.
  */
@@ -116,14 +139,21 @@ type IRPCHandler = Function;
 type IRPCInit<I extends IRPCInputs, O extends IRPCOutput> = {
   /** The name of the RPC function */
   name: string;
-  /** Optional schema for input/output validation */
-  schema?: IRPCSchema<I, O>;
   /** Optional description of the RPC function */
   description?: string;
+  /** Optional schema for input/output validation */
+  schema?: IRPCSchema<I, O>;
   /** Optional maximum age of a call in milliseconds */
   maxAge?: number;
   /** Optional timeout for RPC calls */
   timeout?: number;
+  /**
+   * Whether to coalesce multiple calls to the same RPC function within a short time period.
+   * If true, multiple calls with the same parameters will be combined into a single call,
+   * with subsequent calls waiting for the result of the first call.
+   * This can help reduce the number of actual function executions.
+   */
+  coalesce?: boolean;
 };
 /**
  * Complete specification for an RPC function including its implementation.
@@ -169,10 +199,6 @@ type IRPCCache = {
   expiresAt: number;
   timestamp: number;
 };
-/**
- * Represents a cache for RPC responses.
- */
-type IRPCCaches = Map<string, IRPCCache>;
 /**
  * Context storage mechanism for RPC operations.
  */
@@ -192,7 +218,7 @@ type IRPCContextProvider = {
 };
 type TransportConfig = {
   timeout?: number;
-  debounce?: number;
+  debounce?: number | boolean;
 };
 //#endregion
-export { IRPCArraySchema, IRPCCache, IRPCCaches, IRPCContext, IRPCContextProvider, IRPCData, IRPCDataSchema, IRPCError, IRPCHandler, IRPCInit, IRPCInputs, IRPCModule, IRPCObject, IRPCObjectSchema, IRPCOutput, IRPCPackageConfig, IRPCPackageInfo, IRPCParseResult, IRPCPayload, IRPCPrimitive, IRPCPrimitiveSchema, IRPCRequest, IRPCResponse, IRPCSchema, IRPCSpec, IRPCSpecStore, IRPCStubStore, TransportConfig };
+export { IRPCArraySchema, IRPCCache, IRPCContext, IRPCContextProvider, IRPCData, IRPCDataSchema, IRPCDataType, IRPCError, IRPCEventType, IRPCHandler, IRPCInit, IRPCInputs, IRPCObject, IRPCObjectSchema, IRPCOutput, IRPCPackageConfig, IRPCPackageInfo, IRPCPacket, IRPCPacketAnswer, IRPCPacketCall, IRPCPacketData, IRPCPacketEvent, IRPCPacketType, IRPCParseResult, IRPCPayload, IRPCPrimitive, IRPCPrimitiveSchema, IRPCReadable, IRPCRequest, IRPCResponse, IRPCSchema, IRPCSpec, IRPCSpecStore, IRPCStatus, IRPCStubStore, TransportConfig };

package/package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "@irpclib/irpc",
-  "version": "1.0.0-beta.19",
+  "version": "1.0.0-beta.20",
   "types": "./dist/index.d.ts",
   "module": "./dist/index.js",
   "exports": {
@@ -36,13 +36,16 @@
     "zod": "^4.1.5"
   },
   "scripts": {
-    "dev": "tsdown --watch",
+    "dev": "rimraf dist && tsdown --watch ./src",
     "clean": "rimraf dist",
-    "build": "tsdown && publint",
+    "build": "rimraf dist && tsdown && publint",
     "format": "biome format --write",
     "test": "rimraf coverage && vitest --run",
     "test:preview": "rimraf coverage && vitest --run && vite preview --outDir coverage",
     "prepublish": "bun run format && bun run clean && tsdown && publint"
   },
-  "license": "MIT"
+  "license": "MIT",
+  "dependencies": {
+    "@anchorlib/core": "1.0.0-beta.19"
+  }
 }