@timmy6942025/cli-timer 1.1.8 → 1.1.10

package/README.md

@@ -76,6 +76,7 @@ timer style <font>
 ```
 
 Replace `<font>` with any font name from the list shown by `timer style`.
+If a font is missing native timer digits, CLI Timer now substitutes close glyphs so the display stays stylized instead of falling back to plain text.
 
 ## Settings UI
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@timmy6942025/cli-timer",
-  "version": "1.1.8",
+  "version": "1.1.10",
   "description": "Simple customizable terminal timer and stopwatch",
   "main": "src/index.js",
   "bin": {

package/src/index.js

@@ -12,6 +12,23 @@ const SETTINGS_STATE_PATH = path.join(CONFIG_DIR, "settings-state.json");
 const DEFAULT_FONT = "Standard";
 const TIMER_SAMPLE_TEXT = "01:23:45";
 const MIN_FIGLET_WIDTH = 120;
+const PRINTABLE_ASCII_CANDIDATES = Object.freeze(
+  Array.from({ length: 94 }, (_, index) => String.fromCharCode(33 + index))
+);
+const TIME_CHAR_FALLBACKS = Object.freeze({
+  "0": Object.freeze(["0", "O", "o", "Q", "D", "U", "X"]),
+  "1": Object.freeze(["1", "I", "l", "|", "!", "T", "X"]),
+  "2": Object.freeze(["2", "Z", "z", "S", "s", "X"]),
+  "3": Object.freeze(["3", "E", "e", "B", "b", "X"]),
+  "4": Object.freeze(["4", "A", "a", "H", "h", "X"]),
+  "5": Object.freeze(["5", "S", "s", "$", "X"]),
+  "6": Object.freeze(["6", "G", "g", "b", "X"]),
+  "7": Object.freeze(["7", "T", "t", "Y", "y", "X"]),
+  "8": Object.freeze(["8", "B", "b", "X"]),
+  "9": Object.freeze(["9", "g", "q", "P", "p", "X"]),
+  ":": Object.freeze([":", "|", "!", "i", "I", ".", ";", "X"])
+});
+const SYNTHETIC_FILL_CHARS = Object.freeze(["#", "@", "%", "&", "*", "+", "=", "~", "^", "$", "?"]);
 
 const MIN_TICK_RATE_MS = 50;
 const MAX_TICK_RATE_MS = 1000;
@@ -48,6 +65,9 @@ const DEFAULT_CONFIG = Object.freeze({
 
 let allFontsCache = null;
 let compatibleFontsSlowCache = null;
+const glyphCache = new Map();
+const tokenCandidatesCache = new Map();
+const syntheticFillCache = new Map();
 
 function clearScreen() {
   process.stdout.write("\x1b[2J\x1b[H");
@@ -86,6 +106,21 @@ function hasVisibleGlyphs(text) {
   return typeof text === "string" && /[^\s]/.test(text);
 }
 
+function significantLines(text) {
+  const lines = toDisplayLines(text).map((line) => line.trim());
+  return lines.filter((line) => line.length > 0);
+}
+
+function isPlainTimerRender(rendered, timeText) {
+  const lines = significantLines(rendered);
+  return lines.length === 1 && lines[0] === String(timeText).trim();
+}
+
+function isPlainGlyphRender(rendered, token) {
+  const lines = significantLines(rendered);
+  return lines.length === 1 && lines[0] === String(token).trim();
+}
+
 function renderWithFont(text, fontName) {
   const width = Number.isFinite(process.stdout.columns)
     ? Math.max(MIN_FIGLET_WIDTH, Math.floor(process.stdout.columns))
@@ -104,8 +139,117 @@ function renderWithFont(text, fontName) {
   }
 }
 
+function glyphCacheKey(fontName, token) {
+  return `${fontName}\u0000${token}`;
+}
+
+function tokenCandidates(token) {
+  if (tokenCandidatesCache.has(token)) {
+    return tokenCandidatesCache.get(token);
+  }
+  const seeded = TIME_CHAR_FALLBACKS[token] || [token];
+  const all = [...new Set([...seeded, ...PRINTABLE_ASCII_CANDIDATES])];
+  tokenCandidatesCache.set(token, all);
+  return all;
+}
+
+function glyphFromRendered(rendered) {
+  const lines = toDisplayLines(rendered);
+  const width = lines.reduce((max, line) => Math.max(max, line.length), 0);
+  return { lines, width };
+}
+
+function hashString(value) {
+  let hash = 2166136261;
+  for (const ch of String(value)) {
+    hash ^= ch.charCodeAt(0);
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash >>> 0;
+}
+
+function syntheticFillCharForFont(fontName) {
+  if (syntheticFillCache.has(fontName)) {
+    return syntheticFillCache.get(fontName);
+  }
+  const fill = SYNTHETIC_FILL_CHARS[hashString(fontName) % SYNTHETIC_FILL_CHARS.length];
+  syntheticFillCache.set(fontName, fill);
+  return fill;
+}
+
+function synthesizeGlyph(fontName, token) {
+  const baseline = getRenderableGlyph(DEFAULT_FONT, token);
+  if (!baseline) {
+    return null;
+  }
+  const fill = syntheticFillCharForFont(fontName);
+  const lines = baseline.lines.map((line) => line.replace(/[^\s]/g, fill));
+  const width = lines.reduce((max, line) => Math.max(max, line.length), 0);
+  return { lines, width };
+}
+
+function getRenderableGlyph(fontName, token) {
+  const cacheKey = glyphCacheKey(fontName, token);
+  if (glyphCache.has(cacheKey)) {
+    return glyphCache.get(cacheKey);
+  }
+
+  const options = tokenCandidates(token);
+  for (const candidate of options) {
+    const rendered = renderWithFont(candidate, fontName);
+    if (hasVisibleGlyphs(rendered) && !isPlainGlyphRender(rendered, candidate)) {
+      const glyph = glyphFromRendered(rendered);
+      glyphCache.set(cacheKey, glyph);
+      return glyph;
+    }
+  }
+
+  glyphCache.set(cacheKey, null);
+  return null;
+}
+
+function renderTimeByGlyphs(timeText, fontName) {
+  const glyphs = [];
+  for (const token of String(timeText)) {
+    const preferred = getRenderableGlyph(fontName, token);
+    if (preferred) {
+      glyphs.push(preferred);
+      continue;
+    }
+
+    if (fontName !== DEFAULT_FONT) {
+      const synthesized = synthesizeGlyph(fontName, token);
+      if (synthesized) {
+        glyphs.push(synthesized);
+        continue;
+      }
+    }
+
+    const fallback = getRenderableGlyph(DEFAULT_FONT, token);
+    if (!fallback) {
+      return "";
+    }
+    glyphs.push(fallback);
+  }
+
+  const maxHeight = glyphs.reduce((max, glyph) => Math.max(max, glyph.lines.length), 0);
+  const outputLines = [];
+  for (let row = 0; row < maxHeight; row += 1) {
+    const parts = glyphs.map((glyph) => {
+      const padTop = maxHeight - glyph.lines.length;
+      const sourceIndex = row - padTop;
+      const line = sourceIndex >= 0 ? glyph.lines[sourceIndex] || "" : "";
+      return line.padEnd(glyph.width, " ");
+    });
+    outputLines.push(parts.join(" ").replace(/\s+$/g, ""));
+  }
+
+  return `${outputLines.join("\n")}\n`;
+}
+
 function isTimerCompatibleFont(fontName) {
-  return hasVisibleGlyphs(renderWithFont(TIMER_SAMPLE_TEXT, fontName));
+  const rendered = renderWithFont(TIMER_SAMPLE_TEXT, fontName);
+  return hasVisibleGlyphs(rendered) && !isPlainTimerRender(rendered, TIMER_SAMPLE_TEXT);
 }
 
 function getTimerCompatibleFontsSlow() {
@@ -240,7 +384,7 @@ function normalizeConfig(raw) {
     next.keybindings = normalizeKeybindings(raw.keybindings);
     if (typeof raw.font === "string") {
       const normalizedFont = normalizeFontName(raw.font);
-      if (normalizedFont && isTimerCompatibleFont(normalizedFont)) {
+      if (normalizedFont) {
         next.font = normalizedFont;
       }
     }
@@ -284,9 +428,6 @@ function setFontInConfig(requestedFont) {
   if (!normalized) {
     return { ok: false, reason: "unknown", font: null };
   }
-  if (!isTimerCompatibleFont(normalized)) {
-    return { ok: false, reason: "incompatible", font: null };
-  }
   const updated = updateConfig({ font: normalized });
   return { ok: true, reason: null, font: updated.font };
 }
@@ -346,15 +487,25 @@ function parseDurationArgs(args) {
 
 function renderTimeAscii(timeText, fontName) {
   const preferred = renderWithFont(timeText, fontName);
-  if (hasVisibleGlyphs(preferred)) {
+  if (hasVisibleGlyphs(preferred) && !isPlainTimerRender(preferred, timeText)) {
     return preferred;
   }
 
+  const preferredByGlyph = renderTimeByGlyphs(timeText, fontName);
+  if (hasVisibleGlyphs(preferredByGlyph) && !isPlainTimerRender(preferredByGlyph, timeText)) {
+    return preferredByGlyph;
+  }
+
   const fallback = renderWithFont(timeText, DEFAULT_FONT);
-  if (hasVisibleGlyphs(fallback)) {
+  if (hasVisibleGlyphs(fallback) && !isPlainTimerRender(fallback, timeText)) {
     return fallback;
   }
 
+  const fallbackByGlyph = renderTimeByGlyphs(timeText, DEFAULT_FONT);
+  if (hasVisibleGlyphs(fallbackByGlyph)) {
+    return fallbackByGlyph;
+  }
+
   return `${timeText}\n`;
 }
 
@@ -704,7 +855,7 @@ function playCompletionAlarm(config) {
     return;
   }
   try {
-    process.stderr.write("\x07\x07\x07");
+    process.stderr.write("\x07".repeat(5));
   } catch (_error) {
   }
 }
@@ -1096,13 +1247,8 @@ function runTimer(args) {
     const requestedFont = args.slice(1).join(" ");
     const result = setFontInConfig(requestedFont);
     if (!result.ok) {
-      if (result.reason === "incompatible") {
-        process.stderr.write(`Font is incompatible with timer digits: ${requestedFont}\n`);
-      } else {
-        process.stderr.write(`Unknown font: ${requestedFont}\n`);
-      }
+      process.stderr.write(`Unknown font: ${requestedFont}\n`);
       process.stderr.write("Run `timer style` to list fonts.\n");
-      process.stderr.write("Run `timer style --compatible` to list only compatible fonts.\n");
       process.exitCode = 1;
       return;
     }