fx 26.0.0 → 28.0.0

package/README.md

@@ -1,6 +1,7 @@
 # fx
 
-The JavaScript version of the **fx**. Short for _Function eXecution_ or _f(x)_.
+A non-interactive, JavaScript version of the [**fx**](https://fx.wtf). 
+Short for _Function eXecution_ or _f(x)_.
 
 ```sh
 npm i -g fx
@@ -44,11 +45,56 @@ echo '{"name": "world"}' | fx '.name' '`Hello, ${this}!`'
 Use other JS functions to process the data.
 
 ```sh
-echo `{"name": "world"}` | fx 'Object.keys'
+echo '{"name": "world"}' | fx 'Object.keys'
 ```
 
 ## Advanced Usage
 
+Fx can process a stream of json objects. Fx will apply arguments to each object.
+
+```sh
+echo '{"name": "hello"}\n{"name": "world"}' | fx '.name'
+```
+
+If you want to process a stream of json objects as a single array, 
+use the **--slurp** or **-s** flag.
+
+```sh
+echo '{"name": "hello"}\n{"name": "world"}' | fx --slurp '.map(x => x.name)' '.join(", ")'
+```
+
+If you want to process non-JSON data, use the **--raw** or **-r** flag.
+
+```sh
+ls | fx -r '[this, this.includes(".md")]'
+```
+
+You can use **--raw** and **--slurp** (or **-rs**) together to get a single array of strings.
+
+```sh
+ls | fx -rs '.filter(x => x.includes(".md"))'
+```
+
+Fx has a special symbol **skip** for skipping the printing of the result.
+
+```sh
+ls | fx -r '.includes(".md") ? this : skip'
+```
+
+Fx comes with a set of useful functions: **uniq**, **sort**, **groupBy**, **chunk**, **zip**.
+
+```sh
+cat file.json | fx 'uniq' 'sort' 'groupBy(x => x.name)'
+```
+
+Fx works with promises.
+
+```sh
+echo '"https://medv.io/*"' | fx 'fetch' '.text()'
+```
+
+### Syntactic Sugar
+
 Fx has a shortcut for the map function. Fox example, `this.map(x => x.commit.message)`
 can be rewritten without leading dot and without `x => x` parts.  
 
@@ -67,18 +113,20 @@ Fx has a special syntax for the flatMap function. Fox example,
 curl https://api.github.com/repos/kubernetes/kubernetes/issues | fx '.[].labels[].name'
 ```
 
-Fx works with promises.
+### .fxrc.js
 
-```sh
-echo '"https://medv.io/*"' | fx 'fetch' '.text()'
+Fx supports `.fxrc.js` file in the current directory or in the home directory.
+
+Put the next code in the `.fxrc.js` file to make `myFunction` available in the fx.
+
+```js
+global.myFunction = x => x + 1
 ```
 
-When using the **-r** or **--raw** flag, the input will be treated as a raw string
-instead of JSON. This can be useful when working with non-JSON input data, such as
-plain text or CSV data.
+Now you can use `myFunction` in the fx.
 
 ```sh
-ls | fx -r '.trim().split("\n")'
+echo '1' | fx 'myFunction'
 ```
 
 ## License

package/index.js

@@ -1,29 +1,43 @@
 #!/usr/bin/env node
+'use strict'
+
 void async function main() {
+  const os = await import('node:os')
   const process = await import('node:process')
-  const args = process.argv.slice(2)
-  if ((args.length === 0 && process.stdin.isTTY)
-    || (args.length === 1 && ['-h', '--help'].includes(args[0]))) {
-    printUsage()
-    return
+  let flagHelp = false
+  let flagRaw = false
+  let flagSlurp = false
+  const args = []
+  for (const arg of process.argv.slice(2)) {
+    if (arg === '--help' || arg === '-h') flagHelp = true
+    else if (arg === '--raw' || arg === '-r') flagRaw = true
+    else if (arg === '--slurp' || arg === '-s') flagSlurp = true
+    else if (arg === '-rs' || arg === '-sr') flagRaw = flagSlurp = true
+    else args.push(arg)
   }
-
-  let input = ''
-  process.stdin.setEncoding('utf8')
-  for await (const chunk of process.stdin)
-    input += chunk
-
-  let json
-  if (['-r', '--raw'].includes(args[0])) {
-    args.shift()
-    json = input
-  } else try {
-    json = JSON.parse(input)
-  } catch (err) {
-    process.stderr.write(`Invalid JSON: ${err.message}\n`)
-    process.exit(1)
+  if (flagHelp || (args.length === 0 && process.stdin.isTTY))
+    return printUsage()
+  await importFxrc(process.cwd())
+  await importFxrc(os.homedir())
+  const stdin = await readStdinGenerator()
+  const input = flagRaw ? readLine(stdin) : parseJson(stdin)
+  if (flagSlurp) {
+    const array = []
+    for (const json of input) {
+      array.push(json)
+    }
+    await runTransforms(array, args)
+  } else {
+    for (const json of input) {
+      await runTransforms(json, args)
+    }
   }
+}()
 
+const skip = Symbol('skip')
+
+async function runTransforms(json, args) {
+  const process = await import('node:process')
   let i, code, output = json
   for ([i, code] of args.entries()) try {
     output = await transform(output, code)
@@ -33,24 +47,26 @@ void async function main() {
   }
 
   if (typeof output === 'undefined')
-    process.stderr.write('undefined\n')
+    console.error('undefined')
   else if (typeof output === 'string')
     console.log(output)
+  else if (output === skip)
+    return
   else
-    console.log(JSON.stringify(output, null, 2))
+    console.log(stringify(output, process.stdout.isTTY))
 
   function printErr(err) {
     let pre = args.slice(0, i).join(' ')
     let post = args.slice(i + 1).join(' ')
     if (pre.length > 20) pre = '...' + pre.substring(pre.length - 20)
     if (post.length > 20) post = post.substring(0, 20) + '...'
-    process.stderr.write(
+    console.error(
       `\n  ${pre} ${code} ${post}\n` +
       `  ${' '.repeat(pre.length + 1)}${'^'.repeat(code.length)}\n` +
-      `\n${err.stack || err}\n`
+      `\n${err.stack || err}`
     )
   }
-}()
+}
 
 async function transform(json, code) {
   if ('.' === code)
@@ -87,41 +103,466 @@ async function transform(json, 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)})`
+  }
+
+  function uniq(array) {
+    return [...new Set(array)]
+  }
+
+  function sort(array) {
+    return array.sort()
+  }
+
+  function groupBy(keyOrFunction) {
+    return array => {
+      const grouped = {}
+      for (const item of array) {
+        const key = typeof keyOrFunction === 'function'
+          ? keyOrFunction(item)
+          : item[keyOrFunction]
+        if (!grouped.hasOwnProperty(key))
+          grouped[key] = []
+        grouped[key].push(item)
+      }
+      return grouped
+    }
+  }
+
+  function chunk(size) {
+    return function (arr) {
+      const res = []
+      let i = 0
+      while (i < arr.length) {
+        res.push(arr.slice(i, i += size))
+      }
+      return res
+    }
+  }
+
+  function zip(...arrays) {
+    const length = Math.min(...arrays.map(a => a.length))
+    const res = []
+    for (let i = 0; i < length; i++) {
+      res.push(arrays.map(a => a[i]))
+    }
+    return res
+  }
 }
 
