Address review: inflection, colocation, drop unused helpers

Review feedback on the strict resolver boiled down to three things:
proper pluralization with customization, nested-colocation component
lookup, and dead code in strict-resolver/string.js.

Pluralization: #plural now handles -s/-ss/-sh/-ch/-x/-z suffixes,
consonant + y, and the common irregulars (child/children,
person/people, man/men, woman/women, mouse/mice, tooth/teeth,
foot/feet). The plurals constructor option still overrides anything,
so a user can opt their "childs" type back in.

Nested colocation: added #nestedColocationLookup so component:my-widget
resolves to ./components/my-widget/index.{js,ts,gjs,gts} — the common
pattern for a class paired with a template in a folder. Direct module
matches still take precedence.

Dead code: classify and underscore weren't used by the resolver or
anything else in ember-source, so they're gone (along with their test
files). decamelize is collapsed inside dasherize's implementation.
The setStrings/getStrings/getString runtime string table was also
unused; removed. dasherize loses its yuidoc @method tag since the same
name is already documented via @ember/-internals/string.

Tests: cover -s/-es suffix rules, consonant-y, irregular plurals,
custom plural overriding an irregular, and the three colocation
cases (component/helper/modifier, plus direct-wins-over-colocation).
tests/docs/expected.js drops the entries whose only source was the
trimmed strict-resolver/string.js.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: NullVoxPopuli

packages/@ember/engine/lib/strict-resolver.ts

@@ -30,13 +30,18 @@ export class StrictResolver implements Resolver {
   }
 
   #plural(s: string) {
