meocord 4.1.2 → 4.2.0

package/dist/cjs/_shared/{providers-BMMLp2SN.cjs → providers-ChvMqnLd.cjs}

@@ -1,6 +1,6 @@
 'use strict';
 
-var controller_decorator = require('./controller.decorator-BywwkU9O.cjs');
+var controller_decorator = require('./controller.decorator-CRn9kWob.cjs');
 require('reflect-metadata');
 var node_async_hooks = require('node:async_hooks');
 var inversify = require('inversify');
@@ -101,7 +101,7 @@ var Table__default = /*#__PURE__*/_interopDefaultCompat(Table);
 
 function eventDecorator(event, once) {
     // Generic over the method, so it is checked against the event's arguments rather than required to match exactly
-    return function(target, propertyKey, _descriptor) {
+    return controller_decorator.declaring(function(target, propertyKey, _descriptor) {
         controller_decorator.refuseOnClass(once ? '@Once' : '@On', target, propertyKey);
         const handlers = controller_decorator.ownHandlerList(controller_decorator.META.eventHandlers, target);
         handlers.push({
@@ -110,7 +110,7 @@ function eventDecorator(event, once) {
             once
         });
         Reflect.defineMetadata(controller_decorator.META.eventHandlers, handlers, target);
-    };
+    });
 }
 /**
  * Handles a discord.js client event every time it is emitted, on a controller or a service.
@@ -138,7 +138,7 @@ function eventDecorator(event, once) {
  * @group Decorators
  * @category Handlers
  * @see {@link Once}
- * @see {@link https://meocord.dev/docs/4.1/gateway-events | Gateway events}
+ * @see {@link https://meocord.dev/docs/4.2/gateway-events | Gateway events}
  */ function On(event) {
     return eventDecorator(event, false);
 }
@@ -165,7 +165,7 @@ function eventDecorator(event, once) {
  * @group Decorators
  * @category Handlers
  * @see {@link On}
- * @see {@link https://meocord.dev/docs/4.1/gateway-events | Gateway events}
+ * @see {@link https://meocord.dev/docs/4.2/gateway-events | Gateway events}
  */ function Once(event) {
     return eventDecorator(event, true);
 }
@@ -1376,7 +1376,7 @@ function isInterceptorWithParams(entry) {
 });
 /** Binds `cls` and its unbound dependencies as singletons, refusing any that injects `ExecutionContext`. */ function bindShared(container, cls) {
     if (container.isBound(cls)) return;
-    if (injectedTokens(cls).includes(controller_decorator.ExecutionContext)) throw controller_decorator.refuse(singletonContextError(cls));
+    if (injectedTokens(cls).includes(controller_decorator.ExecutionContext)) return controller_decorator.startupError(singletonContextError(cls));
     assertStartupChecked(container, cls);
     makeInjectable(cls);
     container.bind(cls).toSelf().inSingletonScope();
@@ -1571,7 +1571,7 @@ function isInterceptorWithParams(entry) {
 /** Binds a filter as a singleton, after checking it is one. */ function prepareFilter(container, entry) {
     const cls = filterClass(entry);
     if (!Reflect.hasOwnMetadata(controller_decorator.META.catchTypes, cls)) {
-        throw controller_decorator.refuse(new Error(`${cls.name || 'A filter'}: used as an exception filter, but not decorated with @Catch().`));
+        return controller_decorator.startupError(new Error(`${cls.name || 'A filter'}: used as an exception filter, but not decorated with @Catch().`));
     }
     bindShared(container, cls);
 }
@@ -1683,11 +1683,12 @@ const asList = (entries)=>Array.isArray(entries) ? entries : [
 
 /** Where a container keeps the observers its calls are reported to, in order. */ const OBSERVERS = Symbol('observers');
 const logger$1 = new controller_decorator.Logger('Observer');
-/** Throws unless every entry is an `@Observer` class, naming where it was listed. */ function assertObservers(where, observers) {
+/** Reports each entry that is not an `@Observer` class, naming where it was listed. */ function assertObservers(where, observers) {
     for (const observer of observers){
         if (typeof observer !== 'function' || !Reflect.getMetadata(controller_decorator.META.observerClass, observer)) {
             const name = typeof observer === 'function' ? observer.name : String(observer);
-            throw controller_decorator.refuse(new Error(`${where} takes classes decorated with @Observer(), not ${name}.`));
+            controller_decorator.startupError(new Error(`${where} takes classes decorated with @Observer(), not ${name}.`));
+            continue;
         }
     }
 }
@@ -1942,12 +1943,16 @@ const NO_GLOBAL_STAGES = {
  */ function bindAppPresenter(container, app, client) {
     const options = Reflect.getMetadata(controller_decorator.META.appOptions, app);
     if (!options?.presenter) return undefined;
-    bindShared(container, options.presenter);
+    prepareAppPresenter(container, app);
     const presenter = container.get(options.presenter);
     container.bind(APP_PRESENTER).toConstantValue(presenter);
     if (client) controller_decorator.setPresenter(client, presenter);
     return presenter;
 }
+/** Binds the app's presenter class as a shared stage, checking it as one, without making it. */ function prepareAppPresenter(container, app) {
+    const options = Reflect.getMetadata(controller_decorator.META.appOptions, app);
+    if (options?.presenter) bindShared(container, options.presenter);
+}
 /** Where a container keeps the application's presenter. */ const APP_PRESENTER = Symbol('app_presenter');
 /** The presenter `bindAppPresenter` resolved into `container`, if any. */ function appPresenterOf(container) {
     return container.isBound(APP_PRESENTER) ? container.get(APP_PRESENTER) : undefined;
@@ -2037,18 +2042,21 @@ const stagesByGlobals = new WeakMap();
 /**
  * Binds the interceptors, filters and pipes every handler of `controllers` uses, and the global ones, as singletons, so
  * one that cannot be shared, or a filter without `@Catch`, fails at startup; refuses there `@Defer`, `@Validate`,
- * `@UsePipe` and `@Cooldown` where they cannot apply, and two classes that keep state under one name.
+ * `@UsePipe` and `@Cooldown` where they cannot apply, and two classes that keep state under one name. Binds only; it
+ * makes nothing, so it runs with the other startup checks.
  */ function prepareHandlerStages(container, controllers) {
     assertDistinctNamesWhereKeyed(controllers);
     const globals = globalStagesOf(container);
-    configureThemes(container, globals.theme, controllers, globals.themeFor);
     for (const entry of globals.interceptors)prepareInterceptor(container, entry);
     for (const entry of globals.filters)prepareFilter(container, entry);
     for (const controller of controllers){
         const prototype = controller.prototype;
         for (const method of handlerMethods(prototype)){
             const kind = handlerDefer(prototype, method) ? nonInteractionHandler(prototype, method) : undefined;
-            if (kind) throw controller_decorator.refuse(deferMisuseError(controller.name, method, kind));
+            if (kind) {
+                controller_decorator.startupError(deferMisuseError(controller.name, method, kind));
+                continue;
+            }
             for (const entry of handlerInterceptors(prototype, method))prepareInterceptor(container, entry);
             for (const entry of handlerFilterLevels(prototype, method, []).flat())prepareFilter(container, entry);
             for (const { entry } of handlerInputStages(prototype, method).pipes)preparePipe(container, entry);
@@ -2056,6 +2064,10 @@ const stagesByGlobals = new WeakMap();
         assertInputStagesOnInteractions(controller, prototype);
     }
 }
+/** Records the app's theme for the handlers of `controllers`, once the startup checks have passed: it makes the theme cache. */ function prepareThemes(container, controllers) {
+    const globals = globalStagesOf(container);
+    configureThemes(container, globals.theme, controllers, globals.themeFor);
+}
 /** Whether a class has state keyed by its name: a cooldown on a handler, or a `@Once` handler. */ function keyedByName(cls) {
     const prototype = cls.prototype;
     const handlers = [
@@ -2072,7 +2084,8 @@ const stagesByGlobals = new WeakMap();
     for (const cls of classes){
         const other = byName.get(cls.name);
         if (other && other !== cls && (keyedByName(cls) || keyedByName(other))) {
-            throw controller_decorator.refuse(new Error(`${cls.name}: two classes have this name; @Cooldown and @Once tell classes apart by name, so they would share ` + `their counts. Rename one of them.`));
+            controller_decorator.startupError(new Error(`${cls.name}: two classes have this name; @Cooldown and @Once tell classes apart by name, so they would share ` + `their counts. Rename one of them.`));
+            continue;
         }
         byName.set(cls.name, cls);
     }
@@ -2100,11 +2113,12 @@ const stagesByGlobals = new WeakMap();
         const { schema, pipes } = handlerInputStages(prototype, method);
         const handler = kind === 'message' ? 'a message handler without a pattern' : `${kind === 'autocomplete' || kind === 'event' ? 'an' : 'a'} ${kind} handler`;
         if (schema || pipes.length > 0) {
-            throw controller_decorator.refuse(new Error(`${controller.name}.${method}: @Validate and @UsePipe are for interaction and patterned message handlers, ` + `whose options, customId params, modal fields and pattern params they check, and this is ${handler}.`));
+            controller_decorator.startupError(new Error(`${controller.name}.${method}: @Validate and @UsePipe are for interaction and patterned message handlers, ` + `whose options, customId params, modal fields and pattern params they check, and this is ${handler}.`));
+            continue;
         }
         // A controller's own @Cooldown skips these handlers; one on the method itself is a mistake.
         if (kind !== 'message' && methodCooldowns(prototype, method).length > 0) {
-            throw controller_decorator.refuse(new Error(`${controller.name}.${method}: @Cooldown is for interaction and message handlers, and this is ${handler}.`));
+            controller_decorator.startupError(new Error(`${controller.name}.${method}: @Cooldown is for interaction and message handlers, and this is ${handler}.`));
         }
     }
 }
@@ -3261,7 +3275,8 @@ const FLAG = /^\{--(\w+)(?::([\w-]+(?:\|[\w-]+)*))?(\?)?\}$/;
                 if (own.hidden !== undefined && typeof own.hidden !== 'boolean') throw new Error(`hidden is true or false, not ${JSON.stringify(own.hidden)}.`);
                 aliases = aliasPatterns(pattern, parsed.tokens, own.aliases);
             } catch (error) {
-                throw controller_decorator.refuse(new Error(`${controllerClass.name}.${method}: @MessageHandler('${pattern}'): ${error.message}`));
+                controller_decorator.startupError(new Error(`${controllerClass.name}.${method}: @MessageHandler('${pattern}'): ${error.message}`));
+                continue;
             }
             const shared = {
                 controllerClass,
@@ -3300,7 +3315,7 @@ const FLAG = /^\{--(\w+)(?::([\w-]+(?:\|[\w-]+)*))?(\?)?\}$/;
                 routes.splice(j--, 1);
                 continue;
             }
-            throw controller_decorator.refuse(new Error(`${a.controllerClass.name}.${a.method}: ${describeRoute(a)} and ${describeRoute(b)} in ${b.controllerClass.name}.${b.method} ` + `match the same messages, so only one of them could ever answer those. Change one pattern, or give one its own prefix.`));
+            controller_decorator.startupError(new Error(`${a.controllerClass.name}.${a.method}: ${describeRoute(a)} and ${describeRoute(b)} in ${b.controllerClass.name}.${b.method} ` + `match the same messages, so only one of them could ever answer those. Change one pattern, or give one its own prefix.`));
         }
     }
     return routes;
@@ -4179,7 +4194,7 @@ const COMMAND_TYPES = new Set([
  *
  * @group Controllers
  * @see {@link HandlerEntry}
- * @see {@link https://meocord.dev/docs/4.1/handler-discovery | Handler discovery}
+ * @see {@link https://meocord.dev/docs/4.2/handler-discovery | Handler discovery}
  */ class HandlerRegistry {
     /**
    * Lists the registered handlers.
@@ -4424,7 +4439,7 @@ async function withTimeout(promise, ms, what) {
  *
  * @group Controllers
  * @see {@link ShardCallResult}
- * @see {@link https://meocord.dev/docs/4.1/sharding | Sharding}
+ * @see {@link https://meocord.dev/docs/4.2/sharding | Sharding}
  */ class ShardContext {
     /** The ids of the shards this process runs. With process sharding, one id; otherwise every shard, once ready. */ get ids() {
         if (this.client?.shard) return [
@@ -4601,9 +4616,9 @@ const isFactoryProvider = (provider)=>'useFactory' in provider;
 }
 const isToken = (value)=>typeof value === 'function' || typeof value === 'string' || typeof value === 'symbol';
 /**
- * Checks each provider's shape and indexes them by token, throwing on the first that cannot be bound, such as one with
- * no token, not exactly one of `useValue`, `useClass` and `useFactory`, one that injects `ExecutionContext`, or a
- * token provided twice.
+ * Checks each provider's shape and indexes them by token, reporting each that cannot be bound, such as one with no
+ * token, not exactly one of `useValue`, `useClass` and `useFactory`, one that injects `ExecutionContext`, or a token
+ * provided twice, as a startup error; see `startupError`.
  */ function providerMap(providers, where) {
     const map = new Map();
     for (const provider of providers){
@@ -4612,10 +4627,12 @@ const isToken = (value)=>typeof value === 'function' || typeof value === 'string
         if (typeof entry === 'function') {
             const name = tokenName(entry);
             const listing = where.includes('@MeoCord') ? 'list a service in @MeoCord({ services })' : 'a class a controller or service injects is bound for you, so it needs no listing';
-            throw controller_decorator.refuse(new Error(`${where}: ${name} is a class, not a provider: ${listing}. To put something in its place, write ` + `{ provide: ${name}, useValue } or { provide: ${name}, useClass }.`));
+            controller_decorator.startupError(new Error(`${where}: ${name} is a class, not a provider: ${listing}. To put something in its place, write ` + `{ provide: ${name}, useValue } or { provide: ${name}, useClass }.`));
+            continue;
         }
         if (!entry || typeof entry !== 'object' || !isToken(entry.provide)) {
-            throw controller_decorator.refuse(new Error(`${where}: a provider has no token: set provide to a class, a string or a symbol.`));
+            controller_decorator.startupError(new Error(`${where}: a provider has no token: set provide to a class, a string or a symbol.`));
+            continue;
         }
         const name = tokenName(entry.provide);
         const kinds = [
@@ -4624,26 +4641,35 @@ const isToken = (value)=>typeof value === 'function' || typeof value === 'string
             'useFactory'
         ].filter((kind)=>kind in entry);
         if (kinds.length !== 1) {
-            throw controller_decorator.refuse(new Error(`${where}: the provider for ${name} needs exactly one of useValue, useClass and useFactory.`));
+            controller_decorator.startupError(new Error(`${where}: the provider for ${name} needs exactly one of useValue, useClass and useFactory.`));
+            continue;
         }
         if ('useClass' in entry && typeof entry.useClass !== 'function') {
-            throw controller_decorator.refuse(new Error(`${where}: the provider for ${name} has a useClass that is not a class.`));
+            controller_decorator.startupError(new Error(`${where}: the provider for ${name} has a useClass that is not a class.`));
+            continue;
         }
         if ('useClass' in entry && injectedTokens(entry.useClass).includes(controller_decorator.ExecutionContext)) {
-            throw controller_decorator.refuse(new Error(`${where}: the provider for ${name} uses ${tokenName(entry.useClass)}, which injects ExecutionContext, but it is ` + "made once and shared, so it would keep the first call's context for every later call. Inject " + 'ExecutionContext only into guards.'));
+            controller_decorator.startupError(new Error(`${where}: the provider for ${name} uses ${tokenName(entry.useClass)}, which injects ExecutionContext, but it is ` + "made once and shared, so it would keep the first call's context for every later call. Inject " + 'ExecutionContext only into guards.'));
+            continue;
         }
         if ('useFactory' in entry) {
             if (typeof entry.useFactory !== 'function') {
-                throw controller_decorator.refuse(new Error(`${where}: the provider for ${name} has a useFactory that is not a function.`));
+                controller_decorator.startupError(new Error(`${where}: the provider for ${name} has a useFactory that is not a function.`));
+                continue;
             }
             if (entry.inject !== undefined && !(Array.isArray(entry.inject) && entry.inject.every(isToken))) {
-                throw controller_decorator.refuse(new Error(`${where}: the provider for ${name} has an inject that is not a list of tokens.`));
+                controller_decorator.startupError(new Error(`${where}: the provider for ${name} has an inject that is not a list of tokens.`));
+                continue;
             }
             if (entry.inject?.includes(controller_decorator.ExecutionContext)) {
-                throw controller_decorator.refuse(new Error(`${where}: the provider for ${name} injects ExecutionContext, but its factory runs once and its value is ` + "shared, so it would keep the first call's context for every later call. Inject ExecutionContext only into guards."));
+                controller_decorator.startupError(new Error(`${where}: the provider for ${name} injects ExecutionContext, but its factory runs once and its value is ` + "shared, so it would keep the first call's context for every later call. Inject ExecutionContext only into guards."));
+                continue;
             }
         }
-        if (map.has(entry.provide)) throw controller_decorator.refuse(new Error(`${where}: ${name} is provided twice.`));
+        if (map.has(entry.provide)) {
+            controller_decorator.startupError(new Error(`${where}: ${name} is provided twice.`));
+            continue;
+        }
         map.set(entry.provide, provider);
     }
     return map;
@@ -4696,22 +4722,23 @@ const isToken = (value)=>typeof value === 'function' || typeof value === 'string
     for (const dependency of inject)if (isAppClassToken(dependency)) bindClass(dependency);
 }
 /**
- * Throws when a class or a factory asks for a string or symbol token that nothing binds, naming both,
- * rather than failing when the class is first resolved. A class token is bound on demand, so it is
- * never missing.
+ * Reports a class or a factory that asks for a string or symbol token nothing binds, naming both, rather than failing
+ * when the class is first resolved. A class token is bound on demand, so it is never missing.
  */ function assertProvided(container, providers, classes, where) {
     const missing = (token)=>(typeof token === 'string' || typeof token === 'symbol') && !container.isBound(token);
     for (const cls of classes){
         const token = injectedTokens(cls).find(missing);
         if (token !== undefined) {
-            throw controller_decorator.refuse(new Error(`${cls.name}: it injects ${tokenName(token)}, which nothing provides: add a provider for it to ${where}.`));
+            controller_decorator.startupError(new Error(`${cls.name}: it injects ${tokenName(token)}, which nothing provides: add a provider for it to ${where}.`));
+            continue;
         }
     }
     for (const [provided, provider] of providers){
         const dependencies = isFactoryProvider(provider) ? provider.inject ?? [] : isClassProvider(provider) ? injectedTokens(provider.useClass) : [];
         const token = dependencies.find(missing);
         if (token !== undefined) {
-            throw controller_decorator.refuse(new Error(`${tokenName(provided)}: its provider injects ${tokenName(token)}, which nothing provides: add a provider for it to ${where}.`));
+            controller_decorator.startupError(new Error(`${tokenName(provided)}: its provider injects ${tokenName(token)}, which nothing provides: add a provider for it to ${where}.`));
+            continue;
         }
     }
 }
@@ -4744,16 +4771,21 @@ const isToken = (value)=>typeof value === 'function' || typeof value === 'string
  */ function assertTypedParameters(classes, decorators) {
     for (const cls of classes){
         const instead = meocordClassAdvice(cls);
-        if (instead && undecoratedConstructor(cls)) throw controller_decorator.refuse(new Error(`${cls.name}: MeoCord does not inject it; ${instead}.`));
+        if (instead && undecoratedConstructor(cls)) {
+            controller_decorator.startupError(new Error(`${cls.name}: MeoCord does not inject it; ${instead}.`));
+            continue;
+        }
         if (undecoratedConstructor(cls)) {
             const decorator = decorators.get(cls);
-            throw controller_decorator.refuse(new Error(`${cls.name}: its constructor takes parameters, but ${cls.name} has no decorator, so TypeScript recorded none of ` + `their types and it cannot be created. ${decorator ? `Decorate it with ${decorator}.` : 'Decorate it with @Service(), or give a class from a package a provider in @MeoCord({ providers }).'}`));
+            controller_decorator.startupError(new Error(`${cls.name}: its constructor takes parameters, but ${cls.name} has no decorator, so TypeScript recorded none of ` + `their types and it cannot be created. ${decorator ? `Decorate it with ${decorator}.` : 'Decorate it with @Service(), or give a class from a package a provider in @MeoCord({ providers }).'}`));
+            continue;
         }
         const index = untypedParameter(cls);
         if (index === -1) continue;
         const injectors = classes.filter((other)=>other !== cls && injectedTokens(other).includes(cls)).map((other)=>other.name);
         const injectedBy = injectors.length === 0 ? '' : ` (${injectors.length === 1 ? injectors[0] : `${injectors.slice(0, -1).join(', ')} and ${injectors.at(-1)}`} ` + `inject${injectors.length === 1 ? 's' : ''} ${cls.name})`;
-        throw controller_decorator.refuse(new Error(`${cls.name}: parameter ${index + 1} of its constructor has no runtime type, so it cannot be created. Usually ` + `${cls.name} and a class it injects import each other${injectedBy}, or the parameter is typed with an ` + 'interface or an `import type`. Move what they both need into a third service, or inject the parameter ' + 'with @Inject(token).'));
+        controller_decorator.startupError(new Error(`${cls.name}: parameter ${index + 1} of its constructor has no runtime type, so it cannot be created. Usually ` + `${cls.name} and a class it injects import each other${injectedBy}, or the parameter is typed with an ` + 'interface or an `import type`. Move what they both need into a third service, or inject the parameter ' + 'with @Inject(token).'));
+        continue;
     }
 }
 /** For each container, the tokens MeoCord binds itself, each to the app's class it stands for, if any. */ const ownTokens = new WeakMap();
@@ -4904,7 +4936,9 @@ exports.messageStartsFor = messageStartsFor;
 exports.needsGuild = needsGuild;
 exports.nonInteractionHandler = nonInteractionHandler;
 exports.observeUnclaimed = observeUnclaimed;
+exports.prepareAppPresenter = prepareAppPresenter;
 exports.prepareHandlerStages = prepareHandlerStages;
+exports.prepareThemes = prepareThemes;
 exports.providerMap = providerMap;
 exports.reachableClasses = reachableClasses;
 exports.registerClientTheme = registerClientTheme;

package/dist/cjs/_shared/{sharded-cooldown-store-B65iaiAy.cjs → sharded-cooldown-store-BdAUTdYs.cjs}

@@ -1,7 +1,7 @@
 'use strict';
 
 var node_crypto = require('node:crypto');
-var controller_decorator = require('./controller.decorator-BywwkU9O.cjs');
+var controller_decorator = require('./controller.decorator-CRn9kWob.cjs');
 
 /** The `fatal` code of a shard whose app MeoCord refused, which every shard would refuse alike. */ const REFUSED_CODE = 'Refused';
 /** Whether an IPC message is one of MeoCord's own, rather than one of discord.js's. */ function isShardMessage(message) {