@djs-nest/core/dist/index.mjs

Djs Nest Core Module provides functionality for handling discord events

var __defProp = Object.defineProperty;
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });

// src/djs.service.ts
import { Client } from "@discordjs/core";
import { REST } from "@discordjs/rest";
import { WebSocketManager, WebSocketShardEvents } from "@discordjs/ws";
import { Injectable, Logger } from "@nestjs/common";
var __decorate = function(decorators, target, key, desc) {
  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
    r = Reflect.decorate(decorators, target, key, desc);
  else
    for (var i = decorators.length - 1; i >= 0; i--)
      if (d = decorators[i])
        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
  return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = function(k, v) {
  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
    return Reflect.metadata(k, v);
};
var DjsService = /* @__PURE__ */ __name(class DjsService2 {
  constructor(rest, ws) {
    this.ws = ws;
    this.logger = new Logger(DjsService2.name);
    this._client = new Client({
      rest,
      ws
    });
    this.ws.on(WebSocketShardEvents.Closed, ({ code }) => {
      this.logger.log(`WebSocket Closed with ${code} code`);
    });
    this.ws.on(WebSocketShardEvents.Resumed, () => {
      this.logger.log("WebSocket Resumed");
    });
  }
  get client() {
    return this._client;
  }
  async onApplicationBootstrap() {
    try {
      await this.ws.connect();
    } catch (error) {
      this.logger.error("Failed to connect websocket", error);
    }
  }
  onApplicationShutdown() {
    this.ws.destroy();
  }
}, "DjsService");
DjsService = __decorate([
  Injectable(),
  __metadata("design:type", Function),
  __metadata("design:paramtypes", [
    typeof REST === "undefined" ? Object : REST,
    typeof WebSocketManager === "undefined" ? Object : WebSocketManager
  ])
], DjsService);

// src/client/djs-client.ts
import { AsyncEventEmitter } from "@vladfrangu/async_event_emitter";
var DjsClient = class extends AsyncEventEmitter {
};
__name(DjsClient, "DjsClient");

// src/client/djs-client.provider.ts
var DjsClientProvider = {
  provide: DjsClient,
  useFactory: (djsService) => {
    return djsService.client;
  },
  inject: [
    DjsService
  ]
};

// src/events/decorators/listener.decorator.ts
import { DJS_EVENTS_METADATA, EventsDiscovery } from "@djs-nest/common";
import { SetMetadata } from "@nestjs/common";
var Listener = /* @__PURE__ */ __name((options) => SetMetadata(DJS_EVENTS_METADATA, new EventsDiscovery(options)), "Listener");

// src/events/decorators/on.decorator.ts
var On = /* @__PURE__ */ __name((event) => Listener({
  type: "on",
  event
}), "On");

// src/events/decorators/once.decorator.ts
var Once = /* @__PURE__ */ __name((event) => Listener({
  type: "once",
  event
}), "Once");

// src/events/events.service.ts
import { DJS_EVENTS_METADATA as DJS_EVENTS_METADATA2, ExplorerService } from "@djs-nest/common";
import { Injectable as Injectable2, Logger as Logger2 } from "@nestjs/common";
var __decorate2 = function(decorators, target, key, desc) {
  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
    r = Reflect.decorate(decorators, target, key, desc);
  else
    for (var i = decorators.length - 1; i >= 0; i--)
      if (d = decorators[i])
        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
  return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata2 = function(k, v) {
  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
    return Reflect.metadata(k, v);
};
var EventsService = /* @__PURE__ */ __name(class EventsService2 {
  constructor(djsService, explorerService) {
    this.djsService = djsService;
    this.explorerService = explorerService;
    this.logger = new Logger2(EventsService2.name);
  }
  onModuleInit() {
    return this.explorerService.explore(DJS_EVENTS_METADATA2).forEach((event) => {
      this.logger.log(`Subscribe to event(${event.getType()}): ${event.getEvent()}`);
      this.djsService.client[event.getType()](event.getEvent(), (...args) => {
        event.execute([
          args[0].data,
          {
            api: args[0].api,
            shardId: args[0].shardId
          }
        ]);
      });
    });
  }
}, "EventsService");
EventsService = __decorate2([
  Injectable2(),
  __metadata2("design:type", Function),
  __metadata2("design:paramtypes", [
    typeof DjsService === "undefined" ? Object : DjsService,
    typeof ExplorerService === "undefined" ? Object : ExplorerService
  ])
], EventsService);

// src/djs-core.module.ts
import { createConfigurableDynamicRootModule, createModuleConfigProvider, DJS_CORE_MODULE_OPTIONS as DJS_CORE_MODULE_OPTIONS2, DjsCommonModule } from "@djs-nest/common";
import { DjsRestModule } from "@djs-nest/rest";

// src/ws/djs-ws.provider.ts
import { REST as REST2 } from "@discordjs/rest";
import { WebSocketManager as WebSocketManager2 } from "@discordjs/ws";
import { DJS_CORE_MODULE_OPTIONS } from "@djs-nest/common";
var DjsWsProvider = {
  provide: WebSocketManager2,
  useFactory: (rest, options) => new WebSocketManager2({
    rest,
    token: options.token,
    intents: options.intents,
    ...options.ws
  }),
  inject: [
    REST2,
    DJS_CORE_MODULE_OPTIONS
  ]
};

// src/djs-core.module.ts
var CoreModuleProperties = {
  imports: [
    DjsCommonModule,
    DjsRestModule.deferred()
  ],
  providers: [
    DjsService,
    DjsClientProvider,
    DjsWsProvider,
    EventsService
  ],
  exports: [
    DjsClientProvider,
    DjsWsProvider
  ]
};
var DjsCoreModule = class extends createConfigurableDynamicRootModule() {
  static forRootAsync(asyncModuleConfig) {
    const dynamicModule = {
      module: DjsCoreModule,
      imports: [
        ...CoreModuleProperties.imports,
        DjsRestModule.forRootAsync(asyncModuleConfig)
      ],
      exports: CoreModuleProperties.exports,
      providers: [
        ...createModuleConfigProvider(DJS_CORE_MODULE_OPTIONS2, asyncModuleConfig),
        ...CoreModuleProperties.providers
      ]
    };
    DjsCoreModule.moduleSubject.next(dynamicModule);
    return dynamicModule;
  }
  static forRoot(moduleConfig) {
    const dynamicModule = {
      module: DjsCoreModule,
      imports: [
        ...CoreModuleProperties.imports,
        DjsRestModule.forRoot(moduleConfig)
      ],
      exports: CoreModuleProperties.exports,
      providers: [
        {
          provide: DJS_CORE_MODULE_OPTIONS2,
          useValue: moduleConfig
        },
        ...CoreModuleProperties.providers
      ]
    };
    DjsCoreModule.moduleSubject.next(dynamicModule);
    return dynamicModule;
  }
  static forExistingRestAsync(asyncModuleConfig) {
    const dynamicModule = {
      module: DjsCoreModule,
      imports: [
        ...CoreModuleProperties.imports
      ],
      exports: CoreModuleProperties.exports,
      providers: [
        ...createModuleConfigProvider(DJS_CORE_MODULE_OPTIONS2, asyncModuleConfig),
        ...CoreModuleProperties.providers
      ]
    };
    DjsCoreModule.moduleSubject.next(dynamicModule);
    return dynamicModule;
  }
  static forExistingRest(moduleConfig) {
    const dynamicModule = {
      module: DjsCoreModule,
      imports: [
        ...CoreModuleProperties.imports
      ],
      exports: CoreModuleProperties.exports,
      providers: [
        {
          provide: DJS_CORE_MODULE_OPTIONS2,
          useValue: moduleConfig
        },
        ...CoreModuleProperties.providers
      ]
    };
    DjsCoreModule.moduleSubject.next(dynamicModule);
    return dynamicModule;
  }
};
__name(DjsCoreModule, "DjsCoreModule");
export {
  DjsClient,
  DjsClientProvider,
  DjsCoreModule,
  EventsService,
  Listener,
  On,
  Once
};
//# sourceMappingURL=index.mjs.map