@ionic/core 7.5.6-dev.11700169088.140f3e6a → 7.5.6-dev.11700519388.1583475f

package/dist/collection/components/router/test/matching.spec.js

@@ -0,0 +1,250 @@
+/*!
+ * (C) Ionic http://ionicframework.com - MIT License
+ */
+import { RouterSegments, matchesIDs, matchesSegments, matchesRedirect, mergeParams, findChainForSegments, } from "../utils/matching";
+import { parsePath } from "../utils/path";
+const CHAIN_1 = [
+  { id: '2', segments: ['to'], params: undefined },
+  { id: '1', segments: ['path'], params: undefined },
+  { id: '3', segments: ['segment'], params: undefined },
+  { id: '4', segments: [''], params: undefined },
+];
+const CHAIN_2 = [
+  { id: '2', segments: [''], params: undefined },
+  { id: '1', segments: [''], params: undefined },
+  { id: '3', segments: ['segment', 'to'], params: undefined },
+  { id: '4', segments: [''], params: undefined },
+  { id: '5', segments: ['hola'], params: undefined },
+  { id: '6', segments: [''], params: undefined },
+  { id: '7', segments: [''], params: undefined },
+  { id: '8', segments: ['adios', 'que', 'tal'], params: undefined },
+];
+const CHAIN_3 = [
+  { id: '2', segments: ['this', 'to'], params: undefined },
+  { id: '1', segments: ['path'], params: undefined },
+  { id: '3', segments: ['segment', 'to', 'element'], params: undefined },
+  { id: '4', segments: [''], params: undefined },
+];
+describe('matchesIDs', () => {
+  it('should match simple set of ids', () => {
+    const chain = CHAIN_1;
+    expect(matchesIDs([{ id: '2' }], chain)).toBe(1);
+    expect(matchesIDs([{ id: '2' }, { id: '1' }], chain)).toBe(2);
+    expect(matchesIDs([{ id: '2' }, { id: '1' }, { id: '3' }], chain)).toBe(3);
+    expect(matchesIDs([{ id: '2' }, { id: '1' }, { id: '3' }, { id: '4' }], chain)).toBe(4);
+    expect(matchesIDs([{ id: '2' }, { id: '1' }, { id: '3' }, { id: '4' }, { id: '5' }], chain)).toBe(4);
+    expect(matchesIDs([], chain)).toBe(0);
+    expect(matchesIDs([{ id: '1' }], chain)).toBe(0);
+  });
+  it('should match path with params', () => {
+    const ids = [{ id: 'my-page', params: { s1: 'a', s2: 'b' } }];
+    expect(matchesIDs(ids, [{ id: 'my-page', segments: [''], params: {} }])).toBe(1);
+    expect(matchesIDs(ids, [{ id: 'my-page', segments: [':s1'], params: {} }])).toBe(1);
+    expect(matchesIDs(ids, [{ id: 'my-page', segments: [':s1', ':s2'], params: {} }])).toBe(3);
+    expect(matchesIDs(ids, [{ id: 'my-page', segments: [':s1', ':s2', ':s3'], params: {} }])).toBe(1);
+  });
+});
+describe('matchesSegments', () => {
+  it('should match simple path', () => {
+    const chain = CHAIN_3;
+    expect(matchesSegments(['this'], chain)).toEqual(null);
+    expect(matchesSegments(['this', 'to'], chain)).toEqual(null);
+    expect(matchesSegments(['this', 'to', 'path'], chain)).toEqual(null);
+    expect(matchesSegments(['this', 'to', 'path', 'segment'], chain)).toEqual(null);
+    expect(matchesSegments(['this', 'to', 'path', 'segment', 'to'], chain)).toEqual(null);
+    expect(matchesSegments(['this', 'to', 'path', 'segment', 'to', 'element'], chain)).toEqual(chain);
+    expect(matchesSegments(['this', 'to', 'path', 'segment', 'to', 'element', 'more'], chain)).toEqual(null);
+    expect(matchesSegments([], chain)).toEqual(null);
+    expect(matchesSegments([''], chain)).toEqual(null);
+    expect(matchesSegments(['path'], chain)).toEqual(null);
+  });
+  it('should match simple default route', () => {
+    const chain = CHAIN_2;
+    expect(matchesSegments([''], chain)).toEqual(null);
+    expect(matchesSegments(['segment'], chain)).toEqual(null);
+    expect(matchesSegments(['segment', 'to'], chain)).toEqual(null);
+    expect(matchesSegments(['segment', 'to', 'hola'], chain)).toEqual(null);
+    expect(matchesSegments(['segment', 'to', 'hola', 'adios'], chain)).toEqual(null);
+    expect(matchesSegments(['segment', 'to', 'hola', 'adios', 'que'], chain)).toEqual(null);
+    expect(matchesSegments(['segment', 'to', 'hola', 'adios', 'que', 'tal'], chain)).toEqual(chain);
+    expect(matchesSegments(['segment', 'to', 'hola', 'adios', 'que', 'tal', 'more'], chain)).toEqual(chain);
+    expect(matchesSegments(['to'], chain)).toEqual(null);
+    expect(matchesSegments(['path', 'to'], chain)).toEqual(null);
+  });
+  it('should match simple route 2', () => {
+    const chain = [{ id: '5', segments: ['hola'], params: undefined }];
+    expect(matchesSegments([''], chain)).toEqual(null);
+    expect(matchesSegments(['hola'], chain)).toEqual(chain);
+    expect(matchesSegments(['hola', 'hola'], chain)).toEqual(chain);
+    expect(matchesSegments(['hola', 'adios'], chain)).toEqual(chain);
+  });
+  it('should match simple route 3', () => {
+    const chain = [{ id: '5', segments: ['hola', 'adios'], params: undefined }];
+    expect(matchesSegments([''], chain)).toEqual(null);
+    expect(matchesSegments(['hola'], chain)).toEqual(null);
+    expect(matchesSegments(['hola', 'hola'], chain)).toEqual(null);
+    expect(matchesSegments(['hola', 'adios'], chain)).toEqual(chain);
+    expect(matchesSegments(['hola', 'adios', 'bye'], chain)).toEqual(chain);
+  });
+  it('should match simple route 4', () => {
+    const chain = [
+      { id: '5', segments: ['hola'], params: undefined },
+      { id: '5', segments: ['adios'], params: undefined },
+    ];
+    expect(matchesSegments([''], chain)).toEqual(null);
+    expect(matchesSegments(['hola'], chain)).toEqual(null);
+    expect(matchesSegments(['hola', 'hola'], chain)).toEqual(null);
+    expect(matchesSegments(['hola', 'adios'], chain)).toEqual(chain);
+  });
+  it('should match with parameters', () => {
+    const chain = [
+      { id: '5', segments: ['profile', ':name'], params: undefined },
+      { id: '5', segments: [''], params: undefined },
+      { id: '5', segments: ['image'], params: { size: 'lg' } },
+      { id: '5', segments: ['image', ':size', ':type'], params: { size: 'mg' } },
+    ];
+    const matched = matchesSegments(parsePath('/profile/manu/image/image/large/retina').segments, chain);
+    expect(matched).toEqual([
+      { id: '5', segments: ['profile', ':name'], params: { name: 'manu' } },
+      { id: '5', segments: [''], params: undefined },
+      { id: '5', segments: ['image'], params: { size: 'lg' } },
+      { id: '5', segments: ['image', ':size', ':type'], params: { size: 'large', type: 'retina' } },
+    ]);
+  });
+});
+describe('findChainForSegments', () => {
+  it('should match the route with higher priority', () => {
+    const chain3 = [{ id: '5', segments: ['hola'], params: undefined }];
+    const chain4 = [
+      { id: '5', segments: ['hola'], params: undefined },
+      { id: '5', segments: ['adios'], params: undefined },
+    ];
+    const routes = [CHAIN_1, CHAIN_2, chain3, chain4];
+    expect(findChainForSegments(['to'], routes)).toEqual(null);
+    expect(findChainForSegments([''], routes)).toEqual(null);
+    expect(findChainForSegments(['segment', 'to'], routes)).toEqual(null);
+    expect(findChainForSegments(['hola'], routes)).toEqual(chain3);
+    expect(findChainForSegments(['hola', 'hola'], routes)).toEqual(chain3);
+    expect(findChainForSegments(['hola', 'adios'], routes)).toEqual(chain4);
+  });
+  it('should match the route with higher priority 2', () => {
+    const chain1 = [{ id: '1', segments: ['categories', ':category_slug'], params: undefined }];
+    const chain2 = [{ id: '2', segments: ['workouts', ':workout_slug'], params: undefined }];
+    const chain3 = [{ id: '3', segments: ['workouts', ':workout_slug', 'time-select'], params: undefined }];
+    const chain4 = [{ id: '4', segments: ['workouts', ':workout_slug', 'end-workout'], params: undefined }];
+    const chain5 = [{ id: '5', segments: ['plans'], params: undefined }];
+    const chain6 = [{ id: '6', segments: ['custom'], params: undefined }];
+    const chain7 = [{ id: '7', segments: ['workouts', 'list'], params: undefined }];
+    const routes = [chain1, chain2, chain3, chain4, chain5, chain6, chain7];
+    // no match
+    expect(findChainForSegments(['categories'], routes)).toEqual(null);
+    expect(findChainForSegments(['workouts'], routes)).toEqual(null);
+    expect(findChainForSegments(['plans'], routes)).toEqual(chain5);
+    expect(findChainForSegments(['custom'], routes)).toEqual(chain6);
+    expect(findChainForSegments(['workouts', 'list'], routes)).toEqual(chain7);
+    expect(findChainForSegments(['workouts', 'hola'], routes)).toEqual([
+      { id: '2', segments: ['workouts', ':workout_slug'], params: { workout_slug: 'hola' } },
+    ]);
+    expect(findChainForSegments(['workouts', 'hello', 'time-select'], routes)).toEqual([
+      { id: '3', segments: ['workouts', ':workout_slug', 'time-select'], params: { workout_slug: 'hello' } },
+    ]);
+    expect(findChainForSegments(['workouts', 'hello2', 'end-workout'], routes)).toEqual([
+      { id: '4', segments: ['workouts', ':workout_slug', 'end-workout'], params: { workout_slug: 'hello2' } },
+    ]);
+  });
+  it('should match the default route', () => {
+    const chain1 = [
+      { id: 'tabs', segments: [''], params: undefined },
+      { id: 'tab1', segments: [''], params: undefined },
+      { id: 'schedule', segments: [''], params: undefined },
+    ];
+    const chain2 = [
+      { id: 'tabs', segments: [''], params: undefined },
+      { id: 'tab2', segments: ['tab2'], params: undefined },
+      { id: 'page2', segments: [''], params: undefined },
+    ];
+    expect(findChainForSegments([''], [chain1])).toEqual(chain1);
+    expect(findChainForSegments(['tab2'], [chain1])).toEqual(null);
+    expect(findChainForSegments([''], [chain2])).toEqual(null);
+    expect(findChainForSegments(['tab2'], [chain2])).toEqual(chain2);
+  });
+});
+describe('mergeParams', () => {
+  it('should merge undefined', () => {
+    expect(mergeParams(undefined, undefined)).toBeUndefined();
+    expect(mergeParams(null, undefined)).toBeUndefined();
+    expect(mergeParams(undefined, null)).toBeUndefined();
+    expect(mergeParams(null, null)).toBeUndefined();
+  });
+  it('should merge undefined with params', () => {
+    const params = { data: '1' };
+    expect(mergeParams(undefined, params)).toEqual(params);
+    expect(mergeParams(null, params)).toEqual(params);
+    expect(mergeParams(params, undefined)).toEqual(params);
+    expect(mergeParams(params, null)).toEqual(params);
+  });
+  it('should merge params with params', () => {
+    const params1 = { data: '1', data3: 'hello' };
+    const params2 = { data: '2', data2: 'hola' };
+    expect(mergeParams(params1, params2)).toEqual({
+      data: '2',
+      data2: 'hola',
+      data3: 'hello',
+    });
+    expect(params1).toEqual({ data: '1', data3: 'hello' });
+    expect(params2).toEqual({ data: '2', data2: 'hola' });
+  });
+});
+describe('RouterSegments', () => {
+  it('should initialize with empty array', () => {
+    const s = new RouterSegments([]);
+    expect(s.next()).toEqual('');
+    expect(s.next()).toEqual('');
+    expect(s.next()).toEqual('');
+    expect(s.next()).toEqual('');
+    expect(s.next()).toEqual('');
+  });
+  it('should initialize with array', () => {
+    const s = new RouterSegments(['', 'path', 'to', 'destination']);
+    expect(s.next()).toEqual('');
+    expect(s.next()).toEqual('path');
+    expect(s.next()).toEqual('to');
+    expect(s.next()).toEqual('destination');
+    expect(s.next()).toEqual('');
+    expect(s.next()).toEqual('');
+  });
+});
+describe('matchesRedirect', () => {
+  it('should match empty redirect', () => {
+    expect(matchesRedirect([''], { from: [''], to: { segments: [''] } })).toBeTruthy();
+    expect(matchesRedirect([''], { from: ['*'], to: { segments: [''] } })).toBeTruthy();
+    expect(matchesRedirect([''], { from: ['hola'], to: { segments: [] } })).toBeFalsy();
+    expect(matchesRedirect([''], { from: ['hola', '*'], to: { segments: [''] } })).toBeFalsy();
+  });
+  it('should match simple segment redirect', () => {
+    expect(matchesRedirect(['workouts'], { from: ['workouts'], to: { segments: [''] } })).toBeTruthy();
+    expect(matchesRedirect(['workouts'], { from: ['*'], to: { segments: [''] } })).toBeTruthy();
+    expect(matchesRedirect(['workouts', 'hola'], { from: ['workouts', '*'], to: { segments: [''] } })).toBeTruthy();
+    expect(matchesRedirect(['workouts', 'hola'], { from: ['workouts', 'hola'], to: { segments: [''] } })).toBeTruthy();
+    expect(matchesRedirect(['workouts'], { from: ['workouts', '*'], to: { segments: [''] } })).toBeFalsy();
+    expect(matchesRedirect(['workouts', 'hola'], { from: ['workouts'], to: { segments: [''] } })).toBeFalsy();
+    expect(matchesRedirect(['workouts', 'hola'], { from: ['workouts', 'adios'], to: { segments: [''] } })).toBeFalsy();
+  });
+  it('should match long route', () => {
+    expect(matchesRedirect(['workouts', 'path', 'to'], { from: ['*'], to: { segments: [''] } })).toBeTruthy();
+    expect(matchesRedirect(['workouts', 'path', 'to'], { from: ['workouts', '*'], to: { segments: [''] } })).toBeTruthy();
+    expect(matchesRedirect(['workouts', 'path', 'to'], { from: ['workouts', 'path', '*'], to: { segments: [''] } })).toBeTruthy();
+    expect(matchesRedirect(['workouts', 'path', 'to'], { from: ['workouts', 'path', 'to'], to: { segments: [''] } })).toBeTruthy();
+    expect(matchesRedirect(['workouts', 'path', 'to'], { from: ['login'], to: { segments: [''] } })).toBeFalsy();
+    expect(matchesRedirect(['workouts', 'path', 'to'], { from: ['login', '*'], to: { segments: [''] } })).toBeFalsy();
+    expect(matchesRedirect(['workouts', 'path', 'to'], { from: ['workouts'], to: { segments: [''] } })).toBeFalsy();
+    expect(matchesRedirect(['workouts', 'path', 'to'], { from: ['workouts', 'path'], to: { segments: [''] } })).toBeFalsy();
+    expect(matchesRedirect(['workouts', 'path', 'to'], { from: ['workouts', 'path', 'to', '*'], to: { segments: [''] } })).toBeFalsy();
+  });
+  it('should not match undefined "to"', () => {
+    expect(matchesRedirect(['workouts', 'path', 'to'], { from: ['*'], to: undefined })).toBeFalsy();
+    expect(matchesRedirect(['workouts', 'path', 'to'], { from: ['workouts', '*'], to: undefined })).toBeFalsy();
+    expect(matchesRedirect(['workouts', 'path', 'to'], { from: ['workouts', 'path', '*'], to: undefined })).toBeFalsy();
+    expect(matchesRedirect(['workouts', 'path', 'to'], { from: ['workouts', 'path', 'to'], to: undefined })).toBeFalsy();
+  });
+});

