Sea-of-Stars-studio/Construct-CN
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

feat: bump MCBE-IPC to 3.4.2

Browse Source
This commit is contained in:
ForestOfLight
2026-05-30 00:24:43 +02:00
Unverified
parent 2b90020e37
commit 5177f7c986
2 changed files with 314 additions and 235 deletions
Download Patch File Download Diff File Expand all files Collapse all files
packs/BP/scripts/lib/AddonAPIKit/MCBE-IPC/ipc.d.ts
Vendored
+50 -34
View File
@@ -2,7 +2,7 @@
* @license
* MIT License
*
* Copyright (c) 2025 OmniacDev
* Copyright (c) 2026 OmniacDev
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
@@ -23,11 +23,15 @@
* SOFTWARE.
*/
export declare namespace PROTO {
interface Serializable<T> {
serialize(value: T, stream: ByteQueue): Generator<void, void, void>;
deserialize(stream: ByteQueue): Generator<void, T, void>;
interface Serializer<T> {
serialize(value: T, stream: Buffer): Generator<void, void, void>;
}
class ByteQueue {
interface Deserializer<T> {
deserialize(stream: Buffer): Generator<void, T, void>;
}
interface Serializable<T> extends Serializer<T>, Deserializer<T> {
}
class Buffer {
private _buffer;
private _data_view;
private _length;
@@ -36,15 +40,20 @@ export declare namespace PROTO {
get front(): number;
get data_view(): DataView;
constructor(size?: number);
write(...values: number[]): void;
read(amount?: number): number[];
reserve(amount: number): number;
consume(amount: number): number;
write(byte: number): void;
write(bytes: Uint8Array): void;
read(): number;
read(amount: number): Uint8Array;
ensure_capacity(size: number): void;
static from_uint8array(array: Uint8Array): ByteQueue;
static from_uint8array(array: Uint8Array): Buffer;
to_uint8array(): Uint8Array;
}
namespace MIPS {
function serialize(byte_queue: PROTO.ByteQueue): Generator<void, string, void>;
function deserialize(str: string): Generator<void, PROTO.ByteQueue, void>;
function is_valid(str: string): boolean;
function serialize(stream: PROTO.Buffer): Generator<void, string, void>;
function deserialize(str: string): Generator<void, PROTO.Buffer, void>;
}
const Void: PROTO.Serializable<void>;
const Null: PROTO.Serializable<null>;
@@ -56,48 +65,55 @@ export declare namespace PROTO {
const UInt16: PROTO.Serializable<number>;
const UInt32: PROTO.Serializable<number>;
const UVarInt32: PROTO.Serializable<number>;
const VarInt32: PROTO.Serializable<number>;
const Float32: PROTO.Serializable<number>;
const Float64: PROTO.Serializable<number>;
const String: PROTO.Serializable<string>;
const Boolean: PROTO.Serializable<boolean>;
const UInt8Array: PROTO.Serializable<Uint8Array>;
const Date: PROTO.Serializable<Date>;
function Object<T extends object>(obj: {
function Object<T extends object>(s: {
[K in keyof T]: PROTO.Serializable<T[K]>;
}): PROTO.Serializable<T>;
function Array<T>(value: PROTO.Serializable<T>): PROTO.Serializable<T[]>;
function Tuple<T extends any[]>(...values: {
function Array<T>(s: PROTO.Serializable<T>): PROTO.Serializable<T[]>;
function Tuple<T extends any[]>(...s: {
[K in keyof T]: PROTO.Serializable<T[K]>;
}): PROTO.Serializable<T>;
function Optional<T>(value: PROTO.Serializable<T>): PROTO.Serializable<T | undefined>;
function Map<K, V>(key: PROTO.Serializable<K>, value: PROTO.Serializable<V>): PROTO.Serializable<Map<K, V>>;
function Set<V>(value: PROTO.Serializable<V>): PROTO.Serializable<Set<V>>;
type Endpoint = string;
type Header = {
guid: string;
encoding: string;
index: number;
final: boolean;
};
const Endpoint: PROTO.Serializable<Endpoint>;
const Header: PROTO.Serializable<Header>;
function Optional<T>(s: PROTO.Serializable<T>): PROTO.Serializable<T | undefined>;
function Map<K, V>(kS: PROTO.Serializable<K>, vS: PROTO.Serializable<V>): PROTO.Serializable<Map<K, V>>;
function Set<V>(s: PROTO.Serializable<V>): PROTO.Serializable<Set<V>>;
function Cached<V>(s: PROTO.Serializable<V>, depth?: number): PROTO.Serializable<V>;
}
export declare namespace NET {
function serialize(byte_queue: PROTO.ByteQueue, max_size?: number): Generator<void, string[], void>;
function deserialize(strings: string[]): Generator<void, PROTO.ByteQueue, void>;
function emit<S extends PROTO.Serializable<T>, T>(endpoint: string, serializer: S & PROTO.Serializable<T>, value: T): Generator<void, void, void>;
function listen<T, S extends PROTO.Serializable<T>>(endpoint: string, serializer: S & PROTO.Serializable<T>, callback: (value: T) => Generator<void, void, void>): () => void;
type Meta = {
guid: string;
signature: string;
};
const Meta: PROTO.Serializable<Meta>;
export const SIGNATURE: string;
export let FRAG_MAX: number;
export function serialize(buffer: PROTO.Buffer, max_size?: number): Generator<void, string[], void>;
export function deserialize(strings: string[]): Generator<void, PROTO.Buffer, void>;
export interface EmitOptions {
metaOverride?: Partial<Meta>;
}
export function emit<S>(endpoint: string, serializer: PROTO.Serializer<S>, value: NoInfer<S>, options?: EmitOptions): Generator<void, void, void>;
export interface ListenOptions {
filter?: (meta: Meta) => boolean;
}
export function listen<D>(endpoint: string, deserializer: PROTO.Deserializer<D>, callback: (value: NoInfer<D>, meta: Meta) => Generator<void, void, void>, options?: ListenOptions): () => void;
export {};
}
export declare namespace IPC {
/** Sends a message with `args` to `channel` */
function send<S extends PROTO.Serializable<T>, T>(channel: string, serializer: S & PROTO.Serializable<T>, value: T): void;
function send<S>(channel: string, serializer: PROTO.Serializer<S>, value: NoInfer<S>): void;
/** Sends an `invoke` message through IPC, and expects a result asynchronously. */
function invoke<TS extends PROTO.Serializable<T>, T, RS extends PROTO.Serializable<R>, R>(channel: string, serializer: TS & PROTO.Serializable<T>, value: T, deserializer: RS & PROTO.Serializable<R>): Promise<R>;
function invoke<S, D>(channel: string, serializer: PROTO.Serializer<S>, value: NoInfer<S>, deserializer: PROTO.Deserializer<D>): Promise<NoInfer<D>>;
/** Listens to `channel`. When a new message arrives, `listener` will be called with `listener(args)`. */
function on<S extends PROTO.Serializable<T>, T>(channel: string, deserializer: S & PROTO.Serializable<T>, listener: (value: T) => void): () => void;
function on<D>(channel: string, deserializer: PROTO.Deserializer<D>, listener: (value: NoInfer<D>) => void): () => void;
/** Listens to `channel` once. When a new message arrives, `listener` will be called with `listener(args)`, and then removed. */
function once<S extends PROTO.Serializable<T>, T>(channel: string, deserializer: S & PROTO.Serializable<T>, listener: (value: T) => void): () => void;
function once<D>(channel: string, deserializer: PROTO.Deserializer<D>, listener: (value: NoInfer<D>) => void): () => void;
/** Adds a handler for an `invoke` IPC. This handler will be called whenever `invoke(channel, ...args)` is called */
function handle<TS extends PROTO.Serializable<T>, T, RS extends PROTO.Serializable<R>, R>(channel: string, deserializer: TS & PROTO.Serializable<T>, serializer: RS & PROTO.Serializable<R>, listener: (value: T) => R): () => void;
function handle<D, S>(channel: string, deserializer: PROTO.Deserializer<D>, serializer: PROTO.Serializer<S>, listener: (value: NoInfer<D>) => NoInfer<S>): () => void;
}
export default IPC;