"use strict";

import { RouteMatcher } from "./RouteMatcher.js";
describe('RouteMatcher', () => {
  let uut;
  beforeEach(() => {
    uut = new RouteMatcher();
  });
  function configure(screens) {
    uut.setRouteTree(uut.buildRouteTree(screens));
  }
  it('matches a flat route', () => {
    configure({
      Home: 'home'
    });
    expect(uut.match('home', 'myapp://home', {})).toEqual({
      url: 'myapp://home',
      path: [{
        screen: 'Home',
        params: {}
      }],
      queryParams: {}
    });
  });
  it('extracts a single path parameter', () => {
    configure({
      Profile: 'user/:id'
    });
    expect(uut.match('user/42', 'myapp://user/42', {})).toEqual({
      url: 'myapp://user/42',
      path: [{
        screen: 'Profile',
        params: {
          id: '42'
        }
      }],
      queryParams: {}
    });
  });
  it('extracts multiple path parameters', () => {
    configure({
      Post: 'user/:userId/post/:postId'
    });
    const result = uut.match('user/5/post/99', 'myapp://user/5/post/99', {});
    expect(result?.path[0].params).toEqual({
      userId: '5',
      postId: '99'
    });
  });
  it('returns null when no route matches', () => {
    configure({
      Home: 'home'
    });
    expect(uut.match('unknown', 'myapp://unknown', {})).toBeNull();
  });
  it('returns null when path is longer than any pattern', () => {
    configure({
      Home: 'home'
    });
    expect(uut.match('home/extra', 'myapp://home/extra', {})).toBeNull();
  });
  it('matches the first registered route on ambiguity', () => {
    configure({
      Profile: 'user/:id',
      User: 'user/:userId'
    });
    const result = uut.match('user/42', 'myapp://user/42', {});
    expect(result?.path[0].screen).toBe('Profile');
  });
  it('matches a nested route as a chain', () => {
    configure({
      Settings: {
        path: 'settings',
        screens: {
          Notifications: 'notifications'
        }
      }
    });
    expect(uut.match('settings/notifications', 'myapp://settings/notifications', {})).toEqual({
      url: 'myapp://settings/notifications',
      path: [{
        screen: 'Settings',
        params: {}
      }, {
        screen: 'Notifications',
        params: {}
      }],
      queryParams: {}
    });
  });
  it('matches a parent-only nested route', () => {
    configure({
      Settings: {
        path: 'settings',
        screens: {
          Notifications: 'notifications'
        }
      }
    });
    expect(uut.match('settings', 'myapp://settings', {})).toEqual({
      url: 'myapp://settings',
      path: [{
        screen: 'Settings',
        params: {}
      }],
      queryParams: {}
    });
  });
  it('supports grouping nodes that consume no segments', () => {
    configure({
      Main: {
        screens: {
          Feed: 'feed',
          Search: 'search'
        }
      }
    });
    const result = uut.match('feed', 'myapp://feed', {});
    expect(result?.path).toEqual([{
      screen: 'Main',
      params: {}
    }, {
      screen: 'Feed',
      params: {}
    }]);
  });
  it('passes query params through to the match result', () => {
    configure({
      Home: 'home'
    });
    const result = uut.match('home', 'myapp://home?ref=push', {
      ref: 'push'
    });
    expect(result?.queryParams).toEqual({
      ref: 'push'
    });
  });
  it('returns null when no route tree has been configured', () => {
    expect(uut.match('home', 'myapp://home', {})).toBeNull();
  });
  it('matches nested params at multiple levels', () => {
    configure({
      Org: {
        path: 'org/:orgId',
        screens: {
          Project: 'project/:projectId'
        }
      }
    });
    const result = uut.match('org/1/project/2', 'myapp://org/1/project/2', {});
    expect(result?.path).toEqual([{
      screen: 'Org',
      params: {
        orgId: '1'
      }
    }, {
      screen: 'Project',
      params: {
        projectId: '2'
      }
    }]);
  });
});
//# sourceMappingURL=RouteMatcher.test.js.map