Two way `URL` <==> `route(params)` converter with mapper

Downloads in past


4202.0.06 years ago9 years agoMinified + gzip package size for url-mapper in KB


Two way URL <==> route(params) converter with mapper.
!NPM versionnpm-imagenpm-url !Build statustravis-imagetravis-url !Test coveragecoveralls-imagecoveralls-url !bitHound Scorebithound-imagebithound-url !Commitizen friendlycommitizen-imagecommitizen-url !Semantic Releasesemantic-release-imagesemantic-release-url !js-standard-stylestandard-imagestandard-url


npm install url-mapper --save



The main purpose of url-mapper is to match given URL to one of the routes. It will return the matched route (key and associated value) and parsed parameters. You can associate anything you want with route: function, React component or just plain object.
url-mapper is helpful when creating router packages for frameworks or can be used as router itself. It allows you to outsource working with a url (mapping, parsing, stringifying) and concentrate on wiring up things related to your favorite framework.


import React from 'react'
import ReactDOM from 'react-dom'
import Mapper from 'url-mapper'
import { CoreApp, ComponentA, ComponentB, Component404 } from './components'

const urlMapper = Mapper()

var matchedRoute = urlMapper.map('/bar/baz/:42', { // routable part of url
  '/foo/:id': ComponentA,
  '/bar/:list/:itemId': ComponentB,
  '*': Component404

if (matchedRoute) {
  const Component = matchedRoute.match // ComponentB
  const props = matchedRoute.values // { list: 'baz', itemId: 42 }

      <Component {...props} />

See @cerebral/router as an example of building your own router solution on top of url-mapper. Also see example at Runkit Sandbox to try it right in your browser.


Main module

At top level the url-mapper module exports a factory which returns default implementation of an URL <==> route(params) converter.


var urlMapper = require('url-mapper')
var mapper = urlMapper(options)
<td>Options passed to converter.
      <td>Enables converting values not defined in route as query in URL Object Notation</td>
      <td>String used to separate query from routable part. Default <code>'?'</code>.</td>
Object - Object with parse, stringify and map methods.
Returned methods deals with Express-style route definitions and cleaned routable part of url (without origin, base path, leading hash symbol).
Params defined in route are mapped to the same named properties in the values Object with help of path-to-regexp module. It is safe to pass Numbers and Booleans as well as Strings as path parameteres. The original type would be preserved while parsing back stringified one.
By default, the query part is ignored. Query part params are mapped to the same named properties in values Object if { query: true } option was passed to factory. Conversion of the query part is made with help of URLON module. Therefore, it can accept any JSON serializable value.
Hash part is ignored at all if any present. You still can manage your routes in location.hash but don't provide # symbol before routable part.

parse method

mapper.parse(route, url)
Param | Type | Details ------|----------|-------- route | String | Express style route definition url | String | Routable part of url
Object - values parsed from url with given route.
Path parsed using path-to-regexp module, tweaked to support Boolean and Number. Query part parsed with URLON module if { query: true } option was passed to factory.

stringify method

mapper.stringify(route, values)
Param | Type | Details -------|----------|-------- route | String | Express style route definition values | Object | Object used to populate parameters in route definition
String - values stringified to url with given route.
Properties defined in route are stringified to path part using path-to-regexp module, tweaked to support Boolean and Number. Properties not defined in route are stringified to query part using URLON module if { query: true } option was passed to factory.

map method

mapper.map(url, routes)
Param | Type | Details -------|----------|-------- url | String | Routable part of url routes | Object | Routes to map url with
Object - Object representing matched route with properties:
Property | Type | Details ----------|----------|-------- route | String | Matched route defined as key in routes match | Any | Value from routes associated with matched route values | Object | Values parsed from given url with matched route


Custom converting algoritms could be implemented by providing a custom compile function. If you don't like default route definition format or converting algorithms, feel free to make your own.


var urlMapper = require('url-mapper/mapper')
var mapper = urlMapper(compileFn, options)
Param | Type | Details ----------|------------|-------- compileFn | Function | Function used by mapper to "compile" a route. options | Any | Optional. Passed to compileFn as second argument.
For each route mapper would call compileFn(route, options) and cache result internally. compileFn should return parse(url) and stringify(values) methods for any given route. See default implementation for reference.
Object - Object with parse(route, url), stringify(route, values) and map(url, routes) methods.
These methods will use cached methods returned by compileFn for given routes.