-function apply(fn, ...args) {
-  if (typeof fn === 'function') return fn(...args)
-  return fn
+async function readStdinGenerator() {
+  const fs = await import('node:fs')
+  const {Buffer} = await import('node:buffer')
+  const {StringDecoder} = await import('node:string_decoder')
+  const decoder = new StringDecoder('utf8')
+  return function* () {
+    while (true) {
+      const buffer = Buffer.alloc(4_096)
+      let bytesRead
+      try {
+        bytesRead = fs.readSync(0, buffer, 0, buffer.length, null)
+      } catch (e) {
+        if (e.code === 'EAGAIN' || e.code === 'EWOULDBLOCK') {
+          sleepSync(10)
+          continue
+        }
+        if (e.code === 'EOF') break
+        throw e
+      }
+      if (bytesRead === 0) break
+      for (const ch of decoder.write(buffer.subarray(0, bytesRead)))
+        yield ch
+    }
+    for (const ch of decoder.end())
+      yield ch
+  }()
 }
 
-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)})`
+function sleepSync(ms) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms)
 }
 
-function uniq(array) {
-  return [...new Set(array)]
+function* readLine(stdin) {
+  let buffer = ''
+  for (const ch of stdin) {
+    if (ch === '\n') {
+      yield buffer
+      buffer = ''
+    } else {
+      buffer += ch
+    }
+  }
+  return buffer
 }
 
-function sort(array) {
-  return array.sort()
+function* parseJson(stdin) {
+  let lineNumber = 1, buffer = '', lastChar, done = false
+
+  function next() {
+    ({value: lastChar, done} = stdin.next())
+    if (lastChar === '\n') lineNumber++
+    buffer += (lastChar || '')
+    if (buffer.length > 100) buffer = buffer.slice(-40)
+  }
+
+  next()
+  while (!done) {
+    const value = parseValue()
+    expectValue(value)
+    yield value
+  }
+
+  function parseValue() {
+    skipWhitespace()
+    const value =
+      parseString() ??
+      parseNumber() ??
+      parseObject() ??
+      parseArray() ??
+      parseKeyword('true', true) ??
+      parseKeyword('false', false) ??
+      parseKeyword('null', null)
+    skipWhitespace()
+    return value
+  }
+
+  function parseString() {
+    if (lastChar !== '"') return
+    let str = ''
+    let escaped = false
+    while (true) {
+      next()
+      if (escaped) {
+        if (lastChar === 'u') {
+          let unicode = ''
+          for (let i = 0; i < 4; i++) {
+            next()
+            if (!isHexDigit(lastChar)) {
+              throw new SyntaxError(errorSnippet(`Invalid Unicode escape sequence '\\u${unicode}${lastChar}'`))
+            }
+            unicode += lastChar
+          }
+          str += String.fromCharCode(parseInt(unicode, 16))
+        } else {
+          const escapedChar = {
+            '"': '"',
+            '\\': '\\',
+            '/': '/',
+            'b': '\b',
+            'f': '\f',
+            'n': '\n',
+            'r': '\r',
+            't': '\t'
+          }[lastChar]
+          if (!escapedChar) {
+            throw new SyntaxError(errorSnippet())
+          }
+          str += escapedChar
+        }
+        escaped = false
+      } else if (lastChar === '\\') {
+        escaped = true
+      } else if (lastChar === '"') {
+        break
+      } else if (lastChar === undefined) {
+        throw new SyntaxError(errorSnippet())
+      } else {
+        str += lastChar
+      }
+    }
+    next()
+    return str
+  }
+
+  function parseNumber() {
+    if (!isDigit(lastChar) && lastChar !== '-') return
+    let numStr = ''
+    if (lastChar === '-') {
+      numStr += lastChar
+      next()
+      if (!isDigit(lastChar)) {
+        throw new SyntaxError(errorSnippet())
+      }
+    }
+    if (lastChar === '0') {
+      numStr += lastChar
+      next()
+    } else {
+      while (isDigit(lastChar)) {
+        numStr += lastChar
+        next()
+      }
+    }
+    if (lastChar === '.') {
+      numStr += lastChar
+      next()
+      if (!isDigit(lastChar)) {
+        throw new SyntaxError(errorSnippet())
+      }
+      while (isDigit(lastChar)) {
+        numStr += lastChar
+        next()
+      }
+    }
+    if (lastChar === 'e' || lastChar === 'E') {
+      numStr += lastChar
+      next()
+      if (lastChar === '+' || lastChar === '-') {
+        numStr += lastChar
+        next()
+      }
+      if (!isDigit(lastChar)) {
+        throw new SyntaxError(errorSnippet())
+      }
+      while (isDigit(lastChar)) {
+        numStr += lastChar
+        next()
+      }
+    }
+    return isInteger(numStr) ? toSafeNumber(numStr) : parseFloat(numStr)
+  }
+
+  function parseObject() {
+    if (lastChar !== '{') return
+    next()
+    skipWhitespace()
+    const obj = {}
+    if (lastChar === '}') {
+      next()
+      return obj
+    }
+    while (true) {
+      if (lastChar !== '"') {
+        throw new SyntaxError(errorSnippet())
+      }
+      const key = parseString()
+      skipWhitespace()
+      if (lastChar !== ':') {
+        throw new SyntaxError(errorSnippet())
+      }
+      next()
+      const value = parseValue()
+      expectValue(value)
+      obj[key] = value
+      skipWhitespace()
+      if (lastChar === '}') {
+        next()
+        return obj
+      } else if (lastChar === ',') {
+        next()
+        skipWhitespace()
+        if (lastChar === '}') {
+          next()
+          return obj
+        }
+      } else {
+        throw new SyntaxError(errorSnippet())
+      }
+    }
+  }
+
+  function parseArray() {
+    if (lastChar !== '[') return
+    next()
+    skipWhitespace()
+    const array = []
+    if (lastChar === ']') {
+      next()
+      return array
+    }
+    while (true) {
+      const value = parseValue()
+      expectValue(value)
+      array.push(value)
+      skipWhitespace()
+      if (lastChar === ']') {
+        next()
+        return array
+      } else if (lastChar === ',') {
+        next()
+        skipWhitespace()
+        if (lastChar === ']') {
+          next()
+          return array
+        }
+      } else {
+        throw new SyntaxError(errorSnippet())
+      }
+    }
+  }
+
+  function parseKeyword(name, value) {
+    if (lastChar !== name[0]) return
+    for (let i = 1; i < name.length; i++) {
+      next()
+      if (lastChar !== name[i]) {
+        throw new SyntaxError(errorSnippet())
+      }
+    }
+    next()
+    if (isWhitespace(lastChar) || lastChar === ',' || lastChar === '}' || lastChar === ']' || lastChar === undefined) {
+      return value
+    }
+    throw new SyntaxError(errorSnippet())
+  }
+
+  function skipWhitespace() {
+    while (isWhitespace(lastChar)) {
+      next()
+    }
+    skipComment()
+  }
+
+  function skipComment() {
+    if (lastChar === '/') {
+      next()
+      if (lastChar === '/') {
+        while (!done && lastChar !== '\n') {
+          next()
+        }
+        skipWhitespace()
+      } else if (lastChar === '*') {
+        while (!done) {
+          next()
+          if (lastChar === '*') {
+            next()
+            if (lastChar === '/') {
+              next()
+              break
+            }
+          }
+        }
+        skipWhitespace()
+      } else {
+        throw new SyntaxError(errorSnippet())
+      }
+    }
+  }
+
+  function isWhitespace(ch) {
+    return ch === ' ' || ch === '\n' || ch === '\t' || ch === '\r'
+  }
+
+  function isHexDigit(ch) {
+    return (ch >= '0' && ch <= '9') || (ch >= 'a' && ch <= 'f') || (ch >= 'A' && ch <= 'F')
+  }
+
+  function isDigit(ch) {
+    return ch >= '0' && ch <= '9'
+  }
+
+  function isInteger(value) {
+    return /^-?[0-9]+$/.test(value)
+  }
+
+  function toSafeNumber(str) {
+    const maxSafeInteger = Number.MAX_SAFE_INTEGER
+    const minSafeInteger = Number.MIN_SAFE_INTEGER
+    const num = BigInt(str)
+    return num >= minSafeInteger && num <= maxSafeInteger ? Number(num) : num
+  }
+
+  function expectValue(value) {
+    if (value === undefined) {
+      throw new SyntaxError(errorSnippet(`JSON value expected`))
+    }
+  }
+
+  function errorSnippet(message = `Unexpected character '${lastChar}'`) {
+    if (!lastChar) {
+      message = 'Unexpected end of input'
+    }
+    const lines = buffer.slice(-40).split('\n')
+    const lastLine = lines.pop()
+    const source =
+      lines.map(line => `    ${line}\n`).join('')
+      + `    ${lastLine}${readEOL()}\n`
+    const p = `    ${'.'.repeat(Math.max(0, lastLine.length - 1))}^\n`
+    return `${message} on line ${lineNumber}.\n\n${source}${p}`
+  }
+
+  function readEOL() {
+    let line = ''
+    for (const ch of stdin) {
+      if (!ch || ch === '\n' || line.length >= 60) break
+      line += ch
+    }
+    return line
+  }
 }
 
-function groupBy(keyOrFunction) {
-  return array => {
-    const grouped = {}
-    for (const item of array) {
-      const key = typeof keyOrFunction === 'function'
-        ? keyOrFunction(item)
-        : item[keyOrFunction]
-      if (!grouped.hasOwnProperty(key))
-        grouped[key] = []
-      grouped[key].push(item)
+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[2m' : '',
+    reset: isPretty ? '\x1b[0m' : '',
+  }
+
+  function getIndent(level) {
+    return ' '.repeat(2 * level)
+  }
+
+  function stringifyValue(value, level = 0) {
+    if (typeof value === 'string') {
+      return `${colors.string}"${value}"${colors.reset}`
+    } else if (typeof value === 'number') {
+      return `${colors.number}${value}${colors.reset}`
+    } else if (typeof value === 'bigint') {
+      return `${colors.number}${value}${colors.reset}`
+    } else if (typeof value === 'boolean') {
+      return `${colors.boolean}${value}${colors.reset}`
+    } else if (value === null || typeof value === 'undefined') {
+      return `${colors.null}null${colors.reset}`
+    } else if (Array.isArray(value)) {
+      if (value.length === 0) {
+        return `[]`
+      }
+      const items = value
+        .map((v) => `${getIndent(level + 1)}${stringifyValue(v, level + 1)}`)
+        .join(',\n')
+      return `[\n${items}\n${getIndent(level)}]`
+    } else if (typeof value === 'object') {
+      const keys = Object.keys(value)
+      if (keys.length === 0) {
+        return `{}`
+      }
+      const entries = keys
+        .map(
+          (key) =>
+            `${getIndent(level + 1)}${colors.key}"${key}"${colors.reset}: ${stringifyValue(
+              value[key],
+              level + 1
+            )}`
+        )
+        .join(',\n')
+      return `{\n${entries}\n${getIndent(level)}}`
     }
-    return grouped
+    throw new Error(`Unsupported value type: ${typeof value}`)
+  }
+
+  return stringifyValue(value)
+}
+
+async function importFxrc(path) {
+  const {join} = await import('node:path')
+  try {
+    await import(join(path, '.fxrc.js'))
+  } catch (err) {
+    if (err.code !== 'ERR_MODULE_NOT_FOUND') throw err
   }
 }
 
@@ -131,6 +572,7 @@ function printUsage() {
 
 Flags
   -h, --help    Display this help message
-  -r, --raw     Treat input as raw string`
+  -r, --raw     Treat input as a raw string
+  -s, --slurp   Read all inputs into an array`
   console.log(usage)
 }

package/package.json

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