From 5bdc6ecec822cfeda63b9f943177d8b17d41cffe Mon Sep 17 00:00:00 2001 From: vsavkin Date: Fri, 27 May 2016 11:36:17 -0700 Subject: [PATCH] chore: adds the build dir to use with 'npm install' --- modules/@angular/router/build/README.md | 1 + .../@angular/router/build/es6/src/config.d.ts | 9 + .../@angular/router/build/es6/src/config.js | 1 + .../router/build/es6/src/create_url_tree.d.ts | 4 + .../router/build/es6/src/create_url_tree.js | 185 +++++++++++++++ .../build/es6/src/directives/router_link.d.ts | 13 + .../build/es6/src/directives/router_link.js | 65 +++++ .../es6/src/directives/router_outlet.d.ts | 11 + .../build/es6/src/directives/router_outlet.js | 39 +++ .../@angular/router/build/es6/src/index.d.ts | 7 + .../@angular/router/build/es6/src/index.js | 8 + .../router/build/es6/src/recognize.d.ts | 5 + .../router/build/es6/src/recognize.js | 166 +++++++++++++ .../@angular/router/build/es6/src/router.d.ts | 40 ++++ .../@angular/router/build/es6/src/router.js | 138 +++++++++++ .../build/es6/src/router_outlet_map.d.ts | 7 + .../router/build/es6/src/router_outlet_map.js | 7 + .../router/build/es6/src/router_state.d.ts | 18 ++ .../router/build/es6/src/router_state.js | 28 +++ .../@angular/router/build/es6/src/shared.d.ts | 4 + .../@angular/router/build/es6/src/shared.js | 2 + .../router/build/es6/src/url_serializer.d.ts | 10 + .../router/build/es6/src/url_serializer.js | 212 +++++++++++++++++ .../router/build/es6/src/url_tree.d.ts | 23 ++ .../@angular/router/build/es6/src/url_tree.js | 43 ++++ .../build/es6/src/utils/collection.d.ts | 17 ++ .../router/build/es6/src/utils/collection.js | 49 ++++ .../router/build/es6/src/utils/tree.d.ts | 17 ++ .../router/build/es6/src/utils/tree.js | 71 ++++++ modules/@angular/router/build/package.json | 68 ++++++ modules/@angular/router/build/src/config.d.ts | 9 + modules/@angular/router/build/src/config.js | 2 + .../router/build/src/create_url_tree.d.ts | 4 + .../router/build/src/create_url_tree.js | 189 +++++++++++++++ .../build/src/directives/router_link.d.ts | 13 + .../build/src/directives/router_link.js | 72 ++++++ .../build/src/directives/router_outlet.d.ts | 11 + .../build/src/directives/router_outlet.js | 46 ++++ modules/@angular/router/build/src/index.d.ts | 7 + modules/@angular/router/build/src/index.js | 15 ++ .../@angular/router/build/src/recognize.d.ts | 5 + .../@angular/router/build/src/recognize.js | 171 +++++++++++++ modules/@angular/router/build/src/router.d.ts | 40 ++++ modules/@angular/router/build/src/router.js | 159 +++++++++++++ .../router/build/src/router_outlet_map.d.ts | 7 + .../router/build/src/router_outlet_map.js | 10 + .../router/build/src/router_state.d.ts | 18 ++ .../@angular/router/build/src/router_state.js | 40 ++++ modules/@angular/router/build/src/shared.d.ts | 4 + modules/@angular/router/build/src/shared.js | 3 + .../router/build/src/url_serializer.d.ts | 10 + .../router/build/src/url_serializer.js | 224 ++++++++++++++++++ .../@angular/router/build/src/url_tree.d.ts | 23 ++ modules/@angular/router/build/src/url_tree.js | 56 +++++ .../router/build/src/utils/collection.d.ts | 17 ++ .../router/build/src/utils/collection.js | 55 +++++ .../@angular/router/build/src/utils/tree.d.ts | 17 ++ .../@angular/router/build/src/utils/tree.js | 88 +++++++ modules/@angular/router/package.json | 6 +- 59 files changed, 2586 insertions(+), 3 deletions(-) create mode 100644 modules/@angular/router/build/README.md create mode 100644 modules/@angular/router/build/es6/src/config.d.ts create mode 100644 modules/@angular/router/build/es6/src/config.js create mode 100644 modules/@angular/router/build/es6/src/create_url_tree.d.ts create mode 100644 modules/@angular/router/build/es6/src/create_url_tree.js create mode 100644 modules/@angular/router/build/es6/src/directives/router_link.d.ts create mode 100644 modules/@angular/router/build/es6/src/directives/router_link.js create mode 100644 modules/@angular/router/build/es6/src/directives/router_outlet.d.ts create mode 100644 modules/@angular/router/build/es6/src/directives/router_outlet.js create mode 100644 modules/@angular/router/build/es6/src/index.d.ts create mode 100644 modules/@angular/router/build/es6/src/index.js create mode 100644 modules/@angular/router/build/es6/src/recognize.d.ts create mode 100644 modules/@angular/router/build/es6/src/recognize.js create mode 100644 modules/@angular/router/build/es6/src/router.d.ts create mode 100644 modules/@angular/router/build/es6/src/router.js create mode 100644 modules/@angular/router/build/es6/src/router_outlet_map.d.ts create mode 100644 modules/@angular/router/build/es6/src/router_outlet_map.js create mode 100644 modules/@angular/router/build/es6/src/router_state.d.ts create mode 100644 modules/@angular/router/build/es6/src/router_state.js create mode 100644 modules/@angular/router/build/es6/src/shared.d.ts create mode 100644 modules/@angular/router/build/es6/src/shared.js create mode 100644 modules/@angular/router/build/es6/src/url_serializer.d.ts create mode 100644 modules/@angular/router/build/es6/src/url_serializer.js create mode 100644 modules/@angular/router/build/es6/src/url_tree.d.ts create mode 100644 modules/@angular/router/build/es6/src/url_tree.js create mode 100644 modules/@angular/router/build/es6/src/utils/collection.d.ts create mode 100644 modules/@angular/router/build/es6/src/utils/collection.js create mode 100644 modules/@angular/router/build/es6/src/utils/tree.d.ts create mode 100644 modules/@angular/router/build/es6/src/utils/tree.js create mode 100644 modules/@angular/router/build/package.json create mode 100644 modules/@angular/router/build/src/config.d.ts create mode 100644 modules/@angular/router/build/src/config.js create mode 100644 modules/@angular/router/build/src/create_url_tree.d.ts create mode 100644 modules/@angular/router/build/src/create_url_tree.js create mode 100644 modules/@angular/router/build/src/directives/router_link.d.ts create mode 100644 modules/@angular/router/build/src/directives/router_link.js create mode 100644 modules/@angular/router/build/src/directives/router_outlet.d.ts create mode 100644 modules/@angular/router/build/src/directives/router_outlet.js create mode 100644 modules/@angular/router/build/src/index.d.ts create mode 100644 modules/@angular/router/build/src/index.js create mode 100644 modules/@angular/router/build/src/recognize.d.ts create mode 100644 modules/@angular/router/build/src/recognize.js create mode 100644 modules/@angular/router/build/src/router.d.ts create mode 100644 modules/@angular/router/build/src/router.js create mode 100644 modules/@angular/router/build/src/router_outlet_map.d.ts create mode 100644 modules/@angular/router/build/src/router_outlet_map.js create mode 100644 modules/@angular/router/build/src/router_state.d.ts create mode 100644 modules/@angular/router/build/src/router_state.js create mode 100644 modules/@angular/router/build/src/shared.d.ts create mode 100644 modules/@angular/router/build/src/shared.js create mode 100644 modules/@angular/router/build/src/url_serializer.d.ts create mode 100644 modules/@angular/router/build/src/url_serializer.js create mode 100644 modules/@angular/router/build/src/url_tree.d.ts create mode 100644 modules/@angular/router/build/src/url_tree.js create mode 100644 modules/@angular/router/build/src/utils/collection.d.ts create mode 100644 modules/@angular/router/build/src/utils/collection.js create mode 100644 modules/@angular/router/build/src/utils/tree.d.ts create mode 100644 modules/@angular/router/build/src/utils/tree.js diff --git a/modules/@angular/router/build/README.md b/modules/@angular/router/build/README.md new file mode 100644 index 0000000000..eb02ffb1d1 --- /dev/null +++ b/modules/@angular/router/build/README.md @@ -0,0 +1 @@ +# vladivostok diff --git a/modules/@angular/router/build/es6/src/config.d.ts b/modules/@angular/router/build/es6/src/config.d.ts new file mode 100644 index 0000000000..d0f5b418d6 --- /dev/null +++ b/modules/@angular/router/build/es6/src/config.d.ts @@ -0,0 +1,9 @@ +import { Type } from '@angular/core'; +export declare type RouterConfig = Route[]; +export interface Route { + index?: boolean; + path?: string; + component: Type | string; + outlet?: string; + children?: Route[]; +} diff --git a/modules/@angular/router/build/es6/src/config.js b/modules/@angular/router/build/es6/src/config.js new file mode 100644 index 0000000000..bc64eabff3 --- /dev/null +++ b/modules/@angular/router/build/es6/src/config.js @@ -0,0 +1 @@ +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZmlnLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2NvbmZpZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgVHlwZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5leHBvcnQgdHlwZSBSb3V0ZXJDb25maWcgPSBSb3V0ZVtdO1xuXG5leHBvcnQgaW50ZXJmYWNlIFJvdXRlIHtcbiAgaW5kZXg/OiBib29sZWFuO1xuICBwYXRoPzogc3RyaW5nO1xuICBjb21wb25lbnQ6IFR5cGUgfCBzdHJpbmc7XG4gIG91dGxldD86IHN0cmluZztcbiAgY2hpbGRyZW4/OiBSb3V0ZVtdO1xufSJdfQ== \ No newline at end of file diff --git a/modules/@angular/router/build/es6/src/create_url_tree.d.ts b/modules/@angular/router/build/es6/src/create_url_tree.d.ts new file mode 100644 index 0000000000..999cea0d39 --- /dev/null +++ b/modules/@angular/router/build/es6/src/create_url_tree.d.ts @@ -0,0 +1,4 @@ +import { UrlTree } from './url_tree'; +import { ActivatedRoute } from './router_state'; +import { Params } from './shared'; +export declare function createUrlTree(route: ActivatedRoute, urlTree: UrlTree, commands: any[], queryParameters: Params | undefined, fragment: string | undefined): UrlTree; diff --git a/modules/@angular/router/build/es6/src/create_url_tree.js b/modules/@angular/router/build/es6/src/create_url_tree.js new file mode 100644 index 0000000000..e08b1586c8 --- /dev/null +++ b/modules/@angular/router/build/es6/src/create_url_tree.js @@ -0,0 +1,185 @@ +import { UrlTree, UrlSegment } from './url_tree'; +import { TreeNode, rootNode } from './utils/tree'; +import { forEach, shallowEqual } from './utils/collection'; +import { PRIMARY_OUTLET } from './shared'; +export function createUrlTree(route, urlTree, commands, queryParameters, fragment) { + if (commands.length === 0) { + return tree(rootNode(urlTree), urlTree, queryParameters, fragment); + } + const normalizedCommands = normalizeCommands(commands); + if (navigateToRoot(normalizedCommands)) { + return tree(new TreeNode(urlTree.root, []), urlTree, queryParameters, fragment); + } + const startingNode = findStartingNode(normalizedCommands, urlTree, route); + const updated = normalizedCommands.commands.length > 0 ? + updateMany(startingNode.children.slice(0), normalizedCommands.commands) : + []; + const newRoot = constructNewTree(rootNode(urlTree), startingNode, updated); + return tree(newRoot, urlTree, queryParameters, fragment); +} +function tree(root, urlTree, queryParameters, fragment) { + const q = queryParameters ? stringify(queryParameters) : urlTree.queryParameters; + const f = fragment ? fragment : urlTree.fragment; + return new UrlTree(root, q, f); +} +function navigateToRoot(normalizedChange) { + return normalizedChange.isAbsolute && normalizedChange.commands.length === 1 && + normalizedChange.commands[0] == "/"; +} +class NormalizedNavigationCommands { + constructor(isAbsolute, numberOfDoubleDots, commands) { + this.isAbsolute = isAbsolute; + this.numberOfDoubleDots = numberOfDoubleDots; + this.commands = commands; + } +} +function normalizeCommands(commands) { + if ((typeof commands[0] === "string") && commands.length === 1 && commands[0] == "/") { + return new NormalizedNavigationCommands(true, 0, commands); + } + let numberOfDoubleDots = 0; + let isAbsolute = false; + const res = []; + for (let i = 0; i < commands.length; ++i) { + const c = commands[i]; + if (!(typeof c === "string")) { + res.push(c); + continue; + } + const parts = c.split('/'); + for (let j = 0; j < parts.length; ++j) { + let cc = parts[j]; + if (i == 0) { + if (j == 0 && cc == ".") { + } + else if (j == 0 && cc == "") { + isAbsolute = true; + } + else if (cc == "..") { + numberOfDoubleDots++; + } + else if (cc != '') { + res.push(cc); + } + } + else { + if (cc != '') { + res.push(cc); + } + } + } + } + return new NormalizedNavigationCommands(isAbsolute, numberOfDoubleDots, res); +} +function findStartingNode(normalizedChange, urlTree, route) { + if (normalizedChange.isAbsolute) { + return rootNode(urlTree); + } + else { + const urlSegment = findUrlSegment(route, urlTree, normalizedChange.numberOfDoubleDots); + return findMatchingNode(urlSegment, rootNode(urlTree)); + } +} +function findUrlSegment(route, urlTree, numberOfDoubleDots) { + const segments = route.urlSegments.value; + const urlSegment = segments[segments.length - 1]; + const path = urlTree.pathFromRoot(urlSegment); + if (path.length <= numberOfDoubleDots) { + throw new Error("Invalid number of '../'"); + } + return path[path.length - 1 - numberOfDoubleDots]; +} +function findMatchingNode(segment, node) { + if (node.value === segment) + return node; + for (let c of node.children) { + const r = findMatchingNode(segment, c); + if (r) + return r; + } + throw new Error(`Cannot find url segment '${segment}'`); +} +function constructNewTree(node, original, updated) { + if (node === original) { + return new TreeNode(node.value, updated); + } + else { + return new TreeNode(node.value, node.children.map(c => constructNewTree(c, original, updated))); + } +} +function updateMany(nodes, commands) { + const outlet = getOutlet(commands); + const nodesInRightOutlet = nodes.filter(c => c.value.outlet === outlet); + if (nodesInRightOutlet.length > 0) { + const nodeRightOutlet = nodesInRightOutlet[0]; + nodes[nodes.indexOf(nodeRightOutlet)] = update(nodeRightOutlet, commands); + } + else { + nodes.push(update(null, commands)); + } + return nodes; +} +function getPath(commands) { + if (!(typeof commands[0] === "string")) + return commands[0]; + const parts = commands[0].toString().split(":"); + return parts.length > 1 ? parts[1] : commands[0]; +} +function getOutlet(commands) { + if (!(typeof commands[0] === "string")) + return PRIMARY_OUTLET; + const parts = commands[0].toString().split(":"); + return parts.length > 1 ? parts[0] : PRIMARY_OUTLET; +} +function update(node, commands) { + const rest = commands.slice(1); + const next = rest.length === 0 ? null : rest[0]; + const outlet = getOutlet(commands); + const path = getPath(commands); + if (!node && !(typeof next === 'object')) { + const urlSegment = new UrlSegment(path, {}, outlet); + const children = rest.length === 0 ? [] : [update(null, rest)]; + return new TreeNode(urlSegment, children); + } + else if (!node && typeof next === 'object') { + const urlSegment = new UrlSegment(path, stringify(next), outlet); + return recurse(urlSegment, node, rest.slice(1)); + } + else if (node && outlet !== node.value.outlet) { + return node; + } + else if (node && typeof path === 'object') { + const newSegment = new UrlSegment(node.value.path, stringify(path), node.value.outlet); + return recurse(newSegment, node, rest); + } + else if (node && typeof next === 'object' && compare(path, stringify(next), node.value)) { + return recurse(node.value, node, rest.slice(1)); + } + else if (node && typeof next === 'object') { + const urlSegment = new UrlSegment(path, stringify(next), outlet); + return recurse(urlSegment, node, rest.slice(1)); + } + else if (node && compare(path, {}, node.value)) { + return recurse(node.value, node, rest); + } + else { + const urlSegment = new UrlSegment(path, {}, outlet); + return recurse(urlSegment, node, rest); + } +} +function stringify(params) { + const res = {}; + forEach(params, (v, k) => res[k] = v.toString()); + return res; +} +function compare(path, params, segment) { + return path == segment.path && shallowEqual(params, segment.parameters); +} +function recurse(urlSegment, node, rest) { + if (rest.length === 0) { + return new TreeNode(urlSegment, []); + } + const children = node ? node.children.slice(0) : []; + return new TreeNode(urlSegment, updateMany(children, rest)); +} +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"create_url_tree.js","sourceRoot":"","sources":["../../../src/create_url_tree.ts"],"names":[],"mappings":"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","sourcesContent":["import { UrlTree, UrlSegment, equalUrlSegments } from './url_tree';\nimport { TreeNode, rootNode } from './utils/tree';\nimport { forEach, shallowEqual } from './utils/collection';\nimport { RouterState, ActivatedRoute } from './router_state';\nimport { Params, PRIMARY_OUTLET } from './shared';\n\nexport function createUrlTree(route: ActivatedRoute, urlTree: UrlTree, commands: any[], \n                              queryParameters: Params | undefined, fragment: string | undefined): UrlTree {\n  if (commands.length === 0) {\n    return tree(rootNode(urlTree), urlTree, queryParameters, fragment);\n  }\n\n  const normalizedCommands = normalizeCommands(commands);\n  if (navigateToRoot(normalizedCommands)) {\n    return tree(new TreeNode<UrlSegment>(urlTree.root, []), urlTree, queryParameters, fragment);\n  }\n\n  const startingNode = findStartingNode(normalizedCommands, urlTree, route);\n  const updated = normalizedCommands.commands.length > 0 ?\n      updateMany(startingNode.children.slice(0), normalizedCommands.commands) :\n      [];\n  const newRoot = constructNewTree(rootNode(urlTree), startingNode, updated);\n\n  return tree(newRoot, urlTree, queryParameters, fragment);\n}\n\nfunction tree(root: TreeNode<UrlSegment>, urlTree: UrlTree, queryParameters: Params | undefined, fragment: string | undefined): UrlTree {\n  const q = queryParameters ? stringify(queryParameters) : urlTree.queryParameters;\n  const f = fragment ? fragment : urlTree.fragment;\n  return new UrlTree(root, q, f);\n}\n\nfunction navigateToRoot(normalizedChange: NormalizedNavigationCommands): boolean {\n  return normalizedChange.isAbsolute && normalizedChange.commands.length === 1 &&\n    normalizedChange.commands[0] == \"/\";\n}\n\nclass NormalizedNavigationCommands {\n  constructor(public isAbsolute: boolean, public numberOfDoubleDots: number,\n              public commands: any[]) {}\n}\n\nfunction normalizeCommands(commands: any[]): NormalizedNavigationCommands {\n  if ((typeof commands[0] === \"string\") && commands.length === 1 && commands[0] == \"/\") {\n    return new NormalizedNavigationCommands(true, 0, commands);\n  }\n\n  let numberOfDoubleDots = 0;\n  let isAbsolute = false;\n  const res = [];\n\n  for (let i = 0; i < commands.length; ++i) {\n    const c = commands[i];\n\n    if (!(typeof c === \"string\")) {\n      res.push(c);\n      continue;\n    }\n\n    const parts = c.split('/');\n    for (let j = 0; j < parts.length; ++j) {\n      let cc = parts[j];\n\n      // first exp is treated in a special way\n      if (i == 0) {\n        if (j == 0 && cc == \".\") {  //  './a'\n          // skip it\n        } else if (j == 0 && cc == \"\") {  //  '/a'\n          isAbsolute = true;\n        } else if (cc == \"..\") {  //  '../a'\n          numberOfDoubleDots++;\n        } else if (cc != '') {\n          res.push(cc);\n        }\n\n      } else {\n        if (cc != '') {\n          res.push(cc);\n        }\n      }\n    }\n  }\n\n  return new NormalizedNavigationCommands(isAbsolute, numberOfDoubleDots, res);\n}\n\nfunction findStartingNode(normalizedChange: NormalizedNavigationCommands, urlTree: UrlTree,\n                           route: ActivatedRoute): TreeNode<UrlSegment> {\n  if (normalizedChange.isAbsolute) {\n    return rootNode(urlTree);\n  } else {\n    const urlSegment =\n      findUrlSegment(route, urlTree, normalizedChange.numberOfDoubleDots);\n    return findMatchingNode(urlSegment, rootNode(urlTree));\n  }\n}\n\nfunction findUrlSegment(route: ActivatedRoute, urlTree: UrlTree, numberOfDoubleDots: number): UrlSegment {\n  const segments = (<any>route.urlSegments).value;\n  const urlSegment = segments[segments.length - 1];\n  const path = urlTree.pathFromRoot(urlSegment);\n  if (path.length <= numberOfDoubleDots) {\n    throw new Error(\"Invalid number of '../'\");\n  }\n  return path[path.length - 1 - numberOfDoubleDots];\n}\n\nfunction findMatchingNode(segment: UrlSegment, node: TreeNode<UrlSegment>): TreeNode<UrlSegment> {\n  if (node.value === segment) return node;\n  for (let c of node.children) {\n    const r = findMatchingNode(segment, c);\n    if (r) return r;\n  }\n  throw new Error(`Cannot find url segment '${segment}'`);\n}\n\nfunction constructNewTree(node: TreeNode<UrlSegment>, original: TreeNode<UrlSegment>,\n                          updated: TreeNode<UrlSegment>[]): TreeNode<UrlSegment> {\n  if (node === original) {\n    return new TreeNode<UrlSegment>(node.value, updated);\n  } else {\n    return new TreeNode<UrlSegment>(\n      node.value, node.children.map(c => constructNewTree(c, original, updated)));\n  }\n}\n\nfunction updateMany(nodes: TreeNode<UrlSegment>[], commands: any[]): TreeNode<UrlSegment>[] {\n  const outlet = getOutlet(commands);\n  const nodesInRightOutlet = nodes.filter(c => c.value.outlet === outlet);\n  if (nodesInRightOutlet.length > 0) {\n    const nodeRightOutlet = nodesInRightOutlet[0];  // there can be only one\n    nodes[nodes.indexOf(nodeRightOutlet)] = update(nodeRightOutlet, commands);\n  } else {\n    nodes.push(update(null, commands));\n  }\n  return nodes;\n}\n\nfunction getPath(commands: any[]): any {\n  if (!(typeof commands[0] === \"string\")) return commands[0];\n  const parts = commands[0].toString().split(\":\");\n  return parts.length > 1 ? parts[1] : commands[0];\n}\n\nfunction getOutlet(commands: any[]): string {\n  if (!(typeof commands[0] === \"string\")) return PRIMARY_OUTLET;\n  const parts = commands[0].toString().split(\":\");\n  return parts.length > 1 ? parts[0] : PRIMARY_OUTLET;\n}\n\nfunction update(node: TreeNode<UrlSegment>|null, commands: any[]): TreeNode<UrlSegment> {\n  const rest = commands.slice(1);\n  const next = rest.length === 0 ? null : rest[0];\n  const outlet = getOutlet(commands);\n  const path = getPath(commands);\n\n  // reach the end of the tree => create new tree nodes.\n  if (!node && !(typeof next === 'object')) {\n    const urlSegment = new UrlSegment(path, {}, outlet);\n    const children = rest.length === 0 ? [] : [update(null, rest)];\n    return new TreeNode<UrlSegment>(urlSegment, children);\n\n  } else if (!node && typeof next === 'object') {\n    const urlSegment = new UrlSegment(path, stringify(next), outlet);\n    return recurse(urlSegment, node, rest.slice(1));\n\n    // different outlet => preserve the subtree\n  } else if (node && outlet !== node.value.outlet) {\n    return node;\n\n    // params command\n  } else if (node && typeof path === 'object') {\n    const newSegment = new UrlSegment(node.value.path, stringify(path), node.value.outlet);\n    return recurse(newSegment, node, rest);\n\n    // next one is a params command && can reuse the node\n  } else if (node && typeof next === 'object' && compare(path, stringify(next), node.value)) {\n    return recurse(node.value, node, rest.slice(1));\n\n    // next one is a params command && cannot reuse the node\n  } else if (node && typeof next === 'object') {\n    const urlSegment = new UrlSegment(path, stringify(next), outlet);\n    return recurse(urlSegment, node, rest.slice(1));\n\n    // next one is not a params command && can reuse the node\n  } else if (node && compare(path, {}, node.value)) {\n    return recurse(node.value, node, rest);\n\n    // next one is not a params command && cannot reuse the node\n  } else {\n    const urlSegment = new UrlSegment(path, {}, outlet);\n    return recurse(urlSegment, node, rest);\n  }\n}\n\nfunction stringify(params: {[key: string]: any}): {[key: string]: string} {\n  const res = {};\n  forEach(params, (v, k) => res[k] = v.toString());\n  return res;\n}\n\nfunction compare(path: string, params: {[key: string]: any}, segment: UrlSegment): boolean {\n  return path == segment.path && shallowEqual(params, segment.parameters);\n}\n\nfunction recurse(urlSegment: UrlSegment, node: TreeNode<UrlSegment> | null,\n                  rest: any[]): TreeNode<UrlSegment> {\n  if (rest.length === 0) {\n    return new TreeNode<UrlSegment>(urlSegment, []);\n  }\n  const children = node ? node.children.slice(0) : [];\n  return new TreeNode<UrlSegment>(urlSegment, updateMany(children, rest));\n}"]} \ No newline at end of file diff --git a/modules/@angular/router/build/es6/src/directives/router_link.d.ts b/modules/@angular/router/build/es6/src/directives/router_link.d.ts new file mode 100644 index 0000000000..5ce81cb7fc --- /dev/null +++ b/modules/@angular/router/build/es6/src/directives/router_link.d.ts @@ -0,0 +1,13 @@ +import { Router } from '../router'; +import { ActivatedRoute } from '../router_state'; +export declare class RouterLink { + private router; + private route; + target: string; + private commands; + href: string; + constructor(router: Router, route: ActivatedRoute); + routerLink: any[] | string; + onClick(): boolean; + private updateTargetUrlAndHref(); +} diff --git a/modules/@angular/router/build/es6/src/directives/router_link.js b/modules/@angular/router/build/es6/src/directives/router_link.js new file mode 100644 index 0000000000..14ec38401e --- /dev/null +++ b/modules/@angular/router/build/es6/src/directives/router_link.js @@ -0,0 +1,65 @@ +var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; +}; +var __metadata = (this && this.__metadata) || function (k, v) { + if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v); +}; +import { Directive, HostListener, HostBinding, Input } from '@angular/core'; +import { Router } from '../router'; +import { ActivatedRoute } from '../router_state'; +export let RouterLink = class RouterLink { + constructor(router, route) { + this.router = router; + this.route = route; + this.commands = []; + } + set routerLink(data) { + if (Array.isArray(data)) { + this.commands = data; + } + else { + this.commands = [data]; + } + this.updateTargetUrlAndHref(); + } + onClick() { + if (!(typeof this.target === "string") || this.target == '_self') { + this.router.navigate(this.commands, { relativeTo: this.route }); + return false; + } + return true; + } + updateTargetUrlAndHref() { + const tree = this.router.createUrlTree(this.commands, { relativeTo: this.route }); + if (tree) { + this.href = this.router.serializeUrl(tree); + } + } +}; +__decorate([ + Input(), + __metadata('design:type', String) +], RouterLink.prototype, "target", void 0); +__decorate([ + HostBinding(), + __metadata('design:type', String) +], RouterLink.prototype, "href", void 0); +__decorate([ + Input(), + __metadata('design:type', Object), + __metadata('design:paramtypes', [Object]) +], RouterLink.prototype, "routerLink", null); +__decorate([ + HostListener("click"), + __metadata('design:type', Function), + __metadata('design:paramtypes', []), + __metadata('design:returntype', Boolean) +], RouterLink.prototype, "onClick", null); +RouterLink = __decorate([ + Directive({ selector: '[routerLink]' }), + __metadata('design:paramtypes', [Router, ActivatedRoute]) +], RouterLink); +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/modules/@angular/router/build/es6/src/directives/router_outlet.d.ts b/modules/@angular/router/build/es6/src/directives/router_outlet.d.ts new file mode 100644 index 0000000000..bfddeddb4b --- /dev/null +++ b/modules/@angular/router/build/es6/src/directives/router_outlet.d.ts @@ -0,0 +1,11 @@ +import { ViewContainerRef, ComponentFactory, ResolvedReflectiveProvider } from '@angular/core'; +import { RouterOutletMap } from '../router_outlet_map'; +export declare class RouterOutlet { + private location; + private activated; + outletMap: RouterOutletMap; + constructor(parentOutletMap: RouterOutletMap, location: ViewContainerRef, name: string); + readonly isActivated: boolean; + deactivate(): void; + activate(factory: ComponentFactory, providers: ResolvedReflectiveProvider[], outletMap: RouterOutletMap): void; +} diff --git a/modules/@angular/router/build/es6/src/directives/router_outlet.js b/modules/@angular/router/build/es6/src/directives/router_outlet.js new file mode 100644 index 0000000000..e43821d1a5 --- /dev/null +++ b/modules/@angular/router/build/es6/src/directives/router_outlet.js @@ -0,0 +1,39 @@ +var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; +}; +var __metadata = (this && this.__metadata) || function (k, v) { + if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v); +}; +var __param = (this && this.__param) || function (paramIndex, decorator) { + return function (target, key) { decorator(target, key, paramIndex); } +}; +import { Directive, ViewContainerRef, Attribute, ReflectiveInjector } from '@angular/core'; +import { RouterOutletMap } from '../router_outlet_map'; +import { PRIMARY_OUTLET } from '../shared'; +export let RouterOutlet = class RouterOutlet { + constructor(parentOutletMap, location, name) { + this.location = location; + parentOutletMap.registerOutlet(name ? name : PRIMARY_OUTLET, this); + } + get isActivated() { return !!this.activated; } + deactivate() { + if (this.activated) { + this.activated.destroy(); + this.activated = null; + } + } + activate(factory, providers, outletMap) { + this.outletMap = outletMap; + let inj = ReflectiveInjector.fromResolvedProviders(providers, this.location.parentInjector); + this.activated = this.location.createComponent(factory, this.location.length, inj, []); + } +}; +RouterOutlet = __decorate([ + Directive({ selector: 'router-outlet' }), + __param(2, Attribute('name')), + __metadata('design:paramtypes', [RouterOutletMap, ViewContainerRef, String]) +], RouterOutlet); +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/modules/@angular/router/build/es6/src/index.d.ts b/modules/@angular/router/build/es6/src/index.d.ts new file mode 100644 index 0000000000..7ec5c4879d --- /dev/null +++ b/modules/@angular/router/build/es6/src/index.d.ts @@ -0,0 +1,7 @@ +export { Router } from './router'; +export { UrlSerializer, DefaultUrlSerializer } from './url_serializer'; +export { RouterState, ActivatedRoute } from './router_state'; +export { RouterOutletMap } from './router_outlet_map'; +import { RouterOutlet } from './directives/router_outlet'; +import { RouterLink } from './directives/router_link'; +export declare const ROUTER_DIRECTIVES: (typeof RouterOutlet | typeof RouterLink)[]; diff --git a/modules/@angular/router/build/es6/src/index.js b/modules/@angular/router/build/es6/src/index.js new file mode 100644 index 0000000000..2dc4a76fa6 --- /dev/null +++ b/modules/@angular/router/build/es6/src/index.js @@ -0,0 +1,8 @@ +export { Router } from './router'; +export { UrlSerializer, DefaultUrlSerializer } from './url_serializer'; +export { RouterState, ActivatedRoute } from './router_state'; +export { RouterOutletMap } from './router_outlet_map'; +import { RouterOutlet } from './directives/router_outlet'; +import { RouterLink } from './directives/router_link'; +export const ROUTER_DIRECTIVES = [RouterOutlet, RouterLink]; +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsU0FBUyxNQUFNLFFBQVEsVUFBVSxDQUFDO0FBQ2xDLFNBQVMsYUFBYSxFQUFFLG9CQUFvQixRQUFRLGtCQUFrQixDQUFDO0FBQ3ZFLFNBQVMsV0FBVyxFQUFFLGNBQWMsUUFBUSxnQkFBZ0IsQ0FBQztBQUM3RCxTQUFTLGVBQWUsUUFBUSxxQkFBcUIsQ0FBQztPQUUvQyxFQUFFLFlBQVksRUFBRSxNQUFNLDRCQUE0QjtPQUNsRCxFQUFFLFVBQVUsRUFBRSxNQUFNLDBCQUEwQjtBQUVyRCxPQUFPLE1BQU0saUJBQWlCLEdBQUcsQ0FBQyxZQUFZLEVBQUUsVUFBVSxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBSb3V0ZXIgfSBmcm9tICcuL3JvdXRlcic7XG5leHBvcnQgeyBVcmxTZXJpYWxpemVyLCBEZWZhdWx0VXJsU2VyaWFsaXplciB9IGZyb20gJy4vdXJsX3NlcmlhbGl6ZXInO1xuZXhwb3J0IHsgUm91dGVyU3RhdGUsIEFjdGl2YXRlZFJvdXRlIH0gZnJvbSAnLi9yb3V0ZXJfc3RhdGUnO1xuZXhwb3J0IHsgUm91dGVyT3V0bGV0TWFwIH0gZnJvbSAnLi9yb3V0ZXJfb3V0bGV0X21hcCc7XG5cbmltcG9ydCB7IFJvdXRlck91dGxldCB9IGZyb20gJy4vZGlyZWN0aXZlcy9yb3V0ZXJfb3V0bGV0JztcbmltcG9ydCB7IFJvdXRlckxpbmsgfSBmcm9tICcuL2RpcmVjdGl2ZXMvcm91dGVyX2xpbmsnO1xuXG5leHBvcnQgY29uc3QgUk9VVEVSX0RJUkVDVElWRVMgPSBbUm91dGVyT3V0bGV0LCBSb3V0ZXJMaW5rXTsiXX0= \ No newline at end of file diff --git a/modules/@angular/router/build/es6/src/recognize.d.ts b/modules/@angular/router/build/es6/src/recognize.d.ts new file mode 100644 index 0000000000..64aeb9f2f7 --- /dev/null +++ b/modules/@angular/router/build/es6/src/recognize.d.ts @@ -0,0 +1,5 @@ +import { UrlTree } from './url_tree'; +import { RouterState } from './router_state'; +import { RouterConfig } from './config'; +import { Observable } from 'rxjs/Observable'; +export declare function recognize(config: RouterConfig, url: UrlTree, existingState: RouterState): Observable; diff --git a/modules/@angular/router/build/es6/src/recognize.js b/modules/@angular/router/build/es6/src/recognize.js new file mode 100644 index 0000000000..5bfb6a2326 --- /dev/null +++ b/modules/@angular/router/build/es6/src/recognize.js @@ -0,0 +1,166 @@ +import { flatten, first, merge } from './utils/collection'; +import { TreeNode, rootNode } from './utils/tree'; +import { RouterState, ActivatedRoute } from './router_state'; +import { PRIMARY_OUTLET } from './shared'; +import { Observable } from 'rxjs/Observable'; +import { BehaviorSubject } from 'rxjs/BehaviorSubject'; +export function recognize(config, url, existingState) { + try { + const match = new MatchResult(existingState.root.component, config, [url.root], {}, rootNode(url).children, [], PRIMARY_OUTLET); + existingState.queryParams.next(url.queryParameters); + existingState.fragment.next(url.fragment); + const roots = constructActivatedRoute(match, rootNode(existingState)); + const res = new RouterState(roots[0], existingState.queryParams, existingState.fragment); + return new Observable(obs => { + obs.next(res); + obs.complete(); + }); + } + catch (e) { + return new Observable(obs => obs.error(e)); + } +} +function constructActivatedRoute(match, existingRoute) { + const activatedRoute = createOrReuseRoute(match, existingRoute); + const existingChildren = existingRoute ? existingRoute.children : []; + if (match.leftOverUrl.length > 0) { + const children = recognizeMany(match.children, match.leftOverUrl, existingChildren); + checkOutletNameUniqueness(children); + return [new TreeNode(activatedRoute, children)]; + } + else { + return [new TreeNode(activatedRoute, [])]; + } +} +function recognizeMany(config, urls, existingRoutes) { + return flatten(urls.map(url => recognizeOne(config, url, existingRoutes))); +} +function createOrReuseRoute(match, existing) { + if (existing) { + const v = existing.value; + if (v.component === match.component && v.outlet === match.outlet) { + (v.params).next(match.parameters); + (v.urlSegments).next(match.consumedUrlSegments); + return v; + } + } + return new ActivatedRoute(new BehaviorSubject(match.consumedUrlSegments), new BehaviorSubject(match.parameters), match.outlet, match.component); +} +function recognizeOne(config, url, existingRoutes) { + let m = match(config, url); + const routesWithRightOutlet = existingRoutes.filter(r => r.value.outlet == m.outlet); + const routeWithRightOutlet = routesWithRightOutlet.length > 0 ? routesWithRightOutlet[0] : null; + const primary = constructActivatedRoute(m, routeWithRightOutlet); + const secondary = recognizeMany(config, m.secondary, existingRoutes); + const res = primary.concat(secondary); + checkOutletNameUniqueness(res); + return res; +} +function checkOutletNameUniqueness(nodes) { + let names = {}; + nodes.forEach(n => { + let routeWithSameOutletName = names[n.value.outlet]; + if (routeWithSameOutletName) { + const p = routeWithSameOutletName.urlSegments.value.map(s => s.toString()).join("/"); + const c = n.value.urlSegments.value.map(s => s.toString()).join("/"); + throw new Error(`Two segments cannot have the same outlet name: '${p}' and '${c}'.`); + } + names[n.value.outlet] = n.value; + }); + return nodes; +} +function match(config, url) { + const m = matchNonIndex(config, url); + if (m) + return m; + const mIndex = matchIndex(config, url); + if (mIndex) + return mIndex; + const availableRoutes = config.map(r => { + const outlet = !r.outlet ? '' : `${r.outlet}:`; + return `'${outlet}${r.path}'`; + }).join(", "); + throw new Error(`Cannot match any routes. Current segment: '${url.value}'. Available routes: [${availableRoutes}].`); +} +function matchNonIndex(config, url) { + for (let r of config) { + let m = matchWithParts(r, url); + if (m) + return m; + } + return null; +} +function matchIndex(config, url) { + for (let r of config) { + if (r.index) { + const outlet = r.outlet ? r.outlet : PRIMARY_OUTLET; + const children = r.children ? r.children : []; + return new MatchResult(r.component, children, [], {}, [url], [], outlet); + } + } + return null; +} +function matchWithParts(route, url) { + if (!route.path) + return null; + if ((route.outlet ? route.outlet : PRIMARY_OUTLET) !== url.value.outlet) + return null; + const path = route.path.startsWith("/") ? route.path.substring(1) : route.path; + if (path === "**") { + const consumedUrl = []; + let u = url; + while (u) { + consumedUrl.push(u.value); + u = first(u.children); + } + const last = consumedUrl[consumedUrl.length - 1]; + return new MatchResult(route.component, [], consumedUrl, last.parameters, [], [], PRIMARY_OUTLET); + } + const parts = path.split("/"); + const positionalParams = {}; + const consumedUrlSegments = []; + let lastParent = null; + let lastSegment = null; + let current = url; + for (let i = 0; i < parts.length; ++i) { + if (!current) + return null; + const p = parts[i]; + const isLastSegment = i === parts.length - 1; + const isLastParent = i === parts.length - 2; + const isPosParam = p.startsWith(":"); + if (!isPosParam && p != current.value.path) + return null; + if (isLastSegment) { + lastSegment = current; + } + if (isLastParent) { + lastParent = current; + } + if (isPosParam) { + positionalParams[p.substring(1)] = current.value.path; + } + consumedUrlSegments.push(current.value); + current = first(current.children); + } + if (!lastSegment) + throw "Cannot be reached"; + const p = lastSegment.value.parameters; + const parameters = merge(p, positionalParams); + const secondarySubtrees = lastParent ? lastParent.children.slice(1) : []; + const children = route.children ? route.children : []; + const outlet = route.outlet ? route.outlet : PRIMARY_OUTLET; + return new MatchResult(route.component, children, consumedUrlSegments, parameters, lastSegment.children, secondarySubtrees, outlet); +} +class MatchResult { + constructor(component, children, consumedUrlSegments, parameters, leftOverUrl, secondary, outlet) { + this.component = component; + this.children = children; + this.consumedUrlSegments = consumedUrlSegments; + this.parameters = parameters; + this.leftOverUrl = leftOverUrl; + this.secondary = secondary; + this.outlet = outlet; + } +} +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"recognize.js","sourceRoot":"","sources":["../../../src/recognize.ts"],"names":[],"mappings":"OACO,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,oBAAoB;OACnD,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,cAAc;OAC1C,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,gBAAgB;OACrD,EAAU,cAAc,EAAE,MAAM,UAAU;OAG1C,EAAE,UAAU,EAAE,MAAM,iBAAiB;OACrC,EAAE,eAAe,EAAE,MAAM,sBAAsB;AAEtD,0BAA0B,MAAoB,EAAE,GAAY,EAAE,aAA0B;IACtF,IAAI,CAAC;QACH,MAAM,KAAK,GAAG,IAAI,WAAW,CAAC,aAAa,CAAC,IAAI,CAAC,SAAS,EAAE,MAAM,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,EAAE,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE,EAAE,cAAc,CAAC,CAAC;QAC1H,aAAa,CAAC,WAAY,CAAC,IAAI,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC;QACrD,aAAa,CAAC,QAAS,CAAC,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QACjD,MAAM,KAAK,GAAG,uBAAuB,CAAC,KAAK,EAAE,QAAQ,CAAC,aAAa,CAAC,CAAC,CAAC;QACtE,MAAM,GAAG,GAAG,IAAI,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,aAAa,CAAC,WAAW,EAAE,aAAa,CAAC,QAAQ,CAAC,CAAC;QACzF,MAAM,CAAC,IAAI,UAAU,CAAc,GAAG;YACpC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;YACd,GAAG,CAAC,QAAQ,EAAE,CAAC;QACjB,CAAC,CAAC,CAAC;IACL,CAAE;IAAA,KAAK,CAAA,CAAC,CAAC,CAAC,CAAC,CAAC;QACV,MAAM,CAAC,IAAI,UAAU,CAAc,GAAG,IAAI,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;IAC1D,CAAC;AACH,CAAC;AAED,iCAAiC,KAAkB,EAAE,aAA8C;IACjG,MAAM,cAAc,GAAG,kBAAkB,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC;IAChE,MAAM,gBAAgB,GAAG,aAAa,GAAG,aAAa,CAAC,QAAQ,GAAG,EAAE,CAAC;IAErE,EAAE,CAAC,CAAC,KAAK,CAAC,WAAW,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC;QACjC,MAAM,QAAQ,GAAG,aAAa,CAAC,KAAK,CAAC,QAAQ,EAAE,KAAK,CAAC,WAAW,EAAE,gBAAgB,CAAC,CAAC;QACpF,yBAAyB,CAAC,QAAQ,CAAC,CAAC;QACpC,MAAM,CAAC,CAAC,IAAI,QAAQ,CAAiB,cAAc,EAAE,QAAQ,CAAC,CAAC,CAAC;IAClE,CAAC;IAAC,IAAI,CAAC,CAAC;QACN,MAAM,CAAC,CAAC,IAAI,QAAQ,CAAiB,cAAc,EAAE,EAAE,CAAC,CAAC,CAAC;IAC5D,CAAC;AACH,CAAC;AAED,uBAAuB,MAAe,EAAE,IAA4B,EAC7C,cAA0C;IAC/D,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,IAAI,YAAY,CAAC,MAAM,EAAE,GAAG,EAAE,cAAc,CAAC,CAAC,CAAC,CAAC;AAC7E,CAAC;AAED,4BAA4B,KAAkB,EAAE,QAAyC;IACvF,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC;QACb,MAAM,CAAC,GAAG,QAAQ,CAAC,KAAK,CAAC;QACzB,EAAE,CAAC,CAAC,CAAC,CAAC,SAAS,KAAK,KAAK,CAAC,SAAS,IAAI,CAAC,CAAC,MAAM,KAAK,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC;YAC3D,CAAC,CAAC,CAAC,MAAM,CAAE,CAAC,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;YACnC,CAAC,CAAC,CAAC,WAAW,CAAE,CAAC,IAAI,CAAC,KAAK,CAAC,mBAAmB,CAAC,CAAC;YACvD,MAAM,CAAC,CAAC,CAAC;QACX,CAAC;IACH,CAAC;IACD,MAAM,CAAC,IAAI,cAAc,CAAC,IAAI,eAAe,CAAC,KAAK,CAAC,mBAAmB,CAAC,EAAE,IAAI,eAAe,CAAC,KAAK,CAAC,UAAU,CAAC,EAAE,KAAK,CAAC,MAAM,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC;AAClJ,CAAC;AAED,sBAAsB,MAAe,EAAE,GAAyB,EAC1C,cAA0C;IAC9D,IAAI,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAE3B,MAAM,qBAAqB,GAAG,cAAc,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,MAAM,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC;IACrF,MAAM,oBAAoB,GAAG,qBAAqB,CAAC,MAAM,GAAG,CAAC,GAAG,qBAAqB,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IAEhG,MAAM,OAAO,GAAG,uBAAuB,CAAC,CAAC,EAAE,oBAAoB,CAAC,CAAC;IACjE,MAAM,SAAS,GAAG,aAAa,CAAC,MAAM,EAAE,CAAC,CAAC,SAAS,EAAE,cAAc,CAAC,CAAC;IACrE,MAAM,GAAG,GAAG,OAAO,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;IACtC,yBAAyB,CAAC,GAAG,CAAC,CAAC;IAC/B,MAAM,CAAC,GAAG,CAAC;AACb,CAAC;AAED,mCAAmC,KAAiC;IAClE,IAAI,KAAK,GAAG,EAAE,CAAC;IACf,KAAK,CAAC,OAAO,CAAC,CAAC;QACb,IAAI,uBAAuB,GAAG,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;QACpD,EAAE,CAAC,CAAC,uBAAuB,CAAC,CAAC,CAAC;YAC5B,MAAM,CAAC,GAAS,uBAAuB,CAAC,WAAY,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;YAC5F,MAAM,CAAC,GAAS,CAAC,CAAC,KAAK,CAAC,WAAY,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;YAC5E,MAAM,IAAI,KAAK,CAAC,mDAAmD,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;QACvF,CAAC;QACD,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC;IAClC,CAAC,CAAC,CAAC;IACH,MAAM,CAAC,KAAK,CAAC;AACf,CAAC;AAED,eAAe,MAAe,EAAE,GAAyB;IACvD,MAAM,CAAC,GAAG,aAAa,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IACrC,EAAE,CAAC,CAAC,CAAC,CAAC;QAAC,MAAM,CAAC,CAAC,CAAC;IAEhB,MAAM,MAAM,GAAG,UAAU,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IACvC,EAAE,CAAC,CAAC,MAAM,CAAC;QAAC,MAAM,CAAC,MAAM,CAAC;IAE1B,MAAM,eAAe,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;QAClC,MAAM,MAAM,GAAG,CAAC,CAAC,CAAC,MAAM,GAAG,EAAE,GAAG,GAAG,CAAC,CAAC,MAAM,GAAG,CAAC;QAC/C,MAAM,CAAC,IAAI,MAAM,GAAG,CAAC,CAAC,IAAI,GAAG,CAAC;IAChC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACd,MAAM,IAAI,KAAK,CACb,8CAA8C,GAAG,CAAC,KAAK,yBAAyB,eAAe,IAAI,CAAC,CAAC;AACzG,CAAC;AAED,uBAAuB,MAAe,EAAE,GAAyB;IAC/D,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC;QACrB,IAAI,CAAC,GAAG,cAAc,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;QAC/B,EAAE,CAAC,CAAC,CAAC,CAAC;YAAC,MAAM,CAAC,CAAC,CAAC;IAClB,CAAC;IACD,MAAM,CAAC,IAAI,CAAC;AACd,CAAC;AAED,oBAAoB,MAAe,EAAE,GAAyB;IAC5D,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC;QACrB,EAAE,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC;YACZ,MAAM,MAAM,GAAG,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,MAAM,GAAG,cAAc,CAAC;YACpD,MAAM,QAAQ,GAAG,CAAC,CAAC,QAAQ,GAAG,CAAC,CAAC,QAAQ,GAAG,EAAE,CAAC;YAC9C,MAAM,CAAC,IAAI,WAAW,CAAC,CAAC,CAAC,SAAS,EAAE,QAAQ,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,GAAG,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,CAAC;QAC3E,CAAC;IACH,CAAC;IACD,MAAM,CAAC,IAAI,CAAC;AACd,CAAC;AAED,wBAAwB,KAAY,EAAE,GAAyB;IAC7D,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC;QAAC,MAAM,CAAC,IAAI,CAAC;IAC7B,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,GAAG,KAAK,CAAC,MAAM,GAAG,cAAc,CAAC,KAAK,GAAG,CAAC,KAAK,CAAC,MAAM,CAAC;QAAC,MAAM,CAAC,IAAI,CAAC;IAErF,MAAM,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,IAAI,CAAC;IAC/E,EAAE,CAAC,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC,CAAC;QAClB,MAAM,WAAW,GAAG,EAAE,CAAC;QACvB,IAAI,CAAC,GAA6B,GAAG,CAAC;QACtC,OAAO,CAAC,EAAE,CAAC;YACT,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;YAC1B,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC;QACxB,CAAC;QACD,MAAM,IAAI,GAAG,WAAW,CAAC,WAAW,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;QACjD,MAAM,CAAC,IAAI,WAAW,CAAC,KAAK,CAAC,SAAS,EAAE,EAAE,EAAE,WAAW,EAAE,IAAI,CAAC,UAAU,EAAE,EAAE,EAAE,EAAE,EAAE,cAAc,CAAC,CAAC;IACpG,CAAC;IAED,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IAC9B,MAAM,gBAAgB,GAAG,EAAE,CAAC;IAC5B,MAAM,mBAAmB,GAAG,EAAE,CAAC;IAE/B,IAAI,UAAU,GAA8B,IAAI,CAAC;IACjD,IAAI,WAAW,GAA8B,IAAI,CAAC;IAElD,IAAI,OAAO,GAA8B,GAAG,CAAC;IAC7C,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE,CAAC;QACtC,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC;YAAC,MAAM,CAAC,IAAI,CAAC;QAE1B,MAAM,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;QACnB,MAAM,aAAa,GAAG,CAAC,KAAK,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC;QAC7C,MAAM,YAAY,GAAG,CAAC,KAAK,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC;QAC5C,MAAM,UAAU,GAAG,CAAC,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;QAErC,EAAE,CAAC,CAAC,CAAC,UAAU,IAAI,CAAC,IAAI,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC;YAAC,MAAM,CAAC,IAAI,CAAC;QACxD,EAAE,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC;YAClB,WAAW,GAAG,OAAO,CAAC;QACxB,CAAC;QACD,EAAE,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC;YACjB,UAAU,GAAG,OAAO,CAAC;QACvB,CAAC;QAED,EAAE,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC;YACf,gBAAgB,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC;QACxD,CAAC;QAED,mBAAmB,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;QAExC,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;IACpC,CAAC;IAED,EAAE,CAAC,CAAC,CAAC,WAAW,CAAC;QAAC,MAAM,mBAAmB,CAAC;IAE5C,MAAM,CAAC,GAAG,WAAW,CAAC,KAAK,CAAC,UAAU,CAAC;IACvC,MAAM,UAAU,GAA4B,KAAK,CAAC,CAAC,EAAE,gBAAgB,CAAC,CAAC;IACvE,MAAM,iBAAiB,GAAG,UAAU,GAAG,UAAU,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC;IACzE,MAAM,QAAQ,GAAG,KAAK,CAAC,QAAQ,GAAG,KAAK,CAAC,QAAQ,GAAG,EAAE,CAAC;IACtD,MAAM,MAAM,GAAG,KAAK,CAAC,MAAM,GAAG,KAAK,CAAC,MAAM,GAAG,cAAc,CAAC;IAE5D,MAAM,CAAC,IAAI,WAAW,CAAC,KAAK,CAAC,SAAS,EAAE,QAAQ,EAAE,mBAAmB,EAAE,UAAU,EAAE,WAAW,CAAC,QAAQ,EACrG,iBAAiB,EAAE,MAAM,CAAC,CAAC;AAC/B,CAAC;AAED;IACE,YAAmB,SAAwB,EACxB,QAAiB,EACjB,mBAAiC,EACjC,UAAmC,EACnC,WAAmC,EACnC,SAAiC,EACjC,MAAc;QANd,cAAS,GAAT,SAAS,CAAe;QACxB,aAAQ,GAAR,QAAQ,CAAS;QACjB,wBAAmB,GAAnB,mBAAmB,CAAc;QACjC,eAAU,GAAV,UAAU,CAAyB;QACnC,gBAAW,GAAX,WAAW,CAAwB;QACnC,cAAS,GAAT,SAAS,CAAwB;QACjC,WAAM,GAAN,MAAM,CAAQ;IAC9B,CAAC;AACN,CAAC;AAAA","sourcesContent":["import { UrlTree, UrlSegment } from './url_tree';\nimport { flatten, first, merge } from './utils/collection';\nimport { TreeNode, rootNode } from './utils/tree';\nimport { RouterState, ActivatedRoute } from './router_state';\nimport { Params, PRIMARY_OUTLET } from './shared';\nimport { RouterConfig, Route } from './config';\nimport { Type } from '@angular/core';\nimport { Observable } from 'rxjs/Observable';\nimport { BehaviorSubject } from 'rxjs/BehaviorSubject';\n\nexport function recognize(config: RouterConfig, url: UrlTree, existingState: RouterState): Observable<RouterState> {\n  try {\n    const match = new MatchResult(existingState.root.component, config, [url.root], {}, rootNode(url).children, [], PRIMARY_OUTLET);\n    (<any>existingState.queryParams).next(url.queryParameters);\n    (<any>existingState.fragment).next(url.fragment);\n    const roots = constructActivatedRoute(match, rootNode(existingState));\n    const res = new RouterState(roots[0], existingState.queryParams, existingState.fragment);\n    return new Observable<RouterState>(obs => {\n      obs.next(res);\n      obs.complete();\n    });\n  } catch(e) {\n    return new Observable<RouterState>(obs => obs.error(e));\n  }\n}\n\nfunction constructActivatedRoute(match: MatchResult, existingRoute: TreeNode<ActivatedRoute> | null): TreeNode<ActivatedRoute>[] {\n  const activatedRoute = createOrReuseRoute(match, existingRoute);\n  const existingChildren = existingRoute ? existingRoute.children : [];\n\n  if (match.leftOverUrl.length > 0) {\n    const children = recognizeMany(match.children, match.leftOverUrl, existingChildren);\n    checkOutletNameUniqueness(children);\n    return [new TreeNode<ActivatedRoute>(activatedRoute, children)];\n  } else {\n    return [new TreeNode<ActivatedRoute>(activatedRoute, [])];\n  }\n}\n\nfunction recognizeMany(config: Route[], urls: TreeNode<UrlSegment>[],\n                       existingRoutes: TreeNode<ActivatedRoute>[]): TreeNode<ActivatedRoute>[] {\n  return flatten(urls.map(url => recognizeOne(config, url, existingRoutes)));\n}\n\nfunction createOrReuseRoute(match: MatchResult, existing: TreeNode<ActivatedRoute> | null): ActivatedRoute {\n  if (existing) {\n    const v = existing.value;\n    if (v.component === match.component && v.outlet === match.outlet) {\n      (<any>(v.params)).next(match.parameters);\n      (<any>(v.urlSegments)).next(match.consumedUrlSegments);\n      return v;\n    }\n  }\n  return new ActivatedRoute(new BehaviorSubject(match.consumedUrlSegments), new BehaviorSubject(match.parameters), match.outlet, match.component);\n}\n\nfunction recognizeOne(config: Route[], url: TreeNode<UrlSegment>,\n                      existingRoutes: TreeNode<ActivatedRoute>[]): TreeNode<ActivatedRoute>[] {\n  let m = match(config, url);\n\n  const routesWithRightOutlet = existingRoutes.filter(r => r.value.outlet == m.outlet);\n  const routeWithRightOutlet = routesWithRightOutlet.length > 0 ? routesWithRightOutlet[0] : null;\n\n  const primary = constructActivatedRoute(m, routeWithRightOutlet);\n  const secondary = recognizeMany(config, m.secondary, existingRoutes);\n  const res = primary.concat(secondary);\n  checkOutletNameUniqueness(res);\n  return res;\n}\n\nfunction checkOutletNameUniqueness(nodes: TreeNode<ActivatedRoute>[]): TreeNode<ActivatedRoute>[] {\n  let names = {};\n  nodes.forEach(n => {\n    let routeWithSameOutletName = names[n.value.outlet];\n    if (routeWithSameOutletName) {\n      const p = (<any>routeWithSameOutletName.urlSegments).value.map(s => s.toString()).join(\"/\");\n      const c = (<any>n.value.urlSegments).value.map(s => s.toString()).join(\"/\");\n      throw new Error(`Two segments cannot have the same outlet name: '${p}' and '${c}'.`);\n    }\n    names[n.value.outlet] = n.value;\n  });\n  return nodes;\n}\n\nfunction match(config: Route[], url: TreeNode<UrlSegment>): MatchResult {\n  const m = matchNonIndex(config, url);\n  if (m) return m;\n\n  const mIndex = matchIndex(config, url);\n  if (mIndex) return mIndex;\n\n  const availableRoutes = config.map(r => {\n    const outlet = !r.outlet ? '' : `${r.outlet}:`;\n    return `'${outlet}${r.path}'`;\n  }).join(\", \");\n  throw new Error(\n    `Cannot match any routes. Current segment: '${url.value}'. Available routes: [${availableRoutes}].`);\n}\n\nfunction matchNonIndex(config: Route[], url: TreeNode<UrlSegment>): MatchResult | null {\n  for (let r of config) {\n    let m = matchWithParts(r, url);\n    if (m) return m;\n  }\n  return null;\n}\n\nfunction matchIndex(config: Route[], url: TreeNode<UrlSegment>): MatchResult | null {\n  for (let r of config) {\n    if (r.index) {\n      const outlet = r.outlet ? r.outlet : PRIMARY_OUTLET;\n      const children = r.children ? r.children : [];\n      return new MatchResult(r.component, children, [], {}, [url], [], outlet);\n    }\n  }\n  return null;\n}\n\nfunction matchWithParts(route: Route, url: TreeNode<UrlSegment>): MatchResult | null {\n  if (!route.path) return null;\n  if ((route.outlet ? route.outlet : PRIMARY_OUTLET) !== url.value.outlet) return null;\n\n  const path = route.path.startsWith(\"/\") ? route.path.substring(1) : route.path;\n  if (path === \"**\") {\n    const consumedUrl = [];\n    let u:TreeNode<UrlSegment>|null = url;\n    while (u) {\n      consumedUrl.push(u.value);\n      u = first(u.children);\n    }\n    const last = consumedUrl[consumedUrl.length - 1];\n    return new MatchResult(route.component, [], consumedUrl, last.parameters, [], [], PRIMARY_OUTLET);\n  }\n\n  const parts = path.split(\"/\");\n  const positionalParams = {};\n  const consumedUrlSegments = [];\n\n  let lastParent: TreeNode<UrlSegment>|null = null;\n  let lastSegment: TreeNode<UrlSegment>|null = null;\n\n  let current: TreeNode<UrlSegment>|null = url;\n  for (let i = 0; i < parts.length; ++i) {\n    if (!current) return null;\n\n    const p = parts[i];\n    const isLastSegment = i === parts.length - 1;\n    const isLastParent = i === parts.length - 2;\n    const isPosParam = p.startsWith(\":\");\n\n    if (!isPosParam && p != current.value.path) return null;\n    if (isLastSegment) {\n      lastSegment = current;\n    }\n    if (isLastParent) {\n      lastParent = current;\n    }\n\n    if (isPosParam) {\n      positionalParams[p.substring(1)] = current.value.path;\n    }\n\n    consumedUrlSegments.push(current.value);\n\n    current = first(current.children);\n  }\n\n  if (!lastSegment) throw \"Cannot be reached\";\n\n  const p = lastSegment.value.parameters;\n  const parameters = <{[key: string]: string}>merge(p, positionalParams);\n  const secondarySubtrees = lastParent ? lastParent.children.slice(1) : [];\n  const children = route.children ? route.children : [];\n  const outlet = route.outlet ? route.outlet : PRIMARY_OUTLET;\n\n  return new MatchResult(route.component, children, consumedUrlSegments, parameters, lastSegment.children,\n    secondarySubtrees, outlet);\n}\n\nclass MatchResult {\n  constructor(public component: Type | string,\n              public children: Route[],\n              public consumedUrlSegments: UrlSegment[],\n              public parameters: {[key: string]: string},\n              public leftOverUrl: TreeNode<UrlSegment>[],\n              public secondary: TreeNode<UrlSegment>[],\n              public outlet: string\n  ) {}\n}"]} \ No newline at end of file diff --git a/modules/@angular/router/build/es6/src/router.d.ts b/modules/@angular/router/build/es6/src/router.d.ts new file mode 100644 index 0000000000..7fd1b6a794 --- /dev/null +++ b/modules/@angular/router/build/es6/src/router.d.ts @@ -0,0 +1,40 @@ +import { ComponentResolver } from '@angular/core'; +import { Location } from '@angular/common'; +import { UrlSerializer } from './url_serializer'; +import { RouterOutletMap } from './router_outlet_map'; +import { UrlTree } from './url_tree'; +import { Params } from './shared'; +import { RouterState, ActivatedRoute } from './router_state'; +import { RouterConfig } from './config'; +import { Observable } from 'rxjs/Observable'; +import 'rxjs/add/operator/map'; +import 'rxjs/add/operator/mergeMap'; +import 'rxjs/add/operator/toPromise'; +export interface NavigationExtras { + relativeTo?: ActivatedRoute; + queryParameters?: Params; + fragment?: string; +} +export declare class Router { + private rootComponent; + private resolver; + private urlSerializer; + private outletMap; + private location; + private currentUrlTree; + private currentRouterState; + private config; + private locationSubscription; + constructor(rootComponent: Object, resolver: ComponentResolver, urlSerializer: UrlSerializer, outletMap: RouterOutletMap, location: Location); + readonly routerState: RouterState; + readonly urlTree: UrlTree; + navigateByUrl(url: string): Observable; + resetConfig(config: RouterConfig): void; + dispose(): void; + createUrlTree(commands: any[], {relativeTo, queryParameters, fragment}?: NavigationExtras): UrlTree; + navigate(commands: any[], extras?: NavigationExtras): Observable; + serializeUrl(url: UrlTree): string; + parseUrl(url: string): UrlTree; + private setUpLocationChangeListener(); + private runNavigate(url, pop?); +} diff --git a/modules/@angular/router/build/es6/src/router.js b/modules/@angular/router/build/es6/src/router.js new file mode 100644 index 0000000000..32029bef2a --- /dev/null +++ b/modules/@angular/router/build/es6/src/router.js @@ -0,0 +1,138 @@ +import { ReflectiveInjector } from '@angular/core'; +import { RouterOutletMap } from './router_outlet_map'; +import { recognize } from './recognize'; +import { rootNode } from './utils/tree'; +import { createEmptyUrlTree } from './url_tree'; +import { PRIMARY_OUTLET } from './shared'; +import { createEmptyState, ActivatedRoute } from './router_state'; +import { createUrlTree } from './create_url_tree'; +import { forEach } from './utils/collection'; +import 'rxjs/add/operator/map'; +import 'rxjs/add/operator/mergeMap'; +import 'rxjs/add/operator/toPromise'; +import { fromPromise } from 'rxjs/observable/fromPromise'; +import { forkJoin } from 'rxjs/observable/forkJoin'; +export class Router { + constructor(rootComponent, resolver, urlSerializer, outletMap, location) { + this.rootComponent = rootComponent; + this.resolver = resolver; + this.urlSerializer = urlSerializer; + this.outletMap = outletMap; + this.location = location; + this.currentUrlTree = createEmptyUrlTree(); + this.currentRouterState = createEmptyState(rootComponent.constructor); + this.setUpLocationChangeListener(); + this.navigateByUrl(this.location.path()); + } + get routerState() { + return this.currentRouterState; + } + get urlTree() { + return this.currentUrlTree; + } + navigateByUrl(url) { + const urlTree = this.urlSerializer.parse(url); + return this.runNavigate(urlTree, false); + } + resetConfig(config) { + this.config = config; + } + dispose() { this.locationSubscription.unsubscribe(); } + createUrlTree(commands, { relativeTo, queryParameters, fragment } = {}) { + const a = relativeTo ? relativeTo : this.routerState.root; + return createUrlTree(a, this.currentUrlTree, commands, queryParameters, fragment); + } + navigate(commands, extras = {}) { + return this.runNavigate(this.createUrlTree(commands, extras)); + } + serializeUrl(url) { return this.urlSerializer.serialize(url); } + parseUrl(url) { return this.urlSerializer.parse(url); } + setUpLocationChangeListener() { + this.locationSubscription = this.location.subscribe((change) => { + this.runNavigate(this.urlSerializer.parse(change['url']), change['pop']); + }); + } + runNavigate(url, pop) { + const r = recognize(this.config, url, this.currentRouterState).mergeMap((newState) => { + return new ActivateRoutes(this.resolver, newState, this.currentRouterState).activate(this.outletMap).map(() => { + this.currentUrlTree = url; + this.currentRouterState = newState; + if (!pop) { + this.location.go(this.urlSerializer.serialize(url)); + } + }); + }); + r.subscribe((a) => { }, (e) => { }, () => { }); + return r; + } +} +class ActivateRoutes { + constructor(resolver, futureState, currState) { + this.resolver = resolver; + this.futureState = futureState; + this.currState = currState; + } + activate(parentOutletMap) { + const currRoot = this.currState ? rootNode(this.currState) : null; + const futureRoot = rootNode(this.futureState); + return this.activateChildRoutes(futureRoot, currRoot, parentOutletMap); + } + activateChildRoutes(futureNode, currNode, outletMap) { + const prevChildren = nodeChildrenAsMap(currNode); + const observables = []; + futureNode.children.forEach(c => { + observables.push(this.activateRoutes(c, prevChildren[c.value.outlet], outletMap).toPromise()); + delete prevChildren[c.value.outlet]; + }); + forEach(prevChildren, (v, k) => this.deactivateOutletAndItChildren(outletMap._outlets[k])); + return forkJoin(observables); + } + activateRoutes(futureNode, currNode, parentOutletMap) { + const future = futureNode.value; + const curr = currNode ? currNode.value : null; + const outlet = getOutlet(parentOutletMap, futureNode.value); + if (future === curr) { + return this.activateChildRoutes(futureNode, currNode, outlet.outletMap); + } + else { + this.deactivateOutletAndItChildren(outlet); + const outletMap = new RouterOutletMap(); + return this.activateNewRoutes(outletMap, future, outlet).mergeMap(() => this.activateChildRoutes(futureNode, currNode, outletMap)); + } + } + activateNewRoutes(outletMap, future, outlet) { + const resolved = ReflectiveInjector.resolve([ + { provide: ActivatedRoute, useValue: future }, + { provide: RouterOutletMap, useValue: outletMap } + ]); + return fromPromise(this.resolver.resolveComponent(future.component)). + map(factory => outlet.activate(factory, resolved, outletMap)); + } + deactivateOutletAndItChildren(outlet) { + if (outlet && outlet.isActivated) { + forEach(outlet.outletMap._outlets, (v, k) => this.deactivateOutletAndItChildren(v)); + outlet.deactivate(); + } + } +} +function nodeChildrenAsMap(node) { + return node ? + node.children.reduce((m, c) => { + m[c.value.outlet] = c; + return m; + }, {}) : + {}; +} +function getOutlet(outletMap, route) { + let outlet = outletMap._outlets[route.outlet]; + if (!outlet) { + if (route.outlet === PRIMARY_OUTLET) { + throw new Error(`Cannot find primary outlet`); + } + else { + throw new Error(`Cannot find the outlet ${route.outlet}`); + } + } + return outlet; +} +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"router.js","sourceRoot":"","sources":["../../../src/router.ts"],"names":[],"mappings":"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","sourcesContent":["import { ComponentResolver, ReflectiveInjector } from '@angular/core';\nimport { Location } from '@angular/common';\nimport { UrlSerializer } from './url_serializer';\nimport { RouterOutletMap } from './router_outlet_map';\nimport { recognize } from './recognize';\nimport { rootNode, TreeNode } from './utils/tree';\nimport { UrlTree, createEmptyUrlTree } from './url_tree';\nimport { PRIMARY_OUTLET, Params } from './shared';\nimport { createEmptyState, RouterState, ActivatedRoute} from './router_state';\nimport { RouterConfig } from './config';\nimport { RouterOutlet } from './directives/router_outlet';\nimport { createUrlTree } from './create_url_tree';\nimport { forEach } from './utils/collection';\nimport { Observable } from 'rxjs/Observable';\nimport { Subscription } from 'rxjs/Subscription';\nimport 'rxjs/add/operator/map';\nimport 'rxjs/add/operator/mergeMap';\nimport 'rxjs/add/operator/toPromise';\nimport {fromPromise} from 'rxjs/observable/fromPromise';\nimport {forkJoin} from 'rxjs/observable/forkJoin';\n\nexport interface NavigationExtras { relativeTo?: ActivatedRoute; queryParameters?: Params; fragment?: string; }\n\n/**\n * The `Router` is responsible for mapping URLs to components.\n */\nexport class Router {\n  private currentUrlTree: UrlTree;\n  private currentRouterState: RouterState;\n  private config: RouterConfig;\n  private locationSubscription: Subscription;\n\n  /**\n   * @internal\n   */\n  constructor(private rootComponent:Object, private resolver: ComponentResolver, private urlSerializer: UrlSerializer, private outletMap: RouterOutletMap, private location: Location) {\n    this.currentUrlTree = createEmptyUrlTree();\n    this.currentRouterState = createEmptyState(<any>rootComponent.constructor);\n    this.setUpLocationChangeListener();\n    this.navigateByUrl(this.location.path());\n  }\n\n  /**\n   * Returns the current route state.\n   */\n  get routerState(): RouterState {\n    return this.currentRouterState;\n  }\n\n  /**\n   * Returns the current url tree.\n   */\n  get urlTree(): UrlTree {\n    return this.currentUrlTree;\n  }\n\n  /**\n   * Navigate based on the provided url. This navigation is always absolute.\n   *\n   * ### Usage\n   *\n   * ```\n   * router.navigateByUrl(\"/team/33/user/11\");\n   * ```\n   */\n  navigateByUrl(url: string): Observable<void> {\n    const urlTree = this.urlSerializer.parse(url);\n    return this.runNavigate(urlTree, false);\n  }\n\n  /**\n   * Resets the configuration used for navigation and generating links.\n   *\n   * ### Usage\n   *\n   * ```\n   * router.resetConfig([\n   *  { path: 'team/:id', component: TeamCmp, children: [\n   *    { path: 'simple', component: SimpleCmp },\n   *    { path: 'user/:name', component: UserCmp }\n   *  ] }\n   * ]);\n   * ```\n   */\n  resetConfig(config: RouterConfig): void {\n    this.config = config;\n  }\n\n  /**\n   * @internal\n   */\n  dispose(): void { this.locationSubscription.unsubscribe(); }\n\n  /**\n   * Applies an array of commands to the current url tree and creates\n   * a new url tree.\n   *\n   * When given an activate route, applies the given commands starting from the route.\n   * When not given a route, applies the given command starting from the root.\n   *\n   * ### Usage\n   *\n   * ```\n   * // create /team/33/user/11\n   * router.createUrlTree(['/team', 33, 'user', 11]);\n   *\n   * // create /team/33;expand=true/user/11\n   * router.createUrlTree(['/team', 33, {expand: true}, 'user', 11]);\n   *\n   * // you can collapse static fragments like this\n   * router.createUrlTree(['/team/33/user', userId]);\n   *\n   * // assuming the current url is `/team/33/user/11` and the route points to `user/11`\n   *\n   * // navigate to /team/33/user/11/details\n   * router.createUrlTree(['details'], {relativeTo: route});\n   *\n   * // navigate to /team/33/user/22\n   * router.createUrlTree(['../22'], {relativeTo: route});\n   *\n   * // navigate to /team/44/user/22\n   * router.createUrlTree(['../../team/44/user/22'], {relativeTo: route});\n   * ```\n   */\n  createUrlTree(commands: any[], {relativeTo, queryParameters, fragment}: NavigationExtras = {}): UrlTree {\n    const a = relativeTo ? relativeTo : this.routerState.root;\n    return createUrlTree(a, this.currentUrlTree, commands, queryParameters, fragment);\n  }\n\n\n  /**\n   * Navigate based on the provided array of commands and a starting point.\n   * If no starting route is provided, the navigation is absolute.\n   *\n   * ### Usage\n   *\n   * ```\n   * router.navigate(['team', 33, 'team', '11], {relativeTo: route});\n   * ```\n   */\n  navigate(commands: any[], extras: NavigationExtras = {}): Observable<void> {\n    return this.runNavigate(this.createUrlTree(commands, extras));\n  }\n\n  /**\n   * Serializes a {@link UrlTree} into a string.\n   */\n  serializeUrl(url: UrlTree): string { return this.urlSerializer.serialize(url); }\n\n  /**\n   * Parse a string into a {@link UrlTree}.\n   */\n  parseUrl(url: string): UrlTree { return this.urlSerializer.parse(url); }\n\n  private setUpLocationChangeListener(): void {\n    this.locationSubscription = <any>this.location.subscribe((change) => {\n      this.runNavigate(this.urlSerializer.parse(change['url']), change['pop'])\n    });\n  }\n\n  private runNavigate(url:UrlTree, pop?:boolean):Observable<void> {\n    const r = recognize(this.config, url, this.currentRouterState).mergeMap((newState:RouterState) => {\n      return new ActivateRoutes(this.resolver, newState, this.currentRouterState).activate(this.outletMap).map(() => {\n        this.currentUrlTree = url;\n        this.currentRouterState = newState;\n        if (!pop) {\n          this.location.go(this.urlSerializer.serialize(url));\n        }\n      });\n    });\n    r.subscribe((a) => {}, (e) => {}, () => {}); // force execution\n    return r;\n  }\n}\n\nclass ActivateRoutes {\n  constructor(private resolver: ComponentResolver, private futureState: RouterState, private currState: RouterState) {}\n\n  activate(parentOutletMap: RouterOutletMap): Observable<void> {\n    const currRoot = this.currState ? rootNode(this.currState) : null;\n    const futureRoot = rootNode(this.futureState);\n    return this.activateChildRoutes(futureRoot, currRoot, parentOutletMap);\n  }\n\n  private activateChildRoutes(futureNode: TreeNode<ActivatedRoute>,\n                              currNode: TreeNode<ActivatedRoute> | null,\n                              outletMap: RouterOutletMap): Observable<any> {\n    const prevChildren = nodeChildrenAsMap(currNode);\n    const observables = [];\n    futureNode.children.forEach(c => {\n      observables.push(this.activateRoutes(c, prevChildren[c.value.outlet], outletMap).toPromise());\n      delete prevChildren[c.value.outlet];\n    });\n    forEach(prevChildren, (v, k) => this.deactivateOutletAndItChildren(outletMap._outlets[k]));\n    return forkJoin(observables);\n  }\n\n\n  activateRoutes(futureNode: TreeNode<ActivatedRoute>, currNode: TreeNode<ActivatedRoute>,\n                 parentOutletMap: RouterOutletMap): Observable<void> {\n    const future = futureNode.value;\n    const curr = currNode ? currNode.value : null;\n    const outlet = getOutlet(parentOutletMap, futureNode.value);\n\n    if (future === curr) {\n      return this.activateChildRoutes(futureNode, currNode, outlet.outletMap);\n    } else {\n      this.deactivateOutletAndItChildren(outlet);\n      const outletMap = new RouterOutletMap();\n      return this.activateNewRoutes(outletMap, future, outlet).mergeMap(() =>\n        this.activateChildRoutes(futureNode, currNode, outletMap));\n    }\n  }\n\n  private activateNewRoutes(outletMap: RouterOutletMap, future: ActivatedRoute, outlet: RouterOutlet): Observable<void> {\n    const resolved = ReflectiveInjector.resolve([\n      {provide: ActivatedRoute, useValue: future},\n      {provide: RouterOutletMap, useValue: outletMap}\n    ]);\n    return fromPromise(this.resolver.resolveComponent(<any>future.component)).\n      map(factory => outlet.activate(factory, resolved, outletMap));\n  }\n\n  private deactivateOutletAndItChildren(outlet: RouterOutlet): void {\n    if (outlet && outlet.isActivated) {\n      forEach(outlet.outletMap._outlets, (v, k) => this.deactivateOutletAndItChildren(v));\n      outlet.deactivate();\n    }\n  }\n}\n\nfunction nodeChildrenAsMap(node: TreeNode<ActivatedRoute>|null) {\n  return node ?\n    node.children.reduce(\n      (m, c) => {\n        m[c.value.outlet] = c;\n        return m;\n      },\n      {}) :\n  {};\n}\n\nfunction getOutlet(outletMap: RouterOutletMap, route: ActivatedRoute): RouterOutlet {\n  let outlet = outletMap._outlets[route.outlet];\n  if (!outlet) {\n    if (route.outlet === PRIMARY_OUTLET) {\n      throw new Error(`Cannot find primary outlet`);\n    } else {\n      throw new Error(`Cannot find the outlet ${route.outlet}`);\n    }\n  }\n  return outlet;\n}\n"]} \ No newline at end of file diff --git a/modules/@angular/router/build/es6/src/router_outlet_map.d.ts b/modules/@angular/router/build/es6/src/router_outlet_map.d.ts new file mode 100644 index 0000000000..df50474269 --- /dev/null +++ b/modules/@angular/router/build/es6/src/router_outlet_map.d.ts @@ -0,0 +1,7 @@ +import { RouterOutlet } from './directives/router_outlet'; +export declare class RouterOutletMap { + _outlets: { + [name: string]: RouterOutlet; + }; + registerOutlet(name: string, outlet: RouterOutlet): void; +} diff --git a/modules/@angular/router/build/es6/src/router_outlet_map.js b/modules/@angular/router/build/es6/src/router_outlet_map.js new file mode 100644 index 0000000000..111d0035ab --- /dev/null +++ b/modules/@angular/router/build/es6/src/router_outlet_map.js @@ -0,0 +1,7 @@ +export class RouterOutletMap { + constructor() { + this._outlets = {}; + } + registerOutlet(name, outlet) { this._outlets[name] = outlet; } +} +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicm91dGVyX291dGxldF9tYXAuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvcm91dGVyX291dGxldF9tYXAudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBS0E7SUFBQTtRQUVFLGFBQVEsR0FBbUMsRUFBRSxDQUFDO0lBRWhELENBQUM7SUFEQyxjQUFjLENBQUMsSUFBWSxFQUFFLE1BQW9CLElBQVUsSUFBSSxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsR0FBRyxNQUFNLENBQUMsQ0FBQyxDQUFDO0FBQzVGLENBQUM7QUFBQSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFJvdXRlck91dGxldCB9IGZyb20gJy4vZGlyZWN0aXZlcy9yb3V0ZXJfb3V0bGV0JztcblxuLyoqXG4gKiBAaW50ZXJuYWxcbiAqL1xuZXhwb3J0IGNsYXNzIFJvdXRlck91dGxldE1hcCB7XG4gIC8qKiBAaW50ZXJuYWwgKi9cbiAgX291dGxldHM6IHtbbmFtZTogc3RyaW5nXTogUm91dGVyT3V0bGV0fSA9IHt9O1xuICByZWdpc3Rlck91dGxldChuYW1lOiBzdHJpbmcsIG91dGxldDogUm91dGVyT3V0bGV0KTogdm9pZCB7IHRoaXMuX291dGxldHNbbmFtZV0gPSBvdXRsZXQ7IH1cbn1cbiJdfQ== \ No newline at end of file diff --git a/modules/@angular/router/build/es6/src/router_state.d.ts b/modules/@angular/router/build/es6/src/router_state.d.ts new file mode 100644 index 0000000000..569b8837ac --- /dev/null +++ b/modules/@angular/router/build/es6/src/router_state.d.ts @@ -0,0 +1,18 @@ +import { Tree, TreeNode } from './utils/tree'; +import { UrlSegment } from './url_tree'; +import { Params } from './shared'; +import { Observable } from 'rxjs/Observable'; +import { Type } from '@angular/core'; +export declare class RouterState extends Tree { + queryParams: Observable; + fragment: Observable; + constructor(root: TreeNode, queryParams: Observable, fragment: Observable); +} +export declare function createEmptyState(rootComponent: Type): RouterState; +export declare class ActivatedRoute { + urlSegments: Observable; + params: Observable; + outlet: string; + component: Type | string; + constructor(urlSegments: Observable, params: Observable, outlet: string, component: Type | string); +} diff --git a/modules/@angular/router/build/es6/src/router_state.js b/modules/@angular/router/build/es6/src/router_state.js new file mode 100644 index 0000000000..301c5f6e47 --- /dev/null +++ b/modules/@angular/router/build/es6/src/router_state.js @@ -0,0 +1,28 @@ +import { Tree, TreeNode } from './utils/tree'; +import { UrlSegment } from './url_tree'; +import { PRIMARY_OUTLET } from './shared'; +import { BehaviorSubject } from 'rxjs/BehaviorSubject'; +export class RouterState extends Tree { + constructor(root, queryParams, fragment) { + super(root); + this.queryParams = queryParams; + this.fragment = fragment; + } +} +export function createEmptyState(rootComponent) { + const emptyUrl = new BehaviorSubject([new UrlSegment("", {}, PRIMARY_OUTLET)]); + const emptyParams = new BehaviorSubject({}); + const emptyQueryParams = new BehaviorSubject({}); + const fragment = new BehaviorSubject(""); + const activated = new ActivatedRoute(emptyUrl, emptyParams, PRIMARY_OUTLET, rootComponent); + return new RouterState(new TreeNode(activated, []), emptyQueryParams, fragment); +} +export class ActivatedRoute { + constructor(urlSegments, params, outlet, component) { + this.urlSegments = urlSegments; + this.params = params; + this.outlet = outlet; + this.component = component; + } +} +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/modules/@angular/router/build/es6/src/shared.d.ts b/modules/@angular/router/build/es6/src/shared.d.ts new file mode 100644 index 0000000000..2aacfdf7a6 --- /dev/null +++ b/modules/@angular/router/build/es6/src/shared.d.ts @@ -0,0 +1,4 @@ +export declare const PRIMARY_OUTLET: string; +export declare type Params = { + [key: string]: string; +}; diff --git a/modules/@angular/router/build/es6/src/shared.js b/modules/@angular/router/build/es6/src/shared.js new file mode 100644 index 0000000000..9cc0b44dc9 --- /dev/null +++ b/modules/@angular/router/build/es6/src/shared.js @@ -0,0 +1,2 @@ +export const PRIMARY_OUTLET = "PRIMARY_OUTLET"; +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2hhcmVkLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3NoYXJlZC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFJQSxPQUFPLE1BQU0sY0FBYyxHQUFXLGdCQUFnQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBOYW1lIG9mIHRoZSBwcmltYXJ5IG91dGxldC5cbiAqIEB0eXBlIHtzdHJpbmd9XG4gKi9cbmV4cG9ydCBjb25zdCBQUklNQVJZX09VVExFVDogc3RyaW5nID0gXCJQUklNQVJZX09VVExFVFwiO1xuXG4vKipcbiAqIEEgY29sbGVjdGlvbiBvZiBwYXJhbWV0ZXJzLlxuICovXG5leHBvcnQgdHlwZSBQYXJhbXMgPSB7IFtrZXk6IHN0cmluZ106IHN0cmluZyB9O1xuIl19 \ No newline at end of file diff --git a/modules/@angular/router/build/es6/src/url_serializer.d.ts b/modules/@angular/router/build/es6/src/url_serializer.d.ts new file mode 100644 index 0000000000..509f6b4ea0 --- /dev/null +++ b/modules/@angular/router/build/es6/src/url_serializer.d.ts @@ -0,0 +1,10 @@ +import { UrlTree, UrlSegment } from './url_tree'; +export declare abstract class UrlSerializer { + abstract parse(url: string): UrlTree; + abstract serialize(tree: UrlTree): string; +} +export declare class DefaultUrlSerializer implements UrlSerializer { + parse(url: string): UrlTree; + serialize(tree: UrlTree): string; +} +export declare function serializeSegment(segment: UrlSegment): string; diff --git a/modules/@angular/router/build/es6/src/url_serializer.js b/modules/@angular/router/build/es6/src/url_serializer.js new file mode 100644 index 0000000000..3ee0925dbf --- /dev/null +++ b/modules/@angular/router/build/es6/src/url_serializer.js @@ -0,0 +1,212 @@ +import { UrlTree, UrlSegment } from './url_tree'; +import { PRIMARY_OUTLET } from './shared'; +import { rootNode, TreeNode } from './utils/tree'; +export class UrlSerializer { +} +export class DefaultUrlSerializer { + parse(url) { + const p = new UrlParser(url); + return new UrlTree(p.parseRootSegment(), p.parseQueryParams(), p.parseFragment()); + } + serialize(tree) { + const node = serializeUrlTreeNode(rootNode(tree)); + const query = serializeQueryParams(tree.queryParameters); + const fragment = tree.fragment !== null ? `#${tree.fragment}` : ''; + return `${node}${query}${fragment}`; + } +} +function serializeUrlTreeNode(node) { + return `${serializeSegment(node.value)}${serializeChildren(node)}`; +} +function serializeUrlTreeNodes(nodes) { + const primary = serializeSegment(nodes[0].value); + const secondaryNodes = nodes.slice(1); + const secondary = secondaryNodes.length > 0 ? `(${secondaryNodes.map(serializeUrlTreeNode).join("//")})` : ""; + const children = serializeChildren(nodes[0]); + return `${primary}${secondary}${children}`; +} +function serializeChildren(node) { + if (node.children.length > 0) { + return `/${serializeUrlTreeNodes(node.children)}`; + } + else { + return ""; + } +} +export function serializeSegment(segment) { + const outlet = segment.outlet === PRIMARY_OUTLET ? '' : `${segment.outlet}:`; + return `${outlet}${segment.path}${serializeParams(segment.parameters)}`; +} +function serializeParams(params) { + return pairs(params).map(p => `;${p.first}=${p.second}`).join(""); +} +function serializeQueryParams(params) { + const strs = pairs(params).map(p => `${p.first}=${p.second}`); + return strs.length > 0 ? `?${strs.join("&")}` : ""; +} +class Pair { + constructor(first, second) { + this.first = first; + this.second = second; + } +} +function pairs(obj) { + const res = []; + for (let prop in obj) { + if (obj.hasOwnProperty(prop)) { + res.push(new Pair(prop, obj[prop])); + } + } + return res; +} +const SEGMENT_RE = /^[^\/\(\)\?;=&#]+/; +function matchUrlSegment(str) { + SEGMENT_RE.lastIndex = 0; + var match = SEGMENT_RE.exec(str); + return match ? match[0] : ''; +} +const QUERY_PARAM_VALUE_RE = /^[^\(\)\?;&#]+/; +function matchUrlQueryParamValue(str) { + QUERY_PARAM_VALUE_RE.lastIndex = 0; + const match = QUERY_PARAM_VALUE_RE.exec(str); + return match ? match[0] : ''; +} +class UrlParser { + constructor(remaining) { + this.remaining = remaining; + } + peekStartsWith(str) { return this.remaining.startsWith(str); } + capture(str) { + if (!this.remaining.startsWith(str)) { + throw new Error(`Expected "${str}".`); + } + this.remaining = this.remaining.substring(str.length); + } + parseRootSegment() { + if (this.remaining == '' || this.remaining == '/') { + return new TreeNode(new UrlSegment('', {}, PRIMARY_OUTLET), []); + } + else { + const segments = this.parseSegments(false); + return new TreeNode(new UrlSegment('', {}, PRIMARY_OUTLET), segments); + } + } + parseSegments(hasOutletName) { + if (this.remaining.length == 0) { + return []; + } + if (this.peekStartsWith('/')) { + this.capture('/'); + } + let path = matchUrlSegment(this.remaining); + this.capture(path); + let outletName; + if (hasOutletName) { + if (path.indexOf(":") === -1) { + throw new Error("Not outlet name is provided"); + } + if (path.indexOf(":") > -1 && hasOutletName) { + let parts = path.split(":"); + outletName = parts[0]; + path = parts[1]; + } + } + else { + if (path.indexOf(":") > -1) { + throw new Error("Not outlet name is allowed"); + } + outletName = PRIMARY_OUTLET; + } + let matrixParams = {}; + if (this.peekStartsWith(';')) { + matrixParams = this.parseMatrixParams(); + } + let secondary = []; + if (this.peekStartsWith('(')) { + secondary = this.parseSecondarySegments(); + } + let children = []; + if (this.peekStartsWith('/') && !this.peekStartsWith('//')) { + this.capture('/'); + children = this.parseSegments(false); + } + const segment = new UrlSegment(path, matrixParams, outletName); + const node = new TreeNode(segment, children); + return [node].concat(secondary); + } + parseQueryParams() { + var params = {}; + if (this.peekStartsWith('?')) { + this.capture('?'); + this.parseQueryParam(params); + while (this.remaining.length > 0 && this.peekStartsWith('&')) { + this.capture('&'); + this.parseQueryParam(params); + } + } + return params; + } + parseFragment() { + if (this.peekStartsWith('#')) { + return this.remaining.substring(1); + } + else { + return null; + } + } + parseMatrixParams() { + var params = {}; + while (this.remaining.length > 0 && this.peekStartsWith(';')) { + this.capture(';'); + this.parseParam(params); + } + return params; + } + parseParam(params) { + var key = matchUrlSegment(this.remaining); + if (!key) { + return; + } + this.capture(key); + var value = "true"; + if (this.peekStartsWith('=')) { + this.capture('='); + var valueMatch = matchUrlSegment(this.remaining); + if (valueMatch) { + value = valueMatch; + this.capture(value); + } + } + params[key] = value; + } + parseQueryParam(params) { + var key = matchUrlSegment(this.remaining); + if (!key) { + return; + } + this.capture(key); + var value = "true"; + if (this.peekStartsWith('=')) { + this.capture('='); + var valueMatch = matchUrlQueryParamValue(this.remaining); + if (valueMatch) { + value = valueMatch; + this.capture(value); + } + } + params[key] = value; + } + parseSecondarySegments() { + var segments = []; + this.capture('('); + while (!this.peekStartsWith(')') && this.remaining.length > 0) { + segments = segments.concat(this.parseSegments(true)); + if (this.peekStartsWith('//')) { + this.capture('//'); + } + } + this.capture(')'); + return segments; + } +} +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"url_serializer.js","sourceRoot":"","sources":["../../../src/url_serializer.ts"],"names":[],"mappings":"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","sourcesContent":["import { UrlTree, UrlSegment } from './url_tree';\nimport { PRIMARY_OUTLET } from './shared';\nimport { rootNode, TreeNode } from './utils/tree';\n\n/**\n * Defines a way to serialize/deserialize a url tree.\n */\nexport abstract class UrlSerializer {\n  /**\n   * Parse a url into a {@Link UrlTree}\n   */\n  abstract parse(url: string): UrlTree;\n\n  /**\n   * Converts a {@Link UrlTree} into a url\n   */\n  abstract serialize(tree: UrlTree): string;\n}\n\n/**\n * A default implementation of the serialization.\n */\nexport class DefaultUrlSerializer implements UrlSerializer {\n  parse(url: string): UrlTree {\n    const p = new UrlParser(url);\n    return new UrlTree(p.parseRootSegment(), p.parseQueryParams(), p.parseFragment());\n  }\n\n  serialize(tree: UrlTree): string { \n    const node = serializeUrlTreeNode(rootNode(tree));\n    const query = serializeQueryParams(tree.queryParameters);\n    const fragment = tree.fragment !== null ? `#${tree.fragment}` : '';\n    return `${node}${query}${fragment}`;\n  }\n}\n\nfunction serializeUrlTreeNode(node: TreeNode<UrlSegment>): string {\n  return `${serializeSegment(node.value)}${serializeChildren(node)}`;\n}\n\nfunction serializeUrlTreeNodes(nodes: TreeNode<UrlSegment>[]): string {\n  const primary = serializeSegment(nodes[0].value);\n  const secondaryNodes = nodes.slice(1);\n  const secondary = secondaryNodes.length > 0 ? `(${secondaryNodes.map(serializeUrlTreeNode).join(\"//\")})` : \"\";\n  const children = serializeChildren(nodes[0]);\n  return `${primary}${secondary}${children}`;\n}\n\nfunction serializeChildren(node: TreeNode<UrlSegment>): string {\n  if (node.children.length > 0) {\n    return `/${serializeUrlTreeNodes(node.children)}`;\n  } else {\n    return \"\";\n  }\n}\n\nexport function serializeSegment(segment: UrlSegment): string {\n  const outlet = segment.outlet === PRIMARY_OUTLET ? '' : `${segment.outlet}:`;\n  return `${outlet}${segment.path}${serializeParams(segment.parameters)}`;\n}\n\nfunction serializeParams(params: {[key: string]: string}): string {\n  return pairs(params).map(p => `;${p.first}=${p.second}`).join(\"\");\n}\n\nfunction serializeQueryParams(params: {[key: string]: string}): string {\n  const strs = pairs(params).map(p => `${p.first}=${p.second}`);\n  return strs.length > 0 ? `?${strs.join(\"&\")}` : \"\";\n}\n\nclass Pair<A,B> { constructor(public first:A, public second:B) {} }\nfunction pairs<T>(obj: {[key: string]: T}):Pair<string,T>[] {\n  const res = [];\n  for (let prop in obj) {\n    if (obj.hasOwnProperty(prop)) {\n      res.push(new Pair<string, T>(prop, obj[prop]));\n    }\n  }\n  return res;\n}\n\nconst SEGMENT_RE = /^[^\\/\\(\\)\\?;=&#]+/;\nfunction matchUrlSegment(str: string): string {\n  SEGMENT_RE.lastIndex = 0;\n  var match = SEGMENT_RE.exec(str);\n  return match ? match[0] : '';\n}\n\nconst QUERY_PARAM_VALUE_RE = /^[^\\(\\)\\?;&#]+/;\nfunction matchUrlQueryParamValue(str: string): string {\n  QUERY_PARAM_VALUE_RE.lastIndex = 0;\n  const match = QUERY_PARAM_VALUE_RE.exec(str);\n  return match ? match[0] : '';\n}\n\nclass UrlParser {\n  constructor(private remaining: string) {}\n\n  peekStartsWith(str: string): boolean { return this.remaining.startsWith(str); }\n\n  capture(str: string): void {\n    if (!this.remaining.startsWith(str)) {\n      throw new Error(`Expected \"${str}\".`);\n    }\n    this.remaining = this.remaining.substring(str.length);\n  }\n\n  parseRootSegment(): TreeNode<UrlSegment> {\n    if (this.remaining  == '' || this.remaining == '/') {\n      return new TreeNode<UrlSegment>(new UrlSegment('', {}, PRIMARY_OUTLET), []);\n    } else {\n      const segments = this.parseSegments(false);\n      return new TreeNode<UrlSegment>(new UrlSegment('', {}, PRIMARY_OUTLET), segments);\n    }\n  }\n\n  parseSegments(hasOutletName: boolean): TreeNode<UrlSegment>[] {\n    if (this.remaining.length == 0) {\n      return [];\n    }\n    if (this.peekStartsWith('/')) {\n      this.capture('/');\n    }\n    let path = matchUrlSegment(this.remaining);\n    this.capture(path);\n\n    let outletName;\n    if (hasOutletName) {\n      if (path.indexOf(\":\") === -1) {\n        throw new Error(\"Not outlet name is provided\");\n      }\n      if (path.indexOf(\":\") > -1 && hasOutletName) {\n        let parts = path.split(\":\");\n        outletName = parts[0];\n        path = parts[1];\n      }\n    } else {\n      if (path.indexOf(\":\") > -1) {\n        throw new Error(\"Not outlet name is allowed\");\n      }\n      outletName = PRIMARY_OUTLET;\n    }\n\n    let matrixParams: {[key: string]: any} = {};\n    if (this.peekStartsWith(';')) {\n      matrixParams = this.parseMatrixParams();\n    }\n\n    let secondary = [];\n    if (this.peekStartsWith('(')) {\n      secondary = this.parseSecondarySegments();\n    }\n\n    let children: TreeNode<UrlSegment>[] = [];\n    if (this.peekStartsWith('/') && !this.peekStartsWith('//')) {\n      this.capture('/');\n      children = this.parseSegments(false);\n    }\n\n    const segment = new UrlSegment(path, matrixParams, outletName);\n    const node = new TreeNode<UrlSegment>(segment, children);\n    return [node].concat(secondary);\n  }\n\n  parseQueryParams(): {[key: string]: any} {\n    var params: {[key: string]: any} = {};\n    if (this.peekStartsWith('?')) {\n      this.capture('?');\n      this.parseQueryParam(params);\n      while (this.remaining.length > 0 && this.peekStartsWith('&')) {\n        this.capture('&');\n        this.parseQueryParam(params);\n      }\n    }\n    return params;\n  }\n\n  parseFragment(): string | null {\n    if (this.peekStartsWith('#')) {\n      return this.remaining.substring(1);\n    } else {\n      return null;\n    }\n  }\n\n  parseMatrixParams(): {[key: string]: any} {\n    var params: {[key: string]: any} = {};\n    while (this.remaining.length > 0 && this.peekStartsWith(';')) {\n      this.capture(';');\n      this.parseParam(params);\n    }\n    return params;\n  }\n\n  parseParam(params: {[key: string]: any}): void {\n    var key = matchUrlSegment(this.remaining);\n    if (!key) {\n      return;\n    }\n    this.capture(key);\n    var value: any = \"true\";\n    if (this.peekStartsWith('=')) {\n      this.capture('=');\n      var valueMatch = matchUrlSegment(this.remaining);\n      if (valueMatch) {\n        value = valueMatch;\n        this.capture(value);\n      }\n    }\n\n    params[key] = value;\n  }\n\n  parseQueryParam(params: {[key: string]: any}): void {\n    var key = matchUrlSegment(this.remaining);\n    if (!key) {\n      return;\n    }\n    this.capture(key);\n    var value: any = \"true\";\n    if (this.peekStartsWith('=')) {\n      this.capture('=');\n      var valueMatch = matchUrlQueryParamValue(this.remaining);\n      if (valueMatch) {\n        value = valueMatch;\n        this.capture(value);\n      }\n    }\n    params[key] = value;\n  }\n\n  parseSecondarySegments(): TreeNode<UrlSegment>[] {\n    var segments = [];\n    this.capture('(');\n\n    while (!this.peekStartsWith(')') && this.remaining.length > 0) {\n      segments = segments.concat(this.parseSegments(true));\n      if (this.peekStartsWith('//')) {\n        this.capture('//');\n      }\n    }\n    this.capture(')');\n\n    return segments;\n  }\n}\n"]} \ No newline at end of file diff --git a/modules/@angular/router/build/es6/src/url_tree.d.ts b/modules/@angular/router/build/es6/src/url_tree.d.ts new file mode 100644 index 0000000000..f9ea224dae --- /dev/null +++ b/modules/@angular/router/build/es6/src/url_tree.d.ts @@ -0,0 +1,23 @@ +import { Tree, TreeNode } from './utils/tree'; +export declare function createEmptyUrlTree(): UrlTree; +export declare class UrlTree extends Tree { + queryParameters: { + [key: string]: string; + }; + fragment: string | null; + constructor(root: TreeNode, queryParameters: { + [key: string]: string; + }, fragment: string | null); +} +export declare class UrlSegment { + path: string; + parameters: { + [key: string]: string; + }; + outlet: string; + constructor(path: string, parameters: { + [key: string]: string; + }, outlet: string); + toString(): string; +} +export declare function equalUrlSegments(a: UrlSegment[], b: UrlSegment[]): boolean; diff --git a/modules/@angular/router/build/es6/src/url_tree.js b/modules/@angular/router/build/es6/src/url_tree.js new file mode 100644 index 0000000000..272b03bf73 --- /dev/null +++ b/modules/@angular/router/build/es6/src/url_tree.js @@ -0,0 +1,43 @@ +import { Tree, TreeNode } from './utils/tree'; +import { shallowEqual } from './utils/collection'; +import { PRIMARY_OUTLET } from './shared'; +export function createEmptyUrlTree() { + return new UrlTree(new TreeNode(new UrlSegment("", {}, PRIMARY_OUTLET), []), {}, null); +} +export class UrlTree extends Tree { + constructor(root, queryParameters, fragment) { + super(root); + this.queryParameters = queryParameters; + this.fragment = fragment; + } +} +export class UrlSegment { + constructor(path, parameters, outlet) { + this.path = path; + this.parameters = parameters; + this.outlet = outlet; + } + toString() { + const params = []; + for (let prop in this.parameters) { + if (this.parameters.hasOwnProperty(prop)) { + params.push(`${prop}=${this.parameters[prop]}`); + } + } + const paramsString = params.length > 0 ? `(${params.join(',')})` : ''; + const outlet = this.outlet === PRIMARY_OUTLET ? '' : `${this.outlet}:`; + return `${outlet}${this.path}${paramsString}`; + } +} +export function equalUrlSegments(a, b) { + if (a.length !== b.length) + return false; + for (let i = 0; i < a.length; ++i) { + if (a[i].path !== b[i].path) + return false; + if (!shallowEqual(a[i].parameters, b[i].parameters)) + return false; + } + return true; +} +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/modules/@angular/router/build/es6/src/utils/collection.d.ts b/modules/@angular/router/build/es6/src/utils/collection.d.ts new file mode 100644 index 0000000000..9df4eefaf9 --- /dev/null +++ b/modules/@angular/router/build/es6/src/utils/collection.d.ts @@ -0,0 +1,17 @@ +export declare function shallowEqual(a: { + [x: string]: any; +}, b: { + [x: string]: any; +}): boolean; +export declare function flatten(a: T[][]): T[]; +export declare function first(a: T[]): T | null; +export declare function merge(m1: { + [key: string]: V; +}, m2: { + [key: string]: V; +}): { + [key: string]: V; +}; +export declare function forEach(map: { + [key: string]: V; +}, callback: Function): void; diff --git a/modules/@angular/router/build/es6/src/utils/collection.js b/modules/@angular/router/build/es6/src/utils/collection.js new file mode 100644 index 0000000000..92be32b5cf --- /dev/null +++ b/modules/@angular/router/build/es6/src/utils/collection.js @@ -0,0 +1,49 @@ +export function shallowEqual(a, b) { + var k1 = Object.keys(a); + var k2 = Object.keys(b); + if (k1.length != k2.length) { + return false; + } + var key; + for (var i = 0; i < k1.length; i++) { + key = k1[i]; + if (a[key] !== b[key]) { + return false; + } + } + return true; +} +export function flatten(a) { + const target = []; + for (let i = 0; i < a.length; ++i) { + for (let j = 0; j < a[i].length; ++j) { + target.push(a[i][j]); + } + } + return target; +} +export function first(a) { + return a.length > 0 ? a[0] : null; +} +export function merge(m1, m2) { + var m = {}; + for (var attr in m1) { + if (m1.hasOwnProperty(attr)) { + m[attr] = m1[attr]; + } + } + for (var attr in m2) { + if (m2.hasOwnProperty(attr)) { + m[attr] = m2[attr]; + } + } + return m; +} +export function forEach(map, callback) { + for (var prop in map) { + if (map.hasOwnProperty(prop)) { + callback(map[prop], prop); + } + } +} +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/modules/@angular/router/build/es6/src/utils/tree.d.ts b/modules/@angular/router/build/es6/src/utils/tree.d.ts new file mode 100644 index 0000000000..1b025de959 --- /dev/null +++ b/modules/@angular/router/build/es6/src/utils/tree.d.ts @@ -0,0 +1,17 @@ +export declare class Tree { + _root: TreeNode; + constructor(root: TreeNode); + readonly root: T; + parent(t: T): T | null; + children(t: T): T[]; + firstChild(t: T): T | null; + siblings(t: T): T[]; + pathFromRoot(t: T): T[]; + contains(tree: Tree): boolean; +} +export declare function rootNode(tree: Tree): TreeNode; +export declare class TreeNode { + value: T; + children: TreeNode[]; + constructor(value: T, children: TreeNode[]); +} diff --git a/modules/@angular/router/build/es6/src/utils/tree.js b/modules/@angular/router/build/es6/src/utils/tree.js new file mode 100644 index 0000000000..b0a517094a --- /dev/null +++ b/modules/@angular/router/build/es6/src/utils/tree.js @@ -0,0 +1,71 @@ +export class Tree { + constructor(root) { + this._root = root; + } + get root() { return this._root.value; } + parent(t) { + const p = this.pathFromRoot(t); + return p.length > 1 ? p[p.length - 2] : null; + } + children(t) { + const n = findNode(t, this._root); + return n ? n.children.map(t => t.value) : []; + } + firstChild(t) { + const n = findNode(t, this._root); + return n && n.children.length > 0 ? n.children[0].value : null; + } + siblings(t) { + const p = findPath(t, this._root, []); + if (p.length < 2) + return []; + const c = p[p.length - 2].children.map(c => c.value); + return c.filter(cc => cc !== t); + } + pathFromRoot(t) { return findPath(t, this._root, []).map(s => s.value); } + contains(tree) { return contains(this._root, tree._root); } +} +export function rootNode(tree) { + return tree._root; +} +function findNode(expected, c) { + if (expected === c.value) + return c; + for (let cc of c.children) { + const r = findNode(expected, cc); + if (r) + return r; + } + return null; +} +function findPath(expected, c, collected) { + collected.push(c); + if (expected === c.value) + return collected; + for (let cc of c.children) { + const cloned = collected.slice(0); + const r = findPath(expected, cc, cloned); + if (r) + return r; + } + return []; +} +function contains(tree, subtree) { + if (tree.value !== subtree.value) + return false; + for (let subtreeNode of subtree.children) { + const s = tree.children.filter(child => child.value === subtreeNode.value); + if (s.length === 0) + return false; + if (!contains(s[0], subtreeNode)) + return false; + } + return true; +} +export class TreeNode { + constructor(value, children) { + this.value = value; + this.children = children; + } +} +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/modules/@angular/router/build/package.json b/modules/@angular/router/build/package.json new file mode 100644 index 0000000000..312420f918 --- /dev/null +++ b/modules/@angular/router/build/package.json @@ -0,0 +1,68 @@ +{ + "name": "vladivostok", + "version": "0.9.1", + "description": "", + "main": "./build/src/index.js", + "jsnext:main": "./build/es6/index.js", + "scripts": { + "karma": "karma start", + "test": "npm run build; karma start", + "build_watch": "rm -rf dist; tsc -w", + "build": "rm -rf dist; tsc", + "build_npm": "rm -rf dist && tsc -p tsconfig.publish.es5.json && tsc -p tsconfig.publish.es6.json", + "postbuild_npm": "cp package.json README.md dist/ && npm run rewrite_npm_package", + "rewrite_npm_package": "node --harmony_destructuring tools/rewrite-published-package.js", + "build_bundle": "cp -r src router && tsc typings/index.d.ts src/router.ts --rootDir . --module system -t es5 --outFile dist/bundles/router.js --moduleResolution node --emitDecoratorMetadata --experimentalDecorators" + }, + "keywords": [ + "angular2", + "angular", + "router" + ], + "repository": { + "type": "git", + "url": "git+https://github.com/angular/vladivostok.git" + }, + "author": "vsavkin", + "license": "MIT", + "bugs": { + "url": "https://github.com/angular/vladivostok/issues" + }, + "homepage": "https://github.com/angular/vladivostok#readme", + "devDependencies": { + "es6-module-loader": "^0.17.10", + "es6-shim": "^0.35.0", + "gulp": "^3.9.0", + "gulp-jasmine": "^2.2.1", + "gulp-typescript": "^2.10.0", + "http-server": "^0.8.5", + "jasmine": "^2.4.1", + "jasmine-core": "^2.4.1", + "json": "^9.0.3", + "karma": "^0.13.19", + "karma-chrome-launcher": "^0.2.2", + "karma-firefox-launcher": "^0.1.7", + "karma-jasmine": "^0.3.6", + "karma-systemjs": "^0.10.0", + "karma-sourcemap-loader": "~0.3", + "parse5": "^1.3.2", + "protractor": "3.0.0", + "reflect-metadata": "0.1.2", + "systemjs": "^0.19.16", + "systemjs-builder": "^0.15.7", + "traceur": "0.0.96", + "tsd": "^0.6.5", + "typescript": "^1.9.0-dev.20160409", + "typings": "^1.0.4", + "zone.js": "^0.6.6" + }, + "typings": "router.d.ts", + "peerDependencies": { + "@angular/common": "2.0.0-rc.1", + "@angular/compiler": "2.0.0-rc.1", + "@angular/core": "2.0.0-rc.1", + "@angular/platform-browser": "2.0.0-rc.1", + "@angular/platform-browser-dynamic": "2.0.0-rc.1", + "rxjs": "5.0.0-beta.6" + } +} \ No newline at end of file diff --git a/modules/@angular/router/build/src/config.d.ts b/modules/@angular/router/build/src/config.d.ts new file mode 100644 index 0000000000..d0f5b418d6 --- /dev/null +++ b/modules/@angular/router/build/src/config.d.ts @@ -0,0 +1,9 @@ +import { Type } from '@angular/core'; +export declare type RouterConfig = Route[]; +export interface Route { + index?: boolean; + path?: string; + component: Type | string; + outlet?: string; + children?: Route[]; +} diff --git a/modules/@angular/router/build/src/config.js b/modules/@angular/router/build/src/config.js new file mode 100644 index 0000000000..c50ab67c1f --- /dev/null +++ b/modules/@angular/router/build/src/config.js @@ -0,0 +1,2 @@ +"use strict"; +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZmlnLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2NvbmZpZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgVHlwZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5leHBvcnQgdHlwZSBSb3V0ZXJDb25maWcgPSBSb3V0ZVtdO1xuXG5leHBvcnQgaW50ZXJmYWNlIFJvdXRlIHtcbiAgaW5kZXg/OiBib29sZWFuO1xuICBwYXRoPzogc3RyaW5nO1xuICBjb21wb25lbnQ6IFR5cGUgfCBzdHJpbmc7XG4gIG91dGxldD86IHN0cmluZztcbiAgY2hpbGRyZW4/OiBSb3V0ZVtdO1xufSJdfQ== \ No newline at end of file diff --git a/modules/@angular/router/build/src/create_url_tree.d.ts b/modules/@angular/router/build/src/create_url_tree.d.ts new file mode 100644 index 0000000000..999cea0d39 --- /dev/null +++ b/modules/@angular/router/build/src/create_url_tree.d.ts @@ -0,0 +1,4 @@ +import { UrlTree } from './url_tree'; +import { ActivatedRoute } from './router_state'; +import { Params } from './shared'; +export declare function createUrlTree(route: ActivatedRoute, urlTree: UrlTree, commands: any[], queryParameters: Params | undefined, fragment: string | undefined): UrlTree; diff --git a/modules/@angular/router/build/src/create_url_tree.js b/modules/@angular/router/build/src/create_url_tree.js new file mode 100644 index 0000000000..0053e97510 --- /dev/null +++ b/modules/@angular/router/build/src/create_url_tree.js @@ -0,0 +1,189 @@ +"use strict"; +var url_tree_1 = require('./url_tree'); +var tree_1 = require('./utils/tree'); +var collection_1 = require('./utils/collection'); +var shared_1 = require('./shared'); +function createUrlTree(route, urlTree, commands, queryParameters, fragment) { + if (commands.length === 0) { + return tree(tree_1.rootNode(urlTree), urlTree, queryParameters, fragment); + } + var normalizedCommands = normalizeCommands(commands); + if (navigateToRoot(normalizedCommands)) { + return tree(new tree_1.TreeNode(urlTree.root, []), urlTree, queryParameters, fragment); + } + var startingNode = findStartingNode(normalizedCommands, urlTree, route); + var updated = normalizedCommands.commands.length > 0 ? + updateMany(startingNode.children.slice(0), normalizedCommands.commands) : + []; + var newRoot = constructNewTree(tree_1.rootNode(urlTree), startingNode, updated); + return tree(newRoot, urlTree, queryParameters, fragment); +} +exports.createUrlTree = createUrlTree; +function tree(root, urlTree, queryParameters, fragment) { + var q = queryParameters ? stringify(queryParameters) : urlTree.queryParameters; + var f = fragment ? fragment : urlTree.fragment; + return new url_tree_1.UrlTree(root, q, f); +} +function navigateToRoot(normalizedChange) { + return normalizedChange.isAbsolute && normalizedChange.commands.length === 1 && + normalizedChange.commands[0] == "/"; +} +var NormalizedNavigationCommands = (function () { + function NormalizedNavigationCommands(isAbsolute, numberOfDoubleDots, commands) { + this.isAbsolute = isAbsolute; + this.numberOfDoubleDots = numberOfDoubleDots; + this.commands = commands; + } + return NormalizedNavigationCommands; +}()); +function normalizeCommands(commands) { + if ((typeof commands[0] === "string") && commands.length === 1 && commands[0] == "/") { + return new NormalizedNavigationCommands(true, 0, commands); + } + var numberOfDoubleDots = 0; + var isAbsolute = false; + var res = []; + for (var i = 0; i < commands.length; ++i) { + var c = commands[i]; + if (!(typeof c === "string")) { + res.push(c); + continue; + } + var parts = c.split('/'); + for (var j = 0; j < parts.length; ++j) { + var cc = parts[j]; + if (i == 0) { + if (j == 0 && cc == ".") { + } + else if (j == 0 && cc == "") { + isAbsolute = true; + } + else if (cc == "..") { + numberOfDoubleDots++; + } + else if (cc != '') { + res.push(cc); + } + } + else { + if (cc != '') { + res.push(cc); + } + } + } + } + return new NormalizedNavigationCommands(isAbsolute, numberOfDoubleDots, res); +} +function findStartingNode(normalizedChange, urlTree, route) { + if (normalizedChange.isAbsolute) { + return tree_1.rootNode(urlTree); + } + else { + var urlSegment = findUrlSegment(route, urlTree, normalizedChange.numberOfDoubleDots); + return findMatchingNode(urlSegment, tree_1.rootNode(urlTree)); + } +} +function findUrlSegment(route, urlTree, numberOfDoubleDots) { + var segments = route.urlSegments.value; + var urlSegment = segments[segments.length - 1]; + var path = urlTree.pathFromRoot(urlSegment); + if (path.length <= numberOfDoubleDots) { + throw new Error("Invalid number of '../'"); + } + return path[path.length - 1 - numberOfDoubleDots]; +} +function findMatchingNode(segment, node) { + if (node.value === segment) + return node; + for (var _i = 0, _a = node.children; _i < _a.length; _i++) { + var c = _a[_i]; + var r = findMatchingNode(segment, c); + if (r) + return r; + } + throw new Error("Cannot find url segment '" + segment + "'"); +} +function constructNewTree(node, original, updated) { + if (node === original) { + return new tree_1.TreeNode(node.value, updated); + } + else { + return new tree_1.TreeNode(node.value, node.children.map(function (c) { return constructNewTree(c, original, updated); })); + } +} +function updateMany(nodes, commands) { + var outlet = getOutlet(commands); + var nodesInRightOutlet = nodes.filter(function (c) { return c.value.outlet === outlet; }); + if (nodesInRightOutlet.length > 0) { + var nodeRightOutlet = nodesInRightOutlet[0]; + nodes[nodes.indexOf(nodeRightOutlet)] = update(nodeRightOutlet, commands); + } + else { + nodes.push(update(null, commands)); + } + return nodes; +} +function getPath(commands) { + if (!(typeof commands[0] === "string")) + return commands[0]; + var parts = commands[0].toString().split(":"); + return parts.length > 1 ? parts[1] : commands[0]; +} +function getOutlet(commands) { + if (!(typeof commands[0] === "string")) + return shared_1.PRIMARY_OUTLET; + var parts = commands[0].toString().split(":"); + return parts.length > 1 ? parts[0] : shared_1.PRIMARY_OUTLET; +} +function update(node, commands) { + var rest = commands.slice(1); + var next = rest.length === 0 ? null : rest[0]; + var outlet = getOutlet(commands); + var path = getPath(commands); + if (!node && !(typeof next === 'object')) { + var urlSegment = new url_tree_1.UrlSegment(path, {}, outlet); + var children = rest.length === 0 ? [] : [update(null, rest)]; + return new tree_1.TreeNode(urlSegment, children); + } + else if (!node && typeof next === 'object') { + var urlSegment = new url_tree_1.UrlSegment(path, stringify(next), outlet); + return recurse(urlSegment, node, rest.slice(1)); + } + else if (node && outlet !== node.value.outlet) { + return node; + } + else if (node && typeof path === 'object') { + var newSegment = new url_tree_1.UrlSegment(node.value.path, stringify(path), node.value.outlet); + return recurse(newSegment, node, rest); + } + else if (node && typeof next === 'object' && compare(path, stringify(next), node.value)) { + return recurse(node.value, node, rest.slice(1)); + } + else if (node && typeof next === 'object') { + var urlSegment = new url_tree_1.UrlSegment(path, stringify(next), outlet); + return recurse(urlSegment, node, rest.slice(1)); + } + else if (node && compare(path, {}, node.value)) { + return recurse(node.value, node, rest); + } + else { + var urlSegment = new url_tree_1.UrlSegment(path, {}, outlet); + return recurse(urlSegment, node, rest); + } +} +function stringify(params) { + var res = {}; + collection_1.forEach(params, function (v, k) { return res[k] = v.toString(); }); + return res; +} +function compare(path, params, segment) { + return path == segment.path && collection_1.shallowEqual(params, segment.parameters); +} +function recurse(urlSegment, node, rest) { + if (rest.length === 0) { + return new tree_1.TreeNode(urlSegment, []); + } + var children = node ? node.children.slice(0) : []; + return new tree_1.TreeNode(urlSegment, updateMany(children, rest)); +} +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"create_url_tree.js","sourceRoot":"","sources":["../../src/create_url_tree.ts"],"names":[],"mappings":"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","sourcesContent":["import { UrlTree, UrlSegment, equalUrlSegments } from './url_tree';\nimport { TreeNode, rootNode } from './utils/tree';\nimport { forEach, shallowEqual } from './utils/collection';\nimport { RouterState, ActivatedRoute } from './router_state';\nimport { Params, PRIMARY_OUTLET } from './shared';\n\nexport function createUrlTree(route: ActivatedRoute, urlTree: UrlTree, commands: any[], \n                              queryParameters: Params | undefined, fragment: string | undefined): UrlTree {\n  if (commands.length === 0) {\n    return tree(rootNode(urlTree), urlTree, queryParameters, fragment);\n  }\n\n  const normalizedCommands = normalizeCommands(commands);\n  if (navigateToRoot(normalizedCommands)) {\n    return tree(new TreeNode<UrlSegment>(urlTree.root, []), urlTree, queryParameters, fragment);\n  }\n\n  const startingNode = findStartingNode(normalizedCommands, urlTree, route);\n  const updated = normalizedCommands.commands.length > 0 ?\n      updateMany(startingNode.children.slice(0), normalizedCommands.commands) :\n      [];\n  const newRoot = constructNewTree(rootNode(urlTree), startingNode, updated);\n\n  return tree(newRoot, urlTree, queryParameters, fragment);\n}\n\nfunction tree(root: TreeNode<UrlSegment>, urlTree: UrlTree, queryParameters: Params | undefined, fragment: string | undefined): UrlTree {\n  const q = queryParameters ? stringify(queryParameters) : urlTree.queryParameters;\n  const f = fragment ? fragment : urlTree.fragment;\n  return new UrlTree(root, q, f);\n}\n\nfunction navigateToRoot(normalizedChange: NormalizedNavigationCommands): boolean {\n  return normalizedChange.isAbsolute && normalizedChange.commands.length === 1 &&\n    normalizedChange.commands[0] == \"/\";\n}\n\nclass NormalizedNavigationCommands {\n  constructor(public isAbsolute: boolean, public numberOfDoubleDots: number,\n              public commands: any[]) {}\n}\n\nfunction normalizeCommands(commands: any[]): NormalizedNavigationCommands {\n  if ((typeof commands[0] === \"string\") && commands.length === 1 && commands[0] == \"/\") {\n    return new NormalizedNavigationCommands(true, 0, commands);\n  }\n\n  let numberOfDoubleDots = 0;\n  let isAbsolute = false;\n  const res = [];\n\n  for (let i = 0; i < commands.length; ++i) {\n    const c = commands[i];\n\n    if (!(typeof c === \"string\")) {\n      res.push(c);\n      continue;\n    }\n\n    const parts = c.split('/');\n    for (let j = 0; j < parts.length; ++j) {\n      let cc = parts[j];\n\n      // first exp is treated in a special way\n      if (i == 0) {\n        if (j == 0 && cc == \".\") {  //  './a'\n          // skip it\n        } else if (j == 0 && cc == \"\") {  //  '/a'\n          isAbsolute = true;\n        } else if (cc == \"..\") {  //  '../a'\n          numberOfDoubleDots++;\n        } else if (cc != '') {\n          res.push(cc);\n        }\n\n      } else {\n        if (cc != '') {\n          res.push(cc);\n        }\n      }\n    }\n  }\n\n  return new NormalizedNavigationCommands(isAbsolute, numberOfDoubleDots, res);\n}\n\nfunction findStartingNode(normalizedChange: NormalizedNavigationCommands, urlTree: UrlTree,\n                           route: ActivatedRoute): TreeNode<UrlSegment> {\n  if (normalizedChange.isAbsolute) {\n    return rootNode(urlTree);\n  } else {\n    const urlSegment =\n      findUrlSegment(route, urlTree, normalizedChange.numberOfDoubleDots);\n    return findMatchingNode(urlSegment, rootNode(urlTree));\n  }\n}\n\nfunction findUrlSegment(route: ActivatedRoute, urlTree: UrlTree, numberOfDoubleDots: number): UrlSegment {\n  const segments = (<any>route.urlSegments).value;\n  const urlSegment = segments[segments.length - 1];\n  const path = urlTree.pathFromRoot(urlSegment);\n  if (path.length <= numberOfDoubleDots) {\n    throw new Error(\"Invalid number of '../'\");\n  }\n  return path[path.length - 1 - numberOfDoubleDots];\n}\n\nfunction findMatchingNode(segment: UrlSegment, node: TreeNode<UrlSegment>): TreeNode<UrlSegment> {\n  if (node.value === segment) return node;\n  for (let c of node.children) {\n    const r = findMatchingNode(segment, c);\n    if (r) return r;\n  }\n  throw new Error(`Cannot find url segment '${segment}'`);\n}\n\nfunction constructNewTree(node: TreeNode<UrlSegment>, original: TreeNode<UrlSegment>,\n                          updated: TreeNode<UrlSegment>[]): TreeNode<UrlSegment> {\n  if (node === original) {\n    return new TreeNode<UrlSegment>(node.value, updated);\n  } else {\n    return new TreeNode<UrlSegment>(\n      node.value, node.children.map(c => constructNewTree(c, original, updated)));\n  }\n}\n\nfunction updateMany(nodes: TreeNode<UrlSegment>[], commands: any[]): TreeNode<UrlSegment>[] {\n  const outlet = getOutlet(commands);\n  const nodesInRightOutlet = nodes.filter(c => c.value.outlet === outlet);\n  if (nodesInRightOutlet.length > 0) {\n    const nodeRightOutlet = nodesInRightOutlet[0];  // there can be only one\n    nodes[nodes.indexOf(nodeRightOutlet)] = update(nodeRightOutlet, commands);\n  } else {\n    nodes.push(update(null, commands));\n  }\n  return nodes;\n}\n\nfunction getPath(commands: any[]): any {\n  if (!(typeof commands[0] === \"string\")) return commands[0];\n  const parts = commands[0].toString().split(\":\");\n  return parts.length > 1 ? parts[1] : commands[0];\n}\n\nfunction getOutlet(commands: any[]): string {\n  if (!(typeof commands[0] === \"string\")) return PRIMARY_OUTLET;\n  const parts = commands[0].toString().split(\":\");\n  return parts.length > 1 ? parts[0] : PRIMARY_OUTLET;\n}\n\nfunction update(node: TreeNode<UrlSegment>|null, commands: any[]): TreeNode<UrlSegment> {\n  const rest = commands.slice(1);\n  const next = rest.length === 0 ? null : rest[0];\n  const outlet = getOutlet(commands);\n  const path = getPath(commands);\n\n  // reach the end of the tree => create new tree nodes.\n  if (!node && !(typeof next === 'object')) {\n    const urlSegment = new UrlSegment(path, {}, outlet);\n    const children = rest.length === 0 ? [] : [update(null, rest)];\n    return new TreeNode<UrlSegment>(urlSegment, children);\n\n  } else if (!node && typeof next === 'object') {\n    const urlSegment = new UrlSegment(path, stringify(next), outlet);\n    return recurse(urlSegment, node, rest.slice(1));\n\n    // different outlet => preserve the subtree\n  } else if (node && outlet !== node.value.outlet) {\n    return node;\n\n    // params command\n  } else if (node && typeof path === 'object') {\n    const newSegment = new UrlSegment(node.value.path, stringify(path), node.value.outlet);\n    return recurse(newSegment, node, rest);\n\n    // next one is a params command && can reuse the node\n  } else if (node && typeof next === 'object' && compare(path, stringify(next), node.value)) {\n    return recurse(node.value, node, rest.slice(1));\n\n    // next one is a params command && cannot reuse the node\n  } else if (node && typeof next === 'object') {\n    const urlSegment = new UrlSegment(path, stringify(next), outlet);\n    return recurse(urlSegment, node, rest.slice(1));\n\n    // next one is not a params command && can reuse the node\n  } else if (node && compare(path, {}, node.value)) {\n    return recurse(node.value, node, rest);\n\n    // next one is not a params command && cannot reuse the node\n  } else {\n    const urlSegment = new UrlSegment(path, {}, outlet);\n    return recurse(urlSegment, node, rest);\n  }\n}\n\nfunction stringify(params: {[key: string]: any}): {[key: string]: string} {\n  const res = {};\n  forEach(params, (v, k) => res[k] = v.toString());\n  return res;\n}\n\nfunction compare(path: string, params: {[key: string]: any}, segment: UrlSegment): boolean {\n  return path == segment.path && shallowEqual(params, segment.parameters);\n}\n\nfunction recurse(urlSegment: UrlSegment, node: TreeNode<UrlSegment> | null,\n                  rest: any[]): TreeNode<UrlSegment> {\n  if (rest.length === 0) {\n    return new TreeNode<UrlSegment>(urlSegment, []);\n  }\n  const children = node ? node.children.slice(0) : [];\n  return new TreeNode<UrlSegment>(urlSegment, updateMany(children, rest));\n}"]} \ No newline at end of file diff --git a/modules/@angular/router/build/src/directives/router_link.d.ts b/modules/@angular/router/build/src/directives/router_link.d.ts new file mode 100644 index 0000000000..5ce81cb7fc --- /dev/null +++ b/modules/@angular/router/build/src/directives/router_link.d.ts @@ -0,0 +1,13 @@ +import { Router } from '../router'; +import { ActivatedRoute } from '../router_state'; +export declare class RouterLink { + private router; + private route; + target: string; + private commands; + href: string; + constructor(router: Router, route: ActivatedRoute); + routerLink: any[] | string; + onClick(): boolean; + private updateTargetUrlAndHref(); +} diff --git a/modules/@angular/router/build/src/directives/router_link.js b/modules/@angular/router/build/src/directives/router_link.js new file mode 100644 index 0000000000..11f7f909e3 --- /dev/null +++ b/modules/@angular/router/build/src/directives/router_link.js @@ -0,0 +1,72 @@ +"use strict"; +var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; +}; +var __metadata = (this && this.__metadata) || function (k, v) { + if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v); +}; +var core_1 = require('@angular/core'); +var router_1 = require('../router'); +var router_state_1 = require('../router_state'); +var RouterLink = (function () { + function RouterLink(router, route) { + this.router = router; + this.route = route; + this.commands = []; + } + Object.defineProperty(RouterLink.prototype, "routerLink", { + set: function (data) { + if (Array.isArray(data)) { + this.commands = data; + } + else { + this.commands = [data]; + } + this.updateTargetUrlAndHref(); + }, + enumerable: true, + configurable: true + }); + RouterLink.prototype.onClick = function () { + if (!(typeof this.target === "string") || this.target == '_self') { + this.router.navigate(this.commands, { relativeTo: this.route }); + return false; + } + return true; + }; + RouterLink.prototype.updateTargetUrlAndHref = function () { + var tree = this.router.createUrlTree(this.commands, { relativeTo: this.route }); + if (tree) { + this.href = this.router.serializeUrl(tree); + } + }; + __decorate([ + core_1.Input(), + __metadata('design:type', String) + ], RouterLink.prototype, "target", void 0); + __decorate([ + core_1.HostBinding(), + __metadata('design:type', String) + ], RouterLink.prototype, "href", void 0); + __decorate([ + core_1.Input(), + __metadata('design:type', Object), + __metadata('design:paramtypes', [Object]) + ], RouterLink.prototype, "routerLink", null); + __decorate([ + core_1.HostListener("click"), + __metadata('design:type', Function), + __metadata('design:paramtypes', []), + __metadata('design:returntype', Boolean) + ], RouterLink.prototype, "onClick", null); + RouterLink = __decorate([ + core_1.Directive({ selector: '[routerLink]' }), + __metadata('design:paramtypes', [router_1.Router, router_state_1.ActivatedRoute]) + ], RouterLink); + return RouterLink; +}()); +exports.RouterLink = RouterLink; +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/modules/@angular/router/build/src/directives/router_outlet.d.ts b/modules/@angular/router/build/src/directives/router_outlet.d.ts new file mode 100644 index 0000000000..bfddeddb4b --- /dev/null +++ b/modules/@angular/router/build/src/directives/router_outlet.d.ts @@ -0,0 +1,11 @@ +import { ViewContainerRef, ComponentFactory, ResolvedReflectiveProvider } from '@angular/core'; +import { RouterOutletMap } from '../router_outlet_map'; +export declare class RouterOutlet { + private location; + private activated; + outletMap: RouterOutletMap; + constructor(parentOutletMap: RouterOutletMap, location: ViewContainerRef, name: string); + readonly isActivated: boolean; + deactivate(): void; + activate(factory: ComponentFactory, providers: ResolvedReflectiveProvider[], outletMap: RouterOutletMap): void; +} diff --git a/modules/@angular/router/build/src/directives/router_outlet.js b/modules/@angular/router/build/src/directives/router_outlet.js new file mode 100644 index 0000000000..41ac2aef21 --- /dev/null +++ b/modules/@angular/router/build/src/directives/router_outlet.js @@ -0,0 +1,46 @@ +"use strict"; +var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; +}; +var __metadata = (this && this.__metadata) || function (k, v) { + if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v); +}; +var __param = (this && this.__param) || function (paramIndex, decorator) { + return function (target, key) { decorator(target, key, paramIndex); } +}; +var core_1 = require('@angular/core'); +var router_outlet_map_1 = require('../router_outlet_map'); +var shared_1 = require('../shared'); +var RouterOutlet = (function () { + function RouterOutlet(parentOutletMap, location, name) { + this.location = location; + parentOutletMap.registerOutlet(name ? name : shared_1.PRIMARY_OUTLET, this); + } + Object.defineProperty(RouterOutlet.prototype, "isActivated", { + get: function () { return !!this.activated; }, + enumerable: true, + configurable: true + }); + RouterOutlet.prototype.deactivate = function () { + if (this.activated) { + this.activated.destroy(); + this.activated = null; + } + }; + RouterOutlet.prototype.activate = function (factory, providers, outletMap) { + this.outletMap = outletMap; + var inj = core_1.ReflectiveInjector.fromResolvedProviders(providers, this.location.parentInjector); + this.activated = this.location.createComponent(factory, this.location.length, inj, []); + }; + RouterOutlet = __decorate([ + core_1.Directive({ selector: 'router-outlet' }), + __param(2, core_1.Attribute('name')), + __metadata('design:paramtypes', [router_outlet_map_1.RouterOutletMap, core_1.ViewContainerRef, String]) + ], RouterOutlet); + return RouterOutlet; +}()); +exports.RouterOutlet = RouterOutlet; +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/modules/@angular/router/build/src/index.d.ts b/modules/@angular/router/build/src/index.d.ts new file mode 100644 index 0000000000..7ec5c4879d --- /dev/null +++ b/modules/@angular/router/build/src/index.d.ts @@ -0,0 +1,7 @@ +export { Router } from './router'; +export { UrlSerializer, DefaultUrlSerializer } from './url_serializer'; +export { RouterState, ActivatedRoute } from './router_state'; +export { RouterOutletMap } from './router_outlet_map'; +import { RouterOutlet } from './directives/router_outlet'; +import { RouterLink } from './directives/router_link'; +export declare const ROUTER_DIRECTIVES: (typeof RouterOutlet | typeof RouterLink)[]; diff --git a/modules/@angular/router/build/src/index.js b/modules/@angular/router/build/src/index.js new file mode 100644 index 0000000000..0804f1e456 --- /dev/null +++ b/modules/@angular/router/build/src/index.js @@ -0,0 +1,15 @@ +"use strict"; +var router_1 = require('./router'); +exports.Router = router_1.Router; +var url_serializer_1 = require('./url_serializer'); +exports.UrlSerializer = url_serializer_1.UrlSerializer; +exports.DefaultUrlSerializer = url_serializer_1.DefaultUrlSerializer; +var router_state_1 = require('./router_state'); +exports.RouterState = router_state_1.RouterState; +exports.ActivatedRoute = router_state_1.ActivatedRoute; +var router_outlet_map_1 = require('./router_outlet_map'); +exports.RouterOutletMap = router_outlet_map_1.RouterOutletMap; +var router_outlet_1 = require('./directives/router_outlet'); +var router_link_1 = require('./directives/router_link'); +exports.ROUTER_DIRECTIVES = [router_outlet_1.RouterOutlet, router_link_1.RouterLink]; +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLHVCQUF1QixVQUFVLENBQUM7QUFBekIsaUNBQXlCO0FBQ2xDLCtCQUFvRCxrQkFBa0IsQ0FBQztBQUE5RCx1REFBYTtBQUFFLHFFQUErQztBQUN2RSw2QkFBNEMsZ0JBQWdCLENBQUM7QUFBcEQsaURBQVc7QUFBRSx1REFBdUM7QUFDN0Qsa0NBQWdDLHFCQUFxQixDQUFDO0FBQTdDLDhEQUE2QztBQUV0RCw4QkFBNkIsNEJBQTRCLENBQUMsQ0FBQTtBQUMxRCw0QkFBMkIsMEJBQTBCLENBQUMsQ0FBQTtBQUV6Qyx5QkFBaUIsR0FBRyxDQUFDLDRCQUFZLEVBQUUsd0JBQVUsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgUm91dGVyIH0gZnJvbSAnLi9yb3V0ZXInO1xuZXhwb3J0IHsgVXJsU2VyaWFsaXplciwgRGVmYXVsdFVybFNlcmlhbGl6ZXIgfSBmcm9tICcuL3VybF9zZXJpYWxpemVyJztcbmV4cG9ydCB7IFJvdXRlclN0YXRlLCBBY3RpdmF0ZWRSb3V0ZSB9IGZyb20gJy4vcm91dGVyX3N0YXRlJztcbmV4cG9ydCB7IFJvdXRlck91dGxldE1hcCB9IGZyb20gJy4vcm91dGVyX291dGxldF9tYXAnO1xuXG5pbXBvcnQgeyBSb3V0ZXJPdXRsZXQgfSBmcm9tICcuL2RpcmVjdGl2ZXMvcm91dGVyX291dGxldCc7XG5pbXBvcnQgeyBSb3V0ZXJMaW5rIH0gZnJvbSAnLi9kaXJlY3RpdmVzL3JvdXRlcl9saW5rJztcblxuZXhwb3J0IGNvbnN0IFJPVVRFUl9ESVJFQ1RJVkVTID0gW1JvdXRlck91dGxldCwgUm91dGVyTGlua107Il19 \ No newline at end of file diff --git a/modules/@angular/router/build/src/recognize.d.ts b/modules/@angular/router/build/src/recognize.d.ts new file mode 100644 index 0000000000..64aeb9f2f7 --- /dev/null +++ b/modules/@angular/router/build/src/recognize.d.ts @@ -0,0 +1,5 @@ +import { UrlTree } from './url_tree'; +import { RouterState } from './router_state'; +import { RouterConfig } from './config'; +import { Observable } from 'rxjs/Observable'; +export declare function recognize(config: RouterConfig, url: UrlTree, existingState: RouterState): Observable; diff --git a/modules/@angular/router/build/src/recognize.js b/modules/@angular/router/build/src/recognize.js new file mode 100644 index 0000000000..0b4cb3fbe6 --- /dev/null +++ b/modules/@angular/router/build/src/recognize.js @@ -0,0 +1,171 @@ +"use strict"; +var collection_1 = require('./utils/collection'); +var tree_1 = require('./utils/tree'); +var router_state_1 = require('./router_state'); +var shared_1 = require('./shared'); +var Observable_1 = require('rxjs/Observable'); +var BehaviorSubject_1 = require('rxjs/BehaviorSubject'); +function recognize(config, url, existingState) { + try { + var match_1 = new MatchResult(existingState.root.component, config, [url.root], {}, tree_1.rootNode(url).children, [], shared_1.PRIMARY_OUTLET); + existingState.queryParams.next(url.queryParameters); + existingState.fragment.next(url.fragment); + var roots = constructActivatedRoute(match_1, tree_1.rootNode(existingState)); + var res_1 = new router_state_1.RouterState(roots[0], existingState.queryParams, existingState.fragment); + return new Observable_1.Observable(function (obs) { + obs.next(res_1); + obs.complete(); + }); + } + catch (e) { + return new Observable_1.Observable(function (obs) { return obs.error(e); }); + } +} +exports.recognize = recognize; +function constructActivatedRoute(match, existingRoute) { + var activatedRoute = createOrReuseRoute(match, existingRoute); + var existingChildren = existingRoute ? existingRoute.children : []; + if (match.leftOverUrl.length > 0) { + var children = recognizeMany(match.children, match.leftOverUrl, existingChildren); + checkOutletNameUniqueness(children); + return [new tree_1.TreeNode(activatedRoute, children)]; + } + else { + return [new tree_1.TreeNode(activatedRoute, [])]; + } +} +function recognizeMany(config, urls, existingRoutes) { + return collection_1.flatten(urls.map(function (url) { return recognizeOne(config, url, existingRoutes); })); +} +function createOrReuseRoute(match, existing) { + if (existing) { + var v = existing.value; + if (v.component === match.component && v.outlet === match.outlet) { + (v.params).next(match.parameters); + (v.urlSegments).next(match.consumedUrlSegments); + return v; + } + } + return new router_state_1.ActivatedRoute(new BehaviorSubject_1.BehaviorSubject(match.consumedUrlSegments), new BehaviorSubject_1.BehaviorSubject(match.parameters), match.outlet, match.component); +} +function recognizeOne(config, url, existingRoutes) { + var m = match(config, url); + var routesWithRightOutlet = existingRoutes.filter(function (r) { return r.value.outlet == m.outlet; }); + var routeWithRightOutlet = routesWithRightOutlet.length > 0 ? routesWithRightOutlet[0] : null; + var primary = constructActivatedRoute(m, routeWithRightOutlet); + var secondary = recognizeMany(config, m.secondary, existingRoutes); + var res = primary.concat(secondary); + checkOutletNameUniqueness(res); + return res; +} +function checkOutletNameUniqueness(nodes) { + var names = {}; + nodes.forEach(function (n) { + var routeWithSameOutletName = names[n.value.outlet]; + if (routeWithSameOutletName) { + var p = routeWithSameOutletName.urlSegments.value.map(function (s) { return s.toString(); }).join("/"); + var c = n.value.urlSegments.value.map(function (s) { return s.toString(); }).join("/"); + throw new Error("Two segments cannot have the same outlet name: '" + p + "' and '" + c + "'."); + } + names[n.value.outlet] = n.value; + }); + return nodes; +} +function match(config, url) { + var m = matchNonIndex(config, url); + if (m) + return m; + var mIndex = matchIndex(config, url); + if (mIndex) + return mIndex; + var availableRoutes = config.map(function (r) { + var outlet = !r.outlet ? '' : r.outlet + ":"; + return "'" + outlet + r.path + "'"; + }).join(", "); + throw new Error("Cannot match any routes. Current segment: '" + url.value + "'. Available routes: [" + availableRoutes + "]."); +} +function matchNonIndex(config, url) { + for (var _i = 0, config_1 = config; _i < config_1.length; _i++) { + var r = config_1[_i]; + var m = matchWithParts(r, url); + if (m) + return m; + } + return null; +} +function matchIndex(config, url) { + for (var _i = 0, config_2 = config; _i < config_2.length; _i++) { + var r = config_2[_i]; + if (r.index) { + var outlet = r.outlet ? r.outlet : shared_1.PRIMARY_OUTLET; + var children = r.children ? r.children : []; + return new MatchResult(r.component, children, [], {}, [url], [], outlet); + } + } + return null; +} +function matchWithParts(route, url) { + if (!route.path) + return null; + if ((route.outlet ? route.outlet : shared_1.PRIMARY_OUTLET) !== url.value.outlet) + return null; + var path = route.path.startsWith("/") ? route.path.substring(1) : route.path; + if (path === "**") { + var consumedUrl = []; + var u = url; + while (u) { + consumedUrl.push(u.value); + u = collection_1.first(u.children); + } + var last = consumedUrl[consumedUrl.length - 1]; + return new MatchResult(route.component, [], consumedUrl, last.parameters, [], [], shared_1.PRIMARY_OUTLET); + } + var parts = path.split("/"); + var positionalParams = {}; + var consumedUrlSegments = []; + var lastParent = null; + var lastSegment = null; + var current = url; + for (var i = 0; i < parts.length; ++i) { + if (!current) + return null; + var p_1 = parts[i]; + var isLastSegment = i === parts.length - 1; + var isLastParent = i === parts.length - 2; + var isPosParam = p_1.startsWith(":"); + if (!isPosParam && p_1 != current.value.path) + return null; + if (isLastSegment) { + lastSegment = current; + } + if (isLastParent) { + lastParent = current; + } + if (isPosParam) { + positionalParams[p_1.substring(1)] = current.value.path; + } + consumedUrlSegments.push(current.value); + current = collection_1.first(current.children); + } + if (!lastSegment) + throw "Cannot be reached"; + var p = lastSegment.value.parameters; + var parameters = collection_1.merge(p, positionalParams); + var secondarySubtrees = lastParent ? lastParent.children.slice(1) : []; + var children = route.children ? route.children : []; + var outlet = route.outlet ? route.outlet : shared_1.PRIMARY_OUTLET; + return new MatchResult(route.component, children, consumedUrlSegments, parameters, lastSegment.children, secondarySubtrees, outlet); +} +var MatchResult = (function () { + function MatchResult(component, children, consumedUrlSegments, parameters, leftOverUrl, secondary, outlet) { + this.component = component; + this.children = children; + this.consumedUrlSegments = consumedUrlSegments; + this.parameters = parameters; + this.leftOverUrl = leftOverUrl; + this.secondary = secondary; + this.outlet = outlet; + } + return MatchResult; +}()); +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"recognize.js","sourceRoot":"","sources":["../../src/recognize.ts"],"names":[],"mappings":"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","sourcesContent":["import { UrlTree, UrlSegment } from './url_tree';\nimport { flatten, first, merge } from './utils/collection';\nimport { TreeNode, rootNode } from './utils/tree';\nimport { RouterState, ActivatedRoute } from './router_state';\nimport { Params, PRIMARY_OUTLET } from './shared';\nimport { RouterConfig, Route } from './config';\nimport { Type } from '@angular/core';\nimport { Observable } from 'rxjs/Observable';\nimport { BehaviorSubject } from 'rxjs/BehaviorSubject';\n\nexport function recognize(config: RouterConfig, url: UrlTree, existingState: RouterState): Observable<RouterState> {\n  try {\n    const match = new MatchResult(existingState.root.component, config, [url.root], {}, rootNode(url).children, [], PRIMARY_OUTLET);\n    (<any>existingState.queryParams).next(url.queryParameters);\n    (<any>existingState.fragment).next(url.fragment);\n    const roots = constructActivatedRoute(match, rootNode(existingState));\n    const res = new RouterState(roots[0], existingState.queryParams, existingState.fragment);\n    return new Observable<RouterState>(obs => {\n      obs.next(res);\n      obs.complete();\n    });\n  } catch(e) {\n    return new Observable<RouterState>(obs => obs.error(e));\n  }\n}\n\nfunction constructActivatedRoute(match: MatchResult, existingRoute: TreeNode<ActivatedRoute> | null): TreeNode<ActivatedRoute>[] {\n  const activatedRoute = createOrReuseRoute(match, existingRoute);\n  const existingChildren = existingRoute ? existingRoute.children : [];\n\n  if (match.leftOverUrl.length > 0) {\n    const children = recognizeMany(match.children, match.leftOverUrl, existingChildren);\n    checkOutletNameUniqueness(children);\n    return [new TreeNode<ActivatedRoute>(activatedRoute, children)];\n  } else {\n    return [new TreeNode<ActivatedRoute>(activatedRoute, [])];\n  }\n}\n\nfunction recognizeMany(config: Route[], urls: TreeNode<UrlSegment>[],\n                       existingRoutes: TreeNode<ActivatedRoute>[]): TreeNode<ActivatedRoute>[] {\n  return flatten(urls.map(url => recognizeOne(config, url, existingRoutes)));\n}\n\nfunction createOrReuseRoute(match: MatchResult, existing: TreeNode<ActivatedRoute> | null): ActivatedRoute {\n  if (existing) {\n    const v = existing.value;\n    if (v.component === match.component && v.outlet === match.outlet) {\n      (<any>(v.params)).next(match.parameters);\n      (<any>(v.urlSegments)).next(match.consumedUrlSegments);\n      return v;\n    }\n  }\n  return new ActivatedRoute(new BehaviorSubject(match.consumedUrlSegments), new BehaviorSubject(match.parameters), match.outlet, match.component);\n}\n\nfunction recognizeOne(config: Route[], url: TreeNode<UrlSegment>,\n                      existingRoutes: TreeNode<ActivatedRoute>[]): TreeNode<ActivatedRoute>[] {\n  let m = match(config, url);\n\n  const routesWithRightOutlet = existingRoutes.filter(r => r.value.outlet == m.outlet);\n  const routeWithRightOutlet = routesWithRightOutlet.length > 0 ? routesWithRightOutlet[0] : null;\n\n  const primary = constructActivatedRoute(m, routeWithRightOutlet);\n  const secondary = recognizeMany(config, m.secondary, existingRoutes);\n  const res = primary.concat(secondary);\n  checkOutletNameUniqueness(res);\n  return res;\n}\n\nfunction checkOutletNameUniqueness(nodes: TreeNode<ActivatedRoute>[]): TreeNode<ActivatedRoute>[] {\n  let names = {};\n  nodes.forEach(n => {\n    let routeWithSameOutletName = names[n.value.outlet];\n    if (routeWithSameOutletName) {\n      const p = (<any>routeWithSameOutletName.urlSegments).value.map(s => s.toString()).join(\"/\");\n      const c = (<any>n.value.urlSegments).value.map(s => s.toString()).join(\"/\");\n      throw new Error(`Two segments cannot have the same outlet name: '${p}' and '${c}'.`);\n    }\n    names[n.value.outlet] = n.value;\n  });\n  return nodes;\n}\n\nfunction match(config: Route[], url: TreeNode<UrlSegment>): MatchResult {\n  const m = matchNonIndex(config, url);\n  if (m) return m;\n\n  const mIndex = matchIndex(config, url);\n  if (mIndex) return mIndex;\n\n  const availableRoutes = config.map(r => {\n    const outlet = !r.outlet ? '' : `${r.outlet}:`;\n    return `'${outlet}${r.path}'`;\n  }).join(\", \");\n  throw new Error(\n    `Cannot match any routes. Current segment: '${url.value}'. Available routes: [${availableRoutes}].`);\n}\n\nfunction matchNonIndex(config: Route[], url: TreeNode<UrlSegment>): MatchResult | null {\n  for (let r of config) {\n    let m = matchWithParts(r, url);\n    if (m) return m;\n  }\n  return null;\n}\n\nfunction matchIndex(config: Route[], url: TreeNode<UrlSegment>): MatchResult | null {\n  for (let r of config) {\n    if (r.index) {\n      const outlet = r.outlet ? r.outlet : PRIMARY_OUTLET;\n      const children = r.children ? r.children : [];\n      return new MatchResult(r.component, children, [], {}, [url], [], outlet);\n    }\n  }\n  return null;\n}\n\nfunction matchWithParts(route: Route, url: TreeNode<UrlSegment>): MatchResult | null {\n  if (!route.path) return null;\n  if ((route.outlet ? route.outlet : PRIMARY_OUTLET) !== url.value.outlet) return null;\n\n  const path = route.path.startsWith(\"/\") ? route.path.substring(1) : route.path;\n  if (path === \"**\") {\n    const consumedUrl = [];\n    let u:TreeNode<UrlSegment>|null = url;\n    while (u) {\n      consumedUrl.push(u.value);\n      u = first(u.children);\n    }\n    const last = consumedUrl[consumedUrl.length - 1];\n    return new MatchResult(route.component, [], consumedUrl, last.parameters, [], [], PRIMARY_OUTLET);\n  }\n\n  const parts = path.split(\"/\");\n  const positionalParams = {};\n  const consumedUrlSegments = [];\n\n  let lastParent: TreeNode<UrlSegment>|null = null;\n  let lastSegment: TreeNode<UrlSegment>|null = null;\n\n  let current: TreeNode<UrlSegment>|null = url;\n  for (let i = 0; i < parts.length; ++i) {\n    if (!current) return null;\n\n    const p = parts[i];\n    const isLastSegment = i === parts.length - 1;\n    const isLastParent = i === parts.length - 2;\n    const isPosParam = p.startsWith(\":\");\n\n    if (!isPosParam && p != current.value.path) return null;\n    if (isLastSegment) {\n      lastSegment = current;\n    }\n    if (isLastParent) {\n      lastParent = current;\n    }\n\n    if (isPosParam) {\n      positionalParams[p.substring(1)] = current.value.path;\n    }\n\n    consumedUrlSegments.push(current.value);\n\n    current = first(current.children);\n  }\n\n  if (!lastSegment) throw \"Cannot be reached\";\n\n  const p = lastSegment.value.parameters;\n  const parameters = <{[key: string]: string}>merge(p, positionalParams);\n  const secondarySubtrees = lastParent ? lastParent.children.slice(1) : [];\n  const children = route.children ? route.children : [];\n  const outlet = route.outlet ? route.outlet : PRIMARY_OUTLET;\n\n  return new MatchResult(route.component, children, consumedUrlSegments, parameters, lastSegment.children,\n    secondarySubtrees, outlet);\n}\n\nclass MatchResult {\n  constructor(public component: Type | string,\n              public children: Route[],\n              public consumedUrlSegments: UrlSegment[],\n              public parameters: {[key: string]: string},\n              public leftOverUrl: TreeNode<UrlSegment>[],\n              public secondary: TreeNode<UrlSegment>[],\n              public outlet: string\n  ) {}\n}"]} \ No newline at end of file diff --git a/modules/@angular/router/build/src/router.d.ts b/modules/@angular/router/build/src/router.d.ts new file mode 100644 index 0000000000..7fd1b6a794 --- /dev/null +++ b/modules/@angular/router/build/src/router.d.ts @@ -0,0 +1,40 @@ +import { ComponentResolver } from '@angular/core'; +import { Location } from '@angular/common'; +import { UrlSerializer } from './url_serializer'; +import { RouterOutletMap } from './router_outlet_map'; +import { UrlTree } from './url_tree'; +import { Params } from './shared'; +import { RouterState, ActivatedRoute } from './router_state'; +import { RouterConfig } from './config'; +import { Observable } from 'rxjs/Observable'; +import 'rxjs/add/operator/map'; +import 'rxjs/add/operator/mergeMap'; +import 'rxjs/add/operator/toPromise'; +export interface NavigationExtras { + relativeTo?: ActivatedRoute; + queryParameters?: Params; + fragment?: string; +} +export declare class Router { + private rootComponent; + private resolver; + private urlSerializer; + private outletMap; + private location; + private currentUrlTree; + private currentRouterState; + private config; + private locationSubscription; + constructor(rootComponent: Object, resolver: ComponentResolver, urlSerializer: UrlSerializer, outletMap: RouterOutletMap, location: Location); + readonly routerState: RouterState; + readonly urlTree: UrlTree; + navigateByUrl(url: string): Observable; + resetConfig(config: RouterConfig): void; + dispose(): void; + createUrlTree(commands: any[], {relativeTo, queryParameters, fragment}?: NavigationExtras): UrlTree; + navigate(commands: any[], extras?: NavigationExtras): Observable; + serializeUrl(url: UrlTree): string; + parseUrl(url: string): UrlTree; + private setUpLocationChangeListener(); + private runNavigate(url, pop?); +} diff --git a/modules/@angular/router/build/src/router.js b/modules/@angular/router/build/src/router.js new file mode 100644 index 0000000000..3bbb164b96 --- /dev/null +++ b/modules/@angular/router/build/src/router.js @@ -0,0 +1,159 @@ +"use strict"; +var core_1 = require('@angular/core'); +var router_outlet_map_1 = require('./router_outlet_map'); +var recognize_1 = require('./recognize'); +var tree_1 = require('./utils/tree'); +var url_tree_1 = require('./url_tree'); +var shared_1 = require('./shared'); +var router_state_1 = require('./router_state'); +var create_url_tree_1 = require('./create_url_tree'); +var collection_1 = require('./utils/collection'); +require('rxjs/add/operator/map'); +require('rxjs/add/operator/mergeMap'); +require('rxjs/add/operator/toPromise'); +var fromPromise_1 = require('rxjs/observable/fromPromise'); +var forkJoin_1 = require('rxjs/observable/forkJoin'); +var Router = (function () { + function Router(rootComponent, resolver, urlSerializer, outletMap, location) { + this.rootComponent = rootComponent; + this.resolver = resolver; + this.urlSerializer = urlSerializer; + this.outletMap = outletMap; + this.location = location; + this.currentUrlTree = url_tree_1.createEmptyUrlTree(); + this.currentRouterState = router_state_1.createEmptyState(rootComponent.constructor); + this.setUpLocationChangeListener(); + this.navigateByUrl(this.location.path()); + } + Object.defineProperty(Router.prototype, "routerState", { + get: function () { + return this.currentRouterState; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Router.prototype, "urlTree", { + get: function () { + return this.currentUrlTree; + }, + enumerable: true, + configurable: true + }); + Router.prototype.navigateByUrl = function (url) { + var urlTree = this.urlSerializer.parse(url); + return this.runNavigate(urlTree, false); + }; + Router.prototype.resetConfig = function (config) { + this.config = config; + }; + Router.prototype.dispose = function () { this.locationSubscription.unsubscribe(); }; + Router.prototype.createUrlTree = function (commands, _a) { + var _b = _a === void 0 ? {} : _a, relativeTo = _b.relativeTo, queryParameters = _b.queryParameters, fragment = _b.fragment; + var a = relativeTo ? relativeTo : this.routerState.root; + return create_url_tree_1.createUrlTree(a, this.currentUrlTree, commands, queryParameters, fragment); + }; + Router.prototype.navigate = function (commands, extras) { + if (extras === void 0) { extras = {}; } + return this.runNavigate(this.createUrlTree(commands, extras)); + }; + Router.prototype.serializeUrl = function (url) { return this.urlSerializer.serialize(url); }; + Router.prototype.parseUrl = function (url) { return this.urlSerializer.parse(url); }; + Router.prototype.setUpLocationChangeListener = function () { + var _this = this; + this.locationSubscription = this.location.subscribe(function (change) { + _this.runNavigate(_this.urlSerializer.parse(change['url']), change['pop']); + }); + }; + Router.prototype.runNavigate = function (url, pop) { + var _this = this; + var r = recognize_1.recognize(this.config, url, this.currentRouterState).mergeMap(function (newState) { + return new ActivateRoutes(_this.resolver, newState, _this.currentRouterState).activate(_this.outletMap).map(function () { + _this.currentUrlTree = url; + _this.currentRouterState = newState; + if (!pop) { + _this.location.go(_this.urlSerializer.serialize(url)); + } + }); + }); + r.subscribe(function (a) { }, function (e) { }, function () { }); + return r; + }; + return Router; +}()); +exports.Router = Router; +var ActivateRoutes = (function () { + function ActivateRoutes(resolver, futureState, currState) { + this.resolver = resolver; + this.futureState = futureState; + this.currState = currState; + } + ActivateRoutes.prototype.activate = function (parentOutletMap) { + var currRoot = this.currState ? tree_1.rootNode(this.currState) : null; + var futureRoot = tree_1.rootNode(this.futureState); + return this.activateChildRoutes(futureRoot, currRoot, parentOutletMap); + }; + ActivateRoutes.prototype.activateChildRoutes = function (futureNode, currNode, outletMap) { + var _this = this; + var prevChildren = nodeChildrenAsMap(currNode); + var observables = []; + futureNode.children.forEach(function (c) { + observables.push(_this.activateRoutes(c, prevChildren[c.value.outlet], outletMap).toPromise()); + delete prevChildren[c.value.outlet]; + }); + collection_1.forEach(prevChildren, function (v, k) { return _this.deactivateOutletAndItChildren(outletMap._outlets[k]); }); + return forkJoin_1.forkJoin(observables); + }; + ActivateRoutes.prototype.activateRoutes = function (futureNode, currNode, parentOutletMap) { + var _this = this; + var future = futureNode.value; + var curr = currNode ? currNode.value : null; + var outlet = getOutlet(parentOutletMap, futureNode.value); + if (future === curr) { + return this.activateChildRoutes(futureNode, currNode, outlet.outletMap); + } + else { + this.deactivateOutletAndItChildren(outlet); + var outletMap_1 = new router_outlet_map_1.RouterOutletMap(); + return this.activateNewRoutes(outletMap_1, future, outlet).mergeMap(function () { + return _this.activateChildRoutes(futureNode, currNode, outletMap_1); + }); + } + }; + ActivateRoutes.prototype.activateNewRoutes = function (outletMap, future, outlet) { + var resolved = core_1.ReflectiveInjector.resolve([ + { provide: router_state_1.ActivatedRoute, useValue: future }, + { provide: router_outlet_map_1.RouterOutletMap, useValue: outletMap } + ]); + return fromPromise_1.fromPromise(this.resolver.resolveComponent(future.component)). + map(function (factory) { return outlet.activate(factory, resolved, outletMap); }); + }; + ActivateRoutes.prototype.deactivateOutletAndItChildren = function (outlet) { + var _this = this; + if (outlet && outlet.isActivated) { + collection_1.forEach(outlet.outletMap._outlets, function (v, k) { return _this.deactivateOutletAndItChildren(v); }); + outlet.deactivate(); + } + }; + return ActivateRoutes; +}()); +function nodeChildrenAsMap(node) { + return node ? + node.children.reduce(function (m, c) { + m[c.value.outlet] = c; + return m; + }, {}) : + {}; +} +function getOutlet(outletMap, route) { + var outlet = outletMap._outlets[route.outlet]; + if (!outlet) { + if (route.outlet === shared_1.PRIMARY_OUTLET) { + throw new Error("Cannot find primary outlet"); + } + else { + throw new Error("Cannot find the outlet " + route.outlet); + } + } + return outlet; +} +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"router.js","sourceRoot":"","sources":["../../src/router.ts"],"names":[],"mappings":"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","sourcesContent":["import { ComponentResolver, ReflectiveInjector } from '@angular/core';\nimport { Location } from '@angular/common';\nimport { UrlSerializer } from './url_serializer';\nimport { RouterOutletMap } from './router_outlet_map';\nimport { recognize } from './recognize';\nimport { rootNode, TreeNode } from './utils/tree';\nimport { UrlTree, createEmptyUrlTree } from './url_tree';\nimport { PRIMARY_OUTLET, Params } from './shared';\nimport { createEmptyState, RouterState, ActivatedRoute} from './router_state';\nimport { RouterConfig } from './config';\nimport { RouterOutlet } from './directives/router_outlet';\nimport { createUrlTree } from './create_url_tree';\nimport { forEach } from './utils/collection';\nimport { Observable } from 'rxjs/Observable';\nimport { Subscription } from 'rxjs/Subscription';\nimport 'rxjs/add/operator/map';\nimport 'rxjs/add/operator/mergeMap';\nimport 'rxjs/add/operator/toPromise';\nimport {fromPromise} from 'rxjs/observable/fromPromise';\nimport {forkJoin} from 'rxjs/observable/forkJoin';\n\nexport interface NavigationExtras { relativeTo?: ActivatedRoute; queryParameters?: Params; fragment?: string; }\n\n/**\n * The `Router` is responsible for mapping URLs to components.\n */\nexport class Router {\n  private currentUrlTree: UrlTree;\n  private currentRouterState: RouterState;\n  private config: RouterConfig;\n  private locationSubscription: Subscription;\n\n  /**\n   * @internal\n   */\n  constructor(private rootComponent:Object, private resolver: ComponentResolver, private urlSerializer: UrlSerializer, private outletMap: RouterOutletMap, private location: Location) {\n    this.currentUrlTree = createEmptyUrlTree();\n    this.currentRouterState = createEmptyState(<any>rootComponent.constructor);\n    this.setUpLocationChangeListener();\n    this.navigateByUrl(this.location.path());\n  }\n\n  /**\n   * Returns the current route state.\n   */\n  get routerState(): RouterState {\n    return this.currentRouterState;\n  }\n\n  /**\n   * Returns the current url tree.\n   */\n  get urlTree(): UrlTree {\n    return this.currentUrlTree;\n  }\n\n  /**\n   * Navigate based on the provided url. This navigation is always absolute.\n   *\n   * ### Usage\n   *\n   * ```\n   * router.navigateByUrl(\"/team/33/user/11\");\n   * ```\n   */\n  navigateByUrl(url: string): Observable<void> {\n    const urlTree = this.urlSerializer.parse(url);\n    return this.runNavigate(urlTree, false);\n  }\n\n  /**\n   * Resets the configuration used for navigation and generating links.\n   *\n   * ### Usage\n   *\n   * ```\n   * router.resetConfig([\n   *  { path: 'team/:id', component: TeamCmp, children: [\n   *    { path: 'simple', component: SimpleCmp },\n   *    { path: 'user/:name', component: UserCmp }\n   *  ] }\n   * ]);\n   * ```\n   */\n  resetConfig(config: RouterConfig): void {\n    this.config = config;\n  }\n\n  /**\n   * @internal\n   */\n  dispose(): void { this.locationSubscription.unsubscribe(); }\n\n  /**\n   * Applies an array of commands to the current url tree and creates\n   * a new url tree.\n   *\n   * When given an activate route, applies the given commands starting from the route.\n   * When not given a route, applies the given command starting from the root.\n   *\n   * ### Usage\n   *\n   * ```\n   * // create /team/33/user/11\n   * router.createUrlTree(['/team', 33, 'user', 11]);\n   *\n   * // create /team/33;expand=true/user/11\n   * router.createUrlTree(['/team', 33, {expand: true}, 'user', 11]);\n   *\n   * // you can collapse static fragments like this\n   * router.createUrlTree(['/team/33/user', userId]);\n   *\n   * // assuming the current url is `/team/33/user/11` and the route points to `user/11`\n   *\n   * // navigate to /team/33/user/11/details\n   * router.createUrlTree(['details'], {relativeTo: route});\n   *\n   * // navigate to /team/33/user/22\n   * router.createUrlTree(['../22'], {relativeTo: route});\n   *\n   * // navigate to /team/44/user/22\n   * router.createUrlTree(['../../team/44/user/22'], {relativeTo: route});\n   * ```\n   */\n  createUrlTree(commands: any[], {relativeTo, queryParameters, fragment}: NavigationExtras = {}): UrlTree {\n    const a = relativeTo ? relativeTo : this.routerState.root;\n    return createUrlTree(a, this.currentUrlTree, commands, queryParameters, fragment);\n  }\n\n\n  /**\n   * Navigate based on the provided array of commands and a starting point.\n   * If no starting route is provided, the navigation is absolute.\n   *\n   * ### Usage\n   *\n   * ```\n   * router.navigate(['team', 33, 'team', '11], {relativeTo: route});\n   * ```\n   */\n  navigate(commands: any[], extras: NavigationExtras = {}): Observable<void> {\n    return this.runNavigate(this.createUrlTree(commands, extras));\n  }\n\n  /**\n   * Serializes a {@link UrlTree} into a string.\n   */\n  serializeUrl(url: UrlTree): string { return this.urlSerializer.serialize(url); }\n\n  /**\n   * Parse a string into a {@link UrlTree}.\n   */\n  parseUrl(url: string): UrlTree { return this.urlSerializer.parse(url); }\n\n  private setUpLocationChangeListener(): void {\n    this.locationSubscription = <any>this.location.subscribe((change) => {\n      this.runNavigate(this.urlSerializer.parse(change['url']), change['pop'])\n    });\n  }\n\n  private runNavigate(url:UrlTree, pop?:boolean):Observable<void> {\n    const r = recognize(this.config, url, this.currentRouterState).mergeMap((newState:RouterState) => {\n      return new ActivateRoutes(this.resolver, newState, this.currentRouterState).activate(this.outletMap).map(() => {\n        this.currentUrlTree = url;\n        this.currentRouterState = newState;\n        if (!pop) {\n          this.location.go(this.urlSerializer.serialize(url));\n        }\n      });\n    });\n    r.subscribe((a) => {}, (e) => {}, () => {}); // force execution\n    return r;\n  }\n}\n\nclass ActivateRoutes {\n  constructor(private resolver: ComponentResolver, private futureState: RouterState, private currState: RouterState) {}\n\n  activate(parentOutletMap: RouterOutletMap): Observable<void> {\n    const currRoot = this.currState ? rootNode(this.currState) : null;\n    const futureRoot = rootNode(this.futureState);\n    return this.activateChildRoutes(futureRoot, currRoot, parentOutletMap);\n  }\n\n  private activateChildRoutes(futureNode: TreeNode<ActivatedRoute>,\n                              currNode: TreeNode<ActivatedRoute> | null,\n                              outletMap: RouterOutletMap): Observable<any> {\n    const prevChildren = nodeChildrenAsMap(currNode);\n    const observables = [];\n    futureNode.children.forEach(c => {\n      observables.push(this.activateRoutes(c, prevChildren[c.value.outlet], outletMap).toPromise());\n      delete prevChildren[c.value.outlet];\n    });\n    forEach(prevChildren, (v, k) => this.deactivateOutletAndItChildren(outletMap._outlets[k]));\n    return forkJoin(observables);\n  }\n\n\n  activateRoutes(futureNode: TreeNode<ActivatedRoute>, currNode: TreeNode<ActivatedRoute>,\n                 parentOutletMap: RouterOutletMap): Observable<void> {\n    const future = futureNode.value;\n    const curr = currNode ? currNode.value : null;\n    const outlet = getOutlet(parentOutletMap, futureNode.value);\n\n    if (future === curr) {\n      return this.activateChildRoutes(futureNode, currNode, outlet.outletMap);\n    } else {\n      this.deactivateOutletAndItChildren(outlet);\n      const outletMap = new RouterOutletMap();\n      return this.activateNewRoutes(outletMap, future, outlet).mergeMap(() =>\n        this.activateChildRoutes(futureNode, currNode, outletMap));\n    }\n  }\n\n  private activateNewRoutes(outletMap: RouterOutletMap, future: ActivatedRoute, outlet: RouterOutlet): Observable<void> {\n    const resolved = ReflectiveInjector.resolve([\n      {provide: ActivatedRoute, useValue: future},\n      {provide: RouterOutletMap, useValue: outletMap}\n    ]);\n    return fromPromise(this.resolver.resolveComponent(<any>future.component)).\n      map(factory => outlet.activate(factory, resolved, outletMap));\n  }\n\n  private deactivateOutletAndItChildren(outlet: RouterOutlet): void {\n    if (outlet && outlet.isActivated) {\n      forEach(outlet.outletMap._outlets, (v, k) => this.deactivateOutletAndItChildren(v));\n      outlet.deactivate();\n    }\n  }\n}\n\nfunction nodeChildrenAsMap(node: TreeNode<ActivatedRoute>|null) {\n  return node ?\n    node.children.reduce(\n      (m, c) => {\n        m[c.value.outlet] = c;\n        return m;\n      },\n      {}) :\n  {};\n}\n\nfunction getOutlet(outletMap: RouterOutletMap, route: ActivatedRoute): RouterOutlet {\n  let outlet = outletMap._outlets[route.outlet];\n  if (!outlet) {\n    if (route.outlet === PRIMARY_OUTLET) {\n      throw new Error(`Cannot find primary outlet`);\n    } else {\n      throw new Error(`Cannot find the outlet ${route.outlet}`);\n    }\n  }\n  return outlet;\n}\n"]} \ No newline at end of file diff --git a/modules/@angular/router/build/src/router_outlet_map.d.ts b/modules/@angular/router/build/src/router_outlet_map.d.ts new file mode 100644 index 0000000000..df50474269 --- /dev/null +++ b/modules/@angular/router/build/src/router_outlet_map.d.ts @@ -0,0 +1,7 @@ +import { RouterOutlet } from './directives/router_outlet'; +export declare class RouterOutletMap { + _outlets: { + [name: string]: RouterOutlet; + }; + registerOutlet(name: string, outlet: RouterOutlet): void; +} diff --git a/modules/@angular/router/build/src/router_outlet_map.js b/modules/@angular/router/build/src/router_outlet_map.js new file mode 100644 index 0000000000..1895fca1f3 --- /dev/null +++ b/modules/@angular/router/build/src/router_outlet_map.js @@ -0,0 +1,10 @@ +"use strict"; +var RouterOutletMap = (function () { + function RouterOutletMap() { + this._outlets = {}; + } + RouterOutletMap.prototype.registerOutlet = function (name, outlet) { this._outlets[name] = outlet; }; + return RouterOutletMap; +}()); +exports.RouterOutletMap = RouterOutletMap; +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicm91dGVyX291dGxldF9tYXAuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcm91dGVyX291dGxldF9tYXAudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUtBO0lBQUE7UUFFRSxhQUFRLEdBQW1DLEVBQUUsQ0FBQztJQUVoRCxDQUFDO0lBREMsd0NBQWMsR0FBZCxVQUFlLElBQVksRUFBRSxNQUFvQixJQUFVLElBQUksQ0FBQyxRQUFRLENBQUMsSUFBSSxDQUFDLEdBQUcsTUFBTSxDQUFDLENBQUMsQ0FBQztJQUM1RixzQkFBQztBQUFELENBQUMsQUFKRCxJQUlDO0FBSlksdUJBQWUsa0JBSTNCLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBSb3V0ZXJPdXRsZXQgfSBmcm9tICcuL2RpcmVjdGl2ZXMvcm91dGVyX291dGxldCc7XG5cbi8qKlxuICogQGludGVybmFsXG4gKi9cbmV4cG9ydCBjbGFzcyBSb3V0ZXJPdXRsZXRNYXAge1xuICAvKiogQGludGVybmFsICovXG4gIF9vdXRsZXRzOiB7W25hbWU6IHN0cmluZ106IFJvdXRlck91dGxldH0gPSB7fTtcbiAgcmVnaXN0ZXJPdXRsZXQobmFtZTogc3RyaW5nLCBvdXRsZXQ6IFJvdXRlck91dGxldCk6IHZvaWQgeyB0aGlzLl9vdXRsZXRzW25hbWVdID0gb3V0bGV0OyB9XG59XG4iXX0= \ No newline at end of file diff --git a/modules/@angular/router/build/src/router_state.d.ts b/modules/@angular/router/build/src/router_state.d.ts new file mode 100644 index 0000000000..569b8837ac --- /dev/null +++ b/modules/@angular/router/build/src/router_state.d.ts @@ -0,0 +1,18 @@ +import { Tree, TreeNode } from './utils/tree'; +import { UrlSegment } from './url_tree'; +import { Params } from './shared'; +import { Observable } from 'rxjs/Observable'; +import { Type } from '@angular/core'; +export declare class RouterState extends Tree { + queryParams: Observable; + fragment: Observable; + constructor(root: TreeNode, queryParams: Observable, fragment: Observable); +} +export declare function createEmptyState(rootComponent: Type): RouterState; +export declare class ActivatedRoute { + urlSegments: Observable; + params: Observable; + outlet: string; + component: Type | string; + constructor(urlSegments: Observable, params: Observable, outlet: string, component: Type | string); +} diff --git a/modules/@angular/router/build/src/router_state.js b/modules/@angular/router/build/src/router_state.js new file mode 100644 index 0000000000..558d05b795 --- /dev/null +++ b/modules/@angular/router/build/src/router_state.js @@ -0,0 +1,40 @@ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var tree_1 = require('./utils/tree'); +var url_tree_1 = require('./url_tree'); +var shared_1 = require('./shared'); +var BehaviorSubject_1 = require('rxjs/BehaviorSubject'); +var RouterState = (function (_super) { + __extends(RouterState, _super); + function RouterState(root, queryParams, fragment) { + _super.call(this, root); + this.queryParams = queryParams; + this.fragment = fragment; + } + return RouterState; +}(tree_1.Tree)); +exports.RouterState = RouterState; +function createEmptyState(rootComponent) { + var emptyUrl = new BehaviorSubject_1.BehaviorSubject([new url_tree_1.UrlSegment("", {}, shared_1.PRIMARY_OUTLET)]); + var emptyParams = new BehaviorSubject_1.BehaviorSubject({}); + var emptyQueryParams = new BehaviorSubject_1.BehaviorSubject({}); + var fragment = new BehaviorSubject_1.BehaviorSubject(""); + var activated = new ActivatedRoute(emptyUrl, emptyParams, shared_1.PRIMARY_OUTLET, rootComponent); + return new RouterState(new tree_1.TreeNode(activated, []), emptyQueryParams, fragment); +} +exports.createEmptyState = createEmptyState; +var ActivatedRoute = (function () { + function ActivatedRoute(urlSegments, params, outlet, component) { + this.urlSegments = urlSegments; + this.params = params; + this.outlet = outlet; + this.component = component; + } + return ActivatedRoute; +}()); +exports.ActivatedRoute = ActivatedRoute; +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/modules/@angular/router/build/src/shared.d.ts b/modules/@angular/router/build/src/shared.d.ts new file mode 100644 index 0000000000..2aacfdf7a6 --- /dev/null +++ b/modules/@angular/router/build/src/shared.d.ts @@ -0,0 +1,4 @@ +export declare const PRIMARY_OUTLET: string; +export declare type Params = { + [key: string]: string; +}; diff --git a/modules/@angular/router/build/src/shared.js b/modules/@angular/router/build/src/shared.js new file mode 100644 index 0000000000..9bb5b9dd40 --- /dev/null +++ b/modules/@angular/router/build/src/shared.js @@ -0,0 +1,3 @@ +"use strict"; +exports.PRIMARY_OUTLET = "PRIMARY_OUTLET"; +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2hhcmVkLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3NoYXJlZC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBSWEsc0JBQWMsR0FBVyxnQkFBZ0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogTmFtZSBvZiB0aGUgcHJpbWFyeSBvdXRsZXQuXG4gKiBAdHlwZSB7c3RyaW5nfVxuICovXG5leHBvcnQgY29uc3QgUFJJTUFSWV9PVVRMRVQ6IHN0cmluZyA9IFwiUFJJTUFSWV9PVVRMRVRcIjtcblxuLyoqXG4gKiBBIGNvbGxlY3Rpb24gb2YgcGFyYW1ldGVycy5cbiAqL1xuZXhwb3J0IHR5cGUgUGFyYW1zID0geyBba2V5OiBzdHJpbmddOiBzdHJpbmcgfTtcbiJdfQ== \ No newline at end of file diff --git a/modules/@angular/router/build/src/url_serializer.d.ts b/modules/@angular/router/build/src/url_serializer.d.ts new file mode 100644 index 0000000000..509f6b4ea0 --- /dev/null +++ b/modules/@angular/router/build/src/url_serializer.d.ts @@ -0,0 +1,10 @@ +import { UrlTree, UrlSegment } from './url_tree'; +export declare abstract class UrlSerializer { + abstract parse(url: string): UrlTree; + abstract serialize(tree: UrlTree): string; +} +export declare class DefaultUrlSerializer implements UrlSerializer { + parse(url: string): UrlTree; + serialize(tree: UrlTree): string; +} +export declare function serializeSegment(segment: UrlSegment): string; diff --git a/modules/@angular/router/build/src/url_serializer.js b/modules/@angular/router/build/src/url_serializer.js new file mode 100644 index 0000000000..987e3ba18a --- /dev/null +++ b/modules/@angular/router/build/src/url_serializer.js @@ -0,0 +1,224 @@ +"use strict"; +var url_tree_1 = require('./url_tree'); +var shared_1 = require('./shared'); +var tree_1 = require('./utils/tree'); +var UrlSerializer = (function () { + function UrlSerializer() { + } + return UrlSerializer; +}()); +exports.UrlSerializer = UrlSerializer; +var DefaultUrlSerializer = (function () { + function DefaultUrlSerializer() { + } + DefaultUrlSerializer.prototype.parse = function (url) { + var p = new UrlParser(url); + return new url_tree_1.UrlTree(p.parseRootSegment(), p.parseQueryParams(), p.parseFragment()); + }; + DefaultUrlSerializer.prototype.serialize = function (tree) { + var node = serializeUrlTreeNode(tree_1.rootNode(tree)); + var query = serializeQueryParams(tree.queryParameters); + var fragment = tree.fragment !== null ? "#" + tree.fragment : ''; + return "" + node + query + fragment; + }; + return DefaultUrlSerializer; +}()); +exports.DefaultUrlSerializer = DefaultUrlSerializer; +function serializeUrlTreeNode(node) { + return "" + serializeSegment(node.value) + serializeChildren(node); +} +function serializeUrlTreeNodes(nodes) { + var primary = serializeSegment(nodes[0].value); + var secondaryNodes = nodes.slice(1); + var secondary = secondaryNodes.length > 0 ? "(" + secondaryNodes.map(serializeUrlTreeNode).join("//") + ")" : ""; + var children = serializeChildren(nodes[0]); + return "" + primary + secondary + children; +} +function serializeChildren(node) { + if (node.children.length > 0) { + return "/" + serializeUrlTreeNodes(node.children); + } + else { + return ""; + } +} +function serializeSegment(segment) { + var outlet = segment.outlet === shared_1.PRIMARY_OUTLET ? '' : segment.outlet + ":"; + return "" + outlet + segment.path + serializeParams(segment.parameters); +} +exports.serializeSegment = serializeSegment; +function serializeParams(params) { + return pairs(params).map(function (p) { return (";" + p.first + "=" + p.second); }).join(""); +} +function serializeQueryParams(params) { + var strs = pairs(params).map(function (p) { return (p.first + "=" + p.second); }); + return strs.length > 0 ? "?" + strs.join("&") : ""; +} +var Pair = (function () { + function Pair(first, second) { + this.first = first; + this.second = second; + } + return Pair; +}()); +function pairs(obj) { + var res = []; + for (var prop in obj) { + if (obj.hasOwnProperty(prop)) { + res.push(new Pair(prop, obj[prop])); + } + } + return res; +} +var SEGMENT_RE = /^[^\/\(\)\?;=&#]+/; +function matchUrlSegment(str) { + SEGMENT_RE.lastIndex = 0; + var match = SEGMENT_RE.exec(str); + return match ? match[0] : ''; +} +var QUERY_PARAM_VALUE_RE = /^[^\(\)\?;&#]+/; +function matchUrlQueryParamValue(str) { + QUERY_PARAM_VALUE_RE.lastIndex = 0; + var match = QUERY_PARAM_VALUE_RE.exec(str); + return match ? match[0] : ''; +} +var UrlParser = (function () { + function UrlParser(remaining) { + this.remaining = remaining; + } + UrlParser.prototype.peekStartsWith = function (str) { return this.remaining.startsWith(str); }; + UrlParser.prototype.capture = function (str) { + if (!this.remaining.startsWith(str)) { + throw new Error("Expected \"" + str + "\"."); + } + this.remaining = this.remaining.substring(str.length); + }; + UrlParser.prototype.parseRootSegment = function () { + if (this.remaining == '' || this.remaining == '/') { + return new tree_1.TreeNode(new url_tree_1.UrlSegment('', {}, shared_1.PRIMARY_OUTLET), []); + } + else { + var segments = this.parseSegments(false); + return new tree_1.TreeNode(new url_tree_1.UrlSegment('', {}, shared_1.PRIMARY_OUTLET), segments); + } + }; + UrlParser.prototype.parseSegments = function (hasOutletName) { + if (this.remaining.length == 0) { + return []; + } + if (this.peekStartsWith('/')) { + this.capture('/'); + } + var path = matchUrlSegment(this.remaining); + this.capture(path); + var outletName; + if (hasOutletName) { + if (path.indexOf(":") === -1) { + throw new Error("Not outlet name is provided"); + } + if (path.indexOf(":") > -1 && hasOutletName) { + var parts = path.split(":"); + outletName = parts[0]; + path = parts[1]; + } + } + else { + if (path.indexOf(":") > -1) { + throw new Error("Not outlet name is allowed"); + } + outletName = shared_1.PRIMARY_OUTLET; + } + var matrixParams = {}; + if (this.peekStartsWith(';')) { + matrixParams = this.parseMatrixParams(); + } + var secondary = []; + if (this.peekStartsWith('(')) { + secondary = this.parseSecondarySegments(); + } + var children = []; + if (this.peekStartsWith('/') && !this.peekStartsWith('//')) { + this.capture('/'); + children = this.parseSegments(false); + } + var segment = new url_tree_1.UrlSegment(path, matrixParams, outletName); + var node = new tree_1.TreeNode(segment, children); + return [node].concat(secondary); + }; + UrlParser.prototype.parseQueryParams = function () { + var params = {}; + if (this.peekStartsWith('?')) { + this.capture('?'); + this.parseQueryParam(params); + while (this.remaining.length > 0 && this.peekStartsWith('&')) { + this.capture('&'); + this.parseQueryParam(params); + } + } + return params; + }; + UrlParser.prototype.parseFragment = function () { + if (this.peekStartsWith('#')) { + return this.remaining.substring(1); + } + else { + return null; + } + }; + UrlParser.prototype.parseMatrixParams = function () { + var params = {}; + while (this.remaining.length > 0 && this.peekStartsWith(';')) { + this.capture(';'); + this.parseParam(params); + } + return params; + }; + UrlParser.prototype.parseParam = function (params) { + var key = matchUrlSegment(this.remaining); + if (!key) { + return; + } + this.capture(key); + var value = "true"; + if (this.peekStartsWith('=')) { + this.capture('='); + var valueMatch = matchUrlSegment(this.remaining); + if (valueMatch) { + value = valueMatch; + this.capture(value); + } + } + params[key] = value; + }; + UrlParser.prototype.parseQueryParam = function (params) { + var key = matchUrlSegment(this.remaining); + if (!key) { + return; + } + this.capture(key); + var value = "true"; + if (this.peekStartsWith('=')) { + this.capture('='); + var valueMatch = matchUrlQueryParamValue(this.remaining); + if (valueMatch) { + value = valueMatch; + this.capture(value); + } + } + params[key] = value; + }; + UrlParser.prototype.parseSecondarySegments = function () { + var segments = []; + this.capture('('); + while (!this.peekStartsWith(')') && this.remaining.length > 0) { + segments = segments.concat(this.parseSegments(true)); + if (this.peekStartsWith('//')) { + this.capture('//'); + } + } + this.capture(')'); + return segments; + }; + return UrlParser; +}()); +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"url_serializer.js","sourceRoot":"","sources":["../../src/url_serializer.ts"],"names":[],"mappings":"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","sourcesContent":["import { UrlTree, UrlSegment } from './url_tree';\nimport { PRIMARY_OUTLET } from './shared';\nimport { rootNode, TreeNode } from './utils/tree';\n\n/**\n * Defines a way to serialize/deserialize a url tree.\n */\nexport abstract class UrlSerializer {\n  /**\n   * Parse a url into a {@Link UrlTree}\n   */\n  abstract parse(url: string): UrlTree;\n\n  /**\n   * Converts a {@Link UrlTree} into a url\n   */\n  abstract serialize(tree: UrlTree): string;\n}\n\n/**\n * A default implementation of the serialization.\n */\nexport class DefaultUrlSerializer implements UrlSerializer {\n  parse(url: string): UrlTree {\n    const p = new UrlParser(url);\n    return new UrlTree(p.parseRootSegment(), p.parseQueryParams(), p.parseFragment());\n  }\n\n  serialize(tree: UrlTree): string { \n    const node = serializeUrlTreeNode(rootNode(tree));\n    const query = serializeQueryParams(tree.queryParameters);\n    const fragment = tree.fragment !== null ? `#${tree.fragment}` : '';\n    return `${node}${query}${fragment}`;\n  }\n}\n\nfunction serializeUrlTreeNode(node: TreeNode<UrlSegment>): string {\n  return `${serializeSegment(node.value)}${serializeChildren(node)}`;\n}\n\nfunction serializeUrlTreeNodes(nodes: TreeNode<UrlSegment>[]): string {\n  const primary = serializeSegment(nodes[0].value);\n  const secondaryNodes = nodes.slice(1);\n  const secondary = secondaryNodes.length > 0 ? `(${secondaryNodes.map(serializeUrlTreeNode).join(\"//\")})` : \"\";\n  const children = serializeChildren(nodes[0]);\n  return `${primary}${secondary}${children}`;\n}\n\nfunction serializeChildren(node: TreeNode<UrlSegment>): string {\n  if (node.children.length > 0) {\n    return `/${serializeUrlTreeNodes(node.children)}`;\n  } else {\n    return \"\";\n  }\n}\n\nexport function serializeSegment(segment: UrlSegment): string {\n  const outlet = segment.outlet === PRIMARY_OUTLET ? '' : `${segment.outlet}:`;\n  return `${outlet}${segment.path}${serializeParams(segment.parameters)}`;\n}\n\nfunction serializeParams(params: {[key: string]: string}): string {\n  return pairs(params).map(p => `;${p.first}=${p.second}`).join(\"\");\n}\n\nfunction serializeQueryParams(params: {[key: string]: string}): string {\n  const strs = pairs(params).map(p => `${p.first}=${p.second}`);\n  return strs.length > 0 ? `?${strs.join(\"&\")}` : \"\";\n}\n\nclass Pair<A,B> { constructor(public first:A, public second:B) {} }\nfunction pairs<T>(obj: {[key: string]: T}):Pair<string,T>[] {\n  const res = [];\n  for (let prop in obj) {\n    if (obj.hasOwnProperty(prop)) {\n      res.push(new Pair<string, T>(prop, obj[prop]));\n    }\n  }\n  return res;\n}\n\nconst SEGMENT_RE = /^[^\\/\\(\\)\\?;=&#]+/;\nfunction matchUrlSegment(str: string): string {\n  SEGMENT_RE.lastIndex = 0;\n  var match = SEGMENT_RE.exec(str);\n  return match ? match[0] : '';\n}\n\nconst QUERY_PARAM_VALUE_RE = /^[^\\(\\)\\?;&#]+/;\nfunction matchUrlQueryParamValue(str: string): string {\n  QUERY_PARAM_VALUE_RE.lastIndex = 0;\n  const match = QUERY_PARAM_VALUE_RE.exec(str);\n  return match ? match[0] : '';\n}\n\nclass UrlParser {\n  constructor(private remaining: string) {}\n\n  peekStartsWith(str: string): boolean { return this.remaining.startsWith(str); }\n\n  capture(str: string): void {\n    if (!this.remaining.startsWith(str)) {\n      throw new Error(`Expected \"${str}\".`);\n    }\n    this.remaining = this.remaining.substring(str.length);\n  }\n\n  parseRootSegment(): TreeNode<UrlSegment> {\n    if (this.remaining  == '' || this.remaining == '/') {\n      return new TreeNode<UrlSegment>(new UrlSegment('', {}, PRIMARY_OUTLET), []);\n    } else {\n      const segments = this.parseSegments(false);\n      return new TreeNode<UrlSegment>(new UrlSegment('', {}, PRIMARY_OUTLET), segments);\n    }\n  }\n\n  parseSegments(hasOutletName: boolean): TreeNode<UrlSegment>[] {\n    if (this.remaining.length == 0) {\n      return [];\n    }\n    if (this.peekStartsWith('/')) {\n      this.capture('/');\n    }\n    let path = matchUrlSegment(this.remaining);\n    this.capture(path);\n\n    let outletName;\n    if (hasOutletName) {\n      if (path.indexOf(\":\") === -1) {\n        throw new Error(\"Not outlet name is provided\");\n      }\n      if (path.indexOf(\":\") > -1 && hasOutletName) {\n        let parts = path.split(\":\");\n        outletName = parts[0];\n        path = parts[1];\n      }\n    } else {\n      if (path.indexOf(\":\") > -1) {\n        throw new Error(\"Not outlet name is allowed\");\n      }\n      outletName = PRIMARY_OUTLET;\n    }\n\n    let matrixParams: {[key: string]: any} = {};\n    if (this.peekStartsWith(';')) {\n      matrixParams = this.parseMatrixParams();\n    }\n\n    let secondary = [];\n    if (this.peekStartsWith('(')) {\n      secondary = this.parseSecondarySegments();\n    }\n\n    let children: TreeNode<UrlSegment>[] = [];\n    if (this.peekStartsWith('/') && !this.peekStartsWith('//')) {\n      this.capture('/');\n      children = this.parseSegments(false);\n    }\n\n    const segment = new UrlSegment(path, matrixParams, outletName);\n    const node = new TreeNode<UrlSegment>(segment, children);\n    return [node].concat(secondary);\n  }\n\n  parseQueryParams(): {[key: string]: any} {\n    var params: {[key: string]: any} = {};\n    if (this.peekStartsWith('?')) {\n      this.capture('?');\n      this.parseQueryParam(params);\n      while (this.remaining.length > 0 && this.peekStartsWith('&')) {\n        this.capture('&');\n        this.parseQueryParam(params);\n      }\n    }\n    return params;\n  }\n\n  parseFragment(): string | null {\n    if (this.peekStartsWith('#')) {\n      return this.remaining.substring(1);\n    } else {\n      return null;\n    }\n  }\n\n  parseMatrixParams(): {[key: string]: any} {\n    var params: {[key: string]: any} = {};\n    while (this.remaining.length > 0 && this.peekStartsWith(';')) {\n      this.capture(';');\n      this.parseParam(params);\n    }\n    return params;\n  }\n\n  parseParam(params: {[key: string]: any}): void {\n    var key = matchUrlSegment(this.remaining);\n    if (!key) {\n      return;\n    }\n    this.capture(key);\n    var value: any = \"true\";\n    if (this.peekStartsWith('=')) {\n      this.capture('=');\n      var valueMatch = matchUrlSegment(this.remaining);\n      if (valueMatch) {\n        value = valueMatch;\n        this.capture(value);\n      }\n    }\n\n    params[key] = value;\n  }\n\n  parseQueryParam(params: {[key: string]: any}): void {\n    var key = matchUrlSegment(this.remaining);\n    if (!key) {\n      return;\n    }\n    this.capture(key);\n    var value: any = \"true\";\n    if (this.peekStartsWith('=')) {\n      this.capture('=');\n      var valueMatch = matchUrlQueryParamValue(this.remaining);\n      if (valueMatch) {\n        value = valueMatch;\n        this.capture(value);\n      }\n    }\n    params[key] = value;\n  }\n\n  parseSecondarySegments(): TreeNode<UrlSegment>[] {\n    var segments = [];\n    this.capture('(');\n\n    while (!this.peekStartsWith(')') && this.remaining.length > 0) {\n      segments = segments.concat(this.parseSegments(true));\n      if (this.peekStartsWith('//')) {\n        this.capture('//');\n      }\n    }\n    this.capture(')');\n\n    return segments;\n  }\n}\n"]} \ No newline at end of file diff --git a/modules/@angular/router/build/src/url_tree.d.ts b/modules/@angular/router/build/src/url_tree.d.ts new file mode 100644 index 0000000000..f9ea224dae --- /dev/null +++ b/modules/@angular/router/build/src/url_tree.d.ts @@ -0,0 +1,23 @@ +import { Tree, TreeNode } from './utils/tree'; +export declare function createEmptyUrlTree(): UrlTree; +export declare class UrlTree extends Tree { + queryParameters: { + [key: string]: string; + }; + fragment: string | null; + constructor(root: TreeNode, queryParameters: { + [key: string]: string; + }, fragment: string | null); +} +export declare class UrlSegment { + path: string; + parameters: { + [key: string]: string; + }; + outlet: string; + constructor(path: string, parameters: { + [key: string]: string; + }, outlet: string); + toString(): string; +} +export declare function equalUrlSegments(a: UrlSegment[], b: UrlSegment[]): boolean; diff --git a/modules/@angular/router/build/src/url_tree.js b/modules/@angular/router/build/src/url_tree.js new file mode 100644 index 0000000000..eb5b501d4b --- /dev/null +++ b/modules/@angular/router/build/src/url_tree.js @@ -0,0 +1,56 @@ +"use strict"; +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var tree_1 = require('./utils/tree'); +var collection_1 = require('./utils/collection'); +var shared_1 = require('./shared'); +function createEmptyUrlTree() { + return new UrlTree(new tree_1.TreeNode(new UrlSegment("", {}, shared_1.PRIMARY_OUTLET), []), {}, null); +} +exports.createEmptyUrlTree = createEmptyUrlTree; +var UrlTree = (function (_super) { + __extends(UrlTree, _super); + function UrlTree(root, queryParameters, fragment) { + _super.call(this, root); + this.queryParameters = queryParameters; + this.fragment = fragment; + } + return UrlTree; +}(tree_1.Tree)); +exports.UrlTree = UrlTree; +var UrlSegment = (function () { + function UrlSegment(path, parameters, outlet) { + this.path = path; + this.parameters = parameters; + this.outlet = outlet; + } + UrlSegment.prototype.toString = function () { + var params = []; + for (var prop in this.parameters) { + if (this.parameters.hasOwnProperty(prop)) { + params.push(prop + "=" + this.parameters[prop]); + } + } + var paramsString = params.length > 0 ? "(" + params.join(',') + ")" : ''; + var outlet = this.outlet === shared_1.PRIMARY_OUTLET ? '' : this.outlet + ":"; + return "" + outlet + this.path + paramsString; + }; + return UrlSegment; +}()); +exports.UrlSegment = UrlSegment; +function equalUrlSegments(a, b) { + if (a.length !== b.length) + return false; + for (var i = 0; i < a.length; ++i) { + if (a[i].path !== b[i].path) + return false; + if (!collection_1.shallowEqual(a[i].parameters, b[i].parameters)) + return false; + } + return true; +} +exports.equalUrlSegments = equalUrlSegments; +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/modules/@angular/router/build/src/utils/collection.d.ts b/modules/@angular/router/build/src/utils/collection.d.ts new file mode 100644 index 0000000000..9df4eefaf9 --- /dev/null +++ b/modules/@angular/router/build/src/utils/collection.d.ts @@ -0,0 +1,17 @@ +export declare function shallowEqual(a: { + [x: string]: any; +}, b: { + [x: string]: any; +}): boolean; +export declare function flatten(a: T[][]): T[]; +export declare function first(a: T[]): T | null; +export declare function merge(m1: { + [key: string]: V; +}, m2: { + [key: string]: V; +}): { + [key: string]: V; +}; +export declare function forEach(map: { + [key: string]: V; +}, callback: Function): void; diff --git a/modules/@angular/router/build/src/utils/collection.js b/modules/@angular/router/build/src/utils/collection.js new file mode 100644 index 0000000000..4c1e38130d --- /dev/null +++ b/modules/@angular/router/build/src/utils/collection.js @@ -0,0 +1,55 @@ +"use strict"; +function shallowEqual(a, b) { + var k1 = Object.keys(a); + var k2 = Object.keys(b); + if (k1.length != k2.length) { + return false; + } + var key; + for (var i = 0; i < k1.length; i++) { + key = k1[i]; + if (a[key] !== b[key]) { + return false; + } + } + return true; +} +exports.shallowEqual = shallowEqual; +function flatten(a) { + var target = []; + for (var i = 0; i < a.length; ++i) { + for (var j = 0; j < a[i].length; ++j) { + target.push(a[i][j]); + } + } + return target; +} +exports.flatten = flatten; +function first(a) { + return a.length > 0 ? a[0] : null; +} +exports.first = first; +function merge(m1, m2) { + var m = {}; + for (var attr in m1) { + if (m1.hasOwnProperty(attr)) { + m[attr] = m1[attr]; + } + } + for (var attr in m2) { + if (m2.hasOwnProperty(attr)) { + m[attr] = m2[attr]; + } + } + return m; +} +exports.merge = merge; +function forEach(map, callback) { + for (var prop in map) { + if (map.hasOwnProperty(prop)) { + callback(map[prop], prop); + } + } +} +exports.forEach = forEach; +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/modules/@angular/router/build/src/utils/tree.d.ts b/modules/@angular/router/build/src/utils/tree.d.ts new file mode 100644 index 0000000000..1b025de959 --- /dev/null +++ b/modules/@angular/router/build/src/utils/tree.d.ts @@ -0,0 +1,17 @@ +export declare class Tree { + _root: TreeNode; + constructor(root: TreeNode); + readonly root: T; + parent(t: T): T | null; + children(t: T): T[]; + firstChild(t: T): T | null; + siblings(t: T): T[]; + pathFromRoot(t: T): T[]; + contains(tree: Tree): boolean; +} +export declare function rootNode(tree: Tree): TreeNode; +export declare class TreeNode { + value: T; + children: TreeNode[]; + constructor(value: T, children: TreeNode[]); +} diff --git a/modules/@angular/router/build/src/utils/tree.js b/modules/@angular/router/build/src/utils/tree.js new file mode 100644 index 0000000000..6121f4b421 --- /dev/null +++ b/modules/@angular/router/build/src/utils/tree.js @@ -0,0 +1,88 @@ +"use strict"; +var Tree = (function () { + function Tree(root) { + this._root = root; + } + Object.defineProperty(Tree.prototype, "root", { + get: function () { return this._root.value; }, + enumerable: true, + configurable: true + }); + Tree.prototype.parent = function (t) { + var p = this.pathFromRoot(t); + return p.length > 1 ? p[p.length - 2] : null; + }; + Tree.prototype.children = function (t) { + var n = findNode(t, this._root); + return n ? n.children.map(function (t) { return t.value; }) : []; + }; + Tree.prototype.firstChild = function (t) { + var n = findNode(t, this._root); + return n && n.children.length > 0 ? n.children[0].value : null; + }; + Tree.prototype.siblings = function (t) { + var p = findPath(t, this._root, []); + if (p.length < 2) + return []; + var c = p[p.length - 2].children.map(function (c) { return c.value; }); + return c.filter(function (cc) { return cc !== t; }); + }; + Tree.prototype.pathFromRoot = function (t) { return findPath(t, this._root, []).map(function (s) { return s.value; }); }; + Tree.prototype.contains = function (tree) { return contains(this._root, tree._root); }; + return Tree; +}()); +exports.Tree = Tree; +function rootNode(tree) { + return tree._root; +} +exports.rootNode = rootNode; +function findNode(expected, c) { + if (expected === c.value) + return c; + for (var _i = 0, _a = c.children; _i < _a.length; _i++) { + var cc = _a[_i]; + var r = findNode(expected, cc); + if (r) + return r; + } + return null; +} +function findPath(expected, c, collected) { + collected.push(c); + if (expected === c.value) + return collected; + for (var _i = 0, _a = c.children; _i < _a.length; _i++) { + var cc = _a[_i]; + var cloned = collected.slice(0); + var r = findPath(expected, cc, cloned); + if (r) + return r; + } + return []; +} +function contains(tree, subtree) { + if (tree.value !== subtree.value) + return false; + var _loop_1 = function(subtreeNode) { + var s = tree.children.filter(function (child) { return child.value === subtreeNode.value; }); + if (s.length === 0) + return { value: false }; + if (!contains(s[0], subtreeNode)) + return { value: false }; + }; + for (var _i = 0, _a = subtree.children; _i < _a.length; _i++) { + var subtreeNode = _a[_i]; + var state_1 = _loop_1(subtreeNode); + if (typeof state_1 === "object") return state_1.value; + } + return true; +} +var TreeNode = (function () { + function TreeNode(value, children) { + this.value = value; + this.children = children; + } + return TreeNode; +}()); +exports.TreeNode = TreeNode; +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/modules/@angular/router/package.json b/modules/@angular/router/package.json index 0aa37f13ad..8e5800ddda 100644 --- a/modules/@angular/router/package.json +++ b/modules/@angular/router/package.json @@ -2,8 +2,8 @@ "name": "vladivostok", "version": "0.9.1", "description": "", - "main": "./dist/src/index.js", - "jsnext:main": "./dist/es6/index.js", + "main": "./build/src/index.js", + "jsnext:main": "./build/es6/index.js", "scripts": { "karma": "karma start", "test": "npm run build; karma start", @@ -64,5 +64,5 @@ "typings": "^1.0.4", "zone.js": "^0.6.6" }, - "typings": "dist/router.d.ts" + "typings": "build/src/index.d.ts" }