Nuxt/packages/common/src/utils.js

407 lines
10 KiB
JavaScript
Raw Normal View History

2018-03-16 19:11:24 +00:00
import path from 'path'
import escapeRegExp from 'lodash/escapeRegExp'
import get from 'lodash/get'
import consola from 'consola'
2018-03-16 06:26:23 +00:00
2018-03-16 16:12:06 +00:00
export const encodeHtml = function encodeHtml(str) {
2017-01-11 21:51:52 +00:00
return str.replace(/</g, '&lt;').replace(/>/g, '&gt;')
2017-01-11 19:14:59 +00:00
}
2016-11-07 01:34:58 +00:00
2018-03-16 16:12:06 +00:00
export const getContext = function getContext(req, res) {
2017-01-11 19:14:59 +00:00
return { req, res }
}
2016-11-07 01:34:58 +00:00
2018-03-16 16:12:06 +00:00
export const waitFor = function waitFor(ms) {
2018-01-11 14:11:49 +00:00
return new Promise(resolve => setTimeout(resolve, ms || 0))
2016-11-07 01:34:58 +00:00
}
2016-11-10 18:34:59 +00:00
export const isString = function isString(obj) {
return typeof obj === 'string' || obj instanceof String
}
export const startsWithAlias = aliasArray => str => aliasArray.some(c => str.startsWith(c))
export const startsWithSrcAlias = startsWithAlias(['@', '~'])
export const startsWithRootAlias = startsWithAlias(['@@', '~~'])
async function promiseFinally(fn, finalFn) {
let result
try {
if (typeof fn === 'function') {
result = await fn()
} else {
result = await fn
}
} finally {
finalFn()
}
return result
}
2018-03-16 16:12:06 +00:00
export const timeout = function timeout(fn, ms, msg) {
let timerId
const warpPromise = promiseFinally(fn, () => clearTimeout(timerId))
const timerPromise = new Promise((resolve, reject) => {
timerId = setTimeout(() => reject(new Error(msg)), ms)
})
return Promise.race([warpPromise, timerPromise])
}
2018-03-16 16:12:06 +00:00
export const urlJoin = function urlJoin() {
2018-01-11 14:11:49 +00:00
return [].slice
.call(arguments)
.join('/')
.replace(/\/+/g, '/')
.replace(':/', '://')
2016-11-10 18:34:59 +00:00
}
2016-11-24 00:47:11 +00:00
2018-03-16 16:12:06 +00:00
export const isUrl = function isUrl(url) {
return ['http', '//'].some(str => url.startsWith(str))
2017-03-16 17:52:38 +00:00
}
2018-03-16 16:12:06 +00:00
export const promisifyRoute = function promisifyRoute(fn, ...args) {
// If routes is an array
2016-11-24 00:47:11 +00:00
if (Array.isArray(fn)) {
return Promise.resolve(fn)
}
// If routes is a function expecting a callback
if (fn.length === arguments.length) {
2016-12-10 11:39:11 +00:00
return new Promise((resolve, reject) => {
fn((err, routeParams) => {
2016-11-24 00:47:11 +00:00
if (err) {
reject(err)
}
resolve(routeParams)
}, ...args)
2016-11-24 00:47:11 +00:00
})
}
let promise = fn(...args)
2018-01-11 14:11:49 +00:00
if (
!promise ||
(!(promise instanceof Promise) && typeof promise.then !== 'function')
) {
2016-11-24 00:47:11 +00:00
promise = Promise.resolve(promise)
}
return promise
}
2018-03-16 16:12:06 +00:00
export const sequence = function sequence(tasks, fn) {
2018-01-11 14:11:49 +00:00
return tasks.reduce(
(promise, task) => promise.then(() => fn(task)),
Promise.resolve()
)
}
2017-05-12 07:57:24 +00:00
2018-03-16 16:12:06 +00:00
export const parallel = function parallel(tasks, fn) {
return Promise.all(tasks.map(fn))
2017-06-15 22:19:53 +00:00
}
2018-03-16 16:12:06 +00:00
export const chainFn = function chainFn(base, fn) {
2017-05-14 23:01:41 +00:00
/* istanbul ignore if */
if (typeof fn !== 'function') {
return base
2017-05-12 07:57:24 +00:00
}
2017-08-22 22:50:27 +00:00
return function () {
if (typeof base !== 'function') {
return fn.apply(this, arguments)
}
let baseResult = base.apply(this, arguments)
// Allow function to mutate the first argument instead of returning the result
if (baseResult === undefined) {
baseResult = arguments[0]
}
2018-08-08 10:54:05 +00:00
const fnResult = fn.call(
2018-01-11 14:11:49 +00:00
this,
baseResult,
...Array.prototype.slice.call(arguments, 1)
)
2017-08-22 22:50:27 +00:00
// Return mutated argument if no result was returned
if (fnResult === undefined) {
return baseResult
}
return fnResult
2017-05-12 07:57:24 +00:00
}
}
2017-05-18 08:44:31 +00:00
2018-03-16 16:12:06 +00:00
export const isPureObject = function isPureObject(o) {
2017-08-15 01:06:56 +00:00
return !Array.isArray(o) && typeof o === 'object'
}
2018-03-16 16:12:06 +00:00
export const isWindows = /^win/.test(process.platform)
2017-08-17 17:18:56 +00:00
2018-03-16 16:12:06 +00:00
export const wp = function wp(p = '') {
2017-05-18 08:44:31 +00:00
/* istanbul ignore if */
2017-08-17 17:18:56 +00:00
if (isWindows) {
return p.replace(/\\/g, '\\\\')
}
return p
2018-03-16 16:12:06 +00:00
}
2017-08-17 17:18:56 +00:00
2018-03-16 16:12:06 +00:00
export const wChunk = function wChunk(p = '') {
2017-08-17 17:18:56 +00:00
/* istanbul ignore if */
if (isWindows) {
2017-11-21 21:34:17 +00:00
return p.replace(/\//g, '_')
2017-05-18 08:44:31 +00:00
}
return p
}
const reqSep = /\//g
const sysSep = escapeRegExp(path.sep)
2017-05-18 08:44:31 +00:00
const normalize = string => string.replace(reqSep, sysSep)
export const r = function r(...args) {
const lastArg = args[args.length - 1]
2017-06-11 14:17:36 +00:00
if (startsWithSrcAlias(lastArg)) {
return wp(lastArg)
}
2018-03-16 19:11:24 +00:00
return wp(path.resolve(...args.map(normalize)))
2018-03-16 16:12:06 +00:00
}
2018-03-16 16:12:06 +00:00
export const relativeTo = function relativeTo() {
2018-08-08 10:54:05 +00:00
const args = Array.prototype.slice.apply(arguments)
const dir = args.shift()
// Keep webpack inline loader intact
if (args[0].includes('!')) {
const loaders = args.shift().split('!')
return loaders.concat(relativeTo(dir, loaders.pop(), ...args)).join('!')
}
// Resolve path
2018-08-08 10:54:05 +00:00
const _path = r(...args)
// Check if path is an alias
if (startsWithSrcAlias(_path)) {
2018-03-16 19:11:24 +00:00
return _path
}
// Make correct relative path
2018-03-16 19:11:24 +00:00
let rp = path.relative(dir, _path)
if (rp[0] !== '.') {
rp = './' + rp
}
2018-03-16 19:11:24 +00:00
return wp(rp)
2017-05-18 08:44:31 +00:00
}
2018-03-16 19:11:24 +00:00
export const flatRoutes = function flatRoutes(router, _path = '', routes = []) {
router.forEach((r) => {
if ([':', '*'].some(c => r.path.includes(c))) {
return
}
/* istanbul ignore if */
if (r.children) {
if (_path === '' && r.path === '/') {
routes.push('/')
}
return flatRoutes(r.children, _path + r.path + '/', routes)
}
_path = _path.replace(/^\/+$/, '/')
routes.push(
(r.path === '' && _path[_path.length - 1] === '/'
? _path.slice(0, -1)
: _path) + r.path
)
})
return routes
}
function cleanChildrenRoutes(routes, isChild = false) {
let start = -1
2018-08-08 10:54:05 +00:00
const routesIndex = []
routes.forEach((route) => {
if (/-index$/.test(route.name) || route.name === 'index') {
// Save indexOf 'index' key in name
2018-08-08 10:54:05 +00:00
const res = route.name.split('-')
const s = res.indexOf('index')
2018-01-11 14:11:49 +00:00
start = start === -1 || s < start ? s : start
routesIndex.push(res)
}
})
routes.forEach((route) => {
2018-01-11 14:11:49 +00:00
route.path = isChild ? route.path.replace('/', '') : route.path
if (route.path.includes('?')) {
2018-08-08 10:54:05 +00:00
const names = route.name.split('-')
const paths = route.path.split('/')
if (!isChild) {
paths.shift()
} // clean first / for parents
routesIndex.forEach((r) => {
2018-08-08 10:54:05 +00:00
const i = r.indexOf('index') - start // children names
if (i < paths.length) {
for (let a = 0; a <= i; a++) {
if (a === i) {
paths[a] = paths[a].replace('?', '')
}
if (a < i && names[a] !== r[a]) {
break
}
}
}
})
route.path = (isChild ? '' : '/') + paths.join('/')
}
route.name = route.name.replace(/-index$/, '')
if (route.children) {
2018-01-11 14:11:49 +00:00
if (route.children.find(child => child.path === '')) {
delete route.name
}
route.children = cleanChildrenRoutes(route.children, true)
}
})
return routes
}
2018-03-16 16:12:06 +00:00
export const createRoutes = function createRoutes(files, srcDir, pagesDir) {
2018-08-08 10:54:05 +00:00
const routes = []
files.forEach((file) => {
2018-08-08 10:54:05 +00:00
const keys = file
2018-02-02 17:15:57 +00:00
.replace(RegExp(`^${pagesDir}`), '')
2018-01-11 14:11:49 +00:00
.replace(/\.(vue|js)$/, '')
.replace(/\/{2,}/g, '/')
.split('/')
.slice(1)
2018-08-08 10:54:05 +00:00
const route = { name: '', path: '', component: r(srcDir, file) }
let parent = routes
keys.forEach((key, i) => {
2018-03-11 13:59:37 +00:00
// remove underscore only, if its the prefix
const sanitizedKey = key.startsWith('_') ? key.substr(1) : key
2018-01-11 14:11:49 +00:00
route.name = route.name
2018-07-18 14:39:48 +00:00
? route.name + '-' + sanitizedKey
: sanitizedKey
2018-01-11 14:11:49 +00:00
route.name += key === '_' ? 'all' : ''
route.chunkName = file.replace(/\.(vue|js)$/, '')
const child = parent.find(parentRoute => parentRoute.name === route.name)
if (child) {
child.children = child.children || []
parent = child.children
route.path = ''
} else if (key === 'index' && i + 1 === keys.length) {
route.path += i > 0 ? '' : '/'
} else {
route.path += '/' + getRoutePathExtension(key)
if (key.startsWith('_') && key.length > 1) {
route.path += '?'
}
}
})
// Order Routes path
parent.push(route)
parent.sort((a, b) => {
if (!a.path.length) {
return -1
}
if (!b.path.length) {
return 1
}
// Order: /static, /index, /:dynamic
// Match exact route before index: /login before /index/_slug
if (a.path === '/') {
return DYNAMIC_ROUTE_REGEX.test(b.path) ? -1 : 1
}
if (b.path === '/') {
return DYNAMIC_ROUTE_REGEX.test(a.path) ? 1 : -1
}
let i
let res = 0
2017-08-14 12:01:10 +00:00
let y = 0
let z = 0
const _a = a.path.split('/')
const _b = b.path.split('/')
for (i = 0; i < _a.length; i++) {
if (res !== 0) {
break
}
y = _a[i] === '*' ? 2 : _a[i].includes(':') ? 1 : 0
z = _b[i] === '*' ? 2 : _b[i].includes(':') ? 1 : 0
res = y - z
2017-08-14 12:01:10 +00:00
// If a.length >= b.length
if (i === _b.length - 1 && res === 0) {
2017-08-14 12:01:10 +00:00
// change order if * found
res = _a[i] === '*' ? -1 : 1
}
}
2017-08-14 12:01:10 +00:00
return res === 0 ? (_a[i - 1] === '*' && _b[i] ? 1 : -1) : res
})
})
return cleanChildrenRoutes(routes)
}
// Guard dir1 from dir2 which can be indiscriminately removed
export const guardDir = function guardDir(options, key1, key2) {
const dir1 = get(options, key1, false)
const dir2 = get(options, key2, false)
if (
dir1 &&
dir2 &&
(
dir1 === dir2 ||
(
dir1.startsWith(dir2) &&
!path.basename(dir1).startsWith(path.basename(dir2))
)
)
) {
const errorMessage = `options.${key2} cannot be a parent of or same as ${key1}`
consola.fatal(errorMessage)
throw new Error(errorMessage)
}
}
export const determineGlobals = function determineGlobals(globalName, globals) {
const _globals = {}
for (const global in globals) {
if (typeof globals[global] === 'function') {
_globals[global] = globals[global](globalName)
} else {
_globals[global] = globals[global]
}
}
return _globals
}
const getRoutePathExtension = (key) => {
if (key === '_') {
return '*'
}
if (key.startsWith('_')) {
return `:${key.substr(1)}`
}
return key
}
const DYNAMIC_ROUTE_REGEX = /^\/(:|\*)/
/**
* Wraps value in array if it is not already an array
*
* @param {any} value
* @return {array}
*/
export const wrapArray = value => Array.isArray(value) ? value : [value]
2018-10-24 13:46:06 +00:00
const WHITESPACE_REPLACEMENTS = [
[/[ \t\f\r]+\n/g, '\n'], // strip empty indents
[/{\n{2,}/g, '{\n'], // strip start padding from blocks
[/\n{2,}([ \t\f\r]*})/g, '\n$1'], // strip end padding from blocks
[/\n{3,}/g, '\n\n'], // strip multiple blank lines (1 allowed)
[/\n{2,}$/g, '\n'] // strip blank lines EOF (0 allowed)
]
export const stripWhitespace = function stripWhitespace(string) {
WHITESPACE_REPLACEMENTS.forEach(([regex, newSubstr]) => {
string = string.replace(regex, newSubstr)
})
return string
}