@keyline-icons/cli 0.2.0 → 0.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@keyline-icons/cli",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "Search Keyline Icons and copy them into your project from the terminal.",
   "license": "MIT",
   "publishConfig": {

package/src/index.mjs

@@ -22,9 +22,11 @@ import { existsSync } from "node:fs"
 const data = JSON.parse(
   await readFile(new URL("../icons.json", import.meta.url), "utf8")
 )
-const { icons, styles, keywords = {} } = data
+// `corners` defaults for a bundle generated before the axis existed, so an
+// older icons.json still runs rather than reading `undefined.includes`.
+const { icons, styles, corners = ["regular"], keywords = {} } = data
 const NAMES = Object.keys(icons)
-const VERSION = "0.2.0"
+const VERSION = "0.4.0"
 
 /** Colour only when a human is looking. Piped output stays clean. */
 const tty = process.stdout.isTTY
@@ -49,7 +51,7 @@ function die(msg) {
  * positional, which is what lets `add a b c --style fill` work in any order.
  */
 function parseArgs(argv) {
-  const alias = { s: "style", o: "out", l: "limit", h: "help", v: "version" }
+  const alias = { s: "style", c: "corners", o: "out", l: "limit", h: "help", v: "version" }
   const flags = {}
   const positional = []
   for (let i = 0; i < argv.length; i++) {
@@ -89,10 +91,25 @@ const styleOf = (flags) => {
   return s
 }
 
+const cornersOf = (flags) => {
+  const k = flags.corners ?? "regular"
+  if (!corners.includes(k))
+    die(`unknown corner treatment \`${k}\`. One of: ${corners.join(", ")}`)
+  return k
+}
+
 /* ------------------------------------------------------------------ icons */
 
-function svgFor(name, style) {
-  const art = icons[name]?.[style]
+/**
+ * A drawing in one style and one treatment.
+ *
+ * The rounded half sits at `icons[name][style]` where it has always sat, and
+ * the sharp half one level down under `sharp`, so a project pinned to an older
+ * bundle reads the same shape it read before.
+ */
+function svgFor(name, style, corners = "regular") {
+  const art =
+    corners === "sharp" ? icons[name]?.sharp?.[style] : icons[name]?.[style]
   if (!art) return null
   const attrs = Object.entries(art.root)
     .map(([k, v]) => ` ${k}="${v}"`)
@@ -142,6 +159,54 @@ function keywordsFor(name) {
 
 const haystackFor = (name) => `${name} ${keywordsFor(name).join(" ")}`
 
+/**
+ * A word reduced to its singular, so a plural finds the family.
+ *
+ * Every name in the set is singular: `arrow-down`, `file`, `bar-chart`. Every
+ * heading on the site's category rail is plural. So "Arrows" sat on the screen
+ * while typing `arrows` returned one drawing out of 585, `git-compare-arrows`,
+ * the only name carrying the letter. `charts`, `stars` and `bells` returned
+ * nothing at all. The plural is what someone reads off our own sidebar and
+ * what every other set answers, and here it was the one word that could not
+ * work.
+ *
+ * Applied to both sides, the query word and each word of the haystack, which
+ * also carries the other direction: `chevron` reaches `chevrons-left`, which
+ * whole words alone could not.
+ *
+ * Deliberately blunt: no dictionary, no suffix ladder, one `s`. The guards are
+ * the whole design, and they are read off this vocabulary rather than guessed.
+ * Every `-ss`, `-us` and `-is` word in it is already a word: `progress`,
+ * `compass`, `plus`, `minus`, `status`, `axis`. Past those, `lens`, `atlas`
+ * and `sideways` are the only three that end in `s` without being a plural.
+ * `lens` is the one that mattered. Cut to `len` it lands inside `calendar` and
+ * `silence`, and the word someone types for the camera came back with
+ * seventeen drawings that are not it.
+ *
+ * `arrows` is in the list for the opposite reason. The rule would not damage
+ * it, it would erase it: the plural asks for the drawings carrying more than
+ * one arrowhead, `fullscreen`, `chevrons-up-down`, `refresh-cw`, and folding it
+ * into `arrow` answers with the ninety-nine single arrows instead. The word is
+ * a keyword on those drawings, in lib/icon-aliases.json, and this is what keeps
+ * the two questions apart.
+ *
+ * Same rule as the site, the MCP server and the Figma plugin, checked by
+ * pipeline/check-search.mjs.
+ */
+const singular = (w) =>
+  w.length < 4 ||
+  !w.endsWith("s") ||
+  /(ss|us|is|arrows|lens|atlas|sideways)$/.test(w)
+    ? w
+    : w.endsWith("ies")
+      ? `${w.slice(0, -3)}y`
+      : /(ch|sh|x|z)es$/.test(w)
+        ? w.slice(0, -2)
+        : w.slice(0, -1)
+
+/** Every word in `hay` singular, delimiters kept so `wholeWord` still works. */
+const stemmed = (hay) => hay.replace(/[a-z0-9]+/g, singular)
+
 /**
  * What another set calls a drawing here: `message-square` for `message`,
  * `arrow-big-up` for `arrow-up`, `loader-2` for `loader`.
@@ -181,18 +246,24 @@ const wholeWord = (hay, needle) => {
   return false
 }
 
-function search(query, style, limit) {
+/** Whether one haystack answers every word of a query, whole words only. */
+const answers = (hay, words) =>
+  words.every(
+    (w) => wholeWord(hay, w) || wholeWord(stemmed(hay), singular(w))
+  )
+
+function search(query, style, limit, corners = "regular") {
   const q = query.toLowerCase().trim()
   const words = wordsOf(query)
   if (!words.length) return []
 
   return NAMES.filter(
     (n) =>
-      (!style || icons[n][style]) &&
+      (!style || svgFor(n, style, corners)) &&
       (foreign[q] === n ||
         wholeWord(n, q) ||
-        words.every((w) => wholeWord(n, w)) ||
-        words.every((w) => wholeWord(haystackFor(n), w)))
+        answers(n, words) ||
+        answers(haystackFor(n), words))
   )
     .map((n) => {
       const rank =
@@ -204,7 +275,7 @@ function search(query, style, limit) {
               ? 2
               : wholeWord(n, q)
                 ? 3
-                : words.every((w) => wholeWord(n, w))
+                : answers(n, words)
                   ? 4
                   : 5
       return { n, rank }
@@ -255,17 +326,20 @@ function nearest(name) {
     .map((h) => h.n)
 }
 
-function resolveOrDie(name, style) {
+function resolveOrDie(name, style, corners = "regular") {
   if (!icons[name]) {
     const near = nearest(name)
     die(
       `no icon named \`${name}\`.${near.length ? ` Did you mean: ${near.join(", ")}?` : ""}`
     )
   }
-  const svg = svgFor(name, style)
+  const svg = svgFor(name, style, corners)
   if (!svg) {
+    // `Object.keys` would list `sharp` here as though it were a fourth style,
+    // which is the axis leaking into a sentence about coverage.
+    const has = styles.filter((s) => svgFor(name, s, corners))
     die(
-      `\`${name}\` has no ${style} style. It has: ${Object.keys(icons[name]).join(", ")}.\n` +
+      `\`${name}\` has no ${style} style. It has: ${has.join(", ")}.\n` +
         `      Duotone and fill need a fillable region, and this glyph has none.`
     )
   }
@@ -288,13 +362,14 @@ ${bold("COMMANDS")}
 
 ${bold("OPTIONS")}
   -s, --style <s>    ${styles.join(" | ")}   (default: stroke)
+  -c, --corners <c>  ${corners.join(" | ")}          (default: regular)
   -o, --out <dir>    Where \`add\` writes         (default: ./icons)
   -l, --limit <n>    Max results for \`search\`   (default: 25)
 
 ${bold("EXAMPLES")}
   keyline-icons search arrow
   keyline-icons search mail --style fill
-  keyline-icons show check > check.svg
+  keyline-icons show check --corners sharp > check-sharp.svg
   keyline-icons add circle-arrow-down bell --out src/icons
   keyline-icons list | grep chart
 
@@ -309,7 +384,8 @@ const commands = {
 
   list({ flags }) {
     const style = flags.style ? styleOf(flags) : null
-    const names = style ? NAMES.filter((n) => icons[n][style]) : NAMES
+    const treatment = cornersOf(flags)
+    const names = style ? NAMES.filter((n) => svgFor(n, style, treatment)) : NAMES
     for (const n of names) out(n)
     note(dim(`\n${names.length} icons${style ? ` in ${style}` : ""}`))
   },
@@ -329,7 +405,7 @@ const commands = {
        is not a number at all earns the default. */
     const raw = parseInt(flags.limit ?? "25", 10)
     const limit = Math.min(Math.max(Number.isNaN(raw) ? 25 : raw, 1), 200)
-    const hits = search(query, style, limit)
+    const hits = search(query, style, limit, cornersOf(flags))
     if (!hits.length) {
       const near = nearest(query)
       die(
@@ -337,7 +413,7 @@ const commands = {
       )
     }
     for (const n of hits) {
-      const has = styles.filter((s) => icons[n][s])
+      const has = styles.filter((s) => svgFor(n, s, cornersOf(flags)))
       out(`${n}${tty ? "  " + dim(`[${has.join(", ")}]`) : ""}`)
     }
     note(dim(`\n${hits.length} shown${style ? ` in ${style}` : ""}`))
@@ -346,17 +422,27 @@ const commands = {
   show({ flags, positional }) {
     const [name] = positional
     if (!name) die("show needs an icon name. Try: keyline-icons show check")
-    process.stdout.write(resolveOrDie(name, styleOf(flags)))
+    process.stdout.write(resolveOrDie(name, styleOf(flags), cornersOf(flags)))
   },
 
   async add({ flags, positional }) {
     if (!positional.length) die("add needs at least one icon name.")
     const style = styleOf(flags)
+    const treatment = cornersOf(flags)
     const dir = resolve(flags.out === true || !flags.out ? "icons" : flags.out)
 
+    // The treatment rides in the filename, for the reason the style does not:
+    // two treatments of one drawing are the same name and the same style, so
+    // adding both would otherwise write one file twice and leave whichever ran
+    // last. Rounded keeps the bare name, which is what everyone means by it.
+    const suffix = treatment === "regular" ? "" : `-${treatment}`
+
     // Every name is resolved before anything is written, so a typo in the
     // third of five does not leave two files on disk and an error.
-    const files = positional.map((name) => [name, resolveOrDie(name, style)])
+    const files = positional.map((name) => [
+      `${name}${suffix}`,
+      resolveOrDie(name, style, treatment),
+    ])
 
     await mkdir(dir, { recursive: true })
     for (const [name, svg] of files) {
@@ -369,7 +455,8 @@ const commands = {
     }
     note(
       dim(
-        `\n${files.length} ${style} icon${files.length === 1 ? "" : "s"} to ${dir}`
+        `\n${files.length} ${treatment === "sharp" ? "sharp " : ""}${style} ` +
+          `icon${files.length === 1 ? "" : "s"} to ${dir}`
       )
     )
   },