$urlMatcherFactory

service in module ui.router.util

Methods

• caseInsensitive(value)

  Defines whether URL matching should be case sensitive (the default behavior), or not.

  Parameters

  Param	Type	Details
  value	boolean	false to match URL in a case sensitive manner; otherwise true;

  Returns

  boolean

  the current value of caseInsensitive

• compile(pattern, config)

  Creates a UrlMatcher for the specified pattern.

  Parameters

  Param	Type	Details
  pattern	string	The URL pattern.
  config	Object	The config object hash.

  Returns

  UrlMatcher

  The UrlMatcher.

• defaultSquashPolicy(value)

  Sets the default behavior when generating or matching URLs with default parameter values.

  Parameters

  Param	Type	Details
  value	string	A string that defines the default parameter URL squashing behavior. nosquash: When generating an href with a default parameter value, do not squash the parameter value from the URL slash: When generating an href with a default parameter value, squash (remove) the parameter value, and, if the parameter is surrounded by slashes, squash (remove) one slash from the URL any other string, e.g. "~": When generating an href with a default parameter value, squash (remove) the parameter value from the URL and replace it with this string.

• isMatcher(object)

  Returns true if the specified object is a UrlMatcher, or false otherwise.

  Parameters

  Param	Type	Details
  object	Object	The object to perform the type check against.

  Returns

  Boolean

  Returns true if the object matches the UrlMatcher interface, by implementing all the same methods.

• strictMode(value)

  Defines whether URLs should match trailing slashes, or not (the default behavior).

  Parameters

  Param	Type	Details
  value (optional)	boolean	false to match trailing slashes in URLs, otherwise true.

  Returns

  boolean

  the current value of strictMode

• type(name, definition, definitionFn)

  Registers a custom Type object that can be used to generate URLs with typed parameters.

  Parameters

  Param	Type	Details
  name	string	The type name.
  definition	ObjectFunction	The type definition. See Type for information on the values accepted.
  definitionFn	ObjectFunction	(optional) A function that is injected before the app runtime starts. The result of this function is merged into the existing definition. See Type for information on the values accepted.

  Returns

  Object

  Returns $urlMatcherFactoryProvider.

  Example

  This is a simple example of a custom type that encodes and decodes items from an array, using the array index as the URL-encoded value:

  var list = ['John', 'Paul', 'George', 'Ringo'];
  
  $urlMatcherFactoryProvider.type('listItem', {
    encode: function(item) {
      // Represent the list item in the URL using its corresponding index
      return list.indexOf(item);
    },
    decode: function(item) {
      // Look up the list item by index
      return list[parseInt(item, 10)];
    },
    is: function(item) {
      // Ensure the item is valid by checking to see that it appears
      // in the list
      return list.indexOf(item) > -1;
    }
  });
  
  $stateProvider.state('list', {
    url: "/list/{item:listItem}",
    controller: function($scope, $stateParams) {
      console.log($stateParams.item);
    }
  });
  
  // ...
  
  // Changes URL to '/list/3', logs "Ringo" to the console
  $state.go('list', { item: "Ringo" });
  

  This is a more complex example of a type that relies on dependency injection to interact with services, and uses the parameter name from the URL to infer how to handle encoding and decoding parameter values:

  // Defines a custom type that gets a value from a service,
  // where each service gets different types of values from
  // a backend API:
  $urlMatcherFactoryProvider.type('dbObject', {}, function(Users, Posts) {
  
    // Matches up services to URL parameter names
    var services = {
      user: Users,
      post: Posts
    };
  
    return {
      encode: function(object) {
        // Represent the object in the URL using its unique ID
        return object.id;
      },
      decode: function(value, key) {
        // Look up the object by ID, using the parameter
        // name (key) to call the correct service
        return services[key].findById(value);
      },
      is: function(object, key) {
        // Check that object is a valid dbObject
        return angular.isObject(object) && object.id && services[key];
      }
      equals: function(a, b) {
        // Check the equality of decoded objects by comparing
        // their unique IDs
        return a.id === b.id;
      }
    };
  });
  
  // In a config() block, you can then attach URLs with
  // type-annotated parameters:
  $stateProvider.state('users', {
    url: "/users",
    // ...
  }).state('users.item', {
    url: "/{user:dbObject}",
    controller: function($scope, $stateParams) {
      // $stateParams.user will now be an object returned from
      // the Users service
    },
    // ...
  });