@twardoch/namzy 1.0.21 → 1.0.23

package/src/mangle.ts

@@ -1,8 +1,10 @@
 // this_file: src/mangle.ts
 
-import { ROTATIONS, STEMS } from "./wordlist.js";
+import { BAD_SEAMS, ROTATIONS, STEMS } from "./wordlist.js";
+
+const MAX_LEN = 12;
+const MAX_TRIES = 8;
 
-/** Seeded mulberry32 RNG — yields [0,1) floats. */
 export function mulberry32(seed: number): () => number {
   let s = seed >>> 0;
   return () => {
@@ -17,35 +19,65 @@ function pick<T>(arr: readonly T[], rng: () => number): T {
   return arr[Math.floor(rng() * arr.length)];
 }
 
-const ROT_MAP = new Map<string, string>(ROTATIONS as readonly (readonly [string, string])[]);
+function hasTripleLetter(s: string): boolean {
+  for (let i = 2; i < s.length; i++) {
+    if (s[i] === s[i - 1] && s[i] === s[i - 2]) return true;
+  }
+  return false;
+}
 
-function rotateAt(s: string, pos: number): string {
-  const ch = s[pos];
-  const lower = ch.toLowerCase();
-  const repl = ROT_MAP.get(lower);
-  if (repl === undefined) return s;
-  const out = ch === lower ? repl : repl.toUpperCase();
-  return s.slice(0, pos) + out + s.slice(pos + 1);
+function junctionUgly(compound: string, junction: number): boolean {
+  // Inspect the 4-char window centered on the junction.
+  const start = Math.max(0, junction - 2);
+  const end = Math.min(compound.length, junction + 2);
+  const win = compound.slice(start, end);
+  for (const seam of BAD_SEAMS) {
+    if (win.includes(seam)) return true;
+  }
+  return false;
 }
 
-/** Apply 1 or 2 rotations on randomly selected positions of the compound. */
-export function applyRotations(compound: string, rng: () => number): string {
-  if (compound.length === 0) return compound;
-  const passes = rng() < 0.5 ? 1 : 2;
-  let out = compound;
-  for (let i = 0; i < passes; i++) {
-    out = rotateAt(out, Math.floor(rng() * out.length));
+/** Apply one rotation at a randomly chosen matching position. */
+export function applyRotation(s: string, rng: () => number): string {
+  type Match = { i: number; src: string; dst: string };
+  const matches: Match[] = [];
+  for (let i = 0; i < s.length; i++) {
+    for (const [src, dst] of ROTATIONS) {
+      if (s.slice(i, i + src.length) === src) {
+        matches.push({ i, src, dst });
+      }
+    }
   }
-  return out;
+  if (matches.length === 0) return s;
+  const m = matches[Math.floor(rng() * matches.length)];
+  return s.slice(0, m.i) + m.dst + s.slice(m.i + m.src.length);
 }
 
 function capitalize(s: string): string {
   return s.length === 0 ? s : s[0].toUpperCase() + s.slice(1);
 }
 
-/** Build one name: any two stems, concatenated, lightly rotated, capitalized. */
+/** Build one name with junction validation + one rotation. */
 export function buildName(rng: () => number): string {
-  const a = pick(STEMS, rng);
-  const b = pick(STEMS, rng);
-  return capitalize(applyRotations(a + b, rng));
+  let best = "";
+  for (let attempt = 0; attempt < MAX_TRIES; attempt++) {
+    const a = pick(STEMS, rng);
+    const b = pick(STEMS, rng);
+    const compound = a + b;
+    if (compound.length > MAX_LEN) {
+      best = best || compound;
+      continue;
+    }
+    if (hasTripleLetter(compound)) {
+      best = best || compound;
+      continue;
+    }
+    if (junctionUgly(compound, a.length)) {
+      best = best || compound;
+      continue;
+    }
+    return capitalize(applyRotation(compound, rng));
+  }
+  // All attempts had some flaw; rotate and ship the first candidate anyway.
+  return capitalize(applyRotation(best, rng));
 }

package/src/web.ts

@@ -1,5 +1,5 @@
 // this_file: src/web.ts
 // Browser entry point — exposes namzy.generate() on window.namzy.
 
-export { generate, generateMany, applyRotations, buildName, mulberry32, STEMS, ROTATIONS } from "./index.js";
+export { generate, generateMany, applyRotation, buildName, mulberry32, STEMS, ROTATIONS } from "./index.js";
 export type { NamzyOptions } from "./index.js";