meocord 4.2.1 → 4.2.3

package/dist/esm/decorator/theme.decorator.js

@@ -2,7 +2,7 @@ import 'reflect-metadata';
 import { assertValidTheme } from '../core/theme-validation.js';
 import { THEMED_CLASSES } from '../core/theme-runtime.js';
 import { copyLayer } from '../core/theme-scope.js';
-import { declaring, refuse } from '../util/refusal.util.js';
+import { declaring, decoratedName, refuse } from '../util/refusal.util.js';
 import { META } from '../util/metadata-keys.js';
 
 /**
@@ -37,8 +37,9 @@ import { META } from '../util/metadata-keys.js';
  */ function UseTheme(theme) {
     return declaring(function(target, propertyKey) {
         const onClass = propertyKey === undefined;
-        const owner = onClass ? target : target.constructor;
-        const where = `${owner.name}${onClass ? '' : `.${String(propertyKey)}`}: @UseTheme`;
+        // The class it themes: the target itself on a class or a static member, else the target's constructor
+        const owner = onClass || typeof target === 'function' ? target : target.constructor;
+        const where = `${decoratedName(target, propertyKey)}: @UseTheme`;
         assertValidTheme(theme, where);
         const key = onClass ? META.classTheme : META.methodTheme;
         const existing = onClass ? Reflect.getOwnMetadata(key, target) : Reflect.getOwnMetadata(key, target, propertyKey);

package/dist/esm/decorator/validation.decorator.js

@@ -1,7 +1,7 @@
 import 'reflect-metadata';
 import { makeInjectable } from '../util/injectable.util.js';
 import { assertStageEntries } from '../core/stage-scope.js';
-import { declaring, refuseOnClass, refuse, refuseOnMethod } from '../util/refusal.util.js';
+import { declaring, refuseOnClass, refuse, decoratedName, refuseOnMethod } from '../util/refusal.util.js';
 import { META } from '../util/metadata-keys.js';
 
 /**
@@ -43,15 +43,15 @@ import { META } from '../util/metadata-keys.js';
         refuseOnClass('@Validate', target, propertyKey);
         // Checked where it applies, so the refusal names the handler
         if (typeof schema?.['~standard']?.validate !== 'function') {
-            throw refuse(new Error(`${target.constructor.name}.${propertyKey}: @Validate takes a Standard Schema, such as a zod, valibot or arktype schema.`));
+            throw refuse(new Error(`${decoratedName(target, propertyKey)}: @Validate takes a Standard Schema, such as a zod, valibot or arktype schema.`));
         }
         if (Reflect.hasOwnMetadata(META.methodValidation, target, propertyKey)) {
-            throw refuse(new Error(`${target.constructor.name}.${propertyKey}: more than one @Validate; one @Validate per handler: combine the schemas into one.`));
+            throw refuse(new Error(`${decoratedName(target, propertyKey)}: more than one @Validate; one @Validate per handler: combine the schemas into one.`));
         }
         const inlinePipes = Object.values(options.pipes ?? {}).flatMap((entries)=>Array.isArray(entries) ? entries : [
                 entries
             ]);
-        assertStageEntries('@Validate', 'pipe', `${target.constructor.name}.${propertyKey}`, inlinePipes);
+        assertStageEntries('@Validate', 'pipe', decoratedName(target, propertyKey), inlinePipes);
         const metadata = {
             schema,
             pipes: options.pipes ?? {}
@@ -93,7 +93,7 @@ import { META } from '../util/metadata-keys.js';
  */ function UsePipe(key, ...pipes) {
     return declaring(function(target, propertyKey, _descriptor) {
         refuseOnClass('@UsePipe', target, propertyKey);
-        assertStageEntries('@UsePipe', 'pipe', `${target.constructor.name}.${propertyKey}`, pipes);
+        assertStageEntries('@UsePipe', 'pipe', decoratedName(target, propertyKey), pipes);
         // Decorators apply bottom-up, so a higher @UsePipe's pipes go first, in the order they read.
         const existing = Reflect.getOwnMetadata(META.methodPipes, target, propertyKey) ?? [];
         Reflect.defineMetadata(META.methodPipes, [

package/dist/esm/package.json.js

@@ -1,4 +1,4 @@
-var version = "4.2.1";
+var version = "4.2.3";
 var engines = {
 	node: ">=22.13"
 };

package/dist/esm/testing/catalog.js

@@ -1,34 +1,33 @@
-import { CATALOGS, placeholderNames } from '../common/translator.js';
+import { isPluralShape, CATALOGS, placeholderNames } from '../common/translator.js';
 import { MEOCORD_MESSAGES } from '../common/meocord-messages.js';
 
-const PLURAL_CATEGORIES = new Set([
-    'zero',
-    'one',
-    'two',
-    'few',
-    'many',
-    'other'
-]);
-/** A plural: an object whose every key is a plural category, as the translator's types read one; any other is a group. */ const isPlural = (value)=>typeof value === 'object' && value !== null && Object.keys(value).length > 0 && Object.keys(value).every((key)=>PLURAL_CATEGORIES.has(key));
-/** Every message key of a catalog, and whether it is a plural. */ function leaves(catalog, prefix = '') {
+/**
+ * Every message key of a catalog, and whether it is a plural. `reference` decides whether an object is a plural or a
+ * group, as the translator reads a translation by the default catalog's shapes; where it lacks a key, the object's own
+ * keys decide.
+ */ function leaves(catalog, prefix = '', reference = catalog) {
     return Object.entries(catalog).flatMap(([name, value])=>{
         const key = `${prefix}${name}`;
-        if (typeof value === 'string') return [
+        // A null message is one where it stands, which the checks below read as missing
+        if (typeof value === 'string' || value === null) return [
             {
                 key,
                 plural: false
             }
         ];
-        if (isPlural(value)) return [
+        const shape = typeof reference === 'object' && reference !== null && Object.hasOwn(reference, name) ? reference[name] : undefined;
+        const plural = typeof shape === 'object' && shape !== null ? isPluralShape(shape) : isPluralShape(value);
+        if (plural) return [
             {
                 key,
                 plural: true
             }
         ];
-        return leaves(value, `${key}.`);
+        return leaves(value, `${key}.`, shape);
     });
 }
 /** A translation's text, which an empty string isn't: the translator reads `''` as missing, as tools export one untranslated. */ const isText = (value)=>typeof value === 'string' && value !== '';
+/** A message the translator reads as missing: none, `null` or `''`, as tools export one untranslated. */ const isMissing = (value)=>value === undefined || value === null || value === '';
 /** The value at a key's path, through own properties only, so `constructor` or `toString` is not read off a prototype. */ function at(catalog, key) {
     return key.split('.').reduce((current, part)=>typeof current === 'object' && current !== null && Object.hasOwn(current, part) ? current[part] : undefined, catalog);
 }
@@ -43,7 +42,7 @@ const isMeoCordKey = (key)=>key.startsWith('meocord.');
 /** A message as a report shows it: the text, or a plural's `other` form. */ const shown = (message)=>typeof message === 'string' ? message : String(message.other);
 /** The `{params}` a translation uses that the message it translates doesn't take; a plural's `{count}` is taken. */ function strayParams(translation, original) {
     const taken = placeholders(original);
-    if (isPlural(original)) taken.add('count');
+    if (isPluralShape(original)) taken.add('count');
     return [
         ...placeholders(translation)
     ].filter((name)=>!taken.has(name));
@@ -53,11 +52,13 @@ const isMeoCordKey = (key)=>key.startsWith('meocord.');
  *
  * Use it in a test for a team that wants no fallback in production. It reports the messages a locale lacks, the
  * messages the default catalog doesn't have, the plural forms a language needs but a plural lacks, such as `few` for
- * Russian, a translation of another shape than the default's, a text for a plural or a plural for a text, and each
- * `{param}` a translation uses that the message it translates doesn't take. An empty translation, `''`, counts as
- * lacking, as the translator reads it as missing. It reads the catalogs' own strings, so it checks the params of a
- * catalog from a plain variable or a JSON file too, which the compiler can't. An object counts as a plural only when
- * its every key is a plural category, so a group with an `other` key is a group.
+ * Russian, a translation of another shape than the default's, a text for a plural or a group, or a plural for a text, and each
+ * `{param}` a translation uses that the message it translates doesn't take. An empty translation, `''` or `null`, counts
+ * as lacking, as the translator reads it as missing. It reads the catalogs' own strings, so it checks the params of a
+ * catalog from a plain variable or a JSON file too, which the compiler can't. An object in the default catalog counts as
+ * a plural only when its every key is a plural category, so a group with an `other` key is a group, and a translation
+ * is read by the default catalog's shapes, as the translator reads it: one that keeps only a group's `other` message
+ * lacks the group's other messages.
  *
  * @remarks
  * MeoCord's own texts, a catalog's `meocord` group, fall back to English by design, so only a key MeoCord lacks, and
@@ -104,12 +105,12 @@ const isMeoCordKey = (key)=>key.startsWith('meocord.');
         const categories = new Intl.PluralRules(locale).resolvedOptions().pluralCategories;
         for (const { key, plural } of reference){
             const message = at(catalog, key);
-            if (message === undefined || message === '') {
+            if (isMissing(message)) {
                 problems.push(`missing ${key}`);
                 continue;
             }
             // A translation of another shape than the default's can't be read as it: a text for a plural, or the reverse
-            if (plural !== isPlural(message) || !plural && typeof message !== 'string') {
+            if (plural !== isPluralShape(message) || !plural && typeof message !== 'string') {
                 problems.push(`${key} should be a ${plural ? 'plural' : 'text'}, as the default is`);
                 continue;
             }
@@ -122,9 +123,11 @@ const isMeoCordKey = (key)=>key.startsWith('meocord.');
             for (const name of stray)problems.push(`${key} takes no {${name}}; the default is "${shown(original)}"`);
         }
         if (options.meocord && !locale.startsWith('en-')) {
-            for (const key of MEOCORD_KEYS)if (at(catalog, key) === undefined || at(catalog, key) === '') problems.push(`missing ${key}`);
+            for (const key of MEOCORD_KEYS)if (isMissing(at(catalog, key))) problems.push(`missing ${key}`);
         }
-        for (const { key } of leaves(catalog)){
+        for (const { key } of leaves(catalog, '', defaultCatalog)){
+            // A message left out, as a null one is, that the default has is reported missing above, and is nothing extra
+            if (isMissing(at(catalog, key)) && at(defaultCatalog, key) !== undefined) continue;
             if (isMeoCordKey(key)) {
                 if (!MEOCORD_KEYS.has(key)) problems.push(`${key} is not one of MeoCord's texts`);
                 else {
@@ -132,7 +135,11 @@ const isMeoCordKey = (key)=>key.startsWith('meocord.');
                     const stray = strayParams(at(catalog, key), english);
                     for (const name of stray)problems.push(`${key} takes no {${name}}: MeoCord's English is "${shown(english)}"`);
                 }
-            } else if (!referenceKeys.has(key)) problems.push(`${key} is not in the default catalog`);
+            } else if (!referenceKeys.has(key)) {
+                // A text where the default has a group: the key is the default's, in another shape
+                const original = at(defaultCatalog, key);
+                problems.push(typeof original === 'object' && original !== null ? `${key} should be a group, as the default is` : `${key} is not in the default catalog`);
+            }
         }
         if (problems.length > 0) gaps.push(`  ${locale}: ${problems.join('; ')}`);
     }

package/dist/esm/testing/cooldown-store-suite.js

@@ -1,5 +1,5 @@
 import { randomUUID } from 'node:crypto';
-import { CooldownStore } from '../common/cooldown-store.js';
+import { isDefaultBatchMethod } from '../common/cooldown-store.js';
 
 /** Long enough for a store over the network to answer each case, short enough that the suite takes seconds. */ const CASE_TIMEOUT_MS = 10000;
 const sleep = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
@@ -408,10 +408,10 @@ const sleep = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
     });
 }
 /** Whether a store overrides `consumeMany`, as a store that counts a batch at once does. */ function overridesConsumeMany(store) {
-    return store.consumeMany !== CooldownStore.prototype.consumeMany;
+    return !isDefaultBatchMethod(store.consumeMany);
 }
 /** Whether a store overrides `peekMany`, as a store that can check a batch without recording it does. */ function overridesPeekMany(store) {
-    return store.peekMany !== CooldownStore.prototype.peekMany;
+    return !isDefaultBatchMethod(store.peekMany);
 }
 
 export { testCooldownStore };