@starci/eslint-canon-be 3.0.10 → 3.2.0

package/runtime/scripts/hfs/architecture/unit-spec-providers.mjs

@@ -3,6 +3,7 @@ import path from 'node:path';
 import { machineKit } from './machine-ast.mjs';
 import { constructorDependencies } from './constructor-deps.mjs';
 import { treeOf } from './required-files.mjs';
+import { byCodeUnit } from '../../lib/list.mjs';
 
 /**
  * R48 `unit-spec-providers` (BE_SPEC_QUALITY), the unit test standard's rule 3: the unit spec of a service builds its
@@ -22,7 +23,6 @@ import { treeOf } from './required-files.mjs';
 export const UNIT_SPEC_PROVIDERS_RULE_IDS = ['BE_SPEC_QUALITY'];
 
 const RULE = 'BE_SPEC_QUALITY';
-const SERVICE_SPEC = /\.service\.spec\.ts$/u;
 const SPEC_ROOT = /^(?:src|apps)\//u;
 
 /** local name -> {name, module} for every named import of a source file. */
@@ -49,6 +49,87 @@ function testingModules(ts, sourceFile) {
 
 const literalKey = (ts, property) => (ts.isPropertyAssignment(property) || ts.isShorthandPropertyAssignment(property)) && (ts.isIdentifier(property.name) || ts.isStringLiteralLike(property.name)) ? property.name.text : null;
 
+function providerList(ts, call, rel, report) {
+  const options = call.arguments[0];
+  const property = options && ts.isObjectLiteralExpression(options) ? options.properties.find(item => literalKey(ts, item) === 'providers') : null;
+  const list = property && ts.isPropertyAssignment(property) && ts.isArrayLiteralExpression(property.initializer) ? property.initializer : null;
+  if (!list) report(call, `${rel}: Test.createTestingModule has no literal \`providers\` array; list the service and each constructor dependency there.`);
+  return list;
+}
+
+function readProviders(ts, list, rel, nameOf, report) {
+  const provided = [];
+  let readable = true;
+  for (const element of list.elements) {
+    if (ts.isIdentifier(element)) { provided.push({ name: nameOf(element), node: element, isClass: true }); continue; }
+    if (ts.isObjectLiteralExpression(element)) {
+      const keys = element.properties.map(item => literalKey(ts, item));
+      const provide = element.properties.find(item => literalKey(ts, item) === 'provide');
+      const value = provide && ts.isPropertyAssignment(provide) ? provide.initializer : null;
+      if (keys.length === 2 && keys.includes('useValue') && value && ts.isIdentifier(value)) { provided.push({ name: nameOf(value), node: element, isClass: false }); continue; }
+    }
+    readable = false;
+    report(element, `${rel}: a provider is a class or \`{ provide: TOKEN, useValue: double }\` and nothing else (no useClass, useFactory, useExisting, spread or computed token).`);
+  }
+  return { provided, readable };
+}
+
+function serviceClassFor(ts, rel, serviceRel, serviceFile, imports, list, report) {
+  const first = list.elements[0];
+  const serviceName = first && ts.isIdentifier(first) ? imports.get(first.text) : null;
+  const target = serviceName ? path.posix.normalize(path.posix.join(path.posix.dirname(rel), serviceName.module)).replace(/\.[cm]?[jt]s$/u, '') : null;
+  const serviceClass = serviceName && target === serviceRel.replace(/\.ts$/u, '')
+    ? serviceFile.sourceFile.statements.find(statement => ts.isClassDeclaration(statement) && statement.name?.text === serviceName.name) : null;
+  if (!serviceClass) report(first ?? list, `${rel}: the first provider is the service under test, imported from ./${path.posix.basename(serviceRel, '.ts')}.`);
+  return serviceClass ? { serviceClass, serviceName } : null;
+}
+
+function checkDependencies(kit, rel, service, serviceFile, list, provided, report) {
+  const { serviceName, serviceClass } = service;
+  const dependencies = constructorDependencies(kit, serviceFile, serviceClass);
+  const expected = [];
+  for (const dependency of dependencies) {
+    if (dependency.kind === 'unresolved') {
+      report(list, `${rel}: a constructor dependency of ${serviceName.name} cannot be resolved to a token (${dependency.reason}), so its provider cannot be checked; inject it through an exported Inject<Thing>() decorator or a class type.`);
+      continue;
+    }
+    expected.push(dependency.name);
+  }
+  const remaining = [...expected];
+  for (const item of provided.slice(1)) {
+    const index = remaining.indexOf(item.name);
+    if (index === -1) report(item.node, `${rel}: ${item.name} is provided but is not a constructor dependency of ${serviceName.name}; a unit spec provides exactly what the constructor needs.`);
+    else remaining.splice(index, 1);
+  }
+  for (const name of remaining) report(list, `${rel}: ${name} is a constructor dependency of ${serviceName.name} but is not provided; add \`{ provide: ${name}, useValue: double }\` (or the class itself) to the providers.`);
+}
+
+function checkTestingModule({ ts, kit, rel, serviceRel, serviceFile, imports, call, report }) {
+  const list = providerList(ts, call, rel, report);
+  if (!list) return;
+  const nameOf = identifier => imports.get(identifier.text)?.name ?? identifier.text;
+  const { provided, readable } = readProviders(ts, list, rel, nameOf, report);
+  if (!readable) return;
+  const service = serviceClassFor(ts, rel, serviceRel, serviceFile, imports, list, report);
+  if (!service) return;
+  checkDependencies(kit, rel, service, serviceFile, list, provided, report);
+}
+
+function checkServiceSpec({ config, graph, kit, ts, rel, violations }) {
+  const abs = path.join(config.root, ...rel.split('/'));
+  if (!fs.existsSync(abs)) return false;
+  const sourceFile = ts.createSourceFile(abs, fs.readFileSync(abs, 'utf8'), ts.ScriptTarget.Latest, true);
+  const report = (node, message) => violations.push({ ruleId: RULE, path: rel, ...kit.at(rel, sourceFile, node), message });
+  const imports = importsOf(ts, sourceFile);
+  const serviceRel = rel.replace(/\.spec\.ts$/u, '.ts');
+  const serviceFile = graph.files.get(serviceRel);
+  if (!serviceFile) { report(sourceFile, `${rel} has no ${path.posix.basename(serviceRel)} beside it; a service spec sits next to the service it tests.`); return true; }
+  const modules = testingModules(ts, sourceFile);
+  if (!modules.length) { report(sourceFile, `${rel} never calls Test.createTestingModule({ providers: [...] }); build the service from a testing module holding exactly its constructor dependencies.`); return true; }
+  for (const call of modules) checkTestingModule({ ts, kit, rel, serviceRel, serviceFile, imports, call, report });
+  return true;
+}
+
 export function checkUnitSpecProviders(input) {
   const { config, graph } = input;
   const kit = machineKit(input);
@@ -56,67 +137,8 @@ export function checkUnitSpecProviders(input) {
   const violations = [];
   let specs = 0;
   const tree = treeOf(config.root);
-  for (const rel of [...tree.files].filter(file => SPEC_ROOT.test(file) && SERVICE_SPEC.test(file)).sort()) {
-    const abs = path.join(config.root, ...rel.split('/'));
-    if (!fs.existsSync(abs)) continue;
-    specs += 1;
-    const sourceFile = ts.createSourceFile(abs, fs.readFileSync(abs, 'utf8'), ts.ScriptTarget.Latest, true);
-    const report = (node, message) => violations.push({ ruleId: RULE, path: rel, ...kit.at(rel, sourceFile, node), message });
-    const imports = importsOf(ts, sourceFile);
-    const nameOf = identifier => imports.get(identifier.text)?.name ?? identifier.text;
-
-    const serviceRel = rel.replace(/\.spec\.ts$/u, '.ts');
-    const serviceFile = graph.files.get(serviceRel);
-    if (!serviceFile) { report(sourceFile, `${rel} has no ${path.posix.basename(serviceRel)} beside it; a service spec sits next to the service it tests.`); continue; }
-
-    const modules = testingModules(ts, sourceFile);
-    if (!modules.length) { report(sourceFile, `${rel} never calls Test.createTestingModule({ providers: [...] }); build the service from a testing module holding exactly its constructor dependencies.`); continue; }
-
-    for (const call of modules) {
-      const options = call.arguments[0];
-      const property = options && ts.isObjectLiteralExpression(options) ? options.properties.find(item => literalKey(ts, item) === 'providers') : null;
-      const list = property && ts.isPropertyAssignment(property) && ts.isArrayLiteralExpression(property.initializer) ? property.initializer : null;
-      if (!list) { report(call, `${rel}: Test.createTestingModule has no literal \`providers\` array; list the service and each constructor dependency there.`); continue; }
-
-      const provided = []; // [{name, node}]
-      let readable = true;
-      for (const element of list.elements) {
-        if (ts.isIdentifier(element)) { provided.push({ name: nameOf(element), node: element, isClass: true }); continue; }
-        if (ts.isObjectLiteralExpression(element)) {
-          const keys = element.properties.map(item => literalKey(ts, item));
-          const provide = element.properties.find(item => literalKey(ts, item) === 'provide');
-          const value = provide && ts.isPropertyAssignment(provide) ? provide.initializer : null;
-          if (keys.length === 2 && keys.includes('useValue') && value && ts.isIdentifier(value)) { provided.push({ name: nameOf(value), node: element, isClass: false }); continue; }
-        }
-        readable = false;
-        report(element, `${rel}: a provider is a class or \`{ provide: TOKEN, useValue: double }\` and nothing else (no useClass, useFactory, useExisting, spread or computed token).`);
-      }
-      if (!readable) continue;
-
-      const first = list.elements[0];
-      const serviceName = first && ts.isIdentifier(first) ? imports.get(first.text) : null;
-      const target = serviceName ? path.posix.normalize(path.posix.join(path.posix.dirname(rel), serviceName.module)).replace(/\.[cm]?[jt]s$/u, '') : null;
-      const serviceClass = serviceName && target === serviceRel.replace(/\.ts$/u, '')
-        ? serviceFile.sourceFile.statements.find(statement => ts.isClassDeclaration(statement) && statement.name?.text === serviceName.name) : null;
-      if (!serviceClass) { report(first ?? list, `${rel}: the first provider is the service under test, imported from ./${path.posix.basename(serviceRel, '.ts')}.`); continue; }
-
-      const dependencies = constructorDependencies(kit, serviceFile, serviceClass);
-      const expected = [];
-      for (const dependency of dependencies) {
-        if (dependency.kind === 'unresolved') {
-          report(list, `${rel}: a constructor dependency of ${serviceName.name} cannot be resolved to a token (${dependency.reason}), so its provider cannot be checked; inject it through an exported Inject<Thing>() decorator or a class type.`);
-          continue;
-        }
-        expected.push(dependency.name);
-      }
-      const remaining = [...expected];
-      for (const item of provided.slice(1)) {
-        const index = remaining.indexOf(item.name);
-        if (index === -1) report(item.node, `${rel}: ${item.name} is provided but is not a constructor dependency of ${serviceName.name}; a unit spec provides exactly what the constructor needs.`);
-        else remaining.splice(index, 1);
-      }
-      for (const name of remaining) report(list, `${rel}: ${name} is a constructor dependency of ${serviceName.name} but is not provided; add \`{ provide: ${name}, useValue: double }\` (or the class itself) to the providers.`);
-    }
+  for (const rel of [...tree.files].filter(file => SPEC_ROOT.test(file) && file.endsWith('.service.spec.ts')).sort(byCodeUnit)) {
+    if (checkServiceSpec({ config, graph, kit, ts, rel, violations })) specs += 1;
   }
   return { violations, coverage: { status: 'checked', specs, files: graph.files.size } };
 }

package/runtime/scripts/hfs/declaration-shape.mjs

@@ -3,17 +3,88 @@
 import { isPlainObject } from '../../engine/plain-object.mjs';
 import { APP_KIND, connectionShapeProblems, NAME, RUNTIME_KIND, SLOT_ID } from './manifest-shape.mjs';
 import { kindShapeProblems, patternShapeProblems } from './declaration-slots.mjs';
+import { byCodeUnit } from '../lib/list.mjs';
 
 /** Shape problems of the optional hfs.json `supabase` block whose auth posture DB_CONFIG_POLICY checks. */
+const isSupabaseStringList = (value) => Array.isArray(value) && value.every((entry) => typeof entry === 'string' && entry.trim());
+
+function supabaseValueProblems(block) {
+  const bad = [];
+  if (block.enableSignup !== undefined && typeof block.enableSignup !== 'boolean') bad.push('supabase.enableSignup must be true or false');
+  if (block.jwtExpiry !== undefined && !(Number.isInteger(block.jwtExpiry) && block.jwtExpiry > 0 && block.jwtExpiry <= 3600)) bad.push('supabase.jwtExpiry must be an integer of seconds, 3600 at most');
+  if (block.siteUrl !== undefined && (typeof block.siteUrl !== 'string' || !block.siteUrl.trim())) bad.push('supabase.siteUrl must be a URL string');
+  for (const key of ['redirectUrls', 'forceRls']) if (block[key] !== undefined && !isSupabaseStringList(block[key])) bad.push(`supabase.${key} must be a list of strings`);
+  return bad;
+}
+
 function supabaseBlockProblems(block) {
   if (block === undefined) return [];
   if (!isPlainObject(block)) return ['supabase must be an object'];
   const bad = [];
   for (const key of Object.keys(block)) if (!['enableSignup', 'jwtExpiry', 'siteUrl', 'redirectUrls', 'forceRls'].includes(key)) bad.push(`supabase has unknown key ${key}`);
-  if (block.enableSignup !== undefined && typeof block.enableSignup !== 'boolean') bad.push('supabase.enableSignup must be true or false');
-  if (block.jwtExpiry !== undefined && !(Number.isInteger(block.jwtExpiry) && block.jwtExpiry > 0 && block.jwtExpiry <= 3600)) bad.push('supabase.jwtExpiry must be an integer of seconds, 3600 at most');
-  if (block.siteUrl !== undefined && (typeof block.siteUrl !== 'string' || !block.siteUrl.trim())) bad.push('supabase.siteUrl must be a URL string');
-  for (const key of ['redirectUrls', 'forceRls']) if (block[key] !== undefined && !(Array.isArray(block[key]) && block[key].every((value) => typeof value === 'string' && value.trim()))) bad.push(`supabase.${key} must be a list of strings`);
+  bad.push(...supabaseValueProblems(block));
+  return bad;
+}
+
+function appShapeProblems(apps, at, side, names) {
+  const bad = [];
+  if (!Array.isArray(apps) || !apps.length) {
+    bad.push(`${at}.apps must list every ${side}/apps/<name> with its kind`);
+    return bad;
+  }
+  apps.forEach((app, index) => {
+    if (!isPlainObject(app) || !NAME.test(String(app.name)) || !NAME.test(String(app.kind)) || Object.keys(app).some((key) => key !== 'name' && key !== 'kind')) bad.push(`${at}.apps[${index}] must be {name, kind}`);
+    else if (names.has(app.name)) bad.push(`app ${app.name} is declared twice (${names.get(app.name)} and ${side})`);
+    else names.set(app.name, side);
+  });
+  return bad;
+}
+
+function connectionProblems(side, value) {
+  const bad = [];
+  if (side !== 'be') {
+    bad.push('connections belong to the be side');
+    return bad;
+  }
+  const list = Array.isArray(value.connections) ? value.connections : null;
+  const shape = connectionShapeProblems(list, value.apps);
+  if (shape.length) {
+    bad.push(...shape);
+    return bad;
+  }
+  if (new Set(list.map((connection) => connection.name)).size !== list.length) bad.push('connections names must be unique');
+  for (const a of list) for (const b of list) if (a !== b && `${b.envPrefix}_`.startsWith(`${a.envPrefix}_`)) bad.push(`connections ${a.name} and ${b.name} share env keys (${a.envPrefix}_ covers ${b.envPrefix}_)`);
+  return bad;
+}
+
+/** Whether a declared list is present but not a list of distinct entries that all satisfy `valid`. */
+const isBadUniqueList = (list, valid) => list !== undefined && (!Array.isArray(list) || !list.every((entry) => valid(entry)) || new Set(list).size !== list.length);
+
+function declarationSideProblems(side, value, names) {
+  const bad = [];
+  const at = `sides.${side}`;
+  if (!isPlainObject(value)) return [`${at} must be an object`];
+  for (const key of Object.keys(value)) if (!['apps', 'optionalSlots', 'patterns', 'kinds', 'connections', 'reads'].includes(key)) bad.push(`${at} has unknown key ${key}`);
+  bad.push(...appShapeProblems(value.apps, at, side, names));
+  if (isBadUniqueList(value.optionalSlots, (slot) => SLOT_ID.test(String(slot)))) bad.push(`${at}.optionalSlots must be a unique list of slot ids`);
+  bad.push(...patternShapeProblems(value, at, NAME), ...kindShapeProblems(value, at, NAME));
+  if (isBadUniqueList(value.reads, (read) => typeof read === 'string' && read.length > 0)) bad.push(`${at}.reads must be a unique list of paths`);
+  if (value.connections !== undefined) bad.push(...connectionProblems(side, value));
+  return bad;
+}
+
+const DECLARATION_KEYS = new Set(['hfs', 'kind', 'project', 'edition', 'supabase', 'sides', 'browser']);
+const RUNTIME_DECLARATION_KEYS = new Set(['hfs', 'kind', 'project']);
+
+function productDeclarationProblems(declaration, profiles) {
+  const bad = [];
+  for (const key of Object.keys(declaration)) if (!DECLARATION_KEYS.has(key)) bad.push(`unknown key ${key}`);
+  bad.push(...supabaseBlockProblems(declaration.supabase));
+  if (declaration.browser !== undefined && declaration.browser !== true) bad.push('browser is `true` when the app has a browser journey (slot app.browser), and is left out otherwise');
+  if (declaration.kind !== APP_KIND) bad.push(`kind must be ${APP_KIND} (a product is one app repository with a be and an fe side) or ${RUNTIME_KIND} (the StarCi runtime repository)`);
+  if (!isPlainObject(declaration.sides) || Object.keys(declaration.sides).sort(byCodeUnit).join() !== profiles.join()) { bad.push('sides must declare exactly be and fe'); return bad; }
+  const names = new Map();
+  for (const side of profiles) bad.push(...declarationSideProblems(side, declaration.sides[side], names));
   return bad;
 }
 
@@ -24,39 +95,9 @@ export function declarationShapeProblems(declaration, profiles) {
   if (!(Number.isInteger(declaration.hfs) && declaration.hfs >= 1)) bad.push('hfs must be the pinned manifest major (an integer, 1 or more)');
   if (!NAME.test(String(declaration.project))) bad.push('project must be a project name');
   if (declaration.kind === RUNTIME_KIND) {
-    for (const key of Object.keys(declaration)) if (!['hfs', 'kind', 'project'].includes(key)) bad.push(`unknown key ${key} (a runtime declaration is {hfs, kind, project})`);
+    for (const key of Object.keys(declaration)) if (!RUNTIME_DECLARATION_KEYS.has(key)) bad.push(`unknown key ${key} (a runtime declaration is {hfs, kind, project})`);
     return bad;
   }
-  for (const key of Object.keys(declaration)) if (!['hfs', 'kind', 'project', 'edition', 'supabase', 'sides', 'browser'].includes(key)) bad.push(`unknown key ${key}`);
-  bad.push(...supabaseBlockProblems(declaration.supabase));
-  if (declaration.browser !== undefined && declaration.browser !== true) bad.push('browser is `true` when the app has a browser journey (slot app.browser), and is left out otherwise');
-  if (declaration.kind !== APP_KIND) bad.push(`kind must be ${APP_KIND} (a product is one app repository with a be and an fe side) or ${RUNTIME_KIND} (the StarCi runtime repository)`);
-  if (!isPlainObject(declaration.sides) || Object.keys(declaration.sides).sort().join() !== profiles.join()) { bad.push('sides must declare exactly be and fe'); return bad; }
-  const names = new Map();
-  for (const side of profiles) {
-    const value = declaration.sides[side];
-    const at = `sides.${side}`;
-    if (!isPlainObject(value)) { bad.push(`${at} must be an object`); continue; }
-    for (const key of Object.keys(value)) if (!['apps', 'optionalSlots', 'patterns', 'kinds', 'connections', 'reads'].includes(key)) bad.push(`${at} has unknown key ${key}`);
-    if (!Array.isArray(value.apps) || !value.apps.length) bad.push(`${at}.apps must list every ${side}/apps/<name> with its kind`);
-    else value.apps.forEach((app, index) => {
-      if (!isPlainObject(app) || !NAME.test(String(app.name)) || !NAME.test(String(app.kind)) || Object.keys(app).some((key) => key !== 'name' && key !== 'kind')) bad.push(`${at}.apps[${index}] must be {name, kind}`);
-      else if (names.has(app.name)) bad.push(`app ${app.name} is declared twice (${names.get(app.name)} and ${side})`);
-      else names.set(app.name, side);
-    });
-    if (value.optionalSlots !== undefined && (!Array.isArray(value.optionalSlots) || !value.optionalSlots.every((slot) => SLOT_ID.test(String(slot))) || new Set(value.optionalSlots).size !== value.optionalSlots.length)) bad.push(`${at}.optionalSlots must be a unique list of slot ids`);
-    bad.push(...patternShapeProblems(value, at, NAME), ...kindShapeProblems(value, at, NAME));
-    if (value.reads !== undefined && (!Array.isArray(value.reads) || !value.reads.every((read) => typeof read === 'string' && read.length > 0) || new Set(value.reads).size !== value.reads.length)) bad.push(`${at}.reads must be a unique list of paths`);
-    if (value.connections !== undefined) {
-      if (side !== 'be') { bad.push('connections belong to the be side'); continue; }
-      const list = Array.isArray(value.connections) ? value.connections : null;
-      const shape = connectionShapeProblems(list, value.apps);
-      if (shape.length) bad.push(...shape);
-      else {
-        if (new Set(list.map((connection) => connection.name)).size !== list.length) bad.push('connections names must be unique');
-        for (const a of list) for (const b of list) if (a !== b && `${b.envPrefix}_`.startsWith(`${a.envPrefix}_`)) bad.push(`connections ${a.name} and ${b.name} share env keys (${a.envPrefix}_ covers ${b.envPrefix}_)`);
-      }
-    }
-  }
+  bad.push(...productDeclarationProblems(declaration, profiles));
   return bad;
 }

package/runtime/scripts/hfs/declaration-slots.mjs

@@ -8,7 +8,7 @@ export function optionalSlotProblems(manifest, side, s) {
   const bad = [];
   for (const id of s.optionalSlots ?? []) {
     const slot = manifest.slots.find((candidate) => candidate.id === id);
-    if (!slot || !slot.profiles.includes(side)) bad.push(`sides.${side}.optionalSlots names ${id}, which is not a ${side} slot`);
+    if (!slot?.profiles.includes(side)) bad.push(`sides.${side}.optionalSlots names ${id}, which is not a ${side} slot`);
     else if (slot.presence !== 'opt-in') bad.push(`sides.${side}.optionalSlots names ${id}, which is ${slot.presence}, not opt-in`);
     else if (slot.appKind !== undefined) bad.push(`sides.${side}.optionalSlots names ${id}; an app of kind ${slot.appKind} enables it`);
   }

package/runtime/scripts/hfs/edition-slots.mjs

@@ -20,8 +20,10 @@ export function effectiveSlot(slot, profile, edition) {
   if (edition !== 'lite') return slot;
   const { lite, litePresence, ...base } = slot;
   const presence = litePresenceOf(slot, profile);
-  const tracked = presence === 'forbidden' ? 'external' : (slot.tracked === 'external' ? 'tracked' : slot.tracked);
-  return { ...base, ...(lite ?? {}), presence, tracked, tests: 'none' };
+  let tracked = slot.tracked;
+  if (presence === 'forbidden') tracked = 'external';
+  else if (tracked === 'external') tracked = 'tracked';
+  return { ...base, ...lite, presence, tracked, tests: 'none' };
 }
 
 /** The template group starci app sync renders `slot` from under `edition`: `liteManagedBy` (else `managedBy`) in lite, `managedBy` otherwise; undefined when unmanaged. */
@@ -61,6 +63,6 @@ export function enforcerJudgedInEdition(rules, kind, id, edition = 'full') {
 export function editionRuleParams(params, edition) {
   const { lite, ...base } = params;
   const merged = edition === 'lite' && lite ? { ...base, ...lite } : base;
-  const deepFreeze = (value) => { if (value && typeof value === 'object') Object.values(value).forEach(deepFreeze); return Object.freeze(value); };
+  const deepFreeze = (value) => { if (value && typeof value === 'object') { Object.values(value).forEach(deepFreeze); } return Object.freeze(value); };
   return deepFreeze(structuredClone(merged));
 }

package/runtime/scripts/hfs/linear-text.mjs

@@ -0,0 +1,30 @@
+// Linear-time text trimming and `<placeholder>` replacement for the HFS path and prose checks.
+
+/** `text` without its trailing characters that are in `chars`. */
+export function trimTrailingChars(text, chars) {
+  let last = text.length - 1;
+  while (last >= 0 && chars.includes(text[last])) last -= 1;
+  return text.slice(0, last + 1);
+}
+
+/** `text` with every `<name>` placeholder (a `<`, one or more characters other than `>`, a `>`) replaced by `replacement`. */
+export function replacePlaceholders(text, replacement) {
+  let out = '';
+  let from = 0;
+  let open = text.indexOf('<');
+  while (open >= 0) {
+    const close = text.indexOf('>', open + 1);
+    if (close < 0) break;
+    if (close === open + 1) {
+      open = text.indexOf('<', close);
+    } else {
+      out += text.slice(from, open) + replacement;
+      from = close + 1;
+      open = text.indexOf('<', from);
+    }
+  }
+  return out + text.slice(from);
+}
+
+/** Whether `text` holds a `<name>` placeholder. */
+export const hasPlaceholder = (text) => replacePlaceholders(text, '') !== text;