Revamped type system for v0.2.0.

Author: T99

.d.ts/builtin/commands/debug/timed-response-command.d.ts

@@ -1,11 +1,9 @@
 import { Command } from "../../../command/command";
 import { CommandStructure } from "../../../schema/command-structure";
 import { CommandSocket } from "../../../command-socket/command-socket";
-export declare class TimedResponseCommand implements Command<TimedResponseCommandStructure, "commandsocket debug timed-response"> {
+export declare class TimedResponseCommand implements Command<TimedResponseCommandStructure> {
     getName(): "commandsocket debug timed-response";
-    execute(params: TimedResponseCommandStructure["params"], context: CommandSocket): Promise<TimedResponseCommandStructure["return"]>;
+    execute(params: TimedResponseCommandStructure["parameter"], context: CommandSocket): Promise<TimedResponseCommandStructure["return"]>;
 }
-export interface TimedResponseCommandStructure extends CommandStructure {
-    params: number;
-    return: string;
+export interface TimedResponseCommandStructure extends CommandStructure<number, string, "commandsocket debug timed-response"> {
 }

.d.ts/builtin/commands/identify-command.d.ts

@@ -1,12 +1,10 @@
 import { Command } from "../../command/command";
 import { CommandSocket } from "../../command-socket/command-socket";
-import { CommandStructure } from "../../schema/command-structure";
+import { CommandStructure, CommandStructureParameterType, CommandStructureReturnType } from "../../schema/command-structure";
 import { CommandSocketIdentity } from "../../schema/command-socket-identity";
-export declare class IdentifyCommand implements Command<IdentifyCommandStructure, "commandsocket identify"> {
+export declare class IdentifyCommand implements Command<IdentifyCommandStructure> {
     getName(): "commandsocket identify";
-    execute(params: IdentifyCommandStructure["params"], context: CommandSocket): Promise<IdentifyCommandStructure["return"]>;
+    execute(params: CommandStructureParameterType<IdentifyCommandStructure>, context: CommandSocket): Promise<CommandStructureReturnType<IdentifyCommandStructure>>;
 }
-export interface IdentifyCommandStructure extends CommandStructure {
-    params: void;
-    return: CommandSocketIdentity;
+export interface IdentifyCommandStructure extends CommandStructure<void, CommandSocketIdentity, "commandsocket identify"> {
 }

.d.ts/builtin/commands/ping-command.d.ts

@@ -1,11 +1,9 @@
-import { CommandStructure } from "../../schema/command-structure";
+import { CommandStructure, CommandStructureParameterType, CommandStructureReturnType } from "../../schema/command-structure";
 import { Command } from "../../command/command";
 import { CommandSocket } from "../../command-socket/command-socket";
-export declare class PingCommand implements Command<PingCommandStructure, "commandsocket ping"> {
+export declare class PingCommand implements Command<PingCommandStructure> {
     getName(): "commandsocket ping";
-    execute(params: PingCommandStructure["params"], context: CommandSocket): Promise<PingCommandStructure["return"]>;
+    execute(params: CommandStructureParameterType<PingCommandStructure>, context: CommandSocket): Promise<CommandStructureReturnType<PingCommandStructure>>;
 }
-export interface PingCommandStructure extends CommandStructure {
-    params: "Ping!";
-    return: "Pong!";
+export interface PingCommandStructure extends CommandStructure<"Ping!", "Pong!", "commandsocket ping"> {
 }

.d.ts/command-socket/command-socket.d.ts

@@ -1,11 +1,16 @@
-import { CommandSetStructure, FullCommandSet, CommandIn, ParamTypeFor, ReturnTypeFor } from "../schema/command-set-structure";
+import { CommandInCommandSet, CommandNameInCommandSet, CommandSetStructure } from "../schema/command-set-structure";
 import { CommandRegistry } from "../command/command-registry";
 import { CommandSocketRequestMessage, CommandSocketResponseMessage } from "../schema/message/command-socket-message";
 import { CommandSocketIdentity } from "../schema/command-socket-identity";
 import { BuiltinCommandSet } from "../builtin/builtin-command-set";
 import { ISocket } from "../socket/i-socket";
 import { CommandSocketEvents } from "./command-socket-events";
 import { CommandSocketState } from "./command-socket-state";
+import { IfAny } from "../util/any-types";
+import { CommandStructureParameterType, CommandStructureReturnType } from "../schema/command-structure";
+export declare type FullCommandSet<CS extends CommandSetStructure> = CS & BuiltinCommandSet;
+declare type ParameterOf<CS extends CommandSetStructure, CN extends keyof CS = CommandNameInCommandSet<CS>> = CommandStructureParameterType<CommandInCommandSet<FullCommandSet<CS>, CN>>;
+declare type ReturnTypeOf<CS extends CommandSetStructure, CN extends keyof CS = CommandNameInCommandSet<CS>> = CommandStructureReturnType<CommandInCommandSet<FullCommandSet<CS>, CN>>;
 export declare abstract class CommandSocket<LCS extends CommandSetStructure = any, RCS extends CommandSetStructure = any> {
     static readonly ID_LENGTH: number;
     private static readonly BUILTIN_COMMANDS;
@@ -16,9 +21,9 @@ export declare abstract class CommandSocket<LCS extends CommandSetStructure = an
     private messageType;
     private outstandingRequests;
     private events;
-    constructor(socket: ISocket, commandRegistry?: CommandRegistry<FullCommandSet<LCS>>);
-    rawRequest<C extends CommandIn<RCS> = CommandIn<RCS>>(command: C, params?: ParamTypeFor<RCS, C>): Promise<CommandSocketResponseMessage>;
-    invoke<C extends CommandIn<RCS> = CommandIn<RCS>>(command: C, params?: ParamTypeFor<RCS, C>): Promise<ReturnTypeFor<RCS, C>>;
+    constructor(socket: ISocket, commandRegistry?: CommandRegistry<LCS>);
+    rawRequest<CommandName extends IfAny<RCS, string, CommandNameInCommandSet<FullCommandSet<RCS>>>>(command: CommandName, params: ParameterOf<RCS, CommandName>): Promise<CommandSocketResponseMessage<CommandInCommandSet<FullCommandSet<RCS>, CommandName>>>;
+    invoke<CommandName extends IfAny<RCS, string, CommandNameInCommandSet<FullCommandSet<RCS>>>>(command: CommandName, params: ParameterOf<RCS, CommandName>): Promise<ReturnTypeOf<RCS, CommandName>>;
     ping(): Promise<number>;
     close(): Promise<void>;
     protected handleMessage(data: any): void;
@@ -30,3 +35,4 @@ export declare abstract class CommandSocket<LCS extends CommandSetStructure = an
     getState(): CommandSocketState;
     getEvents(): CommandSocketEvents;
 }
+export {};

.d.ts/command/command-registry.d.ts

@@ -1,11 +1,16 @@
 import { Command } from "./command";
-import { CommandSetStructure } from "../schema/command-set-structure";
 import { CommandSocket } from "../command-socket/command-socket";
-export declare class CommandRegistry<CS extends CommandSetStructure = any> {
+import { CommandInCommandSet, CommandNameInCommandSet, CommandSetStructure } from "../schema/command-set-structure";
+import { IfAny } from "../util/any-types";
+import { CommandStructureParameterType, CommandStructureReturnType } from "../schema/command-structure";
+declare type ExecuteFunctionType<CS extends CommandSetStructure, CN extends keyof CS> = (params: CommandStructureParameterType<CommandInCommandSet<CS, CN>>, context: CommandSocket) => Promise<CommandStructureReturnType<CommandInCommandSet<CS, CN>>>;
+export declare class CommandRegistry<CommandSet extends CommandSetStructure = any> {
     private commandMap;
-    constructor(...commands: Array<Command<CS[keyof CS]>>);
-    addCommands(...commands: Array<Command<CS[keyof CS]>>): void;
+    constructor(...commands: Array<Command<CommandInCommandSet<CommandSet>>>);
+    addCommands(...commands: Array<Command<CommandInCommandSet<CommandSet>>>): void;
+    addInlineCommand<CommandName extends IfAny<CommandSet, string, CommandNameInCommandSet<CommandSet>>>(commandName: CommandName, implementation: ExecuteFunctionType<CommandSet, CommandName>): void;
     hasCommand(command: string): boolean;
-    getCommand<C extends keyof CS = keyof CS>(command: C): Command<CS[C]> | undefined;
-    execute<C extends keyof CS = keyof CS>(command: C, params: CS[C]["params"], context: CommandSocket<any, any>): Promise<CS[C]["return"]>;
+    getCommand<C extends IfAny<CommandSet, string, CommandNameInCommandSet<CommandSet>>>(command: C): IfAny<CommandSet, Command<any>, Command<CommandSet[C]>>;
+    execute<CommandName extends IfAny<CommandSet, string, CommandNameInCommandSet<CommandSet>>>(commandName: CommandName, params: CommandStructureParameterType<CommandInCommandSet<CommandSet, CommandName>>, context: CommandSocket): Promise<IfAny<CommandSet, any, CommandStructureReturnType<CommandInCommandSet<CommandSet, CommandName>>>>;
 }
+export {};

.d.ts/command/command.d.ts

@@ -1,6 +1,6 @@
-import { CommandStructure } from "../schema/command-structure";
+import { CommandStructure, CommandStructureName, CommandStructureParameterType, CommandStructureReturnType } from "../schema/command-structure";
 import { CommandSocket } from "../command-socket/command-socket";
-export interface Command<C extends CommandStructure, N extends string = string> {
-    getName(): N;
-    execute(params: C["params"], context: CommandSocket): Promise<C["return"]>;
+export interface Command<C extends CommandStructure> {
+    getName(): CommandStructureName<C>;
+    execute(params: CommandStructureParameterType<C>, context: CommandSocket): Promise<CommandStructureReturnType<C>>;
 }

.d.ts/error/command-socket-error.d.ts

@@ -1,6 +1,7 @@
 import { CommandSocketRequestMessage, CommandSocketResponseMessage } from "../schema/message/command-socket-message";
 import { CommandSocket } from "../command-socket/command-socket";
+import { CommandStructure } from "../schema/command-structure";
 export declare class CommandSocketError extends Error {
     constructor(message: string, name?: string);
-    toMessage<P = any, R = any>(request: CommandSocketRequestMessage<P, R>, context: CommandSocket<any, any>): Promise<CommandSocketResponseMessage<P, R>>;
+    toMessage<C extends CommandStructure>(request: CommandSocketRequestMessage<C>, context: CommandSocket): Promise<CommandSocketResponseMessage<C>>;
 }

.d.ts/main.d.ts

@@ -1,6 +1,6 @@
-export { CommandSocket } from "./command-socket/command-socket";
+export { CommandSocket, FullCommandSet } from "./command-socket/command-socket";
 export { ISocket, SocketEvents } from "./socket/i-socket";
-export { CommandSetStructure, FullCommandSet, CommandIn, ParamTypeFor, ReturnTypeFor } from "./schema/command-set-structure";
+export { CommandSetStructure } from "./schema/command-set-structure";
 export { CommandStructure } from "./schema/command-structure";
 export { CommandSocketIdentity } from "./schema/command-socket-identity";
 export { CommandSocketMessage, CommandSocketResponseMessage, CommandSocketRequestMessage, CommandSocketSerializedError, CORRESPONDENCE_ID_LENGTH } from "./schema/message/command-socket-message";

.d.ts/schema/command-set-structure.d.ts

@@ -1,9 +1,8 @@
-import { CommandStructure as CSCommandStructure } from "./command-structure";
-import { BuiltinCommandSet } from "../builtin/builtin-command-set";
+import { CommandStructure } from "./command-structure";
+import { KnownKeys } from "../util/known-keys";
 export interface CommandSetStructure {
-    [commandName: string]: CSCommandStructure;
+    [commandName: string]: CommandStructure;
 }
-export declare type FullCommandSet<CS> = CS & BuiltinCommandSet;
-export declare type CommandIn<CS extends CommandSetStructure> = keyof FullCommandSet<CS>;
-export declare type ParamTypeFor<CS extends CommandSetStructure, C extends keyof CS> = FullCommandSet<CS>[C]["params"];
-export declare type ReturnTypeFor<CS extends CommandSetStructure, C extends keyof CS> = FullCommandSet<CS>[C]["return"];
+export declare type CommandNameInCommandSet<CS extends CommandSetStructure> = keyof CS & KnownKeys<CS>;
+export declare type CommandInCommandSet<CS extends CommandSetStructure, CN extends keyof CS = CommandNameInCommandSet<CS>> = CS[CN];
+export declare type CommandSetWithCommand<C extends CommandStructure> = C extends CommandStructure<infer P, infer R, infer N> ? Record<N, C> : never;

.d.ts/schema/command-structure.d.ts

@@ -1,4 +1,9 @@
-export interface CommandStructure {
-    readonly params: any;
-    readonly return: any;
+import { CommandSetWithCommand } from "./command-set-structure";
+export interface CommandStructure<ParameterType = any, ReturnType = any, Name extends string = string> {
+    readonly name: Name;
+    readonly parameter: ParameterType;
+    readonly return: ReturnType;
 }
+export declare type CommandStructureParameterType<C extends CommandStructure> = C extends CommandStructure<infer P> ? P : never;
+export declare type CommandStructureReturnType<C extends CommandStructure> = C extends CommandStructure<infer P, infer R> ? R : never;
+export declare type CommandStructureName<C extends CommandStructure> = C extends CommandStructure<infer P, infer R, infer N> ? N & keyof CommandSetWithCommand<C> : never;