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

Djs Nest Core Module provides functionality for handling discord events

var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/index.ts
var src_exports = {};
__export(src_exports, {
  DjsClient: () => DjsClient,
  DjsClientProvider: () => DjsClientProvider,
  DjsCoreModule: () => DjsCoreModule,
  EventsService: () => EventsService,
  Listener: () => Listener,
  On: () => On,
  Once: () => Once
});
module.exports = __toCommonJS(src_exports);

// src/djs.service.ts
var import_core = require("@discordjs/core");
var import_rest = require("@discordjs/rest");
var import_ws = require("@discordjs/ws");
var import_common = require("@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 import_common.Logger(DjsService2.name);
    this._client = new import_core.Client({
      rest,
      ws
    });
    this.ws.on(import_ws.WebSocketShardEvents.Closed, ({ code }) => {
      this.logger.log(`WebSocket Closed with ${code} code`);
    });
    this.ws.on(import_ws.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([
  (0, import_common.Injectable)(),
  __metadata("design:type", Function),
  __metadata("design:paramtypes", [
    typeof import_rest.REST === "undefined" ? Object : import_rest.REST,
    typeof import_ws.WebSocketManager === "undefined" ? Object : import_ws.WebSocketManager
  ])
], DjsService);

// src/client/djs-client.ts
var import_async_event_emitter = require("@vladfrangu/async_event_emitter");
var DjsClient = class extends import_async_event_emitter.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
var import_common2 = require("@djs-nest/common");
var import_common3 = require("@nestjs/common");
var Listener = /* @__PURE__ */ __name((options) => (0, import_common3.SetMetadata)(import_common2.DJS_EVENTS_METADATA, new import_common2.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
var import_common4 = require("@djs-nest/common");
var import_common5 = require("@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 import_common5.Logger(EventsService2.name);
  }
  onModuleInit() {
    return this.explorerService.explore(import_common4.DJS_EVENTS_METADATA).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([
  (0, import_common5.Injectable)(),
  __metadata2("design:type", Function),
  __metadata2("design:paramtypes", [
    typeof DjsService === "undefined" ? Object : DjsService,
    typeof import_common4.ExplorerService === "undefined" ? Object : import_common4.ExplorerService
  ])
], EventsService);

// src/djs-core.module.ts
var import_common7 = require("@djs-nest/common");
var import_rest3 = require("@djs-nest/rest");

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

// src/djs-core.module.ts
var CoreModuleProperties = {
  imports: [
    import_common7.DjsCommonModule,
    import_rest3.DjsRestModule.deferred()
  ],
  providers: [
    DjsService,
    DjsClientProvider,
    DjsWsProvider,
    EventsService
  ],
  exports: [
    DjsClientProvider,
    DjsWsProvider
  ]
};
var DjsCoreModule = class extends (0, import_common7.createConfigurableDynamicRootModule)() {
  static forRootAsync(asyncModuleConfig) {
    const dynamicModule = {
      module: DjsCoreModule,
      imports: [
        ...CoreModuleProperties.imports,
        import_rest3.DjsRestModule.forRootAsync(asyncModuleConfig)
      ],
      exports: CoreModuleProperties.exports,
      providers: [
        ...(0, import_common7.createModuleConfigProvider)(import_common7.DJS_CORE_MODULE_OPTIONS, asyncModuleConfig),
        ...CoreModuleProperties.providers
      ]
    };
    DjsCoreModule.moduleSubject.next(dynamicModule);
    return dynamicModule;
  }
  static forRoot(moduleConfig) {
    const dynamicModule = {
      module: DjsCoreModule,
      imports: [
        ...CoreModuleProperties.imports,
        import_rest3.DjsRestModule.forRoot(moduleConfig)
      ],
      exports: CoreModuleProperties.exports,
      providers: [
        {
          provide: import_common7.DJS_CORE_MODULE_OPTIONS,
          useValue: moduleConfig
        },
        ...CoreModuleProperties.providers
      ]
    };
    DjsCoreModule.moduleSubject.next(dynamicModule);
    return dynamicModule;
  }
  static forExistingRestAsync(asyncModuleConfig) {
    const dynamicModule = {
      module: DjsCoreModule,
      imports: [
        ...CoreModuleProperties.imports
      ],
      exports: CoreModuleProperties.exports,
      providers: [
        ...(0, import_common7.createModuleConfigProvider)(import_common7.DJS_CORE_MODULE_OPTIONS, asyncModuleConfig),
        ...CoreModuleProperties.providers
      ]
    };
    DjsCoreModule.moduleSubject.next(dynamicModule);
    return dynamicModule;
  }
  static forExistingRest(moduleConfig) {
    const dynamicModule = {
      module: DjsCoreModule,
      imports: [
        ...CoreModuleProperties.imports
      ],
      exports: CoreModuleProperties.exports,
      providers: [
        {
          provide: import_common7.DJS_CORE_MODULE_OPTIONS,
          useValue: moduleConfig
        },
        ...CoreModuleProperties.providers
      ]
    };
    DjsCoreModule.moduleSubject.next(dynamicModule);
    return dynamicModule;
  }
};
__name(DjsCoreModule, "DjsCoreModule");
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  DjsClient,
  DjsClientProvider,
  DjsCoreModule,
  EventsService,
  Listener,
  On,
  Once
});
//# sourceMappingURL=index.js.map