space-router 0.9.5 → 1.1.0

package/src/router.js

@@ -1,147 +0,0 @@
-import { match as findMatch } from './match'
-import { createHistory } from './history'
-import { qs as defaultQs } from './qs'
-
-export function createRouter(options = {}) {
-  let history = null
-  let routes = []
-  const mode = options.mode || 'history'
-  const qs = options.qs || defaultQs
-  const sync = options.sync || false
-
-  const router = {
-    listen(routeMap, cb) {
-      if (history) {
-        throw new Error('Already listening')
-      }
-
-      routes = flatten(routeMap)
-      history = createHistory({ mode, sync })
-      const dispose = history.listen((url) => transition(router, url, cb))
-
-      return () => {
-        dispose()
-        history = null
-        routes = []
-      }
-    },
-
-    navigate(to, curr) {
-      if (typeof to === 'string') {
-        to = { url: to }
-      }
-      const url = router.href(to, curr)
-      if (to.replace) {
-        history.replace(url)
-      } else {
-        history.push(url)
-      }
-    },
-
-    href(to, curr) {
-      // already a url
-      if (typeof to === 'string') {
-        return to
-      }
-
-      // align with navigate API
-      if (to.url) {
-        return to.url
-      }
-
-      if (to.merge) {
-        curr = curr || router.match(router.getUrl())
-        to = merge(curr, to)
-      }
-
-      let url = to.pathname || '/'
-
-      if (to.params) {
-        Object.keys(to.params).forEach((param) => {
-          url = url.replace(':' + param, to.params[param])
-        })
-      }
-
-      if (to.query && Object.keys(to.query).length) {
-        const query = qs.stringify(to.query)
-        if (query) {
-          url = url + '?' + query
-        }
-      }
-
-      if (to.hash) {
-        const prefix = to.hash.startsWith('#') ? '' : '#'
-        url = url + prefix + to.hash
-      }
-
-      return url
-    },
-
-    match(url) {
-      const route = findMatch(routes, url, qs)
-      if (route) {
-        return { ...route, data: data(routes, route) }
-      }
-    },
-
-    getUrl() {
-      return history.getUrl()
-    },
-  }
-
-  return router
-}
-
-export function flatten(routeMap) {
-  const routes = []
-  const parentData = []
-  function addLevel(level) {
-    level.forEach((route) => {
-      const { path = '', routes: children, ...routeData } = route
-      routes.push({ pattern: path, data: parentData.concat([routeData]) })
-      if (children) {
-        parentData.push(routeData)
-        addLevel(children)
-        parentData.pop()
-      }
-    })
-  }
-  addLevel(routeMap)
-  return routes
-}
-
-function transition(router, url, onNavigated) {
-  const route = router.match(url)
-  if (route) {
-    for (const r of route.data) {
-      if (r.redirect) {
-        const url = redirectUrl(router, r.redirect, route)
-        return router.navigate({ url, replace: true })
-      }
-    }
-    if (onNavigated) onNavigated(route)
-  }
-}
-
-function redirectUrl(router, redirect, matchingRoute) {
-  if (typeof redirect === 'function') {
-    redirect = redirect(matchingRoute)
-  }
-  return router.href(redirect)
-}
-
-function data(routes, matchingRoute) {
-  for (let i = 0; i < routes.length; i++) {
-    if (routes[i].pattern === matchingRoute.pattern) {
-      return routes[i].data
-    }
-  }
-}
-
-export function merge(curr = {}, to) {
-  const pathname = to.pathname || curr.pattern || curr.pathname
-  const params = Object.assign({}, curr.params, to.params)
-  const query = to.query === null ? null : Object.assign({}, curr.query, to.query)
-  const hash = to.hash === null ? null : to.hash || curr.hash || ''
-  return { pathname, params, query, hash }
-}

package/tasks/build.js