package/dist/collection/components/router/test/parser.spec.js

@@ -0,0 +1,133 @@
+/*!
+ * (C) Ionic http://ionicframework.com - MIT License
+ */
+import { mockWindow } from "@stencil/core/testing";
+import { flattenRouterTree, readRedirects, readRouteNodes } from "../utils/parser";
+describe('parser', () => {
+  describe('readRoutes', () => {
+    it('should read URL', () => {
+      const root = win.document.createElement('div');
+      const r1 = mockRouteElement(win, '/', 'MAIN-PAGE');
+      const r2 = mockRouteElement(win, '/one-page', 'one-page');
+      const r3 = mockRouteElement(win, 'secondpage', 'second-page');
+      const r4 = mockRouteElement(win, '/5/hola', '4');
+      const r5 = mockRouteElement(win, '/path/to/five', '5');
+      const r6 = mockRouteElement(win, '/path/to/five2', '6');
+      const r7 = mockRouteElement(win, '/path?flag=true', '6');
+      root.appendChild(r1);
+      root.appendChild(r2);
+      root.appendChild(r3);
+      root.appendChild(r7);
+      r3.appendChild(r4);
+      r4.appendChild(r5);
+      r4.appendChild(r6);
+      const expected = [
+        { segments: [''], id: 'main-page', children: [], params: undefined },
+        { segments: ['one-page'], id: 'one-page', children: [], params: undefined },
+        {
+          segments: ['secondpage'],
+          id: 'second-page',
+          params: undefined,
+          children: [
+            {
+              segments: ['5', 'hola'],
+              id: '4',
+              params: undefined,
+              children: [
+                { segments: ['path', 'to', 'five'], id: '5', children: [], params: undefined },
+                { segments: ['path', 'to', 'five2'], id: '6', children: [], params: undefined },
+              ],
+            },
+          ],
+        },
+        { segments: ['path'], id: '6', children: [], params: undefined },
+      ];
+      expect(readRouteNodes(root)).toEqual(expected);
+    });
+  });
+  describe('readRedirects', () => {
+    it('should read redirects', () => {
+      const root = win.document.createElement('div');
+      const r1 = mockRedirectElement(win, '/', undefined);
+      const r2 = mockRedirectElement(win, undefined, '/workout');
+      const r3 = mockRedirectElement(win, '*', null);
+      const r4 = mockRedirectElement(win, '/workout/*', '');
+      const r5 = mockRedirectElement(win, 'path/hey', '/path/to//login');
+      const r6 = mockRedirectElement(win, 'path/qs', '/path?qs=true');
+      root.appendChild(r1);
+      root.appendChild(r2);
+      root.appendChild(r3);
+      root.appendChild(r4);
+      root.appendChild(r5);
+      root.appendChild(r6);
+      const expected = [
+        { from: [''], to: undefined },
+        { from: [''], to: { segments: ['workout'] } },
+        { from: ['*'], to: undefined },
+        { from: ['workout', '*'], to: { segments: [''] } },
+        { from: ['path', 'hey'], to: { segments: ['path', 'to', 'login'] } },
+        { from: ['path', 'qs'], to: { segments: ['path'], queryString: 'qs=true' } },
+      ];
+      expect(readRedirects(root)).toEqual(expected);
+    });
+  });
+  describe('flattenRouterTree', () => {
+    it('should process routes', () => {
+      const entries = [
+        { segments: [''], id: 'hola', children: [], params: undefined },
+        { segments: ['one-page'], id: 'one-page', children: [], params: undefined },
+        {
+          segments: ['secondpage'],
+          id: 'second-page',
+          params: undefined,
+          children: [
+            {
+              segments: ['5', 'hola'],
+              id: '4',
+              params: undefined,
+              children: [
+                { segments: ['path', 'to', 'five'], id: '5', children: [], params: undefined },
+                { segments: ['path', 'to', 'five2'], id: '6', children: [], params: undefined },
+              ],
+            },
+          ],
+        },
+      ];
+      const routes = flattenRouterTree(entries);
+      expect(routes).toEqual([
+        [{ segments: [''], id: 'hola' }],
+        [{ segments: ['one-page'], id: 'one-page' }],
+        [
+          { segments: ['secondpage'], id: 'second-page' },
+          { segments: ['5', 'hola'], id: '4' },
+          { segments: ['path', 'to', 'five'], id: '5' },
+        ],
+        [
+          { segments: ['secondpage'], id: 'second-page' },
+          { segments: ['5', 'hola'], id: '4' },
+          { segments: ['path', 'to', 'five2'], id: '6' },
+        ],
+      ]);
+    });
+  });
+  let win;
+  beforeEach(() => {
+    win = mockWindow();
+  });
+});
+export function mockRouteElement(win, path, component) {
+  const el = win.document.createElement('ion-route');
+  el.setAttribute('url', path);
+  el.component = component;
+  return el;
+}
+function mockRedirectElement(win, from, to) {
+  const el = win.document.createElement('ion-route-redirect');
+  if (from != null) {
+    el.setAttribute('from', from);
+  }
+  if (to != null) {
+    el.setAttribute('to', to);
+  }
+  return el;
+}

