@twardoch/namzy 1.0.19 → 1.0.23

package/src/index.ts

@@ -1,35 +1,27 @@
 // this_file: src/index.ts
 
-import { activeRotationMask, joinClean, mangle, mulberry32 } from "./mangle.js";
-import { COMMON, GEO } from "./wordlist.js";
+import { applyRotation, buildName, mulberry32 } from "./mangle.js";
+import { ROTATIONS, STEMS } from "./wordlist.js";
 
 export interface NamzyOptions {
-	seed?: number;
+  seed?: number;
 }
 
-function capitalize(s: string): string {
-	return s.charAt(0).toUpperCase() + s.slice(1);
+/** Generate one namzy name. Default seed is the current timestamp. */
+export function generate(opts?: NamzyOptions): string {
+  const seed = opts?.seed ?? Date.now();
+  return buildName(mulberry32(seed));
 }
 
-function pick<T>(arr: T[], rng: () => number): T {
-	return arr[Math.floor(rng() * arr.length)];
+/** Generate `count` names. Distinct seeds derived from the base seed. */
+export function generateMany(count: number, opts?: NamzyOptions): string[] {
+  const base = opts?.seed ?? Date.now();
+  const out: string[] = [];
+  for (let i = 0; i < count; i++) {
+    out.push(generate({ seed: base + i * 2654435761 }));
+  }
+  return out;
 }
 
-/**
- * Generate a single fused, mangled namzy name.
- * Two raw words → junction-cleaned fusion → consonant rotation → capitalize.
- */
-export async function generate(opts?: NamzyOptions): Promise<string> {
-	const seed = opts?.seed ?? Date.now();
-	const rng = mulberry32(seed);
-
-	const w1 = pick(GEO, rng).toLowerCase();
-	const w2 = pick(COMMON, rng).toLowerCase();
-	const [first, second] = rng() < 0.5 ? [w1, w2] : [w2, w1];
-
-	const fused = joinClean(first, second);
-	return capitalize(mangle(fused, activeRotationMask(rng)));
-}
-
-export { COMMON, GEO } from "./wordlist.js";
-export { activeRotationMask, joinClean, mangle, mulberry32 };
+export { STEMS, ROTATIONS } from "./wordlist.js";
+export { applyRotation, buildName, mulberry32 };

package/src/mangle.ts

@@ -1,92 +1,83 @@
 // this_file: src/mangle.ts
 
-/** Simple seeded mulberry32 RNG — returns a function that yields [0,1) floats */
+import { BAD_SEAMS, ROTATIONS, STEMS } from "./wordlist.js";
+
+const MAX_LEN = 12;
+const MAX_TRIES = 8;
+
 export function mulberry32(seed: number): () => number {
   let s = seed >>> 0;
   return () => {
-    s += 0x6d2b79f5;
+    s = (s + 0x6d2b79f5) >>> 0;
     let t = Math.imul(s ^ (s >>> 15), 1 | s);
     t ^= t + Math.imul(t ^ (t >>> 7), 61 | t);
     return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
   };
 }
 
-type RotationRule = readonly [from: string, to: string];
-
-export const ROTATION_RULES: readonly RotationRule[] = [
-  ["c", "q"],
-  ["f", "v"],
-  ["k", "c"],
-  ["q", "k"],
-  ["s", "z"],
-  ["z", "s"],
-  ["v", "f"],
-  ["w", "u"],
-  ["b", "p"],
-  ["p", "b"],
-];
-
-const ALL_ROTATIONS = (1 << ROTATION_RULES.length) - 1;
+function pick<T>(arr: readonly T[], rng: () => number): T {
+  return arr[Math.floor(rng() * arr.length)];
+}
 
-function rotationFor(lower: string, activeMask: number): string | undefined {
-  for (let i = 0; i < ROTATION_RULES.length; i++) {
-    if ((activeMask & (1 << i)) === 0) {
-      continue;
-    }
-    const [from, to] = ROTATION_RULES[i];
-    if (lower === from) {
-      return to;
-    }
+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 undefined;
+  return false;
 }
 
-/** Choose 1..10 active consonant-rotation rules from the seeded RNG. */
-export function activeRotationMask(rng: () => number): number {
-  const order = ROTATION_RULES.map((_, i) => i);
-  const activeCount = 1 + Math.floor(rng() * ROTATION_RULES.length);
-  for (let i = 0; i < activeCount; i++) {
-    const swap = i + Math.floor(rng() * (order.length - i));
-    [order[i], order[swap]] = [order[swap], order[i]];
+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 order.slice(0, activeCount).reduce((mask, i) => mask | (1 << i), 0);
+  return false;
 }
 
-/** Consonant rotation. Case-preserving. Defaults to all rules for direct helper use. */
-export function mangle(s: string, activeMask = ALL_ROTATIONS): string {
-  let out = "";
-  for (const ch of s) {
-    const lower = ch.toLowerCase();
-    const repl = rotationFor(lower, activeMask);
-    if (repl === undefined) {
-      out += ch;
-    } else {
-      out += ch === lower ? repl : repl.toUpperCase();
+/** 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);
 }
 
-const VOWELS = new Set(["a", "e", "i", "o", "u", "y"]);
+function capitalize(s: string): string {
+  return s.length === 0 ? s : s[0].toUpperCase() + s.slice(1);
+}
 
-/**
- * Fuse two lowercase words at a clean junction.
- * Drops the first char of `b` while it duplicates the tail of `a`,
- * or while the seam is vowel-vowel. Max two trims.
- */
-export function joinClean(a: string, b: string): string {
-  const head = a;
-  let tail = b;
-  for (let i = 0; i < 2 && head.length > 0 && tail.length > 0; i++) {
-    const last = head[head.length - 1].toLowerCase();
-    const first = tail[0].toLowerCase();
-    if (last === first) {
-      tail = tail.slice(1);
-    } else if (VOWELS.has(last) && VOWELS.has(first)) {
-      tail = tail.slice(1);
-    } else {
-      break;
+/** Build one name with junction validation + one rotation. */
+export function buildName(rng: () => number): string {
+  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));
   }
-  return head + tail;
+  // 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, mangle, joinClean, mulberry32, GEO, COMMON } from "./index.js";
+export { generate, generateMany, applyRotation, buildName, mulberry32, STEMS, ROTATIONS } from "./index.js";
 export type { NamzyOptions } from "./index.js";