@@ -1,16 +0,0 @@
-const fs = require('fs')
-const path = require('path')
-
-;(async function () {
-  const { execa } = await import('execa')
-  const sh = (...args) => execa(...args, { stdio: 'inherit', shell: true })
-
-  await sh('rm -rf dist')
-  await sh('mkdir -p dist')
-
-  const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, '../package.json')))
-
-  const swc = './node_modules/.bin/swc'
-  await sh(`${swc} --no-swcrc src -d ${pkg.main} --strip-leading-paths --config-file=./.swc-cjs`)
-  await sh(`${swc} --no-swcrc src -d ${pkg.module} --strip-leading-paths --config-file=./.swc-esm`)
-})()

package/test/flatten.test.js

@@ -1,58 +0,0 @@
-import test from 'ava'
-import { flatten } from '../src/router'
-
-test('converts array of routes to array of internal route descriptors', (t) => {
-  t.deepEqual(
-    flatten([
-      { path: '/foo', a: 'foo' },
-      { path: '/bar', a: 'bar' },
-    ]),
-    [
-      { pattern: '/foo', data: [{ a: 'foo' }] },
-      { pattern: '/bar', data: [{ a: 'bar' }] },
-    ],
-  )
-})
-
-test('handles nested routes', (t) => {
-  t.deepEqual(
-    flatten([
-      {
-        component: 'root',
-        routes: [
-          {
-            path: '/foo',
-            component: 'foo',
-            routes: [
-              {
-                path: '/foo/bar',
-                component: 'bar',
-              },
-            ],
-          },
-        ],
-      },
-      {
-        path: '/second',
-        component: 'second-root',
-        routes: [
-          {
-            path: '/baz/*',
-            component: 'baz',
-          },
-        ],
-      },
-    ]),
-    [
-      { pattern: '', data: [{ component: 'root' }] },
-      { pattern: '/foo', data: [{ component: 'root' }, { component: 'foo' }] },
-      { pattern: '/foo/bar', data: [{ component: 'root' }, { component: 'foo' }, { component: 'bar' }] },
-      { pattern: '/second', data: [{ component: 'second-root' }] },
-      { pattern: '/baz/*', data: [{ component: 'second-root' }, { component: 'baz' }] },
-    ],
-  )
-})
-
-test('handles empty array', (t) => {
-  t.deepEqual(flatten([]), [])
-})

package/test/match.test.js

@@ -1,68 +0,0 @@
-import test from 'ava'
-import { qs } from '../src'
-import { matchOne as match } from '../src/match'
-
-test('match explicit equality', (t) => {
-  t.deepEqual(match('/', '/').params, {})
-  t.deepEqual(match('/a', '/a').params, {})
-  t.deepEqual(match('/a', '/b'), false)
-  t.deepEqual(match('/a/b', '/a/b').params, {})
-  t.deepEqual(match('/a/b', '/a/a'), false)
-  t.deepEqual(match('/a/b', '/b/b'), false)
-})
-
-test('match param segments', (t) => {
-  t.deepEqual(match('/:foo', '/'), false)
-  t.deepEqual(match('/:foo', '/bar').params, { foo: 'bar' })
-  t.deepEqual(match('/bar/:foo', '/bar/baz').params, { foo: 'baz' })
-})
-
-test('match optional param segments', (t) => {
-  t.deepEqual(match('/:foo?', '/').params, { foo: '' })
-  t.deepEqual(match('/:foo?', '/bar').params, { foo: 'bar' })
-  t.deepEqual(match('/:foo?/:bar?', '/').params, { foo: '', bar: '' })
-  t.deepEqual(match('/:foo?/:bar?', '/bar').params, { foo: 'bar', bar: '' })
-  t.deepEqual(match('/:foo?/bar', '/bar'), false)
-  t.deepEqual(match('/:foo?/bar', '/foo/bar').params, { foo: 'foo' })
-})
-
-test('match splat param segments', (t) => {
-  t.deepEqual(match('/:foo*', '/').params, { foo: '' })
-  t.deepEqual(match('/:foo*', '/a').params, { foo: 'a' })
-  t.deepEqual(match('/:foo*', '/a/b').params, { foo: 'a/b' })
-  t.deepEqual(match('/:foo*', '/a/b/c').params, { foo: 'a/b/c' })
-})
-
-test('match required splat param segments', (t) => {
-  t.deepEqual(match('/:foo+', '/'), false)
-  t.deepEqual(match('/:foo+', '/a').params, { foo: 'a' })
-  t.deepEqual(match('/:foo+', '/a/b').params, { foo: 'a/b' })
-  t.deepEqual(match('/:foo+', '/a/b/c').params, { foo: 'a/b/c' })
-})
-
-test('match catch all', (t) => {
-  t.deepEqual(match('*', '/some/thing?abc=1', qs), {
-    url: '/some/thing?abc=1',
-    pathname: '/some/thing',
-    pattern: '*',
-    params: {},
-    query: { abc: '1' },
-    search: '?abc=1',
-    hash: '',
-  })
-  t.deepEqual(!!match('*', '/a', qs), true)
-  t.deepEqual(!!match('*', '/a/b', qs), true)
-  t.deepEqual(!!match('*', '/a/b/c', qs), true)
-})
-
-test('match query params', (t) => {
-  t.deepEqual(match('/bar/:foo', '/bar/baz?q=s#abc', qs), {
-    url: '/bar/baz?q=s#abc',
-    pathname: '/bar/baz',
-    pattern: '/bar/:foo',
-    params: { foo: 'baz' },
-    query: { q: 's' },
-    search: '?q=s',
-    hash: '#abc',
-  })
-})

