rubico 2.0.1 → 2.2.0

package/build

@@ -1,472 +0,0 @@
-#!/usr/bin/env node
-
-require('./global')
-const rubico = require('./rubico')
-const x = require('./x')
-const Transducer = require('./Transducer')
-const rubicoVersion = require('./package.json').version
-const fs = require('fs')
-const nodePath = require('path')
-const { minify } = require('terser')
-
-const { identity, noop } = x
-
-const license = `
-/**
- * rubico v${rubicoVersion}
- * https://github.com/a-synchronous/rubico
- * (c) 2019-${new Date().getFullYear()} Richard Tong
- * rubico may be freely distributed under the MIT license.
- */
-`.trim()
-
-const Stdout = {
-  concat(...args) {
-    console.log(...args)
-    return this
-  },
-}
-
-const replace = (pattern, replacement) => value => value.replace(pattern, replacement)
-
-const pathResolve = nodePath.resolve
-
-const pathDirname = nodePath.dirname
-
-// path string => cjs string
-const pathToCode = pipe([
-  fs.readFileSync,
-  value => value.toString(),
-  replace(/\/\*\*[\s\S]+?\*\//g, ''),
-  replace(/module.exports .+?\n/, ''),
-])
-
-// path string => codeBundle string
-const pathToCodeBundle = pipe([
-  all({
-    path: identity,
-    code: pathToCode,
-  }),
-
-  ({ path, code }) => {
-    const alreadyRequiredPaths = new Set()
-    const cwd = pathDirname(path)
-    let result = code
-    while (result.includes('require(')) {
-      result = result.replace(/const \w+ = require\('(?<path>.+)'\)/g, (match, p1, offset, source, groups) => {
-        const { path } = groups
-        const requiredPath = pathResolve(cwd, `${path}.js`)
-        if (alreadyRequiredPaths.has(requiredPath)) {
-          return ''
-        }
-        alreadyRequiredPaths.add(requiredPath)
-        let requiredCode = pathToCode(requiredPath)
-
-        while (requiredCode.includes('require(')) {
-          requiredCode = requiredCode.replace(
-            /const \w+ = require\('(?<path>.+)'\)/,
-            pipe([
-              (match, p1, offset, source, groups) => groups.path,
-              path => `${path}.js`,
-              curry.arity(2, pathResolve, pathDirname(requiredPath), __),
-              switchCase([
-                requiredPath => alreadyRequiredPaths.has(requiredPath),
-                always(''),
-                pipe([
-                  tap(requiredPath => alreadyRequiredPaths.add(requiredPath)),
-                  all({
-                    requiredPath: identity,
-                    code: pathToCode,
-                  }),
-                  ({ requiredPath, code }) => {
-                    code = code.replace(
-                      /const (?<moduleName>\w+) = require\('(?<path>.+)'\)/g,
-                      (match, p1, p2, offset, source, groups) => {
-                        const { moduleName, path } = groups
-                        const newPath = pathResolve(pathDirname(requiredPath), path)
-                        const newStatement = `const ${moduleName} = require('${newPath}')`
-                        return newStatement
-                      }
-                    )
-                    return code
-                  },
-                ]),
-              ]),
-            ]))
-        }
-        return requiredCode
-      })
-      result = result.replace(/\n{2,}/g, '\n\n')
-    }
-    return result
-  },
-])
-
-const ignoredNames = new Set([
-  'is',
-  'heapUsedInLoop',
-  'timeInLoop',
-  'tracef',
-])
-
-// name string => boolean
-const nameIsIgnored = name => ignoredNames.has(name)
-
-const build = pipe([
-  tap(tryCatch(
-    thunkify(fs.promises.rm, `${__dirname}/dist`, { recursive: true }),
-    noop,
-  )),
-  tap(thunkify(fs.promises.mkdir, `${__dirname}/dist/x`, { recursive: true })),
-
-  function createBundles() {
-    const bundles = []
-    for (const functionName of Object.keys(rubico)) {
-      const path = `${__dirname}/${functionName}.js`
-      bundles.push({
-        name: functionName,
-        type: 'cjs',
-        path,
-        distPath: `${__dirname}/dist/${functionName}.js`,
-      })
-      bundles.push({
-        name: functionName,
-        type: 'cjs-minified',
-        path,
-        distPath: `${__dirname}/dist/${functionName}.min.js`,
-      })
-      bundles.push({
-        name: functionName,
-        type: 'esm',
-        path,
-        distPath: `${__dirname}/dist/${functionName}.es.js`,
-      })
-      bundles.push({
-        name: functionName,
-        type: 'esm-minified',
-        path,
-        distPath: `${__dirname}/dist/${functionName}.es.min.js`,
-      })
-      bundles.push({
-        name: functionName,
-        type: 'esm',
-        path,
-        distPath: `${__dirname}/dist/${functionName}.mjs`,
-      })
-    }
-
-    for (const functionName of Object.keys(x)) {
-      const path = `${__dirname}/x/${functionName}.js`
-      bundles.push({
-        name: functionName,
-        type: 'cjs',
-        path,
-        distPath: `${__dirname}/dist/x/${functionName}.js`,
-      })
-      bundles.push({
-        name: functionName,
-        type: 'cjs-minified',
-        path,
-        distPath: `${__dirname}/dist/x/${functionName}.min.js`,
-      })
-      bundles.push({
-        name: functionName,
-        type: 'esm',
-        path,
-        distPath: `${__dirname}/dist/x/${functionName}.es.js`,
-      })
-      bundles.push({
-        name: functionName,
-        type: 'esm-minified',
-        path,
-        distPath: `${__dirname}/dist/x/${functionName}.es.min.js`,
-      })
-      bundles.push({
-        name: functionName,
-        type: 'esm',
-        path,
-        distPath: `${__dirname}/dist/x/${functionName}.mjs`,
-      })
-    }
-
-    bundles.push({
-      name: 'rubico',
-      type: 'cjs',
-      path: `${__dirname}/rubico.js`,
-      distPath: `${__dirname}/index.js`,
-    })
-
-    bundles.push({
-      name: 'rubico',
-      type: 'cjs',
-      path: `${__dirname}/rubico.js`,
-      distPath: `${__dirname}/dist/rubico.js`,
-    })
-
-    bundles.push({
-      name: 'rubico',
-      type: 'cjs-minified',
-      path: `${__dirname}/rubico.js`,
-      distPath: `${__dirname}/dist/rubico.min.js`,
-    })
-
-    bundles.push({
-      name: 'rubico',
-      type: 'cjs-global-module',
-      path: `${__dirname}/rubico.js`,
-      distPath: `${__dirname}/dist/rubico.global.js`,
-    })
-
-    bundles.push({
-      name: 'rubico',
-      type: 'cjs-global-module-minified',
-      path: `${__dirname}/rubico.js`,
-      distPath: `${__dirname}/dist/rubico.global.min.js`,
-    })
-
-    bundles.push({
-      name: 'rubico',
-      type: 'esm',
-      path: `${__dirname}/rubico.js`,
-      distPath: `${__dirname}/es.js`,
-    })
-
-    bundles.push({
-      name: 'rubico',
-      type: 'esm',
-      path: `${__dirname}/rubico.js`,
-      distPath: `${__dirname}/dist/rubico.es.js`,
-    })
-
-    bundles.push({
-      name: 'rubico',
-      type: 'esm-minified',
-      path: `${__dirname}/rubico.js`,
-      distPath: `${__dirname}/dist/rubico.es.min.js`,
-    })
-
-    bundles.push({
-      name: 'rubico',
-      type: 'esm',
-      path: `${__dirname}/rubico.js`,
-      distPath: `${__dirname}/dist/rubico.mjs`,
-    })
-
-    bundles.push({
-      name: 'Transducer',
-      type: 'cjs',
-      path: `${__dirname}/Transducer.js`,
-      distPath: `${__dirname}/dist/Transducer.js`,
-    })
-
-    bundles.push({
-      name: 'Transducer',
-      type: 'cjs-minified',
-      path: `${__dirname}/Transducer.js`,
-      distPath: `${__dirname}/dist/Transducer.min.js`,
-    })
-
-    bundles.push({
-      name: 'Transducer',
-      type: 'esm',
-      path: `${__dirname}/Transducer.js`,
-      distPath: `${__dirname}/dist/Transducer.es.js`,
-    })
-
-    bundles.push({
-      name: 'Transducer',
-      type: 'esm-minified',
-      path: `${__dirname}/Transducer.js`,
-      distPath: `${__dirname}/dist/Transducer.es.min.js`,
-    })
-
-    bundles.push({
-      name: 'Transducer',
-      type: 'esm',
-      path: `${__dirname}/Transducer.js`,
-      distPath: `${__dirname}/dist/Transducer.mjs`,
-    })
-
-    return bundles
-  },
-
-  transform(
-    compose([
-      Transducer.filter(pipe([
-        get('name'),
-        not(nameIsIgnored),
-      ])),
-
-      Transducer.map(assign({
-        baseCodeBundle: pipe([
-          get('path'),
-          pathToCodeBundle,
-        ]),
-      })),
-
-      Transducer.map(switchCase([
-        or([
-          ({ distPath }) => distPath.endsWith('rubico.mjs'),
-          ({ distPath }) => distPath.endsWith('rubico.es.js'),
-        ]),
-        assign({
-          codeBundle: ({ name, baseCodeBundle }) => `
-${license}
-${baseCodeBundle}export {
-  pipe, compose,
-
-  tap, forEach,
-
-  switchCase,
-
-  tryCatch,
-
-  all, assign, get, set, pick, omit,
-
-  map, filter, reduce, transform, flatMap,
-
-  and, or, not, some, every,
-
-  eq, gt, lt, gte, lte,
-
-  thunkify, always, curry, __,
-}
-
-export default ${name}
-`.trimStart(),
-        }),
-
-        or([
-          ({ distPath }) => distPath.endsWith('rubico.min.mjs'),
-          ({ distPath }) => distPath.endsWith('rubico.es.min.js'),
-        ]),
-        assign({
-          codeBundle: async ({ name, baseCodeBundle }) => `
-${license}
-${(await minify(`${baseCodeBundle}export {
-  pipe, compose,
-
-  tap, forEach,
-
-  switchCase,
-
-  tryCatch,
-
-  all, assign, get, set, pick, omit,
-
-  map, filter, reduce, transform, flatMap,
-
-  and, or, not, some, every,
-
-  eq, gt, lt, gte, lte,
-
-  thunkify, always, curry, __,
-}
-
-export default ${name}`)).code}
-`.trimStart(),
-        }),
-
-        eq('esm', get('type')),
-        assign({
-          codeBundle: ({ name, baseCodeBundle }) => `
-${license}
-${baseCodeBundle}export default ${name}
-`.trimStart(),
-        }),
-
-        eq('esm-minified', get('type')),
-        assign({
-          codeBundle: async ({ name, baseCodeBundle }) => `
-${license}
-${(await minify(`${baseCodeBundle}export default ${name}`)).code}
-`.trimStart(),
-        }),
-
-        eq('cjs', get('type')),
-        assign({
-          codeBundle: ({ name, baseCodeBundle }) => `
-${license}
-
-(function (root, ${name}) {
-  if (typeof module == 'object') (module.exports = ${name}) // CommonJS
-  else if (typeof define == 'function') define(() => ${name}) // AMD
-  else (root.${name} = ${name}) // Browser
-}(typeof globalThis == 'object' ? globalThis : this, (function () { 'use strict'
-${baseCodeBundle}return ${name}
-}())))
-`.trimStart(),
-        }),
-
-        eq('cjs-minified', get('type')),
-        assign({
-          codeBundle: async ({ name, baseCodeBundle }) => `
-${license}
-
-${(await minify(`(function (root, ${name}) {
-  if (typeof module == 'object') (module.exports = ${name}) // CommonJS
-  else if (typeof define == 'function') define(() => ${name}) // AMD
-  else (root.${name} = ${name}) // Browser
-}(typeof globalThis == 'object' ? globalThis : this, (function () { 'use strict'
-${baseCodeBundle}return ${name}
-}())))`)).code}
-`.trimStart(),
-        }),
-
-        eq('cjs-global-module', get('type')),
-        assign({
-          codeBundle: ({ name, baseCodeBundle }) => `
-${license}
-
-(function (root, ${name}) {
-  for (const functionName in ${name}) {
-    root[functionName] = ${name}[functionName]
-  }
-}(typeof globalThis == 'object' ? globalThis : this, (function () { 'use strict'
-${baseCodeBundle}return ${name}
-}())))
-`.trimStart(),
-        }),
-
-        eq('cjs-global-module-minified', get('type')),
-        assign({
-          codeBundle: async ({ name, baseCodeBundle }) => `
-${license}
-
-${(await minify(`(function (root, ${name}) {
-  for (const functionName in ${name}) {
-    root[functionName] = ${name}[functionName]
-  }
-}(typeof globalThis == 'object' ? globalThis : this, (function () { 'use strict'
-${baseCodeBundle}return ${name}
-}())))`)).code}
-`.trimStart(),
-        }),
-
-        function throwingUnrecognizedTypeError({ name, type }) {
-          throw new TypeError(`${name} - unrecognized type ${type}`)
-        }
-      ])),
-
-      Transducer.forEach(pipe([
-        get('distPath'),
-        replace(process.env.HOME, '~'),
-        curry.arity(2, console.log, 'writing', __),
-      ])),
-    ]),
-    {
-      async concat({ distPath, codeBundle }) {
-        await fs.promises.writeFile(distPath, codeBundle)
-        return this
-      },
-    },
-    // Stdout,
-    // null,
-  ),
-])
-
-if (require.main == module) {
-  build()
-}
-
-module.exports = build

package/dist-test.js

@@ -1,37 +0,0 @@
-const assert = require('assert')
-const findAllFilePaths = require('./_internal/findAllFilePaths')
-
-const distTest = async function main() {
-  const filePaths = await findAllFilePaths(`${__dirname}/dist`)
-  filePaths.push(`${__dirname}/index.js`)
-  filePaths.push(`${__dirname}/es.js`)
-
-  for (const path of filePaths) {
-    if (
-      path.includes('.es')
-      || path.endsWith('.mjs')
-      || path.includes('es.js')
-    ) {
-      // TODO
-    }
-    else {
-      console.log('Testing', path)
-      const required = require(path)
-
-      if (
-        path.includes('rubico.js')
-        || path.includes('rubico.min.js')
-        || path.includes('index.js')
-      ) {
-        assert.equal(Object.keys(required).length, 31)
-      } else if (
-        path.includes('Transducer.js')
-        || path.includes('Transducer.min.js')
-      ) {
-        assert.equal(Object.keys(required).length, 5)
-      }
-    }
-  }
-}
-
-distTest()

package/examples/type-to-search-wiki/README.md

@@ -1,19 +0,0 @@
-# Type to search Wikipedia example app with Rubico
-
-Small vanilla js example for represent rubico functions:
-
-- `pipe`
-- `switchCase`
-- `noop`
-
-Installation
-
-```bash
-npm install
-```
-
-Run example (dev)
-
-```bash
-npm start
-```

package/examples/type-to-search-wiki/package.json

@@ -1,13 +0,0 @@
-{
-  "name": "type-to-search-wiki",
-  "version": "1.0.0",
-  "description": "Vanilla js example by rubico",
-  "scripts": {
-    "start": "serve ./src"
-  },
-  "author": "",
-  "license": "ISC",
-  "devDependencies": {
-    "serve": "^13.0.2"
-  }
-}

package/examples/type-to-search-wiki/src/app.js

@@ -1,46 +0,0 @@
-const { pipe, switchCase, noop } = rubico
-
-const searchInput = document.getElementById('search')
-const resultList = document.getElementById('results')
-const template = document.getElementById('template').innerHTML
-
-const toSearchUrl = search => `https://en.wikipedia.org/w/api.php?action=opensearch&format=json&search=${search}`
-
-const getSearchResult = pipe([
-  toSearchUrl,
-  fetchJsonp,
-  response => response.json(),
-])
-
-const selectFoundedNames = result => result[1]
-
-const render = resultContent => {
-  resultList.innerHTML = resultContent.reduce((html, item) => html + template.replace(/\{name\}/g, item), '')
-}
-
-const runSearch = pipe([
-  getSearchResult,
-  switchCase([
-    result => Array.isArray(result) && result.length === 4,
-    pipe([
-      selectFoundedNames,
-      render,
-    ]),
-    noop,
-  ]),
-])
-
-const debounce = (func, timeout = 300) => {
-  // eslint-disable-next-line init-declarations
-  let timer
-  return (...args) => {
-    clearTimeout(timer)
-    timer = setTimeout(() => {
-      func.apply(this, args)
-    }, timeout)
-  }
-}
-
-searchInput.onkeyup = function (event) {
-  debounce(() => runSearch(event.target.value), 500)()
-}

package/examples/type-to-search-wiki/src/index.html

@@ -1,18 +0,0 @@
-<!DOCTYPE html>
-<html>
-  <head>
-    <meta charset="UTF-8" />
-    <title>rubico | Wikipedia type to search example</title>
-  </head>
-  <body>
-    <h2>Type to search Wikipedia</h2>
-    <input type="text" id="search" autofocus autocomplete="off" placeholder="Search Wikipedia" />
-    <ul id="results"></ul>
-    <div id="template" style="display: none">
-      <li><a href="https://en.wikipedia.org/wiki/{name}" target="_BLANK">{name}</a></li>
-    </div>
-    <script defer src="https://unpkg.com/rubico@1.8.11/dist/rubico.min.js" crossorigin></script>
-    <script defer src="https://unpkg.com/fetch-jsonp@1.2.1/build/fetch-jsonp.js" crossorigin></script>
-    <script defer src="app.js"></script>
-  </body>
-</html>

package/import-test.html

@@ -1,73 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="UTF-8">
-  <title></title>
-</head>
-<body>
-  <h2>rubico methods - global</h2>
-  <div id="rubico"></div>
-
-  <h2>rubico methods - esm</h2>
-  <div id="rubico-es"></div>
-</body>
-<script src="./index.js"></script>
-<script>
-
-const {
-  pipe, tap,
-  switchCase, tryCatch,
-  fork, assign, get, pick, omit,
-  map, filter, reduce, transform, flatMap,
-  and, or, not, any, all,
-  eq, gt, lt, gte, lte,
-  thunkify, always,
-  curry, __,
-} = rubico
-
-const join = delimiter => array => array.join(delimiter)
-
-/**
- * @name moduleToHTML
- *
- * @synopsis
- * moduleToHTML(myModule object) -> html string
- */
-const moduleToHTML = pipe([
-  Object.keys,
-  join('<br/>'),
-  tap(console.log),
-])
-
-console.log('rubico', rubico)
-document.getElementById('rubico').innerHTML = moduleToHTML(rubico)
-
-</script>
-
-<script type="module">
-import rubico from './es.js'
-
-const {
-  pipe, tap,
-  switchCase, tryCatch,
-  fork, assign, get, pick, omit,
-  map, filter, reduce, transform, flatMap,
-  and, or, not, any, all,
-  eq, gt, lt, gte, lte,
-  thunkify, always,
-  curry, __,
-} = rubico
-
-const join = delimiter => array => array.join(delimiter)
-
-const moduleToHTML = pipe([
-  Object.keys,
-  join('<br/>'),
-  tap(console.log),
-])
-
-console.log('rubico-es', rubico)
-document.getElementById('rubico-es').innerHTML = moduleToHTML(rubico)
-</script>
-
-</html>