-    return this.#plurals.get(s) ?? s + 's';
+    return this.#plurals.get(s) ?? pluralize(s);
   }
 
   resolve(fullName: string): Factory<object> | object | undefined {
     let [type, name] = fullName.split(':') as [string, string];
     name = this.#normalizeName(type, name);
-    for (let strategy of [this.#resolveSelf, this.#mainLookup, this.#defaultLookup]) {
+    for (let strategy of [
+      this.#resolveSelf,
+      this.#mainLookup,
+      this.#defaultLookup,
+      this.#nestedColocationLookup,
+    ]) {
       let result = strategy.call(this, type, name);
       if (result) {
         return this.#extractDefaultExport(result.hit);
@@ -101,6 +106,50 @@ export class StrictResolver implements Resolver {
     }
     return undefined;
   }
+
+  // Supports the nested colocation pattern where `component:my-widget`
+  // resolves to `./components/my-widget/index.{js,ts,gjs,gts}`. The index
+  // file is typically the component class, and it's commonly paired with a
+  // sibling `template.hbs` inside the same folder.
+  #nestedColocationLookup(type: string, name: string): Result {
+    let dir = this.#plural(type);
+    let target = `${dir}/${name}/index`;
+    let module = this.#modules.get(target);
+    if (module) {
+      return { hit: module };
+    }
+    return undefined;
+  }
+}
+
+// Handle the common irregular English plurals plus the standard -s / -es
+// suffix rules. Users can override any type via the `plurals` constructor
+// option (including overriding these defaults).
+const IRREGULAR_PLURALS: Record<string, string> = Object.freeze({
+  child: 'children',
+  man: 'men',
+  woman: 'women',
+  person: 'people',
+  mouse: 'mice',
+  tooth: 'teeth',
+  foot: 'feet',
+});
+
+const NEEDS_ES_SUFFIX = /(s|ss|sh|ch|x|z)$/;
+const ENDS_IN_CONSONANT_Y = /([^aeiou])y$/;
+
+function pluralize(singular: string): string {
+  let irregular = IRREGULAR_PLURALS[singular];
+  if (irregular) {
+    return irregular;
+  }
+  if (ENDS_IN_CONSONANT_Y.test(singular)) {
+    return singular.replace(ENDS_IN_CONSONANT_Y, '$1ies');
+  }
+  if (NEEDS_ES_SUFFIX.test(singular)) {
+    return singular + 'es';
+  }
+  return singular + 's';
 }
 
 const fileExtension = /\.\w{1,4}$/;

packages/@ember/engine/lib/strict-resolver/string.js

@@ -1,127 +1,16 @@
-/* eslint-disable no-useless-escape */
 import Cache from './cache';
-let STRINGS = {};
-export function setStrings(strings) {
-  STRINGS = strings;
-}
-export function getStrings() {
-  return STRINGS;
-}
-export function getString(name) {
-  return STRINGS[name];
-}
+
 const STRING_DASHERIZE_REGEXP = /[ _]/g;
-const STRING_DASHERIZE_CACHE = new Cache(1000, (key) =>
-  decamelize(key).replace(STRING_DASHERIZE_REGEXP, '-')
-);
-const STRING_CLASSIFY_REGEXP_1 = /^(\-|_)+(.)?/;
-const STRING_CLASSIFY_REGEXP_2 = /(.)(\-|\_|\.|\s)+(.)?/g;
-const STRING_CLASSIFY_REGEXP_3 = /(^|\/|\.)([a-z])/g;
-const classifyReplace1 = (_match, _separator, chr) => (chr ? `_${chr.toUpperCase()}` : '');
-const classifyReplace2 = (_match, initialChar, _separator, chr) =>
-  initialChar + (chr ? chr.toUpperCase() : '');
-const CLASSIFY_CACHE = new Cache(1000, (str) => {
-  let parts = str.split('/');
-  for (let i = 0; i < parts.length; i++) {
-    parts[i] = parts[i]
-      .replace(STRING_CLASSIFY_REGEXP_1, classifyReplace1)
-      .replace(STRING_CLASSIFY_REGEXP_2, classifyReplace2);
-  }
-  return parts.join('/').replace(STRING_CLASSIFY_REGEXP_3, (match) => match.toUpperCase());
-});
-const STRING_UNDERSCORE_REGEXP_1 = /([a-z\d])([A-Z]+)/g;
-const STRING_UNDERSCORE_REGEXP_2 = /\-|\s+/g;
-const UNDERSCORE_CACHE = new Cache(1000, (str) =>
-  str
-    .replace(STRING_UNDERSCORE_REGEXP_1, '$1_$2')
-    .replace(STRING_UNDERSCORE_REGEXP_2, '_')
-    .toLowerCase()
-);
 const STRING_DECAMELIZE_REGEXP = /([a-z\d])([A-Z])/g;
+
 const DECAMELIZE_CACHE = new Cache(1000, (str) =>
   str.replace(STRING_DECAMELIZE_REGEXP, '$1_$2').toLowerCase()
 );
-/**
-  Converts a camelized string into all lower case separated by underscores.
-
-  ```javascript
-  import { decamelize } from '@ember/string';
-
-  decamelize('innerHTML');          // 'inner_html'
-  decamelize('action_name');        // 'action_name'
-  decamelize('css-class-name');     // 'css-class-name'
-  decamelize('my favorite items');  // 'my favorite items'
-  ```
-
-  @method decamelize
-  @param {String} str The string to decamelize.
-  @return {String} the decamelized string.
-  @private
-*/
-export function decamelize(str) {
-  return DECAMELIZE_CACHE.get(str);
-}
-/**
-  Replaces underscores, spaces, or camelCase with dashes.
 
-  ```javascript
-  import { dasherize } from '@ember/string';
-
-  dasherize('innerHTML');                // 'inner-html'
-  dasherize('action_name');              // 'action-name'
-  dasherize('css-class-name');           // 'css-class-name'
-  dasherize('my favorite items');        // 'my-favorite-items'
-  dasherize('privateDocs/ownerInvoice';  // 'private-docs/owner-invoice'
-  ```
+const STRING_DASHERIZE_CACHE = new Cache(1000, (key) =>
+  DECAMELIZE_CACHE.get(key).replace(STRING_DASHERIZE_REGEXP, '-')
+);
 
-  @method dasherize
-  @param {String} str The string to dasherize.
-  @return {String} the dasherized string.
-  @public
-*/
 export function dasherize(str) {
   return STRING_DASHERIZE_CACHE.get(str);
 }
-/**
-  Returns the UpperCamelCase form of a string.
-
-  ```javascript
-  import { classify } from '@ember/string';
-
-  classify('innerHTML');                   // 'InnerHTML'
-  classify('action_name');                 // 'ActionName'
-  classify('css-class-name');              // 'CssClassName'
-  classify('my favorite items');           // 'MyFavoriteItems'
-  classify('private-docs/owner-invoice');  // 'PrivateDocs/OwnerInvoice'
-  ```
-
-  @method classify
-  @param {String} str the string to classify
-  @return {String} the classified string
-  @public
-*/
-export function classify(str) {
-  return CLASSIFY_CACHE.get(str);
-}
-/**
-  More general than decamelize. Returns the lower\_case\_and\_underscored
-  form of a string.
-
-  ```javascript
-  import { underscore } from '@ember/string';
-
-  underscore('innerHTML');                 // 'inner_html'
-  underscore('action_name');               // 'action_name'
-  underscore('css-class-name');            // 'css_class_name'
-  underscore('my favorite items');         // 'my_favorite_items'
-  underscore('privateDocs/ownerInvoice');  // 'private_docs/owner_invoice'
-  ```
-
-  @method underscore
-  @param {String} str The string to underscore.
-  @return {String} the underscored string.
-  @private
-*/
-export function underscore(str) {
-  return UNDERSCORE_CACHE.get(str);
-}

packages/@ember/engine/tests/resolver/basic-test.js

@@ -355,4 +355,87 @@ module('strict-resolver | basic', function (hooks) {
 
     assert.strictEqual(result, 'whatever', 'super-duper-config/environment is found');
   });
+
+  test('default plural handles -s / -ss / -sh / -ch / -x / -z suffixes', function (assert) {
+    let cases = {
+      './buses/red': 'bus:red',
+      './brushes/broom': 'brush:broom',
+      './benches/park': 'bench:park',
+      './boxes/cardboard': 'box:cardboard',
+      './buzzes/loud': 'buzz:loud',
+      './classes/math': 'class:math',
+    };
+
+    for (let [modulePath, lookup] of Object.entries(cases)) {
+      let r = new StrictResolver({ [modulePath]: modulePath });
+      assert.strictEqual(r.resolve(lookup), modulePath, `${lookup} -> ${modulePath}`);
+    }
+  });
+
+  test('default plural handles consonant + y suffix (y -> ies)', function (assert) {
+    let r = new StrictResolver({ './categories/widgets': 'widgets-cat' });
+
+    assert.strictEqual(r.resolve('category:widgets'), 'widgets-cat');
+  });
+
+  test('default plural handles common irregular nouns', function (assert) {
+    let cases = {
+      './children/alice': 'child:alice',
+      './people/bob': 'person:bob',
+      './men/carl': 'man:carl',
+      './women/dana': 'woman:dana',
+      './mice/squeaky': 'mouse:squeaky',
+      './teeth/molar': 'tooth:molar',
+      './feet/left': 'foot:left',
+    };
+
+    for (let [modulePath, lookup] of Object.entries(cases)) {
+      let r = new StrictResolver({ [modulePath]: modulePath });
+      assert.strictEqual(r.resolve(lookup), modulePath, `${lookup} -> ${modulePath}`);
+    }
+  });
+
+  test('custom plural overrides irregular default', function (assert) {
+    // a user who insists on "childs" should be able to opt out of the
+    // built-in irregular plural
+    let r = new StrictResolver({ './childs/alice': 'alice' }, { child: 'childs' });
+
+    assert.strictEqual(r.resolve('child:alice'), 'alice');
+  });
+
+  test('can lookup a nested-colocation component (index file)', function (assert) {
+    let expected = { isComponentFactory: true };
+    resolver.addModules({
+      './components/my-widget/index': { default: expected },
+    });
+
+    assert.strictEqual(resolver.resolve('component:my-widget'), expected);
+  });
+
+  test('nested-colocation also works for helpers and modifiers', function (assert) {
+    let helper = {};
+    let modifier = {};
+    resolver.addModules({
+      './helpers/format-date/index': { default: helper },
+      './modifiers/on-intersect/index': { default: modifier },
+    });
+
+    assert.strictEqual(resolver.resolve('helper:format-date'), helper);
+    assert.strictEqual(resolver.resolve('modifier:on-intersect'), modifier);
+  });
+
+  test('direct module takes precedence over the nested-colocation index', function (assert) {
+    let direct = { direct: true };
+    let nested = { nested: true };
+    resolver.addModules({
+      './components/my-widget': { default: direct },
+      './components/my-widget/index': { default: nested },
+    });
+
+    assert.strictEqual(
+      resolver.resolve('component:my-widget'),
+      direct,
+      'direct match wins over the colocation fallback'
+    );
+  });
 });