@rpack-dev/core 0.2.0-canary.2 → 0.2.0-canary.4

package/dist/rpack-core.d.ts

@@ -24,6 +24,7 @@ declare class RPack {
 	private readonly platform;
 	private readonly version;
 	private lateInitCallbacks;
+	private readonly hostManager;
 	private readonly threadManager;
 	private readonly permissionManager;
 	private readonly proxyManager;
@@ -47,6 +48,13 @@ declare class RPack {
 	 * @return an RPVersion instance
 	 */
 	getVersion(): RPVersion;
+	/**
+	 * Retrieves the current HostManager instance.
+	 *
+	 * This class is used when dealing with the host environment.
+	 * It can also be used to create an embedded host instance.
+	 */
+	getHostManager(): HostManager;
 	/**
 	 * Retrieves the current ThreadManager instance.
 	 *
@@ -80,6 +88,7 @@ declare class RPack {
 	isPluginThread(): boolean;
 	isHost(): boolean;
 	isClient(): boolean;
+	getHost(): RPackHost | undefined;
 	/**
 	 * Shorthand for getNetworkManager().getPlugin().
 	 *
@@ -105,6 +114,7 @@ export declare abstract class RPPlatform {
 	private readonly id;
 	protected constructor(id: string);
 	abstract createRPackInstance(constructor: (options: RPackConstructorOptions) => Promise<RPack>): Promise<RPack>;
+	abstract createEmbeddedHost(): Promise<HostCreateResult>;
 	abstract createRPackThread(threadId: string, pluginKey: string): Promise<RPackLocalThread>;
 	abstract restart(): void;
 	abstract addWindowFocusHandler(handler: () => void): void;
@@ -298,6 +308,20 @@ export declare class DevPluginSource implements PluginSource {
 	getPluginArchive(groupId: string, pluginId: string, version: string): Promise<PluginArchive>;
 	removeServer(client: DevPluginServerClient): void;
 }
+export declare class HostManager {
+	private readonly rpack;
+	private connectedHost;
+	private readonly localInstance?;
+	constructor(rpack: RPack, localInstance?: RPackHost);
+	getRPack(): RPack;
+	createEmbeddedHost(): Promise<RPackHost>;
+	getClientId(): string | undefined;
+	/**
+	 * Returns the current RPackHost instance.
+	 */
+	getHost(): RPackHost | undefined;
+	disconnect(): Promise<void>;
+}
 export declare class IteratorHelper<T, TReturn = undefined, TNext = unknown> implements IteratorObject<T, TReturn, TNext>, Iterator<T, TReturn, TNext>, Disposable {
 	private it;
 	private disposed;
@@ -470,18 +494,6 @@ export declare class LocalRemoteMap<Local, Remote> {
 	hasRemote(key: string): boolean;
 	deleteRemote(key: string): boolean;
 }
-export declare class MappedIterator<T, K> implements IterableIterator<K> {
-	private readonly it;
-	private readonly map;
-	constructor(it: Iterator<T>, map: (t: T) => K);
-	[Symbol.iterator](): IterableIterator<K>;
-	next(...args: [
-	] | [
-		any
-	]): IteratorResult<K>;
-	return(value?: any): IteratorResult<K>;
-	throw(e?: any): IteratorResult<K>;
-}
 export declare class Messenger<InPackets extends PacketsType<InPackets>, OutPackets extends PacketsType<OutPackets>> {
 	private readonly handlerLists;
 	private readonly sender;
@@ -497,9 +509,20 @@ export declare class Messenger<InPackets extends PacketsType<InPackets>, OutPack
 	removeHandler<K extends keyof InPackets>(key: K, handler: PacketHandler<InPackets[K]>): boolean;
 	private promiseHandlerImpl;
 	addPromiseNonceHandler<K extends keyof OnlyNoncePackets<InPackets>>(key: K, nonce: string, timeout?: number): Promise<InPackets[K]>;
+	addResponsePromiseNonceHandler<K extends keyof OnlyResponsePackets<InPackets>>(key: K, nonce: string, timeout?: number): Promise<ResponsePacketValue<InPackets[K]>>;
 	addPromiseHandler<K extends keyof InPackets>(key: K, timeout?: number): Promise<InPackets[K]>;
 	receivePacket<K extends keyof InPackets>(packet: InPackets[K]): void;
 	sendPacket<K extends keyof OutPackets>(packet: OutPackets[K]): void;
+	sendNoncePacket<O extends keyof OnlyNoncePackets<OutPackets>>(outPacketKey: O, outPacket: Omit<OutPackets[O], "nonce" | "id">): SentNoncePacket<InPackets, OutPackets>;
+	/**
+	 * Sends a packet with a nonce, and expects a response packet with the same nonce.
+	 * @param outPacketKey the outgoing packet's id
+	 * @param outPacket the outgoing packet (without some fields such as `id` and `nonce`)
+	 * @param inPacket the incoming packet's id
+	 * @param timeout an optional timeout
+	 *
+	 * @deprecated use {@link sendNoncePacket `sendNoncePacket(outPacketKey, outPacket)`}`.`{@link SentNoncePacket.expect `expect(inPacket, timeout)`}
+	 */
 	sendPacketWithNoncePromise<O extends keyof OnlyNoncePackets<OutPackets>, I extends keyof OnlyNoncePackets<InPackets>>(outPacketKey: O, outPacket: Omit<OutPackets[O], "nonce" | "id">, inPacket: I, timeout?: number): Promise<InPackets[I]>;
 	/**
 	 * Shorthand for sending a response packet that has a value with the messenger.
@@ -746,6 +769,7 @@ export declare class RemoteObject<T extends object> implements ProxyHandler<T> {
 }
 export declare class RemoteProxyManager {
 	private readonly parent;
+	private readonly rpack;
 	private readonly thread;
 	private readonly messenger;
 	private readonly objects;
@@ -846,6 +870,13 @@ export declare class RemoteRegistryManager {
 	requestGetAllEntries<Data, Key extends JSONLike>(registryId: string, executingThread: Thread | null, ownerThread?: Thread): RemoteAsyncIterator<RegistryEntry<Data, Key>>;
 	requestGetAll<Data>(registryId: string, executingThread: Thread | null, ownerThread?: Thread): RemoteAsyncIterator<Data>;
 }
+export declare class SentNoncePacket<InPackets extends PacketsType<InPackets>, OutPackets extends PacketsType<OutPackets>> {
+	private readonly messenger;
+	private readonly nonce;
+	constructor(messenger: Messenger<InPackets, OutPackets>, nonce: string);
+	expect<I extends keyof OnlyNoncePackets<InPackets>>(inPacket: I, timeout?: number): Promise<InPackets[I]>;
+	expectResponse<I extends keyof OnlyResponsePackets<InPackets>>(inPacket: I, timeout?: number, rpack?: RPack, thread?: Thread): Promise<ResponsePacketValue<InPackets[I]>>;
+}
 export declare class SerializationManager {
 	private readonly rpack;
 	private readonly wellKnownMap;
@@ -861,6 +892,9 @@ export declare class SerializationManager {
 	}): MappedSerializedData<T>;
 	deserialize<T extends RegistrySerializedData>(thread: Thread, serialized: T): MappedDeserializedData<T>;
 }
+export declare class SerializationUtils {
+	static deserializeStatic<T extends RegistrySerializedData>(serialized: T): MappedDeserializedData<T>;
+}
 /**
  * A collection of string-related utilities.
  */
@@ -887,22 +921,29 @@ export declare class StringUtils {
  * to check for permissions.
  *
  * If this is run in a client environment, and the target thread represents a local client thread,
- * {@link isClient isClient()} will return `true`, but {@link getClientId getClientId()} will return `undefined`.
+ * {@link isClient isClient()} will return `true`, but {@link getClientId getClientId()} may return
+ * `undefined` (if the client is not connected to a host). Use {@link isLocal isLocal()} to check
+ * whether this Thread object is referring to a local thread.
+ *
+ * When referring to a thread in the host environment ({@link isHost isHost()} returned true), then
+ * the {@link getClientId getClientId()} will return `undefined`.
  *
  * Note that this class does not represent any state; it is purely
  * for convenient access to this information and the relevant methods.
  */
 export declare class Thread {
 	private readonly rpack;
+	private readonly environment;
 	private readonly threadId;
-	private readonly clientId?;
+	private readonly clientId;
 	/**
 	 * Creates a new NetworkThread
 	 * @param rpack the RPack instance
 	 * @param threadId the thread ID on the host or client
-	 * @param clientId an optional client ID (only present in a host environment), represents which client this thread is on
+	 * @param clientId an optional client ID (absent when referring to the host or the local client), represents which client this thread is on
+	 * @param environment the environment of this thread
 	 */
-	constructor(rpack: RPack, threadId: string, clientId?: string);
+	constructor(rpack: RPack, environment: EnvironmentType, threadId: string, clientId?: string);
 	/**
 	 * Determines whether this thread is from the host.
 	 *
@@ -916,6 +957,12 @@ export declare class Thread {
 	 * @return `true` if this is a client thread, `false` otherwise
 	 */
 	isClient(): boolean;
+	/**
+	 * Retrieves the environment of this thread.
+	 *
+	 * @return the environment of this thread
+	 */
+	getEnvironmentType(): EnvironmentType;
 	/**
 	 * Determines if this thread is from the current environment.
 	 *
@@ -980,7 +1027,7 @@ export declare class ThreadManager {
 	constructor(rpack: RPack);
 	getLocalThread(threadId: string): Thread;
 	getThread(serialized: RawThread): Thread;
-	getThread(threadId: string, clientId?: string): Thread;
+	getThread(environment: EnvironmentType, threadId: string, clientId?: string): Thread;
 	getCurrentThread(): Thread;
 	getLocalCoreThread(): Thread;
 	private __handleSharedPackets;
@@ -1285,13 +1332,6 @@ export interface EnvironmentInfo {
 	 * Returns the current Thread ID.
 	 */
 	getThreadId(): string;
-	/**
-	 * Returns the current client ID.
-	 *
-	 * If this method is called from a host environment,
-	 * then it will return `undefined`.
-	 */
-	getClientId(): string | undefined;
 	/**
 	 * Returns the Messenger instance used to
 	 * communicate with the current core thread.
@@ -1308,10 +1348,6 @@ export interface EnvironmentInfo {
 	 */
 	getHostMessenger(): Messenger<H2CPackets, C2HPackets> | null;
 }
-export interface H2CHelloResponsePacket extends NoncePacket {
-	id: "host:hello_response";
-	accepted: boolean;
-}
 export interface H2CHostPackets {
 	"host:hello_response": H2CHelloResponsePacket;
 }
@@ -1320,6 +1356,10 @@ export interface Host {
 	perm: string;
 	threadId?: string;
 }
+export interface HostCreateResult {
+	host: RPackHost;
+	messenger: Messenger<H2CPackets, C2HPackets>;
+}
 export interface Local {
 	type: "local";
 	perm: string;
@@ -1485,8 +1525,10 @@ export interface ProxyIteratorNextRequestPacket extends NoncePacket {
 }
 export interface ProxyIteratorNextResponsePacket extends NoncePacket {
 	id: "proxy:iterator_next_response";
-	done?: boolean;
-	value?: SerializedData;
+	value?: {
+		done: boolean;
+		value: SerializedData;
+	};
 	error?: SerializedData;
 }
 export interface ProxyMethodRequestPacket extends NoncePacket {
@@ -1524,8 +1566,11 @@ export interface ProxyRefreshObjectResponsePacket extends NoncePacket {
 	error?: SerializedData;
 }
 export interface RPackHost {
+	isEmbedded(): boolean;
+	disconnect(): Promise<void>;
 }
 export interface RawThread {
+	environment: EnvironmentType;
 	threadId: string;
 	clientId: string | null;
 }
@@ -1783,6 +1828,9 @@ export type FixedLengthArray<T, L extends number, TObj = [
 	[I: number]: T;
 	[Symbol.iterator]: () => IterableIterator<T>;
 };
+export type H2CHelloResponsePacket = ResponsePacket<"host:hello_response", {
+	clientId: string;
+}>;
 export type H2CPackets = H2CHostPackets & ProxyPackets & RegistryPackets & PermissionPackets;
 export type JSONLike = string | number | boolean | null | {
 	[key: string]: JSONLike;
@@ -1826,9 +1874,12 @@ export type OnlyNoncePacketTypes<Packets extends PacketsType<Packets>> = {
 export type OnlyNoncePackets<Packets extends PacketsType<Packets>> = {
 	[Key in OnlyNoncePacketTypes<Packets>]: Packets[Key] & NoncePacket;
 };
-export type OnlyResponsePacketTypes<Packets extends PacketsType<Packets>> = Pick<Packets, {
+export type OnlyResponsePacketTypes<Packets extends PacketsType<Packets>> = {
 	[Key in keyof Packets]: Packets[Key] extends ResponsePacket<unknown, unknown> ? Key : never;
-}[keyof Packets]>;
+}[keyof Packets];
+export type OnlyResponsePackets<Packets extends PacketsType<Packets>> = {
+	[Key in OnlyResponsePacketTypes<Packets>]: Packets[Key] & ResponsePacket<Key, any>;
+};
 export type P2CCheckPermissionRequestBody = Host | Client | Local;
 export type P2CCheckPermissionRequestPacket = P2CCheckPermissionRequestBody & {
 	id: "permission:check_permission_request";
@@ -1856,6 +1907,7 @@ export type RPackConstructorOptions = {
 	platform: RPPlatform;
 	hostMessenger?: Messenger<C2PPackets, P2CPackets>;
 	version: RPVersion;
+	localHostInstance?: RPackHost;
 };
 export type RegistryDataFiltered<Data> = Data extends Serializable ? Data : {
 	readonly [Key in keyof Data]: Data[Key] extends Serializable ? Data[Key] : Data[Key] extends (...args: any) => Promise<any> ? Data[Key] : Data[Key] extends (...args: infer P) => infer R ? (...args: P) => Promise<R> : never;
@@ -1877,7 +1929,7 @@ export type ResponsePacket<Id, Value = SerializedData> = {
 	id: Id;
 	value?: Value;
 	error?: SerializedData;
-};
+} & NoncePacket;
 export type ResponsePacketValue<T> = T extends ResponsePacket<unknown, infer Value> ? Value : never;
 export type SenderFunction<T> = (packet: T[keyof T]) => void;
 export type Serializable = undefined | JSONLike | RegistryType | ErrorType | WellKnownType | SerializableFunction | Thread;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rpack-dev/core",
-  "version": "0.2.0-canary.2",
+  "version": "0.2.0-canary.4",
   "description": "",
   "license": "LGPL-3.0-or-later",
   "repository": {