package/dist/collection/components/router/test/path.spec.js

@@ -0,0 +1,218 @@
+/*!
+ * (C) Ionic http://ionicframework.com - MIT License
+ */
+import { ROUTER_INTENT_FORWARD } from "../utils/constants";
+import { chainToSegments, generatePath, parsePath, readSegments, writeSegments } from "../utils/path";
+describe('parsePath', () => {
+  it('should parse empty path', () => {
+    expect(parsePath('').segments).toEqual(['']);
+  });
+  it('should parse slash path', () => {
+    expect(parsePath('/').segments).toEqual(['']);
+    expect(parsePath(' / ').segments).toEqual(['']);
+  });
+  it('should parse empty path (2)', () => {
+    expect(parsePath('   ').segments).toEqual(['']);
+  });
+  it('should parse null path', () => {
+    expect(parsePath(null).segments).toEqual(['']);
+  });
+  it('should parse undefined path', () => {
+    expect(parsePath(undefined).segments).toEqual(['']);
+  });
+  it('should parse single segment', () => {
+    expect(parsePath('path').segments).toEqual(['path']);
+    expect(parsePath('path/').segments).toEqual(['path']);
+    expect(parsePath('/path/').segments).toEqual(['path']);
+    expect(parsePath('/path').segments).toEqual(['path']);
+  });
+  it('should parse relative path', () => {
+    expect(parsePath('path/to/file.js').segments).toEqual(['path', 'to', 'file.js']);
+  });
+  it('should parse absolute path', () => {
+    expect(parsePath('/path/to/file.js').segments).toEqual(['path', 'to', 'file.js']);
+  });
+  it('should parse absolute path with multiple slashes', () => {
+    expect(parsePath('/PATH///to//file.js//').segments).toEqual(['PATH', 'to', 'file.js']);
+  });
+  it('should parse query string', () => {
+    expect(parsePath(null).queryString).toBe(undefined);
+    expect(parsePath('path/to/file.js').queryString).toBe(undefined);
+    expect(parsePath('path/to/file.js?').queryString).toEqual('');
+    expect(parsePath('path/to/file.js?a=b').queryString).toEqual('a=b');
+  });
+});
+describe('generatePath', () => {
+  it('should generate an empty URL', () => {
+    expect(generatePath([])).toEqual('/');
+    expect(generatePath([{ segments: '' }])).toEqual('/');
+    expect(generatePath([{ segments: '/' }])).toEqual('/');
+    expect(generatePath([{ segments: '//' }])).toEqual('/');
+    expect(generatePath([{ segments: '  ' }])).toEqual('/');
+  });
+  it('should genenerate a basic url', () => {
+    const stack = ['', '', '', 'path/to', 'page', 'number-TWO', ''];
+    expect(generatePath(stack)).toEqual('/path/to/page/number-TWO');
+  });
+});
+describe('chainToSegments', () => {
+  it('should generate a simple URL', () => {
+    const chain = [
+      { id: '2', segments: [''], params: undefined },
+      { id: '1', segments: [''], params: undefined },
+      { id: '3', segments: ['segment', 'to'], params: undefined },
+      { id: '4', segments: [''], params: undefined },
+      { id: '5', segments: ['hola', '', 'hey'], params: undefined },
+      { id: '6', segments: [''], params: undefined },
+      { id: '7', segments: [':param'], params: { param: 'name' } },
+      { id: '8', segments: ['adios', ':name', ':id'], params: { name: 'manu', id: '123' } },
+    ];
+    expect(chainToSegments(chain)).toEqual(['segment', 'to', 'hola', 'hey', 'name', 'adios', 'manu', '123']);
+  });
+  it('should return null on missing parameters', () => {
+    const chain = [
+      { id: '3', segments: ['segment'], params: undefined },
+      { id: '8', segments: [':name'], params: undefined },
+    ];
+    expect(chainToSegments(chain)).toBeNull();
+  });
+  it('should return null on missing parameters 2', () => {
+    const chain = [
+      { id: '3', segments: ['segment'], params: undefined },
+      { id: '8', segments: [':name', ':id'], params: { name: 'hey' } },
+    ];
+    expect(chainToSegments(chain)).toBeNull();
+  });
+});
+describe('readSegments', () => {
+  it('should read the URL from root (no hash)', () => {
+    const loc = mockLocation('/', '');
+    expect(readSegments(loc, '', false)).toEqual(['']);
+    expect(readSegments(loc, '/', false)).toEqual(['']);
+    expect(readSegments(loc, '  / ', false)).toEqual(['']);
+    expect(readSegments(loc, '', true)).toEqual(['']);
+    expect(readSegments(loc, '/', true)).toEqual(['']);
+    expect(readSegments(loc, '  /  ', true)).toEqual(['']);
+  });
+  it('should read the URL from root (hash)', () => {
+    const loc = mockLocation('/', '#');
+    expect(readSegments(loc, '', true)).toEqual(['']);
+    expect(readSegments(loc, '/', true)).toEqual(['']);
+    expect(readSegments(loc, '  /  ', true)).toEqual(['']);
+    const loc2 = mockLocation('/', '#/');
+    expect(readSegments(loc2, '', true)).toEqual(['']);
+    expect(readSegments(loc2, '/', true)).toEqual(['']);
+    expect(readSegments(loc2, '  /  ', true)).toEqual(['']);
+  });
+  it('should not read the URL from root', () => {
+    const loc = mockLocation('/', '');
+    expect(readSegments(loc, '/hola', false)).toBeNull();
+    expect(readSegments(loc, 'hola', false)).toBeNull();
+    expect(readSegments(loc, '/hola', true)).toBeNull();
+    expect(readSegments(loc, 'hola', true)).toBeNull();
+  });
+  it('should read the URL from non root (no hash)', () => {
+    const loc = mockLocation('/path/to/component', '#hello');
+    expect(readSegments(loc, '', false)).toEqual(['path', 'to', 'component']);
+    expect(readSegments(loc, '/', false)).toEqual(['path', 'to', 'component']);
+    expect(readSegments(loc, 'path', false)).toEqual(['to', 'component']);
+    expect(readSegments(loc, '/path', false)).toEqual(['to', 'component']);
+    expect(readSegments(loc, '/path/', false)).toEqual(['to', 'component']);
+    expect(readSegments(loc, '/path/to', false)).toEqual(['component']);
+    expect(readSegments(loc, '/path/to/component', false)).toEqual(['']);
+    expect(readSegments(loc, '/path/to/component/', false)).toEqual(['']);
+    expect(readSegments(loc, '/path/to/component/path', false)).toBeNull();
+  });
+  it('should read the URL from non root (hash)', () => {
+    const loc = mockLocation('/index.html', '#path/to/component');
+    expect(readSegments(loc, '', true)).toEqual(['path', 'to', 'component']);
+    expect(readSegments(loc, '/', true)).toEqual(['path', 'to', 'component']);
+    expect(readSegments(loc, 'path', true)).toEqual(['to', 'component']);
+    expect(readSegments(loc, '/path', true)).toEqual(['to', 'component']);
+    expect(readSegments(loc, '/path/', true)).toEqual(['to', 'component']);
+    expect(readSegments(loc, '/path/to', true)).toEqual(['component']);
+    expect(readSegments(loc, '/path/to/component', true)).toEqual(['']);
+    expect(readSegments(loc, '/path/to/component/', true)).toEqual(['']);
+    expect(readSegments(loc, '/path/to/component/path', true)).toBeNull();
+    expect(readSegments(loc, '/path/to/component2', true)).toBeNull();
+  });
+  it('should read the URL from non root (hash) 2', () => {
+    const loc = mockLocation('/index.html', '#/path/to/component');
+    expect(readSegments(loc, '', true)).toEqual(['path', 'to', 'component']);
+    expect(readSegments(loc, '/', true)).toEqual(['path', 'to', 'component']);
+    expect(readSegments(loc, 'path', true)).toEqual(['to', 'component']);
+    expect(readSegments(loc, '/path', true)).toEqual(['to', 'component']);
+    expect(readSegments(loc, '/path/', true)).toEqual(['to', 'component']);
+    expect(readSegments(loc, '/path/to', true)).toEqual(['component']);
+    expect(readSegments(loc, '/path/to/component', true)).toEqual(['']);
+    expect(readSegments(loc, '/path/to/component/', true)).toEqual(['']);
+    expect(readSegments(loc, '/path/to/component/path', true)).toBeNull();
+  });
+});
+describe('writeSegments', () => {
+  it('should write root path (no hash)', () => {
+    const history = mockHistory();
+    writeSegments(history, '', false, [''], ROUTER_INTENT_FORWARD, 123);
+    expect(history.pushState).toHaveBeenCalledWith(123, '', '/');
+    writeSegments(history, '', false, ['schedule'], ROUTER_INTENT_FORWARD, 123);
+    expect(history.pushState).toHaveBeenCalledWith(123, '', '/schedule');
+    writeSegments(history, '/', false, [''], ROUTER_INTENT_FORWARD, 123);
+    expect(history.pushState).toHaveBeenCalledWith(123, '', '/');
+    writeSegments(history, '/', false, ['to', 'schedule'], ROUTER_INTENT_FORWARD, 123);
+    expect(history.pushState).toHaveBeenCalledWith(123, '', '/to/schedule');
+    writeSegments(history, '/', false, ['to', 'schedule'], ROUTER_INTENT_FORWARD, 123, 'flag=true');
+    expect(history.pushState).toHaveBeenCalledWith(123, '', '/to/schedule?flag=true');
+  });
+  it('should write non root path (no hash)', () => {
+    const history = mockHistory();
+    writeSegments(history, '/path', false, [''], ROUTER_INTENT_FORWARD, 2);
+    expect(history.pushState).toHaveBeenCalledWith(2, '', '/path');
+    writeSegments(history, '/path', false, ['to', 'page'], ROUTER_INTENT_FORWARD, 2);
+    expect(history.pushState).toHaveBeenCalledWith(2, '', '/path/to/page');
+    writeSegments(history, 'path/to', false, ['second', 'page'], ROUTER_INTENT_FORWARD, 2);
+    expect(history.pushState).toHaveBeenCalledWith(2, '', '/path/to/second/page');
+    writeSegments(history, '/path/to/', false, ['second', 'page'], ROUTER_INTENT_FORWARD, 2);
+    expect(history.pushState).toHaveBeenCalledWith(2, '', '/path/to/second/page');
+    writeSegments(history, '/path/to/', false, ['second', 'page'], ROUTER_INTENT_FORWARD, 2, 'flag=true');
+    expect(history.pushState).toHaveBeenCalledWith(2, '', '/path/to/second/page?flag=true');
+  });
+  it('should write root path (no hash)', () => {
+    const history = mockHistory();
+    writeSegments(history, '', true, [''], ROUTER_INTENT_FORWARD, 123);
+    expect(history.pushState).toHaveBeenCalledWith(123, '', '#/');
+    writeSegments(history, '', true, ['schedule'], ROUTER_INTENT_FORWARD, 123);
+    expect(history.pushState).toHaveBeenCalledWith(123, '', '#/schedule');
+    writeSegments(history, '/', true, [''], ROUTER_INTENT_FORWARD, 123);
+    expect(history.pushState).toHaveBeenCalledWith(123, '', '#/');
+    writeSegments(history, '/', true, ['to', 'schedule'], ROUTER_INTENT_FORWARD, 123);
+    expect(history.pushState).toHaveBeenCalledWith(123, '', '#/to/schedule');
+    writeSegments(history, '/', true, ['to', 'schedule'], ROUTER_INTENT_FORWARD, 123, 'flag=true');
+    expect(history.pushState).toHaveBeenCalledWith(123, '', '#/to/schedule?flag=true');
+  });
+  it('should write non root path (no hash)', () => {
+    const history = mockHistory();
+    writeSegments(history, '/path', true, [''], ROUTER_INTENT_FORWARD, 123);
+    expect(history.pushState).toHaveBeenCalledWith(123, '', '#/path');
+    writeSegments(history, '/path', true, ['to', 'page'], ROUTER_INTENT_FORWARD, 123);
+    expect(history.pushState).toHaveBeenCalledWith(123, '', '#/path/to/page');
+    writeSegments(history, 'path/to', true, ['second', 'page'], ROUTER_INTENT_FORWARD, 123);
+    expect(history.pushState).toHaveBeenCalledWith(123, '', '#/path/to/second/page');
+    writeSegments(history, '/path/to/', true, ['second', 'page'], ROUTER_INTENT_FORWARD, 123);
+    expect(history.pushState).toHaveBeenCalledWith(123, '', '#/path/to/second/page');
+    writeSegments(history, '/path/to/', true, ['second', 'page'], ROUTER_INTENT_FORWARD, 123, 'flag=true');
+    expect(history.pushState).toHaveBeenCalledWith(123, '', '#/path/to/second/page?flag=true');
+  });
+});
+function mockHistory() {
+  return {
+    replaceState: jest.fn(),
+    pushState: jest.fn(),
+    length: 0,
+  };
+}
+function mockLocation(pathname, hash) {
+  return {
+    pathname,
+    hash,
+  };
+}