fx 30.0.3 → 30.1.1

package/index.js

@@ -18,6 +18,7 @@ void async function main() {
   }
   if (flagHelp || (args.length === 0 && process.stdin.isTTY))
     return printUsage()
+  const theme = themes(process.stdout.isTTY ? (process.env.FX_THEME || '1') : '0')
   await importFxrc(process.cwd())
   await importFxrc(os.homedir())
   let fd = 0 // stdin
@@ -35,17 +36,17 @@ void async function main() {
     for (const json of input) {
       array.push(json)
     }
-    await runTransforms(array, args)
+    await runTransforms(array, args, theme)
   } else {
     for (const json of input) {
-      await runTransforms(json, args)
+      await runTransforms(json, args, theme)
     }
   }
 }()
 
 const skip = Symbol('skip')
 
-async function runTransforms(json, args) {
+async function runTransforms(json, args, theme) {
   const process = await import('node:process')
   let i, code, output = json
   for ([i, code] of args.entries()) try {
@@ -62,7 +63,7 @@ async function runTransforms(json, args) {
   else if (output === skip)
     return
   else
-    console.log(stringify(output, process.stdout.isTTY))
+    console.log(stringify(output, theme))
 
   function printErr(err) {
     let pre = args.slice(0, i).join(' ')
@@ -89,6 +90,14 @@ async function transform(json, code) {
       return (${fold(code.split('[]'))})(this)
     })`).call(json)
 
+  function fold(s) {
+    if (s.length === 1)
+      return 'x => x' + s[0]
+    let obj = s.shift()
+    obj = obj === '.' ? 'x' : 'x' + obj
+    return `x => Object.values(${obj}).flatMap(${fold(s)})`
+  }
+
   if (/^\.\[/.test(code))
     return eval(`(function () {
       return this${code.substring(1)}
@@ -99,7 +108,7 @@ async function transform(json, code) {
       return this${code}
     })`).call(json)
 
-  if (/^map\(.+?\)$/.test(code)) {
+  if (/^[a-z]+\(.+?\)$/i.test(code)) {
     let s = code.substring(4, code.length - 1)
     if (s[0] === '.') s = 'x' + s
     return eval(`(function () {
@@ -112,36 +121,48 @@ async function transform(json, code) {
     return ${code}
   })`).call(json)
 
-  return apply(fn, json)
-
   function apply(fn, ...args) {
     if (typeof fn === 'function') return fn(...args)
     return fn
   }
 
-  function fold(s) {
-    if (s.length === 1)
-      return 'x => x' + s[0]
-    let obj = s.shift()
-    obj = obj === '.' ? 'x' : 'x' + obj
-    return `x => Object.values(${obj}).flatMap(${fold(s)})`
+  return apply(fn, json)
+
+  function len(x) {
+    if (Array.isArray(x)) return x.length
+    if (typeof x === 'string') return x.length
+    if (typeof x === 'object' && x !== null) return Object.keys(x).length
+    throw new Error(`Cannot get length of ${typeof x}`)
   }
 
-  function uniq(array) {
-    return [...new Set(array)]
+  function uniq(x) {
+    if (Array.isArray(x)) return [...new Set(x)]
+    throw new Error(`Cannot get unique values of ${typeof x}`)
   }
 
-  function sort(array) {
-    return array.sort()
+  function sort(x) {
+    if (Array.isArray(x)) return x.sort()
+    throw new Error(`Cannot sort ${typeof x}`)
+  }
+
+  function sortBy(func) {
+    return function (x) {
+      if (Array.isArray(x)) return x.sort((a, b) => {
+        const fa = func(a)
+        const fb = func(b)
+        return fa < fb ? -1 : fa > fb ? 1 : 0
+      })
+      throw new Error(`Cannot sort ${typeof x}`)
+    }
   }
 
-  function groupBy(keyOrFunction) {
-    return array => {
+  function groupBy(keyFn) {
+    return function (x) {
       const grouped = {}
-      for (const item of array) {
-        const key = typeof keyOrFunction === 'function'
-          ? keyOrFunction(item)
-          : item[keyOrFunction]
+      for (const item of x) {
+        const key = typeof keyFn === 'function'
+          ? keyFn(item)
+          : item[keyFn]
         if (!grouped.hasOwnProperty(key))
           grouped[key] = []
         grouped[key].push(item)
@@ -151,24 +172,34 @@ async function transform(json, code) {
   }
 
   function chunk(size) {
-    return function (arr) {
+    return function (x) {
       const res = []
       let i = 0
-      while (i < arr.length) {
-        res.push(arr.slice(i, i += size))
+      while (i < x.length) {
+        res.push(x.slice(i, i += size))
       }
       return res
     }
   }
 
-  function zip(...arrays) {
-    const length = Math.min(...arrays.map(a => a.length))
+  function zip(...x) {
+    const length = Math.min(...x.map(a => a.length))
     const res = []
     for (let i = 0; i < length; i++) {
-      res.push(arrays.map(a => a[i]))
+      res.push(x.map(a => a[i]))
     }
     return res
   }
+
+  function flatten(x) {
+    if (Array.isArray(x)) return x.flat()
+    throw new Error(`Cannot flatten ${typeof x}`)
+  }
+
+  function reverse(x) {
+    if (Array.isArray(x)) return x.reverse()
+    throw new Error(`Cannot reverse ${typeof x}`)
+  }
 }
 
 async function read(fd = 0) {
@@ -520,14 +551,10 @@ function* parseJson(gen) {
   }
 }
 
-function stringify(value, isPretty = false) {
-  const colors = {
-    key: isPretty ? '\x1b[1;34m' : '',
-    string: isPretty ? '\x1b[32m' : '',
-    number: isPretty ? '\x1b[36m' : '',
-    boolean: isPretty ? '\x1b[35m' : '',
-    null: isPretty ? '\x1b[38;5;243m' : '',
-    reset: isPretty ? '\x1b[0m' : '',
+function stringify(value, theme) {
+  function color(id, str) {
+    if (theme[id] === '') return str
+    return `\x1b[${theme[id]}m${str}\x1b[0m`
   }
 
   function getIndent(level) {
@@ -536,38 +563,35 @@ function stringify(value, isPretty = false) {
 
   function stringifyValue(value, level = 0) {
     if (typeof value === 'string') {
-      return `${colors.string}${JSON.stringify(value)}${colors.reset}`
+      return color(2, JSON.stringify(value))
     } else if (typeof value === 'number') {
-      return `${colors.number}${value}${colors.reset}`
+      return color(3, `${value}`)
     } else if (typeof value === 'bigint') {
-      return `${colors.number}${value}${colors.reset}`
+      return color(3, `${value}`)
     } else if (typeof value === 'boolean') {
-      return `${colors.boolean}${value}${colors.reset}`
+      return color(4, `${value}`)
     } else if (value === null || typeof value === 'undefined') {
-      return `${colors.null}null${colors.reset}`
+      return color(5, `null`)
     } else if (Array.isArray(value)) {
       if (value.length === 0) {
-        return `[]`
+        return color(0, `[]`)
       }
       const items = value
-        .map((v) => `${getIndent(level + 1)}${stringifyValue(v, level + 1)}`)
-        .join(',\n')
-      return `[\n${items}\n${getIndent(level)}]`
+        .map((v) => getIndent(level + 1) + stringifyValue(v, level + 1))
+        .join(color(0, ',') + '\n')
+      return color(0, '[') + '\n' + items + '\n' + getIndent(level) + color(0, ']')
     } else if (typeof value === 'object') {
       const keys = Object.keys(value)
       if (keys.length === 0) {
-        return `{}`
+        return color(0, '{}')
       }
       const entries = keys
-        .map(
-          (key) =>
-            `${getIndent(level + 1)}${colors.key}"${key}"${colors.reset}: ${stringifyValue(
-              value[key],
-              level + 1,
-            )}`,
+        .map((key) =>
+          getIndent(level + 1) + color(1, `"${key}"`) + color(0, ': ') +
+          stringifyValue(value[key], level + 1),
         )
-        .join(',\n')
-      return `{\n${entries}\n${getIndent(level)}}`
+        .join(color(0, ',') + '\n')
+      return color(0, '{') + '\n' + entries + '\n' + getIndent(level) + color(0, '}')
     }
     throw new Error(`Unsupported value type: ${typeof value}`)
   }
@@ -575,6 +599,23 @@ function stringify(value, isPretty = false) {
   return stringifyValue(value)
 }
 
+function themes(id) {
+  const themes = {
+    '0': ['', '', '', '', '', ''],
+    '1': ['', '1;34', '32', '36', '35', '38;5;243'],
+    '2': ['', '32', '34', '36', '35', '38;5;243'],
+    '3': ['', '95', '93', '96', '31', '38;5;243'],
+    '4': ['', '38;5;50', '38;5;39', '38;5;98', '38;5;205', '38;5;243'],
+    '5': ['', '38;5;230', '38;5;221', '38;5;209', '38;5;209', '38;5;243'],
+    '6': ['', '38;5;69', '38;5;78', '38;5;221', '38;5;203', '38;5;243'],
+    '7': ['', '1;38;5;42', '1;38;5;213', '1;38;5;201', '1;38;5;201', '38;5;243'],
+    '8': ['', '1;38;5;51', '38;5;195', '38;5;123', '38;5;50', '38;5;243'],
+    '🔵': ['1;38;5;33', '38;5;33', '', '', '', ''],
+    '🥝': ['38;5;179', '1;38;5;154', '38;5;82', '38;5;226', '38;5;226', '38;5;230'],
+  }
+  return themes[id] || themes['1']
+}
+
 async function importFxrc(path) {
   const {join} = await import('node:path')
   const {pathToFileURL} = await import('node:url')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fx",
-  "version": "30.0.3",
+  "version": "30.1.1",
   "bin": {
     "fx": "index.js"
   },