package/test/router.test.js

@@ -1,157 +0,0 @@
-import test from 'ava'
-import { qs, createRouter } from '../src/index'
-
-test('createRouter, listen, navigate and dispose', (t) => {
-  const calls = []
-
-  const { router, dispose } = createTestRouter((route) => {
-    calls.push(route.data[0].render(route.params, route.query, route.hash))
-  })
-
-  router.navigate({ url: '/foo' })
-  router.navigate({ url: '/user/5' })
-  router.navigate({ url: '/user/7/friends' })
-  router.navigate({ url: '/user/7' })
-  router.navigate({ url: '/user/8/posts' })
-  router.navigate('/bar')
-  router.navigate('/user/1')
-  router.navigate({ pathname: '/user/:id', params: { id: 2 } })
-  router.navigate({ pathname: '/user/2', query: { a: 1, b: 2 } })
-  router.navigate({ query: { a: 11, b: 22 }, merge: true })
-  router.navigate({ query: { b: undefined, c: 'bla' }, hash: 'test', merge: true })
-  router.navigate({ params: { id: 3 }, merge: true })
-  router.navigate({ query: { curr: 'test' }, merge: true }, { pathname: '/user/curr' })
-
-  t.deepEqual(
-    [
-      'foo',
-      'user=5',
-      'friends=7',
-      'user=7',
-      'catchall',
-      'bar',
-      'user=1',
-      'user=2',
-      'user=2?a=1&b=2',
-      'user=2?a=11&b=22',
-      'user=2?a=11&c=bla#test',
-      'user=3?a=11&c=bla#test',
-      'user=curr?curr=test',
-    ],
-    calls,
-  )
-
-  dispose()
-})
-
-test('.href(to)', (t) => {
-  const { router, dispose } = createTestRouter()
-
-  t.deepEqual('/user/7/friends?a=1&b=2', router.href({ pathname: '/user/7/friends', query: { a: 1, b: 2 } }))
-
-  t.deepEqual(
-    router.href({ pathname: '/user/:id/friends', params: { id: 7 }, query: { a: 1, b: 2 } }),
-    '/user/7/friends?a=1&b=2',
-  )
-  t.deepEqual(
-    router.href({ pathname: '/user/:id/friends', params: { id: 7 }, query: { a: 1, b: 2 }, hash: '#bla' }),
-    '/user/7/friends?a=1&b=2#bla',
-  )
-  t.deepEqual(router.href({ pathname: '/user/:id/friends', params: { id: 8 }, hash: '#foo' }), '/user/8/friends#foo')
-  t.deepEqual(
-    router.href({ pathname: '/user/:id/friends', params: { id: 8 }, query: {}, hash: '#foo' }),
-    '/user/8/friends#foo',
-  )
-  t.deepEqual(
-    router.href({ pathname: '/user/:id/friends', params: { id: 8 }, query: { q: null }, hash: '#foo' }),
-    '/user/8/friends?q=null#foo',
-  )
-  t.deepEqual(
-    router.href({ pathname: '/user/:id/friends', params: { id: 8 }, query: { q: undefined }, hash: '#foo' }),
-    '/user/8/friends#foo',
-  )
-  t.deepEqual(
-    router.href({ pathname: '/user/:id/friends', params: { id: 8 }, query: { q: undefined }, hash: '#foo' }),
-    '/user/8/friends#foo',
-  )
-  t.deepEqual(router.href({ params: { id: 8 }, query: { q: 1 }, hash: '#foo' }), '/?q=1#foo')
-
-  dispose()
-})
-
-test('.match(url)', (t) => {
-  const { router, dispose } = createTestRouter()
-
-  const route = {
-    url: '/user/7/settings?a=1#hello',
-    pattern: '/user/:id/settings',
-    pathname: '/user/7/settings',
-    params: { id: '7' },
-    query: { a: '1' },
-    search: '?a=1',
-    hash: '#hello',
-    data: [{ datum: 'settings-data' }],
-  }
-  t.deepEqual(router.match('/user/7/settings?a=1#hello'), route)
-
-  dispose()
-})
-
-test('.match(url) without catch all', (t) => {
-  const { router, dispose } = createTestRouter(null, { withoutCatchAll: true })
-
-  const route = router.match('/unknown')
-  t.is(route, undefined)
-
-  dispose()
-})
-
-test('.getUrl()', (t) => {
-  const { router } = createTestRouter()
-
-  router.navigate('/user/8')
-  t.is(router.getUrl(), '/user/8')
-})
-
-test('redirects', (t) => {
-  const calls = []
-
-  const { router, dispose } = createTestRouter((route) => {
-    calls.push(route.data[0].render(route.params, route.query))
-  })
-
-  router.navigate('/redirect-via-obj-1')
-  router.navigate('/redirect-via-obj-2')
-  router.navigate('/redirect-via-fn-1/2')
-  router.navigate('/redirect-via-fn-2/2')
-
-  t.deepEqual(['bar', 'user=1', 'user=2', 'foo'], calls)
-
-  dispose()
-})
-
-function createTestRouter(cb, { withoutCatchAll = false } = {}) {
-  const router = createRouter({ mode: 'memory', sync: true })
-  const dispose = router.listen(
-    [
-      { path: '/foo', render: () => 'foo' },
-      { path: '/bar', render: () => 'bar' },
-      { path: '/redirect-via-obj-1', redirect: 'bar' },
-      { path: '/redirect-via-obj-2', redirect: { pathname: '/user/:id', params: { id: 1 } } },
-      { path: '/redirect-via-fn-1/:id', redirect: ({ params }) => ({ pathname: '/user/:id', params }) },
-      { path: '/redirect-via-fn-2/:id', redirect: () => ({ url: '/foo' }) },
-      {
-        path: '/user/:id',
-        render: (params, query, hash = '') => {
-          const q = query && Object.keys(query).length ? `?${qs.stringify(query)}` : ''
-          return 'user=' + params.id + q + hash
-        },
-      },
-      { path: '/user/:id/friends', render: (params) => 'friends=' + params.id },
-      { path: '/user/:id/settings', datum: 'settings-data' },
-      !withoutCatchAll && { path: '*', render: () => 'catchall' },
-    ].filter(Boolean),
-    cb,
-  )
-  return { router, dispose }
-}