refactor: remove ts-results-es (#366)

* remove tsresultses

* remove test since it uses external api

* opt in for simpler

* add more debug information

Signed-off-by: Jacob Nguyen <76754747+jacoobes@users.noreply.github.com>

* add more debug information

Signed-off-by: Jacob Nguyen <76754747+jacoobes@users.noreply.github.com>

* clean up if else

---------

Signed-off-by: Jacob Nguyen <76754747+jacoobes@users.noreply.github.com>

src/core/plugin.ts

@@ -1,6 +1,6 @@
 import { CommandType, PluginType } from './structures/enums';
 import type { Plugin, PluginResult, CommandArgs, InitArgs } from '../types/core-plugin';
-import { Err, Ok } from 'ts-results-es';
+import { Err, Ok } from './structures/result';
 
 export function makePlugin<V extends unknown[]>(
     type: PluginType,

src/core/structures/context.ts

@@ -8,8 +8,7 @@ import type {
     Snowflake,
     User,
 } from 'discord.js';
-import { CoreContext } from '../structures/core-context';
-import { Result, Ok, Err } from 'ts-results-es';
+import { Result, Ok, Err, val } from './result';
 import * as assert from 'assert';
 import type { ReplyOptions } from '../../types/utility';
 import { fmt } from '../functions'
@@ -21,39 +20,32 @@ import { SernError } from './enums';
  * Provides values shared between
  * Message and ChatInputCommandInteraction
  */
-export class Context extends CoreContext<Message, ChatInputCommandInteraction> {
+export class Context {
     
     get options() {
         if(this.isMessage()) {
             const [, ...rest] = fmt(this.message.content, this.prefix);
             return rest;
-        } else {
-            return this.interaction.options;
-        }
+        } 
+        return this.interaction.options;
     }
     
 
     protected constructor(protected ctx: Result<Message, ChatInputCommandInteraction>,
-                          private __prefix?: string) {
-        super(ctx);
-    }
+                          private __prefix?: string) { }
     public get prefix() {
         return this.__prefix;
     }
     public get id(): Snowflake {
-        return safeUnwrap(this.ctx
-                            .map(m => m.id)
-                            .mapErr(i => i.id));
+        return val(this.ctx).id
     }
 
     public get channel() {
-        return safeUnwrap(this.ctx.map(m => m.channel).mapErr(i => i.channel));
+        return val(this.ctx).channel;
     }
 
     public get channelId(): Snowflake {
-        return safeUnwrap(this.ctx
-                            .map(m => m.channelId)
-                            .mapErr(i => i.channelId));
+        return val(this.ctx).channelId;
     }
     
     /**
@@ -61,9 +53,11 @@ export class Context extends CoreContext<Message, ChatInputCommandInteraction> {
      * else, interaction.user
      */
     public get user(): User {
-        return safeUnwrap(this.ctx
-                            .map(m => m.author)
-                            .mapErr(i => i.user));
+        if(this.ctx.ok) {
+            return this.ctx.value.author;
+        } 
+        return this.ctx.error.user;
+        
     }
 
     public get userId(): Snowflake {
@@ -71,59 +65,60 @@ export class Context extends CoreContext<Message, ChatInputCommandInteraction> {
     }
 
     public get createdTimestamp(): number {
-        return safeUnwrap(this.ctx 
-                            .map(m => m.createdTimestamp)
-                            .mapErr(i => i.createdTimestamp));
+        return val(this.ctx).createdTimestamp;
     }
 
     public get guild() {
-        return safeUnwrap(this.ctx
-                            .map(m => m.guild)
-                            .mapErr(i => i.guild));
+        return val(this.ctx).guild;
     }
 
     public get guildId() {
-        return safeUnwrap(this.ctx
-                            .map(m => m.guildId)
-                            .mapErr(i => i.guildId));
+        return val(this.ctx).guildId;
     }
     /*
      * interactions can return APIGuildMember if the guild it is emitted from is not cached
      */
     public get member() {
-        return safeUnwrap(this.ctx
-                            .map(m => m.member)
-                            .mapErr(i => i.member));
+        return val(this.ctx).member;
     }
 
     get message(): Message {
-        return this.ctx.expect(SernError.MismatchEvent);
+        if(this.ctx.ok) {
+            return this.ctx.value;
+        }
+        throw Error(SernError.MismatchEvent);
+    }
+    public isMessage(): this is Context & { ctx: Result<Message, never> } {
+        return this.ctx.ok;
+    }
+
+    public isSlash(): this is Context & { ctx: Result<never, ChatInputCommandInteraction> } {
+        return !this.isMessage();
     }
 
     get interaction(): ChatInputCommandInteraction {
-        return this.ctx.expectErr(SernError.MismatchEvent);
+        if(!this.ctx.ok) {
+            return this.ctx.error;
+        }
+        throw Error(SernError.MismatchEvent);
     }
 
 
     public get client(): Client {
-        return safeUnwrap(this.ctx
-                            .map(m => m.client)
-                            .mapErr(i => i.client));
+        return val(this.ctx).client;
     }
 
     public get inGuild(): boolean {
-        return safeUnwrap(this.ctx
-                            .map(m => m.inGuild())
-                            .mapErr(i => i.inGuild()));
+        return val(this.ctx).inGuild()
     }
 
     public async reply(content: ReplyOptions) {
-        return safeUnwrap(
-            this.ctx
-                .map(m => m.reply(content as MessageReplyOptions))
-                .mapErr(i =>
-                    i.reply(content as InteractionReplyOptions).then(() => i.fetchReply())),
-        );
+        if(this.ctx.ok) {
+            return this.ctx.value.reply(content as MessageReplyOptions)
+        } 
+        interface FetchReply { fetchReply: true };
+        return this.ctx.error.reply(content as InteractionReplyOptions & FetchReply)
+       
     }
 
     static wrap(wrappable: BaseInteraction | Message, prefix?: string): Context {
@@ -134,10 +129,3 @@ export class Context extends CoreContext<Message, ChatInputCommandInteraction> {
         return new Context(Err(wrappable), prefix);
     }
 }
-
-function safeUnwrap<T>(res: Result<T, T>) {
-    if(res.isOk()) {
-        return res.expect("Tried unwrapping message field: " + res)
-    } 
-    return res.expectErr("Tried unwrapping interaction field" + res)
-}

src/core/structures/core-context.ts

@@ -1,18 +0,0 @@
-import { Result as Either } from 'ts-results-es';
-import * as assert from 'node:assert';
-
-/**
- * @since 3.0.0
- */
-export abstract class CoreContext<M, I> {
-    protected constructor(protected ctx: Either<M, I>) {
-        assert.ok(typeof ctx === 'object' && ctx != null, "Context was nonobject or null");
-    }
-    public isMessage(): this is CoreContext<M, never> {
-        return this.ctx.isOk();
-    }
-
-    public isSlash(): this is CoreContext<never, I> {
-        return !this.isMessage();
-    }
-}

src/core/structures/result.ts

@@ -0,0 +1,20 @@
+export type Result<Ok, Err> =
+  | { ok: true; value: Ok }
+  | { ok: false; error: Err };
+
+export const Ok = <Ok>(value: Ok) => ({ ok: true, value } as const);
+export const Err = <Err>(error: Err) => ({ ok: false, error } as const);
+
+export const val = <O, E>(r: Result<O, E>) => r.ok ? r.value : r.error;
+export const EMPTY_ERR = Err(undefined);
+
+/**
+ * Wrap an async operation that may throw an Error (`try-catch` style) into checked exception style
+ * @param op The operation function
+ */
+export async function wrapAsync<T, E = unknown>(op: () => Promise<T>): Promise<Result<T, E>> {
+    try { return op()
+            .then(Ok)
+            .catch(Err); } 
+    catch (e) { return Promise.resolve(Err(e as E)); }
+}