@integry/sdk 4.7.39 → 4.7.41

package/src/modules/api/responseHandler.ts

@@ -1,38 +0,0 @@
-/* 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

@@ -1,72 +0,0 @@
-// 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

@@ -1,21 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,34 +0,0 @@
-// 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;
-}