meocord 4.2.0 → 4.2.1

package/dist/cjs/decorator/index.cjs

@@ -1,8 +1,8 @@
 'use strict';
 
 require('reflect-metadata');
-var providers = require('../_shared/providers-ChvMqnLd.cjs');
-var controller_decorator = require('../_shared/controller.decorator-CRn9kWob.cjs');
+var providers = require('../_shared/providers-BZgJyfZS.cjs');
+var controller_decorator = require('../_shared/controller.decorator-XKMlcUZz.cjs');
 var inversify = require('inversify');
 require('node:async_hooks');
 require('../enum/index.cjs');
@@ -123,10 +123,10 @@ require('chalk');
  * which has already run the guards, passes through every wrapper.
  */ function applyGuards(descriptor, prototype, propertyKey) {
     const originalMethod = descriptor.value;
-    descriptor.value = async function(...args) {
+    descriptor.value = controller_decorator.wrapsMethod(async function(...args) {
         if (providers.consumeDispatchMark(args[0], this, propertyKey)) return originalMethod.apply(this, args);
         return providers.runDirectCall(this, propertyKey, args, ()=>originalMethod.apply(this, args));
-    };
+    }, originalMethod);
     const wrappers = Reflect.getOwnMetadata(controller_decorator.META.guardWrappers, prototype, propertyKey) ?? 0;
     Reflect.defineMetadata(controller_decorator.META.guardWrappers, wrappers + 1, prototype, propertyKey);
 }
@@ -449,12 +449,12 @@ require('chalk');
         errorTypes.forEach((type, index)=>{
             if (controller_decorator.isConstructor(type)) return;
             const entry = ORDINALS[index] ? `${ORDINALS[index]} entry` : `entry ${index + 1}`;
-            controller_decorator.warnDeprecatedBehaviour(logger, `${target.name}: @Catch's ${entry}, ${controller_decorator.describeValue(type)}, which matches no error,`, 'is refused', 'an error class, such as @Catch(CooldownError),');
+            controller_decorator.warnDeprecatedBehaviour(logger$1, `${target.name}: @Catch's ${entry}, ${controller_decorator.describeValue(type)}, which matches no error,`, 'is refused', 'an error class, such as @Catch(CooldownError),');
         });
         Reflect.defineMetadata(controller_decorator.META.catchTypes, errorTypes, target);
     });
 }
-const logger = new controller_decorator.Logger('Catch');
+const logger$1 = new controller_decorator.Logger('Catch');
 const ORDINALS = [
     'first',
     'second',
@@ -799,6 +799,7 @@ function Cooldown(options) {
         // Checked where it applies, so the refusal names the handler or controller
         const problem = cooldownProblem(seconds, uses, per, by);
         if (problem) throw controller_decorator.refuse(new Error(`${controller_decorator.decoratedName(target, propertyKey)}: ${problem}`));
+        for (const warning of cooldownWarnings(options))logger.warn(`${controller_decorator.decoratedName(target, propertyKey)}: ${warning}`);
         // Decorators apply bottom-up; prepending keeps them in the order they read.
         if (propertyKey === undefined) {
             const existing = Reflect.getOwnMetadata(controller_decorator.META.classCooldowns, target) ?? [];
@@ -819,6 +820,20 @@ function Cooldown(options) {
  * The longest window, in seconds: half the furthest time a `Date` holds, 8.64e15 ms, so the moment a wait ends, now
  * plus the window, is a real date for a refusal's `retryAt` and the time it shows.
  */ const MAX_SECONDS = 4320000000000;
+const logger = new controller_decorator.Logger('Cooldown');
+/**
+ * What a cooldown's options get wrong that the types refuse, yet still counts: a `bypass` that is not a function, which
+ * fails every call, and a `seconds` that is not a number, read as one. A falsy `bypass` means none.
+ */ function cooldownWarnings({ seconds, bypass }) {
+    const warnings = [];
+    if (bypass && typeof bypass !== 'function') {
+        warnings.push(`@Cooldown takes bypass as a function of the call, returning whether the call skips the cooldown, not ${controller_decorator.describeValue(bypass)}; ` + 'every call it counts fails with it. In the next major version (5.0) it is refused.');
+    }
+    if (typeof seconds !== 'number') {
+        warnings.push(`@Cooldown takes seconds as a number, not ${controller_decorator.describeValue(seconds)}, which it counts as a window of ` + `${Math.round(seconds * 1000)} ms. In the next major version (5.0) it is refused.`);
+    }
+    return warnings;
+}
 /** Why a cooldown's options cannot be counted, or undefined when they can. */ function cooldownProblem(seconds, uses, per, by) {
     if (!(seconds >= 0.001 && seconds <= MAX_SECONDS)) return `@Cooldown needs a number of seconds from 0.001 to ${MAX_SECONDS}, not ${seconds}.`;
     if (!Number.isInteger(uses) || uses < 1) return `@Cooldown needs a whole number of uses of at least 1, not ${uses}.`;