@integry/sdk 4.5.2 → 4.5.4

package/src/modules/api/responseHandler.ts

@@ -0,0 +1,38 @@
+/* eslint-disable no-console */
+
+import { UnfetchResponse } from '../../types';
+import { IntegryAPIError } from '../../extensions/IntegryAPIError';
+
+export const ResponseHandler = async <T>(
+  response: UnfetchResponse,
+): Promise<{
+  data: T | null;
+  status: number;
+}> => {
+  const debugMode = !!process.env.DEBUG;
+
+  if (response.ok) {
+    try {
+      const parsedResponse: T = await response.json();
+      // if (debugMode) console.log(parsedResponse);
+      return {
+        data: parsedResponse,
+        status: response.status,
+      };
+    } catch (error) {
+      if (debugMode) console.log('Response is not in json');
+      return {
+        data: null,
+        status: response.status,
+      };
+    }
+  } else if (response.status === 405) {
+    return {
+      data: await response.json(),
+      status: response.status,
+    };
+  }
+  if (debugMode) console.log('Received a non-2xx status code');
+  const error = new IntegryAPIError(response.statusText, response);
+  return Promise.reject(error);
+};

package/src/modules/event-emitter/index.ts

@@ -0,0 +1,72 @@
+// https://github.com/infinitum11/inf-ee
+
+import EventRunnerDefault from './runners/default';
+import EventRunnerNTimes from './runners/ntimes';
+import {
+  EventListenerStorage,
+  EventSet,
+  EventEmitterType,
+  HandlerRunner,
+} from './types';
+
+export class EventEmitter<ESet extends EventSet>
+  implements EventEmitterType<EventSet> {
+  private events: EventListenerStorage<ESet> = Object.create(null);
+
+  on<EventName extends keyof ESet>(
+    eventName: EventName,
+    handler: ESet[EventName],
+  ): void {
+    this.addEventListener(eventName, new EventRunnerDefault(this, handler));
+  }
+
+  once<EventName extends keyof ESet>(
+    eventName: EventName,
+    handler: ESet[EventName],
+  ): void {
+    this.addEventListener(eventName, new EventRunnerNTimes(this, handler, 1));
+  }
+
+  off<EventName extends keyof ESet>(
+    eventName: EventName,
+    handler: ESet[EventName],
+  ): void {
+    const events = this.events[eventName];
+    if (!events?.length) {
+      return;
+    }
+    this.events[eventName] = events.filter((h) => h.getHandler() !== handler);
+  }
+
+  offAll(): void {
+    Object.keys(this.events).forEach((eventName) => {
+      const events = this.events[eventName];
+      if (events) {
+        events.length = 0;
+      }
+    });
+    this.events = Object.create(null);
+  }
+
+  emit<EventName extends keyof ESet>(
+    eventName: EventName,
+    ...args: Parameters<ESet[EventName]>
+  ): void {
+    const events = this.events[eventName];
+    if (events) {
+      events.forEach((handler) => handler.run(eventName, ...args));
+    }
+  }
+
+  private addEventListener<EventName extends keyof ESet>(
+    eventName: EventName,
+    runner: HandlerRunner<ESet, EventName>,
+  ) {
+    const events = this.events[eventName];
+    if (Array.isArray(events)) {
+      events.push(runner);
+    } else {
+      this.events[eventName] = [runner];
+    }
+  }
+}

package/src/modules/event-emitter/runners/abstract.ts

@@ -0,0 +1,21 @@
+import { EventSet, EventEmitterType, HandlerRunner } from '../types';
+
+export default abstract class EventRunnerAbstract<
+  ESet extends EventSet,
+  EventName extends keyof ESet
+> implements HandlerRunner<ESet, EventName> {
+  // eslint-disable-next-line no-useless-constructor
+  constructor(
+    protected emitter: EventEmitterType<ESet>,
+    protected handler: ESet[EventName],
+  ) {}
+
+  getHandler(): ESet[EventName] {
+    return this.handler;
+  }
+
+  abstract run(
+    eventName: EventName,
+    ...args: Parameters<ESet[EventName]>
+  ): void;
+}

package/src/modules/event-emitter/runners/default.ts

@@ -0,0 +1,11 @@
+import { EventSet } from '../types';
+import EventRunnerAbstract from './abstract';
+
+export default class EventRunnerDefault<
+  ESet extends EventSet,
+  EventName extends keyof ESet
+> extends EventRunnerAbstract<ESet, EventName> {
+  run(_eventName: EventName, ...args: Parameters<ESet[EventName]>): void {
+    this.handler.apply(null, args);
+  }
+}

package/src/modules/event-emitter/runners/ntimes.ts

@@ -0,0 +1,28 @@
+import { EventSet, EventEmitterType } from '../types';
+import EventRunnerDefault from './default';
+
+export default class EventRunnerNTimes<
+  ESet extends EventSet,
+  EventName extends keyof ESet
+> extends EventRunnerDefault<ESet, EventName> {
+  private i = 0;
+
+  constructor(
+    emitter: EventEmitterType<ESet>,
+    handler: ESet[EventName],
+    private total = 1,
+  ) {
+    super(emitter, handler);
+    if (this.total < 1) {
+      throw new Error(`{total} can not be less than 1`);
+    }
+  }
+
+  run(eventName: EventName, ...args: Parameters<ESet[EventName]>): void {
+    super.run(eventName, ...args);
+    // eslint-disable-next-line no-plusplus
+    if (++this.i >= this.total) {
+      this.emitter.off(eventName, this.handler);
+    }
+  }
+}

package/src/modules/event-emitter/types.ts

@@ -0,0 +1,34 @@
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type EventSet = Record<string, (...args: any[]) => void>;
+
+export interface HandlerRunner<
+  ESet extends EventSet,
+  EventName extends keyof ESet
+> {
+  run(eventName: EventName, ...args: Parameters<ESet[EventName]>): void;
+  getHandler(): ESet[EventName];
+}
+
+export type EventListenerStorage<ESet extends EventSet> = {
+  [EventName in keyof ESet]?: Array<HandlerRunner<ESet, EventName>>;
+};
+
+export interface EventEmitterType<ESet extends EventSet> {
+  on<EventName extends keyof ESet>(
+    eventName: EventName,
+    handler: ESet[EventName],
+  ): void;
+  once<EventName extends keyof ESet>(
+    eventName: EventName,
+    handler: ESet[EventName],
+  ): void;
+  off<EventName extends keyof ESet>(
+    eventName: EventName,
+    handler: ESet[EventName],
+  ): void;
+  offAll(): void;
+  emit<EventName extends keyof ESet>(
+    eventName: EventName,
+    ...args: Parameters<ESet[EventName]>
+  ): void;
+}